From 303d005ca9832e5384fa26dcd3c9bca77a4bcea8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Canna=C3=B2?= Date: Wed, 6 Jan 2016 16:02:40 +0000 Subject: [PATCH] SQLite3 is no skipped as source files --- .gitignore | 3 - deps/Makefile | 4 +- deps/sqlite3/sqlite-amalgamation-3090200.zip | Bin 1830895 -> 0 bytes .../sqlite-amalgamation-3090200/shell.c | 4851 + .../sqlite-amalgamation-3090200/sqlite3.c | 184251 +++++++++++++++ .../sqlite-amalgamation-3090200/sqlite3.h | 8443 + .../sqlite-amalgamation-3090200/sqlite3ext.h | 534 + 7 files changed, 198080 insertions(+), 6 deletions(-) delete mode 100644 deps/sqlite3/sqlite-amalgamation-3090200.zip create mode 100644 deps/sqlite3/sqlite-amalgamation-3090200/shell.c create mode 100644 deps/sqlite3/sqlite-amalgamation-3090200/sqlite3.c create mode 100644 deps/sqlite3/sqlite-amalgamation-3090200/sqlite3.h create mode 100644 deps/sqlite3/sqlite-amalgamation-3090200/sqlite3ext.h diff --git a/.gitignore b/.gitignore index b2613b8f2..f09357900 100644 --- a/.gitignore +++ b/.gitignore @@ -64,9 +64,6 @@ architecture.txt ### DEPS -#sqlite -deps/sqlite3/sqlite-amalgamation-3090200/ - #jemalloc source deps/jemalloc/jemalloc-3.6.0/ diff --git a/deps/Makefile b/deps/Makefile index 995859a34..2d2657cc9 100644 --- a/deps/Makefile +++ b/deps/Makefile @@ -48,8 +48,6 @@ mariadb_client: mariadb-client-library/mariadb_client/include/my_config.h sqlite3/sqlite3/sqlite3.o: - cd sqlite3 && rm -rf sqlite-amalgamation-3090200 - cd sqlite3 && unzip sqlite-amalgamation-3090200.zip cd sqlite3/sqlite3 && ${CC} -O2 -c -o sqlite3.o sqlite3.c sqlite3: sqlite3/sqlite3/sqlite3.o @@ -80,6 +78,6 @@ cleanall: cd re2 && rm -rf re2 cd libinjection && ${MAKE} clean cd libevent && rm -rf libevent-2.0.22-stable -# cd sqlite3 && rm -rf sqlite-amalgamation-3080403 + cd sqlite3/sqlite3 && rm -rf *.o .PHONY: cleanall diff --git a/deps/sqlite3/sqlite-amalgamation-3090200.zip b/deps/sqlite3/sqlite-amalgamation-3090200.zip deleted file mode 100644 index 1eae084ead19f3a601ce21d7ad4a6dbea8f27826..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1830895 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

lh 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

wk?-bZ@qzc9?$?R{pw5Tz4Z9E8`%zZB_s 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

^Vg3x-bl$#SX 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

^$-yp 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%0D6oHt*r(}iI$LO>#M=8dzkE- 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̳gwtUr?E9#LF{m113UpM>WIIYNLW7$~ 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

1% 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%0DU(-xP20F9ZjO&pT${*mE&Fjb|Mr$+H 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%0DZNAI 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 z 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%0DJ|;Dd6lY87W*6p6J&**CwC%GRN9cfBiY^ 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 z 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 |kvABRVb@c>(Nr@ZRO5q7r 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 Dd(ovQ diff --git a/deps/sqlite3/sqlite-amalgamation-3090200/shell.c b/deps/sqlite3/sqlite-amalgamation-3090200/shell.c new file mode 100644 index 000000000..f79087122 --- /dev/null +++ b/deps/sqlite3/sqlite-amalgamation-3090200/shell.c @@ -0,0 +1,4851 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code to implement the "sqlite" command line +** utility for accessing SQLite databases. +*/ +#if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS) +/* This needs to come before any includes for MSVC compiler */ +#define _CRT_SECURE_NO_WARNINGS +#endif + +/* +** If requested, include the SQLite compiler options file for MSVC. +*/ +#if defined(INCLUDE_MSVC_H) +#include "msvc.h" +#endif + +/* +** No support for loadable extensions in VxWorks. +*/ +#if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION +# define SQLITE_OMIT_LOAD_EXTENSION 1 +#endif + +/* +** Enable large-file support for fopen() and friends on unix. +*/ +#ifndef SQLITE_DISABLE_LFS +# define _LARGE_FILE 1 +# ifndef _FILE_OFFSET_BITS +# define _FILE_OFFSET_BITS 64 +# endif +# define _LARGEFILE_SOURCE 1 +#endif + +#include +#include +#include +#include +#include "sqlite3.h" +#if SQLITE_USER_AUTHENTICATION +# include "sqlite3userauth.h" +#endif +#include +#include + +#if !defined(_WIN32) && !defined(WIN32) +# include +# if !defined(__RTP__) && !defined(_WRS_KERNEL) +# include +# endif +# include +# include +#endif + +#if HAVE_READLINE +# include +# include +#endif + +#if HAVE_EDITLINE +# include +#endif + +#if HAVE_EDITLINE || HAVE_READLINE + +# define shell_add_history(X) add_history(X) +# define shell_read_history(X) read_history(X) +# define shell_write_history(X) write_history(X) +# define shell_stifle_history(X) stifle_history(X) +# define shell_readline(X) readline(X) + +#elif HAVE_LINENOISE + +# include "linenoise.h" +# define shell_add_history(X) linenoiseHistoryAdd(X) +# define shell_read_history(X) linenoiseHistoryLoad(X) +# define shell_write_history(X) linenoiseHistorySave(X) +# define shell_stifle_history(X) linenoiseHistorySetMaxLen(X) +# define shell_readline(X) linenoise(X) + +#else + +# define shell_read_history(X) +# define shell_write_history(X) +# define shell_stifle_history(X) + +# define SHELL_USE_LOCAL_GETLINE 1 +#endif + + +#if defined(_WIN32) || defined(WIN32) +# include +# include +# define isatty(h) _isatty(h) +# ifndef access +# define access(f,m) _access((f),(m)) +# endif +# undef popen +# define popen _popen +# undef pclose +# define pclose _pclose +#else + /* Make sure isatty() has a prototype. */ + extern int isatty(int); + +# if !defined(__RTP__) && !defined(_WRS_KERNEL) + /* popen and pclose are not C89 functions and so are + ** sometimes omitted from the header */ + extern FILE *popen(const char*,const char*); + extern int pclose(FILE*); +# else +# define SQLITE_OMIT_POPEN 1 +# endif +#endif + +#if defined(_WIN32_WCE) +/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty() + * thus we always assume that we have a console. That can be + * overridden with the -batch command line option. + */ +#define isatty(x) 1 +#endif + +/* ctype macros that work with signed characters */ +#define IsSpace(X) isspace((unsigned char)X) +#define IsDigit(X) isdigit((unsigned char)X) +#define ToLower(X) (char)tolower((unsigned char)X) + +/* On Windows, we normally run with output mode of TEXT so that \n characters +** are automatically translated into \r\n. However, this behavior needs +** to be disabled in some cases (ex: when generating CSV output and when +** rendering quoted strings that contain \n characters). The following +** routines take care of that. +*/ +#if defined(_WIN32) || defined(WIN32) +static void setBinaryMode(FILE *out){ + fflush(out); + _setmode(_fileno(out), _O_BINARY); +} +static void setTextMode(FILE *out){ + fflush(out); + _setmode(_fileno(out), _O_TEXT); +} +#else +# define setBinaryMode(X) +# define setTextMode(X) +#endif + + +/* True if the timer is enabled */ +static int enableTimer = 0; + +/* Return the current wall-clock time */ +static sqlite3_int64 timeOfDay(void){ + static sqlite3_vfs *clockVfs = 0; + sqlite3_int64 t; + if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0); + if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){ + clockVfs->xCurrentTimeInt64(clockVfs, &t); + }else{ + double r; + clockVfs->xCurrentTime(clockVfs, &r); + t = (sqlite3_int64)(r*86400000.0); + } + return t; +} + +#if !defined(_WIN32) && !defined(WIN32) && !defined(__minux) +#include +#include + +/* VxWorks does not support getrusage() as far as we can determine */ +#if defined(_WRS_KERNEL) || defined(__RTP__) +struct rusage { + struct timeval ru_utime; /* user CPU time used */ + struct timeval ru_stime; /* system CPU time used */ +}; +#define getrusage(A,B) memset(B,0,sizeof(*B)) +#endif + +/* Saved resource information for the beginning of an operation */ +static struct rusage sBegin; /* CPU time at start */ +static sqlite3_int64 iBegin; /* Wall-clock time at start */ + +/* +** Begin timing an operation +*/ +static void beginTimer(void){ + if( enableTimer ){ + getrusage(RUSAGE_SELF, &sBegin); + iBegin = timeOfDay(); + } +} + +/* Return the difference of two time_structs in seconds */ +static double timeDiff(struct timeval *pStart, struct timeval *pEnd){ + return (pEnd->tv_usec - pStart->tv_usec)*0.000001 + + (double)(pEnd->tv_sec - pStart->tv_sec); +} + +/* +** Print the timing results. +*/ +static void endTimer(void){ + if( enableTimer ){ + sqlite3_int64 iEnd = timeOfDay(); + struct rusage sEnd; + getrusage(RUSAGE_SELF, &sEnd); + printf("Run Time: real %.3f user %f sys %f\n", + (iEnd - iBegin)*0.001, + timeDiff(&sBegin.ru_utime, &sEnd.ru_utime), + timeDiff(&sBegin.ru_stime, &sEnd.ru_stime)); + } +} + +#define BEGIN_TIMER beginTimer() +#define END_TIMER endTimer() +#define HAS_TIMER 1 + +#elif (defined(_WIN32) || defined(WIN32)) + +#include + +/* Saved resource information for the beginning of an operation */ +static HANDLE hProcess; +static FILETIME ftKernelBegin; +static FILETIME ftUserBegin; +static sqlite3_int64 ftWallBegin; +typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, + LPFILETIME, LPFILETIME); +static GETPROCTIMES getProcessTimesAddr = NULL; + +/* +** Check to see if we have timer support. Return 1 if necessary +** support found (or found previously). +*/ +static int hasTimer(void){ + if( getProcessTimesAddr ){ + return 1; + } else { + /* GetProcessTimes() isn't supported in WIN95 and some other Windows + ** versions. See if the version we are running on has it, and if it + ** does, save off a pointer to it and the current process handle. + */ + hProcess = GetCurrentProcess(); + if( hProcess ){ + HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll")); + if( NULL != hinstLib ){ + getProcessTimesAddr = + (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes"); + if( NULL != getProcessTimesAddr ){ + return 1; + } + FreeLibrary(hinstLib); + } + } + } + return 0; +} + +/* +** Begin timing an operation +*/ +static void beginTimer(void){ + if( enableTimer && getProcessTimesAddr ){ + FILETIME ftCreation, ftExit; + getProcessTimesAddr(hProcess,&ftCreation,&ftExit, + &ftKernelBegin,&ftUserBegin); + ftWallBegin = timeOfDay(); + } +} + +/* Return the difference of two FILETIME structs in seconds */ +static double timeDiff(FILETIME *pStart, FILETIME *pEnd){ + sqlite_int64 i64Start = *((sqlite_int64 *) pStart); + sqlite_int64 i64End = *((sqlite_int64 *) pEnd); + return (double) ((i64End - i64Start) / 10000000.0); +} + +/* +** Print the timing results. +*/ +static void endTimer(void){ + if( enableTimer && getProcessTimesAddr){ + FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd; + sqlite3_int64 ftWallEnd = timeOfDay(); + getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd); + printf("Run Time: real %.3f user %f sys %f\n", + (ftWallEnd - ftWallBegin)*0.001, + timeDiff(&ftUserBegin, &ftUserEnd), + timeDiff(&ftKernelBegin, &ftKernelEnd)); + } +} + +#define BEGIN_TIMER beginTimer() +#define END_TIMER endTimer() +#define HAS_TIMER hasTimer() + +#else +#define BEGIN_TIMER +#define END_TIMER +#define HAS_TIMER 0 +#endif + +/* +** Used to prevent warnings about unused parameters +*/ +#define UNUSED_PARAMETER(x) (void)(x) + +/* +** If the following flag is set, then command execution stops +** at an error if we are not interactive. +*/ +static int bail_on_error = 0; + +/* +** Threat stdin as an interactive input if the following variable +** is true. Otherwise, assume stdin is connected to a file or pipe. +*/ +static int stdin_is_interactive = 1; + +/* +** The following is the open SQLite database. We make a pointer +** to this database a static variable so that it can be accessed +** by the SIGINT handler to interrupt database processing. +*/ +static sqlite3 *globalDb = 0; + +/* +** True if an interrupt (Control-C) has been received. +*/ +static volatile int seenInterrupt = 0; + +/* +** This is the name of our program. It is set in main(), used +** in a number of other places, mostly for error messages. +*/ +static char *Argv0; + +/* +** Prompt strings. Initialized in main. Settable with +** .prompt main continue +*/ +static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/ +static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */ + +/* +** Write I/O traces to the following stream. +*/ +#ifdef SQLITE_ENABLE_IOTRACE +static FILE *iotrace = 0; +#endif + +/* +** This routine works like printf in that its first argument is a +** format string and subsequent arguments are values to be substituted +** in place of % fields. The result of formatting this string +** is written to iotrace. +*/ +#ifdef SQLITE_ENABLE_IOTRACE +static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){ + va_list ap; + char *z; + if( iotrace==0 ) return; + va_start(ap, zFormat); + z = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + fprintf(iotrace, "%s", z); + sqlite3_free(z); +} +#endif + + +/* +** Determines if a string is a number of not. +*/ +static int isNumber(const char *z, int *realnum){ + if( *z=='-' || *z=='+' ) z++; + if( !IsDigit(*z) ){ + return 0; + } + z++; + if( realnum ) *realnum = 0; + while( IsDigit(*z) ){ z++; } + if( *z=='.' ){ + z++; + if( !IsDigit(*z) ) return 0; + while( IsDigit(*z) ){ z++; } + if( realnum ) *realnum = 1; + } + if( *z=='e' || *z=='E' ){ + z++; + if( *z=='+' || *z=='-' ) z++; + if( !IsDigit(*z) ) return 0; + while( IsDigit(*z) ){ z++; } + if( realnum ) *realnum = 1; + } + return *z==0; +} + +/* +** A global char* and an SQL function to access its current value +** from within an SQL statement. This program used to use the +** sqlite_exec_printf() API to substitue a string into an SQL statement. +** The correct way to do this with sqlite3 is to use the bind API, but +** since the shell is built around the callback paradigm it would be a lot +** of work. Instead just use this hack, which is quite harmless. +*/ +static const char *zShellStatic = 0; +static void shellstaticFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + assert( 0==argc ); + assert( zShellStatic ); + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC); +} + + +/* +** This routine reads a line of text from FILE in, stores +** the text in memory obtained from malloc() and returns a pointer +** to the text. NULL is returned at end of file, or if malloc() +** fails. +** +** If zLine is not NULL then it is a malloced buffer returned from +** a previous call to this routine that may be reused. +*/ +static char *local_getline(char *zLine, FILE *in){ + int nLine = zLine==0 ? 0 : 100; + int n = 0; + + while( 1 ){ + if( n+100>nLine ){ + nLine = nLine*2 + 100; + zLine = realloc(zLine, nLine); + if( zLine==0 ) return 0; + } + if( fgets(&zLine[n], nLine - n, in)==0 ){ + if( n==0 ){ + free(zLine); + return 0; + } + zLine[n] = 0; + break; + } + while( zLine[n] ) n++; + if( n>0 && zLine[n-1]=='\n' ){ + n--; + if( n>0 && zLine[n-1]=='\r' ) n--; + zLine[n] = 0; + break; + } + } + return zLine; +} + +/* +** Retrieve a single line of input text. +** +** If in==0 then read from standard input and prompt before each line. +** If isContinuation is true, then a continuation prompt is appropriate. +** If isContinuation is zero, then the main prompt should be used. +** +** If zPrior is not NULL then it is a buffer from a prior call to this +** routine that can be reused. +** +** The result is stored in space obtained from malloc() and must either +** be freed by the caller or else passed back into this routine via the +** zPrior argument for reuse. +*/ +static char *one_input_line(FILE *in, char *zPrior, int isContinuation){ + char *zPrompt; + char *zResult; + if( in!=0 ){ + zResult = local_getline(zPrior, in); + }else{ + zPrompt = isContinuation ? continuePrompt : mainPrompt; +#if SHELL_USE_LOCAL_GETLINE + printf("%s", zPrompt); + fflush(stdout); + zResult = local_getline(zPrior, stdin); +#else + free(zPrior); + zResult = shell_readline(zPrompt); + if( zResult && *zResult ) shell_add_history(zResult); +#endif + } + return zResult; +} + +/* +** Shell output mode information from before ".explain on", +** saved so that it can be restored by ".explain off" +*/ +typedef struct SavedModeInfo SavedModeInfo; +struct SavedModeInfo { + int valid; /* Is there legit data in here? */ + int mode; /* Mode prior to ".explain on" */ + int showHeader; /* The ".header" setting prior to ".explain on" */ + int colWidth[100]; /* Column widths prior to ".explain on" */ +}; + +/* +** State information about the database connection is contained in an +** instance of the following structure. +*/ +typedef struct ShellState ShellState; +struct ShellState { + sqlite3 *db; /* The database */ + int echoOn; /* True to echo input commands */ + int autoEQP; /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */ + int statsOn; /* True to display memory stats before each finalize */ + int scanstatsOn; /* True to display scan stats before each finalize */ + int backslashOn; /* Resolve C-style \x escapes in SQL input text */ + int outCount; /* Revert to stdout when reaching zero */ + int cnt; /* Number of records displayed so far */ + FILE *out; /* Write results here */ + FILE *traceOut; /* Output for sqlite3_trace() */ + int nErr; /* Number of errors seen */ + int mode; /* An output mode setting */ + int writableSchema; /* True if PRAGMA writable_schema=ON */ + int showHeader; /* True to show column names in List or Column mode */ + unsigned shellFlgs; /* Various flags */ + char *zDestTable; /* Name of destination table when MODE_Insert */ + char colSeparator[20]; /* Column separator character for several modes */ + char rowSeparator[20]; /* Row separator character for MODE_Ascii */ + int colWidth[100]; /* Requested width of each column when in column mode*/ + int actualWidth[100]; /* Actual width of each column */ + char nullValue[20]; /* The text to print when a NULL comes back from + ** the database */ + SavedModeInfo normalMode;/* Holds the mode just before .explain ON */ + char outfile[FILENAME_MAX]; /* Filename for *out */ + const char *zDbFilename; /* name of the database file */ + char *zFreeOnClose; /* Filename to free when closing */ + const char *zVfs; /* Name of VFS to use */ + sqlite3_stmt *pStmt; /* Current statement if any. */ + FILE *pLog; /* Write log output here */ + int *aiIndent; /* Array of indents used in MODE_Explain */ + int nIndent; /* Size of array aiIndent[] */ + int iIndent; /* Index of current op in aiIndent[] */ +}; + +/* +** These are the allowed shellFlgs values +*/ +#define SHFLG_Scratch 0x00001 /* The --scratch option is used */ +#define SHFLG_Pagecache 0x00002 /* The --pagecache option is used */ +#define SHFLG_Lookaside 0x00004 /* Lookaside memory is used */ + +/* +** These are the allowed modes. +*/ +#define MODE_Line 0 /* One column per line. Blank line between records */ +#define MODE_Column 1 /* One record per line in neat columns */ +#define MODE_List 2 /* One record per line with a separator */ +#define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */ +#define MODE_Html 4 /* Generate an XHTML table */ +#define MODE_Insert 5 /* Generate SQL "insert" statements */ +#define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */ +#define MODE_Csv 7 /* Quote strings, numbers are plain */ +#define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */ +#define MODE_Ascii 9 /* Use ASCII unit and record separators (0x1F/0x1E) */ + +static const char *modeDescr[] = { + "line", + "column", + "list", + "semi", + "html", + "insert", + "tcl", + "csv", + "explain", + "ascii", +}; + +/* +** These are the column/row/line separators used by the various +** import/export modes. +*/ +#define SEP_Column "|" +#define SEP_Row "\n" +#define SEP_Tab "\t" +#define SEP_Space " " +#define SEP_Comma "," +#define SEP_CrLf "\r\n" +#define SEP_Unit "\x1F" +#define SEP_Record "\x1E" + +/* +** Number of elements in an array +*/ +#define ArraySize(X) (int)(sizeof(X)/sizeof(X[0])) + +/* +** Compute a string length that is limited to what can be stored in +** lower 30 bits of a 32-bit signed integer. +*/ +static int strlen30(const char *z){ + const char *z2 = z; + while( *z2 ){ z2++; } + return 0x3fffffff & (int)(z2 - z); +} + +/* +** A callback for the sqlite3_log() interface. +*/ +static void shellLog(void *pArg, int iErrCode, const char *zMsg){ + ShellState *p = (ShellState*)pArg; + if( p->pLog==0 ) return; + fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg); + fflush(p->pLog); +} + +/* +** Output the given string as a hex-encoded blob (eg. X'1234' ) +*/ +static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){ + int i; + char *zBlob = (char *)pBlob; + fprintf(out,"X'"); + for(i=0; i0 ){ + fprintf(out,"%.*s",i,z); + } + if( z[i]=='<' ){ + fprintf(out,"<"); + }else if( z[i]=='&' ){ + fprintf(out,"&"); + }else if( z[i]=='>' ){ + fprintf(out,">"); + }else if( z[i]=='\"' ){ + fprintf(out,"""); + }else if( z[i]=='\'' ){ + fprintf(out,"'"); + }else{ + break; + } + z += i + 1; + } +} + +/* +** If a field contains any character identified by a 1 in the following +** array, then the string must be quoted for CSV. +*/ +static const char needCsvQuote[] = { + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +}; + +/* +** Output a single term of CSV. Actually, p->colSeparator is used for +** the separator, which may or may not be a comma. p->nullValue is +** the null value. Strings are quoted if necessary. The separator +** is only issued if bSep is true. +*/ +static void output_csv(ShellState *p, const char *z, int bSep){ + FILE *out = p->out; + if( z==0 ){ + fprintf(out,"%s",p->nullValue); + }else{ + int i; + int nSep = strlen30(p->colSeparator); + for(i=0; z[i]; i++){ + if( needCsvQuote[((unsigned char*)z)[i]] + || (z[i]==p->colSeparator[0] && + (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){ + i = 0; + break; + } + } + if( i==0 ){ + putc('"', out); + for(i=0; z[i]; i++){ + if( z[i]=='"' ) putc('"', out); + putc(z[i], out); + } + putc('"', out); + }else{ + fprintf(out, "%s", z); + } + } + if( bSep ){ + fprintf(p->out, "%s", p->colSeparator); + } +} + +#ifdef SIGINT +/* +** This routine runs when the user presses Ctrl-C +*/ +static void interrupt_handler(int NotUsed){ + UNUSED_PARAMETER(NotUsed); + seenInterrupt++; + if( seenInterrupt>2 ) exit(1); + if( globalDb ) sqlite3_interrupt(globalDb); +} +#endif + +/* +** This is the callback routine that the shell +** invokes for each row of a query result. +*/ +static int shell_callback( + void *pArg, + int nArg, /* Number of result columns */ + char **azArg, /* Text of each result column */ + char **azCol, /* Column names */ + int *aiType /* Column types */ +){ + int i; + ShellState *p = (ShellState*)pArg; + + switch( p->mode ){ + case MODE_Line: { + int w = 5; + if( azArg==0 ) break; + for(i=0; iw ) w = len; + } + if( p->cnt++>0 ) fprintf(p->out, "%s", p->rowSeparator); + for(i=0; iout,"%*s = %s%s", w, azCol[i], + azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator); + } + break; + } + case MODE_Explain: + case MODE_Column: { + if( p->cnt++==0 ){ + for(i=0; icolWidth) ){ + w = p->colWidth[i]; + }else{ + w = 0; + } + if( w==0 ){ + w = strlen30(azCol[i] ? azCol[i] : ""); + if( w<10 ) w = 10; + n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullValue); + if( wactualWidth) ){ + p->actualWidth[i] = w; + } + if( p->showHeader ){ + if( w<0 ){ + fprintf(p->out,"%*.*s%s",-w,-w,azCol[i], + i==nArg-1 ? p->rowSeparator : " "); + }else{ + fprintf(p->out,"%-*.*s%s",w,w,azCol[i], + i==nArg-1 ? p->rowSeparator : " "); + } + } + } + if( p->showHeader ){ + for(i=0; iactualWidth) ){ + w = p->actualWidth[i]; + if( w<0 ) w = -w; + }else{ + w = 10; + } + fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------" + "----------------------------------------------------------", + i==nArg-1 ? p->rowSeparator : " "); + } + } + } + if( azArg==0 ) break; + for(i=0; iactualWidth) ){ + w = p->actualWidth[i]; + }else{ + w = 10; + } + if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){ + w = strlen30(azArg[i]); + } + if( i==1 && p->aiIndent && p->pStmt ){ + if( p->iIndentnIndent ){ + fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], ""); + } + p->iIndent++; + } + if( w<0 ){ + fprintf(p->out,"%*.*s%s",-w,-w, + azArg[i] ? azArg[i] : p->nullValue, + i==nArg-1 ? p->rowSeparator : " "); + }else{ + fprintf(p->out,"%-*.*s%s",w,w, + azArg[i] ? azArg[i] : p->nullValue, + i==nArg-1 ? p->rowSeparator : " "); + } + } + break; + } + case MODE_Semi: + case MODE_List: { + if( p->cnt++==0 && p->showHeader ){ + for(i=0; iout,"%s%s",azCol[i], + i==nArg-1 ? p->rowSeparator : p->colSeparator); + } + } + if( azArg==0 ) break; + for(i=0; inullValue; + fprintf(p->out, "%s", z); + if( iout, "%s", p->colSeparator); + }else if( p->mode==MODE_Semi ){ + fprintf(p->out, ";%s", p->rowSeparator); + }else{ + fprintf(p->out, "%s", p->rowSeparator); + } + } + break; + } + case MODE_Html: { + if( p->cnt++==0 && p->showHeader ){ + fprintf(p->out,""); + for(i=0; iout,""); + output_html_string(p->out, azCol[i]); + fprintf(p->out,"\n"); + } + fprintf(p->out,"\n"); + } + if( azArg==0 ) break; + fprintf(p->out,""); + for(i=0; iout,""); + output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue); + fprintf(p->out,"\n"); + } + fprintf(p->out,"\n"); + break; + } + case MODE_Tcl: { + if( p->cnt++==0 && p->showHeader ){ + for(i=0; iout,azCol[i] ? azCol[i] : ""); + if(iout, "%s", p->colSeparator); + } + fprintf(p->out, "%s", p->rowSeparator); + } + if( azArg==0 ) break; + for(i=0; iout, azArg[i] ? azArg[i] : p->nullValue); + if(iout, "%s", p->colSeparator); + } + fprintf(p->out, "%s", p->rowSeparator); + break; + } + case MODE_Csv: { + setBinaryMode(p->out); + if( p->cnt++==0 && p->showHeader ){ + for(i=0; iout, "%s", p->rowSeparator); + } + if( nArg>0 ){ + for(i=0; iout, "%s", p->rowSeparator); + } + setTextMode(p->out); + break; + } + case MODE_Insert: { + p->cnt++; + if( azArg==0 ) break; + fprintf(p->out,"INSERT INTO %s",p->zDestTable); + if( p->showHeader ){ + fprintf(p->out,"("); + for(i=0; i0 ? ",": ""; + fprintf(p->out, "%s%s", zSep, azCol[i]); + } + fprintf(p->out,")"); + } + fprintf(p->out," VALUES("); + for(i=0; i0 ? ",": ""; + if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ + fprintf(p->out,"%sNULL",zSep); + }else if( aiType && aiType[i]==SQLITE_TEXT ){ + if( zSep[0] ) fprintf(p->out,"%s",zSep); + output_quoted_string(p->out, azArg[i]); + }else if( aiType && (aiType[i]==SQLITE_INTEGER + || aiType[i]==SQLITE_FLOAT) ){ + fprintf(p->out,"%s%s",zSep, azArg[i]); + }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ + const void *pBlob = sqlite3_column_blob(p->pStmt, i); + int nBlob = sqlite3_column_bytes(p->pStmt, i); + if( zSep[0] ) fprintf(p->out,"%s",zSep); + output_hex_blob(p->out, pBlob, nBlob); + }else if( isNumber(azArg[i], 0) ){ + fprintf(p->out,"%s%s",zSep, azArg[i]); + }else{ + if( zSep[0] ) fprintf(p->out,"%s",zSep); + output_quoted_string(p->out, azArg[i]); + } + } + fprintf(p->out,");\n"); + break; + } + case MODE_Ascii: { + if( p->cnt++==0 && p->showHeader ){ + for(i=0; i0 ) fprintf(p->out, "%s", p->colSeparator); + fprintf(p->out,"%s",azCol[i] ? azCol[i] : ""); + } + fprintf(p->out, "%s", p->rowSeparator); + } + if( azArg==0 ) break; + for(i=0; i0 ) fprintf(p->out, "%s", p->colSeparator); + fprintf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue); + } + fprintf(p->out, "%s", p->rowSeparator); + break; + } + } + return 0; +} + +/* +** This is the callback routine that the SQLite library +** invokes for each row of a query result. +*/ +static int callback(void *pArg, int nArg, char **azArg, char **azCol){ + /* since we don't have type info, call the shell_callback with a NULL value */ + return shell_callback(pArg, nArg, azArg, azCol, NULL); +} + +/* +** Set the destination table field of the ShellState structure to +** the name of the table given. Escape any quote characters in the +** table name. +*/ +static void set_table_name(ShellState *p, const char *zName){ + int i, n; + int needQuote; + char *z; + + if( p->zDestTable ){ + free(p->zDestTable); + p->zDestTable = 0; + } + if( zName==0 ) return; + needQuote = !isalpha((unsigned char)*zName) && *zName!='_'; + for(i=n=0; zName[i]; i++, n++){ + if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){ + needQuote = 1; + if( zName[i]=='\'' ) n++; + } + } + if( needQuote ) n += 2; + z = p->zDestTable = malloc( n+1 ); + if( z==0 ){ + fprintf(stderr,"Error: out of memory\n"); + exit(1); + } + n = 0; + if( needQuote ) z[n++] = '\''; + for(i=0; zName[i]; i++){ + z[n++] = zName[i]; + if( zName[i]=='\'' ) z[n++] = '\''; + } + if( needQuote ) z[n++] = '\''; + z[n] = 0; +} + +/* zIn is either a pointer to a NULL-terminated string in memory obtained +** from malloc(), or a NULL pointer. The string pointed to by zAppend is +** added to zIn, and the result returned in memory obtained from malloc(). +** zIn, if it was not NULL, is freed. +** +** If the third argument, quote, is not '\0', then it is used as a +** quote character for zAppend. +*/ +static char *appendText(char *zIn, char const *zAppend, char quote){ + int len; + int i; + int nAppend = strlen30(zAppend); + int nIn = (zIn?strlen30(zIn):0); + + len = nAppend+nIn+1; + if( quote ){ + len += 2; + for(i=0; idb, zSelect, -1, &pSelect, 0); + if( rc!=SQLITE_OK || !pSelect ){ + fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db)); + if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; + return rc; + } + rc = sqlite3_step(pSelect); + nResult = sqlite3_column_count(pSelect); + while( rc==SQLITE_ROW ){ + if( zFirstRow ){ + fprintf(p->out, "%s", zFirstRow); + zFirstRow = 0; + } + z = (const char*)sqlite3_column_text(pSelect, 0); + fprintf(p->out, "%s", z); + for(i=1; iout, ",%s", sqlite3_column_text(pSelect, i)); + } + if( z==0 ) z = ""; + while( z[0] && (z[0]!='-' || z[1]!='-') ) z++; + if( z[0] ){ + fprintf(p->out, "\n;\n"); + }else{ + fprintf(p->out, ";\n"); + } + rc = sqlite3_step(pSelect); + } + rc = sqlite3_finalize(pSelect); + if( rc!=SQLITE_OK ){ + fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db)); + if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++; + } + return rc; +} + +/* +** Allocate space and save off current error string. +*/ +static char *save_err_msg( + sqlite3 *db /* Database to query */ +){ + int nErrMsg = 1+strlen30(sqlite3_errmsg(db)); + char *zErrMsg = sqlite3_malloc64(nErrMsg); + if( zErrMsg ){ + memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg); + } + return zErrMsg; +} + +/* +** Display memory stats. +*/ +static int display_stats( + sqlite3 *db, /* Database to query */ + ShellState *pArg, /* Pointer to ShellState */ + int bReset /* True to reset the stats */ +){ + int iCur; + int iHiwtr; + + if( pArg && pArg->out ){ + + iHiwtr = iCur = -1; + sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, + "Memory Used: %d (max %d) bytes\n", + iCur, iHiwtr); + iHiwtr = iCur = -1; + sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Number of Outstanding Allocations: %d (max %d)\n", + iCur, iHiwtr); + if( pArg->shellFlgs & SHFLG_Pagecache ){ + iHiwtr = iCur = -1; + sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, + "Number of Pcache Pages Used: %d (max %d) pages\n", + iCur, iHiwtr); + } + iHiwtr = iCur = -1; + sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, + "Number of Pcache Overflow Bytes: %d (max %d) bytes\n", + iCur, iHiwtr); + if( pArg->shellFlgs & SHFLG_Scratch ){ + iHiwtr = iCur = -1; + sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Number of Scratch Allocations Used: %d (max %d)\n", + iCur, iHiwtr); + } + iHiwtr = iCur = -1; + sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, + "Number of Scratch Overflow Bytes: %d (max %d) bytes\n", + iCur, iHiwtr); + iHiwtr = iCur = -1; + sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Largest Allocation: %d bytes\n", + iHiwtr); + iHiwtr = iCur = -1; + sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Largest Pcache Allocation: %d bytes\n", + iHiwtr); + iHiwtr = iCur = -1; + sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Largest Scratch Allocation: %d bytes\n", + iHiwtr); +#ifdef YYTRACKMAXSTACKDEPTH + iHiwtr = iCur = -1; + sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Deepest Parser Stack: %d (max %d)\n", + iCur, iHiwtr); +#endif + } + + if( pArg && pArg->out && db ){ + if( pArg->shellFlgs & SHFLG_Lookaside ){ + iHiwtr = iCur = -1; + sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED, + &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Lookaside Slots Used: %d (max %d)\n", + iCur, iHiwtr); + sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT, + &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Successful lookaside attempts: %d\n", iHiwtr); + sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE, + &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Lookaside failures due to size: %d\n", iHiwtr); + sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL, + &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Lookaside failures due to OOM: %d\n", iHiwtr); + } + iHiwtr = iCur = -1; + sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Pager Heap Usage: %d bytes\n",iCur); + iHiwtr = iCur = -1; + sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1); + fprintf(pArg->out, "Page cache hits: %d\n", iCur); + iHiwtr = iCur = -1; + sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1); + fprintf(pArg->out, "Page cache misses: %d\n", iCur); + iHiwtr = iCur = -1; + sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1); + fprintf(pArg->out, "Page cache writes: %d\n", iCur); + iHiwtr = iCur = -1; + sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Schema Heap Usage: %d bytes\n",iCur); + iHiwtr = iCur = -1; + sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset); + fprintf(pArg->out, "Statement Heap/Lookaside Usage: %d bytes\n",iCur); + } + + if( pArg && pArg->out && db && pArg->pStmt ){ + iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, + bReset); + fprintf(pArg->out, "Fullscan Steps: %d\n", iCur); + iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset); + fprintf(pArg->out, "Sort Operations: %d\n", iCur); + iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset); + fprintf(pArg->out, "Autoindex Inserts: %d\n", iCur); + iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset); + fprintf(pArg->out, "Virtual Machine Steps: %d\n", iCur); + } + + /* Do not remove this machine readable comment: extra-stats-output-here */ + + return 0; +} + +/* +** Display scan stats. +*/ +static void display_scanstats( + sqlite3 *db, /* Database to query */ + ShellState *pArg /* Pointer to ShellState */ +){ +#ifndef SQLITE_ENABLE_STMT_SCANSTATUS + UNUSED_PARAMETER(db); + UNUSED_PARAMETER(pArg); +#else + int i, k, n, mx; + fprintf(pArg->out, "-------- scanstats --------\n"); + mx = 0; + for(k=0; k<=mx; k++){ + double rEstLoop = 1.0; + for(i=n=0; 1; i++){ + sqlite3_stmt *p = pArg->pStmt; + sqlite3_int64 nLoop, nVisit; + double rEst; + int iSid; + const char *zExplain; + if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){ + break; + } + sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid); + if( iSid>mx ) mx = iSid; + if( iSid!=k ) continue; + if( n==0 ){ + rEstLoop = (double)nLoop; + if( k>0 ) fprintf(pArg->out, "-------- subquery %d -------\n", k); + } + n++; + sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit); + sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst); + sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain); + fprintf(pArg->out, "Loop %2d: %s\n", n, zExplain); + rEstLoop *= rEst; + fprintf(pArg->out, + " nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n", + nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst + ); + } + } + fprintf(pArg->out, "---------------------------\n"); +#endif +} + +/* +** Parameter azArray points to a zero-terminated array of strings. zStr +** points to a single nul-terminated string. Return non-zero if zStr +** is equal, according to strcmp(), to any of the strings in the array. +** Otherwise, return zero. +*/ +static int str_in_array(const char *zStr, const char **azArray){ + int i; + for(i=0; azArray[i]; i++){ + if( 0==strcmp(zStr, azArray[i]) ) return 1; + } + return 0; +} + +/* +** If compiled statement pSql appears to be an EXPLAIN statement, allocate +** and populate the ShellState.aiIndent[] array with the number of +** spaces each opcode should be indented before it is output. +** +** The indenting rules are: +** +** * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent +** all opcodes that occur between the p2 jump destination and the opcode +** itself by 2 spaces. +** +** * For each "Goto", if the jump destination is earlier in the program +** and ends on one of: +** Yield SeekGt SeekLt RowSetRead Rewind +** or if the P1 parameter is one instead of zero, +** then indent all opcodes between the earlier instruction +** and "Goto" by 2 spaces. +*/ +static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){ + const char *zSql; /* The text of the SQL statement */ + const char *z; /* Used to check if this is an EXPLAIN */ + int *abYield = 0; /* True if op is an OP_Yield */ + int nAlloc = 0; /* Allocated size of p->aiIndent[], abYield */ + int iOp; /* Index of operation in p->aiIndent[] */ + + const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", + "NextIfOpen", "PrevIfOpen", 0 }; + const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead", + "Rewind", 0 }; + const char *azGoto[] = { "Goto", 0 }; + + /* Try to figure out if this is really an EXPLAIN statement. If this + ** cannot be verified, return early. */ + zSql = sqlite3_sql(pSql); + if( zSql==0 ) return; + for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++); + if( sqlite3_strnicmp(z, "explain", 7) ) return; + + for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){ + int i; + int iAddr = sqlite3_column_int(pSql, 0); + const char *zOp = (const char*)sqlite3_column_text(pSql, 1); + + /* Set p2 to the P2 field of the current opcode. Then, assuming that + ** p2 is an instruction address, set variable p2op to the index of that + ** instruction in the aiIndent[] array. p2 and p2op may be different if + ** the current instruction is part of a sub-program generated by an + ** SQL trigger or foreign key. */ + int p2 = sqlite3_column_int(pSql, 3); + int p2op = (p2 + (iOp-iAddr)); + + /* Grow the p->aiIndent array as required */ + if( iOp>=nAlloc ){ + nAlloc += 100; + p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int)); + abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int)); + } + abYield[iOp] = str_in_array(zOp, azYield); + p->aiIndent[iOp] = 0; + p->nIndent = iOp+1; + + if( str_in_array(zOp, azNext) ){ + for(i=p2op; iaiIndent[i] += 2; + } + if( str_in_array(zOp, azGoto) && p2opnIndent + && (abYield[p2op] || sqlite3_column_int(pSql, 2)) + ){ + for(i=p2op+1; iaiIndent[i] += 2; + } + } + + p->iIndent = 0; + sqlite3_free(abYield); + sqlite3_reset(pSql); +} + +/* +** Free the array allocated by explain_data_prepare(). +*/ +static void explain_data_delete(ShellState *p){ + sqlite3_free(p->aiIndent); + p->aiIndent = 0; + p->nIndent = 0; + p->iIndent = 0; +} + +/* +** Execute a statement or set of statements. Print +** any result rows/columns depending on the current mode +** set via the supplied callback. +** +** This is very similar to SQLite's built-in sqlite3_exec() +** function except it takes a slightly different callback +** and callback data argument. +*/ +static int shell_exec( + sqlite3 *db, /* An open database */ + const char *zSql, /* SQL to be evaluated */ + int (*xCallback)(void*,int,char**,char**,int*), /* Callback function */ + /* (not the same as sqlite3_exec) */ + ShellState *pArg, /* Pointer to ShellState */ + char **pzErrMsg /* Error msg written here */ +){ + sqlite3_stmt *pStmt = NULL; /* Statement to execute. */ + int rc = SQLITE_OK; /* Return Code */ + int rc2; + const char *zLeftover; /* Tail of unprocessed SQL */ + + if( pzErrMsg ){ + *pzErrMsg = NULL; + } + + while( zSql[0] && (SQLITE_OK == rc) ){ + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover); + if( SQLITE_OK != rc ){ + if( pzErrMsg ){ + *pzErrMsg = save_err_msg(db); + } + }else{ + if( !pStmt ){ + /* this happens for a comment or white-space */ + zSql = zLeftover; + while( IsSpace(zSql[0]) ) zSql++; + continue; + } + + /* save off the prepared statment handle and reset row count */ + if( pArg ){ + pArg->pStmt = pStmt; + pArg->cnt = 0; + } + + /* echo the sql statement if echo on */ + if( pArg && pArg->echoOn ){ + const char *zStmtSql = sqlite3_sql(pStmt); + fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql); + } + + /* Show the EXPLAIN QUERY PLAN if .eqp is on */ + if( pArg && pArg->autoEQP ){ + sqlite3_stmt *pExplain; + char *zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", + sqlite3_sql(pStmt)); + rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0); + if( rc==SQLITE_OK ){ + while( sqlite3_step(pExplain)==SQLITE_ROW ){ + fprintf(pArg->out,"--EQP-- %d,", sqlite3_column_int(pExplain, 0)); + fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1)); + fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2)); + fprintf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3)); + } + } + sqlite3_finalize(pExplain); + sqlite3_free(zEQP); + } + + /* If the shell is currently in ".explain" mode, gather the extra + ** data required to add indents to the output.*/ + if( pArg && pArg->mode==MODE_Explain ){ + explain_data_prepare(pArg, pStmt); + } + + /* perform the first step. this will tell us if we + ** have a result set or not and how wide it is. + */ + rc = sqlite3_step(pStmt); + /* if we have a result set... */ + if( SQLITE_ROW == rc ){ + /* if we have a callback... */ + if( xCallback ){ + /* allocate space for col name ptr, value ptr, and type */ + int nCol = sqlite3_column_count(pStmt); + void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1); + if( !pData ){ + rc = SQLITE_NOMEM; + }else{ + char **azCols = (char **)pData; /* Names of result columns */ + char **azVals = &azCols[nCol]; /* Results */ + int *aiTypes = (int *)&azVals[nCol]; /* Result types */ + int i, x; + assert(sizeof(int) <= sizeof(char *)); + /* save off ptrs to column names */ + for(i=0; imode==MODE_Insert ){ + azVals[i] = ""; + }else{ + azVals[i] = (char*)sqlite3_column_text(pStmt, i); + } + if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){ + rc = SQLITE_NOMEM; + break; /* from for */ + } + } /* end for */ + + /* if data and types extracted successfully... */ + if( SQLITE_ROW == rc ){ + /* call the supplied callback with the result row data */ + if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){ + rc = SQLITE_ABORT; + }else{ + rc = sqlite3_step(pStmt); + } + } + } while( SQLITE_ROW == rc ); + sqlite3_free(pData); + } + }else{ + do{ + rc = sqlite3_step(pStmt); + } while( rc == SQLITE_ROW ); + } + } + + explain_data_delete(pArg); + + /* print usage stats if stats on */ + if( pArg && pArg->statsOn ){ + display_stats(db, pArg, 0); + } + + /* print loop-counters if required */ + if( pArg && pArg->scanstatsOn ){ + display_scanstats(db, pArg); + } + + /* Finalize the statement just executed. If this fails, save a + ** copy of the error message. Otherwise, set zSql to point to the + ** next statement to execute. */ + rc2 = sqlite3_finalize(pStmt); + if( rc!=SQLITE_NOMEM ) rc = rc2; + if( rc==SQLITE_OK ){ + zSql = zLeftover; + while( IsSpace(zSql[0]) ) zSql++; + }else if( pzErrMsg ){ + *pzErrMsg = save_err_msg(db); + } + + /* clear saved stmt handle */ + if( pArg ){ + pArg->pStmt = NULL; + } + } + } /* end while */ + + return rc; +} + + +/* +** This is a different callback routine used for dumping the database. +** Each row received by this callback consists of a table name, +** the table type ("index" or "table") and SQL to create the table. +** This routine should print text sufficient to recreate the table. +*/ +static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){ + int rc; + const char *zTable; + const char *zType; + const char *zSql; + const char *zPrepStmt = 0; + ShellState *p = (ShellState *)pArg; + + UNUSED_PARAMETER(azCol); + if( nArg!=3 ) return 1; + zTable = azArg[0]; + zType = azArg[1]; + zSql = azArg[2]; + + if( strcmp(zTable, "sqlite_sequence")==0 ){ + zPrepStmt = "DELETE FROM sqlite_sequence;\n"; + }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){ + fprintf(p->out, "ANALYZE sqlite_master;\n"); + }else if( strncmp(zTable, "sqlite_", 7)==0 ){ + return 0; + }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){ + char *zIns; + if( !p->writableSchema ){ + fprintf(p->out, "PRAGMA writable_schema=ON;\n"); + p->writableSchema = 1; + } + zIns = sqlite3_mprintf( + "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)" + "VALUES('table','%q','%q',0,'%q');", + zTable, zTable, zSql); + fprintf(p->out, "%s\n", zIns); + sqlite3_free(zIns); + return 0; + }else{ + fprintf(p->out, "%s;\n", zSql); + } + + if( strcmp(zType, "table")==0 ){ + sqlite3_stmt *pTableInfo = 0; + char *zSelect = 0; + char *zTableInfo = 0; + char *zTmp = 0; + int nRow = 0; + + zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0); + zTableInfo = appendText(zTableInfo, zTable, '"'); + zTableInfo = appendText(zTableInfo, ");", 0); + + rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0); + free(zTableInfo); + if( rc!=SQLITE_OK || !pTableInfo ){ + return 1; + } + + zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0); + /* Always quote the table name, even if it appears to be pure ascii, + ** in case it is a keyword. Ex: INSERT INTO "table" ... */ + zTmp = appendText(zTmp, zTable, '"'); + if( zTmp ){ + zSelect = appendText(zSelect, zTmp, '\''); + free(zTmp); + } + zSelect = appendText(zSelect, " || ' VALUES(' || ", 0); + rc = sqlite3_step(pTableInfo); + while( rc==SQLITE_ROW ){ + const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1); + zSelect = appendText(zSelect, "quote(", 0); + zSelect = appendText(zSelect, zText, '"'); + rc = sqlite3_step(pTableInfo); + if( rc==SQLITE_ROW ){ + zSelect = appendText(zSelect, "), ", 0); + }else{ + zSelect = appendText(zSelect, ") ", 0); + } + nRow++; + } + rc = sqlite3_finalize(pTableInfo); + if( rc!=SQLITE_OK || nRow==0 ){ + free(zSelect); + return 1; + } + zSelect = appendText(zSelect, "|| ')' FROM ", 0); + zSelect = appendText(zSelect, zTable, '"'); + + rc = run_table_dump_query(p, zSelect, zPrepStmt); + if( rc==SQLITE_CORRUPT ){ + zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0); + run_table_dump_query(p, zSelect, 0); + } + free(zSelect); + } + return 0; +} + +/* +** Run zQuery. Use dump_callback() as the callback routine so that +** the contents of the query are output as SQL statements. +** +** If we get a SQLITE_CORRUPT error, rerun the query after appending +** "ORDER BY rowid DESC" to the end. +*/ +static int run_schema_dump_query( + ShellState *p, + const char *zQuery +){ + int rc; + char *zErr = 0; + rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr); + if( rc==SQLITE_CORRUPT ){ + char *zQ2; + int len = strlen30(zQuery); + fprintf(p->out, "/****** CORRUPTION ERROR *******/\n"); + if( zErr ){ + fprintf(p->out, "/****** %s ******/\n", zErr); + sqlite3_free(zErr); + zErr = 0; + } + zQ2 = malloc( len+100 ); + if( zQ2==0 ) return rc; + sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery); + rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr); + if( rc ){ + fprintf(p->out, "/****** ERROR: %s ******/\n", zErr); + }else{ + rc = SQLITE_CORRUPT; + } + sqlite3_free(zErr); + free(zQ2); + } + return rc; +} + +/* +** Text of a help message +*/ +static char zHelp[] = + ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n" + ".bail on|off Stop after hitting an error. Default OFF\n" + ".binary on|off Turn binary output on or off. Default OFF\n" + ".clone NEWDB Clone data into NEWDB from the existing database\n" + ".databases List names and files of attached databases\n" + ".dbinfo ?DB? Show status information about the database\n" + ".dump ?TABLE? ... Dump the database in an SQL text format\n" + " If TABLE specified, only dump tables matching\n" + " LIKE pattern TABLE.\n" + ".echo on|off Turn command echo on or off\n" + ".eqp on|off Enable or disable automatic EXPLAIN QUERY PLAN\n" + ".exit Exit this program\n" + ".explain ?on|off? Turn output mode suitable for EXPLAIN on or off.\n" + " With no args, it turns EXPLAIN on.\n" + ".fullschema Show schema and the content of sqlite_stat tables\n" + ".headers on|off Turn display of headers on or off\n" + ".help Show this message\n" + ".import FILE TABLE Import data from FILE into TABLE\n" + ".indexes ?TABLE? Show names of all indexes\n" + " If TABLE specified, only show indexes for tables\n" + " matching LIKE pattern TABLE.\n" +#ifdef SQLITE_ENABLE_IOTRACE + ".iotrace FILE Enable I/O diagnostic logging to FILE\n" +#endif + ".limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT\n" +#ifndef SQLITE_OMIT_LOAD_EXTENSION + ".load FILE ?ENTRY? Load an extension library\n" +#endif + ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n" + ".mode MODE ?TABLE? Set output mode where MODE is one of:\n" + " ascii Columns/rows delimited by 0x1F and 0x1E\n" + " csv Comma-separated values\n" + " column Left-aligned columns. (See .width)\n" + " html HTML code\n" + " insert SQL insert statements for TABLE\n" + " line One value per line\n" + " list Values delimited by .separator strings\n" + " tabs Tab-separated values\n" + " tcl TCL list elements\n" + ".nullvalue STRING Use STRING in place of NULL values\n" + ".once FILENAME Output for the next SQL command only to FILENAME\n" + ".open ?FILENAME? Close existing database and reopen FILENAME\n" + ".output ?FILENAME? Send output to FILENAME or stdout\n" + ".print STRING... Print literal STRING\n" + ".prompt MAIN CONTINUE Replace the standard prompts\n" + ".quit Exit this program\n" + ".read FILENAME Execute SQL in FILENAME\n" + ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n" + ".save FILE Write in-memory database into FILE\n" + ".scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off\n" + ".schema ?TABLE? Show the CREATE statements\n" + " If TABLE specified, only show tables matching\n" + " LIKE pattern TABLE.\n" + ".separator COL ?ROW? Change the column separator and optionally the row\n" + " separator for both the output mode and .import\n" + ".shell CMD ARGS... Run CMD ARGS... in a system shell\n" + ".show Show the current values for various settings\n" + ".stats on|off Turn stats on or off\n" + ".system CMD ARGS... Run CMD ARGS... in a system shell\n" + ".tables ?TABLE? List names of tables\n" + " If TABLE specified, only list tables matching\n" + " LIKE pattern TABLE.\n" + ".timeout MS Try opening locked tables for MS milliseconds\n" + ".timer on|off Turn SQL timer on or off\n" + ".trace FILE|off Output each SQL statement as it is run\n" + ".vfsname ?AUX? Print the name of the VFS stack\n" + ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n" + " Negative values right-justify\n" +; + +/* Forward reference */ +static int process_input(ShellState *p, FILE *in); +/* +** Implementation of the "readfile(X)" SQL function. The entire content +** of the file named X is read and returned as a BLOB. NULL is returned +** if the file does not exist or is unreadable. +*/ +static void readfileFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zName; + FILE *in; + long nIn; + void *pBuf; + + UNUSED_PARAMETER(argc); + zName = (const char*)sqlite3_value_text(argv[0]); + if( zName==0 ) return; + in = fopen(zName, "rb"); + if( in==0 ) return; + fseek(in, 0, SEEK_END); + nIn = ftell(in); + rewind(in); + pBuf = sqlite3_malloc64( nIn ); + if( pBuf && 1==fread(pBuf, nIn, 1, in) ){ + sqlite3_result_blob(context, pBuf, nIn, sqlite3_free); + }else{ + sqlite3_free(pBuf); + } + fclose(in); +} + +/* +** Implementation of the "writefile(X,Y)" SQL function. The argument Y +** is written into file X. The number of bytes written is returned. Or +** NULL is returned if something goes wrong, such as being unable to open +** file X for writing. +*/ +static void writefileFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + FILE *out; + const char *z; + sqlite3_int64 rc; + const char *zFile; + + UNUSED_PARAMETER(argc); + zFile = (const char*)sqlite3_value_text(argv[0]); + if( zFile==0 ) return; + out = fopen(zFile, "wb"); + if( out==0 ) return; + z = (const char*)sqlite3_value_blob(argv[1]); + if( z==0 ){ + rc = 0; + }else{ + rc = fwrite(z, 1, sqlite3_value_bytes(argv[1]), out); + } + fclose(out); + sqlite3_result_int64(context, rc); +} + +/* +** Make sure the database is open. If it is not, then open it. If +** the database fails to open, print an error message and exit. +*/ +static void open_db(ShellState *p, int keepAlive){ + if( p->db==0 ){ + sqlite3_initialize(); + sqlite3_open(p->zDbFilename, &p->db); + globalDb = p->db; + if( p->db && sqlite3_errcode(p->db)==SQLITE_OK ){ + sqlite3_create_function(p->db, "shellstatic", 0, SQLITE_UTF8, 0, + shellstaticFunc, 0, 0); + } + if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){ + fprintf(stderr,"Error: unable to open database \"%s\": %s\n", + p->zDbFilename, sqlite3_errmsg(p->db)); + if( keepAlive ) return; + exit(1); + } +#ifndef SQLITE_OMIT_LOAD_EXTENSION + sqlite3_enable_load_extension(p->db, 1); +#endif + sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0, + readfileFunc, 0, 0); + sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0, + writefileFunc, 0, 0); + } +} + +/* +** Do C-language style dequoting. +** +** \a -> alarm +** \b -> backspace +** \t -> tab +** \n -> newline +** \v -> vertical tab +** \f -> form feed +** \r -> carriage return +** \s -> space +** \" -> " +** \' -> ' +** \\ -> backslash +** \NNN -> ascii character NNN in octal +*/ +static void resolve_backslashes(char *z){ + int i, j; + char c; + while( *z && *z!='\\' ) z++; + for(i=j=0; (c = z[i])!=0; i++, j++){ + if( c=='\\' && z[i+1]!=0 ){ + c = z[++i]; + if( c=='a' ){ + c = '\a'; + }else if( c=='b' ){ + c = '\b'; + }else if( c=='t' ){ + c = '\t'; + }else if( c=='n' ){ + c = '\n'; + }else if( c=='v' ){ + c = '\v'; + }else if( c=='f' ){ + c = '\f'; + }else if( c=='r' ){ + c = '\r'; + }else if( c=='"' ){ + c = '"'; + }else if( c=='\'' ){ + c = '\''; + }else if( c=='\\' ){ + c = '\\'; + }else if( c>='0' && c<='7' ){ + c -= '0'; + if( z[i+1]>='0' && z[i+1]<='7' ){ + i++; + c = (c<<3) + z[i] - '0'; + if( z[i+1]>='0' && z[i+1]<='7' ){ + i++; + c = (c<<3) + z[i] - '0'; + } + } + } + } + z[j] = c; + } + if( j='0' && c<='9' ) return c - '0'; + if( c>='a' && c<='f' ) return c - 'a' + 10; + if( c>='A' && c<='F' ) return c - 'A' + 10; + return -1; +} + +/* +** Interpret zArg as an integer value, possibly with suffixes. +*/ +static sqlite3_int64 integerValue(const char *zArg){ + sqlite3_int64 v = 0; + static const struct { char *zSuffix; int iMult; } aMult[] = { + { "KiB", 1024 }, + { "MiB", 1024*1024 }, + { "GiB", 1024*1024*1024 }, + { "KB", 1000 }, + { "MB", 1000000 }, + { "GB", 1000000000 }, + { "K", 1000 }, + { "M", 1000000 }, + { "G", 1000000000 }, + }; + int i; + int isNeg = 0; + if( zArg[0]=='-' ){ + isNeg = 1; + zArg++; + }else if( zArg[0]=='+' ){ + zArg++; + } + if( zArg[0]=='0' && zArg[1]=='x' ){ + int x; + zArg += 2; + while( (x = hexDigitValue(zArg[0]))>=0 ){ + v = (v<<4) + x; + zArg++; + } + }else{ + while( IsDigit(zArg[0]) ){ + v = v*10 + zArg[0] - '0'; + zArg++; + } + } + for(i=0; i=0; i++){} + }else{ + for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){} + } + if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff); + if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){ + return 1; + } + if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){ + return 0; + } + fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n", + zArg); + return 0; +} + +/* +** Close an output file, assuming it is not stderr or stdout +*/ +static void output_file_close(FILE *f){ + if( f && f!=stdout && f!=stderr ) fclose(f); +} + +/* +** Try to open an output file. The names "stdout" and "stderr" are +** recognized and do the right thing. NULL is returned if the output +** filename is "off". +*/ +static FILE *output_file_open(const char *zFile){ + FILE *f; + if( strcmp(zFile,"stdout")==0 ){ + f = stdout; + }else if( strcmp(zFile, "stderr")==0 ){ + f = stderr; + }else if( strcmp(zFile, "off")==0 ){ + f = 0; + }else{ + f = fopen(zFile, "wb"); + if( f==0 ){ + fprintf(stderr, "Error: cannot open \"%s\"\n", zFile); + } + } + return f; +} + +/* +** A routine for handling output from sqlite3_trace(). +*/ +static void sql_trace_callback(void *pArg, const char *z){ + FILE *f = (FILE*)pArg; + if( f ){ + int i = (int)strlen(z); + while( i>0 && z[i-1]==';' ){ i--; } + fprintf(f, "%.*s;\n", i, z); + } +} + +/* +** A no-op routine that runs with the ".breakpoint" doc-command. This is +** a useful spot to set a debugger breakpoint. +*/ +static void test_breakpoint(void){ + static int nCall = 0; + nCall++; +} + +/* +** An object used to read a CSV and other files for import. +*/ +typedef struct ImportCtx ImportCtx; +struct ImportCtx { + const char *zFile; /* Name of the input file */ + FILE *in; /* Read the CSV text from this input stream */ + char *z; /* Accumulated text for a field */ + int n; /* Number of bytes in z */ + int nAlloc; /* Space allocated for z[] */ + int nLine; /* Current line number */ + int cTerm; /* Character that terminated the most recent field */ + int cColSep; /* The column separator character. (Usually ",") */ + int cRowSep; /* The row separator character. (Usually "\n") */ +}; + +/* Append a single byte to z[] */ +static void import_append_char(ImportCtx *p, int c){ + if( p->n+1>=p->nAlloc ){ + p->nAlloc += p->nAlloc + 100; + p->z = sqlite3_realloc64(p->z, p->nAlloc); + if( p->z==0 ){ + fprintf(stderr, "out of memory\n"); + exit(1); + } + } + p->z[p->n++] = (char)c; +} + +/* Read a single field of CSV text. Compatible with rfc4180 and extended +** with the option of having a separator other than ",". +** +** + Input comes from p->in. +** + Store results in p->z of length p->n. Space to hold p->z comes +** from sqlite3_malloc64(). +** + Use p->cSep as the column separator. The default is ",". +** + Use p->rSep as the row separator. The default is "\n". +** + Keep track of the line number in p->nLine. +** + Store the character that terminates the field in p->cTerm. Store +** EOF on end-of-file. +** + Report syntax errors on stderr +*/ +static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){ + int c; + int cSep = p->cColSep; + int rSep = p->cRowSep; + p->n = 0; + c = fgetc(p->in); + if( c==EOF || seenInterrupt ){ + p->cTerm = EOF; + return 0; + } + if( c=='"' ){ + int pc, ppc; + int startLine = p->nLine; + int cQuote = c; + pc = ppc = 0; + while( 1 ){ + c = fgetc(p->in); + if( c==rSep ) p->nLine++; + if( c==cQuote ){ + if( pc==cQuote ){ + pc = 0; + continue; + } + } + if( (c==cSep && pc==cQuote) + || (c==rSep && pc==cQuote) + || (c==rSep && pc=='\r' && ppc==cQuote) + || (c==EOF && pc==cQuote) + ){ + do{ p->n--; }while( p->z[p->n]!=cQuote ); + p->cTerm = c; + break; + } + if( pc==cQuote && c!='\r' ){ + fprintf(stderr, "%s:%d: unescaped %c character\n", + p->zFile, p->nLine, cQuote); + } + if( c==EOF ){ + fprintf(stderr, "%s:%d: unterminated %c-quoted field\n", + p->zFile, startLine, cQuote); + p->cTerm = c; + break; + } + import_append_char(p, c); + ppc = pc; + pc = c; + } + }else{ + while( c!=EOF && c!=cSep && c!=rSep ){ + import_append_char(p, c); + c = fgetc(p->in); + } + if( c==rSep ){ + p->nLine++; + if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--; + } + p->cTerm = c; + } + if( p->z ) p->z[p->n] = 0; + return p->z; +} + +/* Read a single field of ASCII delimited text. +** +** + Input comes from p->in. +** + Store results in p->z of length p->n. Space to hold p->z comes +** from sqlite3_malloc64(). +** + Use p->cSep as the column separator. The default is "\x1F". +** + Use p->rSep as the row separator. The default is "\x1E". +** + Keep track of the row number in p->nLine. +** + Store the character that terminates the field in p->cTerm. Store +** EOF on end-of-file. +** + Report syntax errors on stderr +*/ +static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){ + int c; + int cSep = p->cColSep; + int rSep = p->cRowSep; + p->n = 0; + c = fgetc(p->in); + if( c==EOF || seenInterrupt ){ + p->cTerm = EOF; + return 0; + } + while( c!=EOF && c!=cSep && c!=rSep ){ + import_append_char(p, c); + c = fgetc(p->in); + } + if( c==rSep ){ + p->nLine++; + } + p->cTerm = c; + if( p->z ) p->z[p->n] = 0; + return p->z; +} + +/* +** Try to transfer data for table zTable. If an error is seen while +** moving forward, try to go backwards. The backwards movement won't +** work for WITHOUT ROWID tables. +*/ +static void tryToCloneData( + ShellState *p, + sqlite3 *newDb, + const char *zTable +){ + sqlite3_stmt *pQuery = 0; + sqlite3_stmt *pInsert = 0; + char *zQuery = 0; + char *zInsert = 0; + int rc; + int i, j, n; + int nTable = (int)strlen(zTable); + int k = 0; + int cnt = 0; + const int spinRate = 10000; + + zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable); + rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); + if( rc ){ + fprintf(stderr, "Error %d: %s on [%s]\n", + sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), + zQuery); + goto end_data_xfer; + } + n = sqlite3_column_count(pQuery); + zInsert = sqlite3_malloc64(200 + nTable + n*3); + if( zInsert==0 ){ + fprintf(stderr, "out of memory\n"); + goto end_data_xfer; + } + sqlite3_snprintf(200+nTable,zInsert, + "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable); + i = (int)strlen(zInsert); + for(j=1; jdb, zQuery, -1, &pQuery, 0); + if( rc ){ + fprintf(stderr, "Warning: cannot step \"%s\" backwards", zTable); + break; + } + } /* End for(k=0...) */ + +end_data_xfer: + sqlite3_finalize(pQuery); + sqlite3_finalize(pInsert); + sqlite3_free(zQuery); + sqlite3_free(zInsert); +} + + +/* +** Try to transfer all rows of the schema that match zWhere. For +** each row, invoke xForEach() on the object defined by that row. +** If an error is encountered while moving forward through the +** sqlite_master table, try again moving backwards. +*/ +static void tryToCloneSchema( + ShellState *p, + sqlite3 *newDb, + const char *zWhere, + void (*xForEach)(ShellState*,sqlite3*,const char*) +){ + sqlite3_stmt *pQuery = 0; + char *zQuery = 0; + int rc; + const unsigned char *zName; + const unsigned char *zSql; + char *zErrMsg = 0; + + zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master" + " WHERE %s", zWhere); + rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); + if( rc ){ + fprintf(stderr, "Error: (%d) %s on [%s]\n", + sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), + zQuery); + goto end_schema_xfer; + } + while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ + zName = sqlite3_column_text(pQuery, 0); + zSql = sqlite3_column_text(pQuery, 1); + printf("%s... ", zName); fflush(stdout); + sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); + if( zErrMsg ){ + fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); + sqlite3_free(zErrMsg); + zErrMsg = 0; + } + if( xForEach ){ + xForEach(p, newDb, (const char*)zName); + } + printf("done\n"); + } + if( rc!=SQLITE_DONE ){ + sqlite3_finalize(pQuery); + sqlite3_free(zQuery); + zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master" + " WHERE %s ORDER BY rowid DESC", zWhere); + rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0); + if( rc ){ + fprintf(stderr, "Error: (%d) %s on [%s]\n", + sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db), + zQuery); + goto end_schema_xfer; + } + while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){ + zName = sqlite3_column_text(pQuery, 0); + zSql = sqlite3_column_text(pQuery, 1); + printf("%s... ", zName); fflush(stdout); + sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg); + if( zErrMsg ){ + fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql); + sqlite3_free(zErrMsg); + zErrMsg = 0; + } + if( xForEach ){ + xForEach(p, newDb, (const char*)zName); + } + printf("done\n"); + } + } +end_schema_xfer: + sqlite3_finalize(pQuery); + sqlite3_free(zQuery); +} + +/* +** Open a new database file named "zNewDb". Try to recover as much information +** as possible out of the main database (which might be corrupt) and write it +** into zNewDb. +*/ +static void tryToClone(ShellState *p, const char *zNewDb){ + int rc; + sqlite3 *newDb = 0; + if( access(zNewDb,0)==0 ){ + fprintf(stderr, "File \"%s\" already exists.\n", zNewDb); + return; + } + rc = sqlite3_open(zNewDb, &newDb); + if( rc ){ + fprintf(stderr, "Cannot create output database: %s\n", + sqlite3_errmsg(newDb)); + }else{ + sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0); + sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0); + tryToCloneSchema(p, newDb, "type='table'", tryToCloneData); + tryToCloneSchema(p, newDb, "type!='table'", 0); + sqlite3_exec(newDb, "COMMIT;", 0, 0, 0); + sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); + } + sqlite3_close(newDb); +} + +/* +** Change the output file back to stdout +*/ +static void output_reset(ShellState *p){ + if( p->outfile[0]=='|' ){ +#ifndef SQLITE_OMIT_POPEN + pclose(p->out); +#endif + }else{ + output_file_close(p->out); + } + p->outfile[0] = 0; + p->out = stdout; +} + +/* +** Run an SQL command and return the single integer result. +*/ +static int db_int(ShellState *p, const char *zSql){ + sqlite3_stmt *pStmt; + int res = 0; + sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){ + res = sqlite3_column_int(pStmt,0); + } + sqlite3_finalize(pStmt); + return res; +} + +/* +** Convert a 2-byte or 4-byte big-endian integer into a native integer +*/ +unsigned int get2byteInt(unsigned char *a){ + return (a[0]<<8) + a[1]; +} +unsigned int get4byteInt(unsigned char *a){ + return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3]; +} + +/* +** Implementation of the ".info" command. +** +** Return 1 on error, 2 to exit, and 0 otherwise. +*/ +static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){ + static const struct { const char *zName; int ofst; } aField[] = { + { "file change counter:", 24 }, + { "database page count:", 28 }, + { "freelist page count:", 36 }, + { "schema cookie:", 40 }, + { "schema format:", 44 }, + { "default cache size:", 48 }, + { "autovacuum top root:", 52 }, + { "incremental vacuum:", 64 }, + { "text encoding:", 56 }, + { "user version:", 60 }, + { "application id:", 68 }, + { "software version:", 96 }, + }; + static const struct { const char *zName; const char *zSql; } aQuery[] = { + { "number of tables:", + "SELECT count(*) FROM %s WHERE type='table'" }, + { "number of indexes:", + "SELECT count(*) FROM %s WHERE type='index'" }, + { "number of triggers:", + "SELECT count(*) FROM %s WHERE type='trigger'" }, + { "number of views:", + "SELECT count(*) FROM %s WHERE type='view'" }, + { "schema size:", + "SELECT total(length(sql)) FROM %s" }, + }; + sqlite3_file *pFile; + int i; + char *zSchemaTab; + char *zDb = nArg>=2 ? azArg[1] : "main"; + unsigned char aHdr[100]; + open_db(p, 0); + if( p->db==0 ) return 1; + sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_FILE_POINTER, &pFile); + if( pFile==0 || pFile->pMethods==0 || pFile->pMethods->xRead==0 ){ + return 1; + } + i = pFile->pMethods->xRead(pFile, aHdr, 100, 0); + if( i!=SQLITE_OK ){ + fprintf(stderr, "unable to read database header\n"); + return 1; + } + i = get2byteInt(aHdr+16); + if( i==1 ) i = 65536; + fprintf(p->out, "%-20s %d\n", "database page size:", i); + fprintf(p->out, "%-20s %d\n", "write format:", aHdr[18]); + fprintf(p->out, "%-20s %d\n", "read format:", aHdr[19]); + fprintf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]); + for(i=0; iout, "%-20s %u", aField[i].zName, val); + switch( ofst ){ + case 56: { + if( val==1 ) fprintf(p->out, " (utf8)"); + if( val==2 ) fprintf(p->out, " (utf16le)"); + if( val==3 ) fprintf(p->out, " (utf16be)"); + } + } + fprintf(p->out, "\n"); + } + if( zDb==0 ){ + zSchemaTab = sqlite3_mprintf("main.sqlite_master"); + }else if( strcmp(zDb,"temp")==0 ){ + zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master"); + }else{ + zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb); + } + for(i=0; iout, "%-20s %d\n", aQuery[i].zName, val); + } + sqlite3_free(zSchemaTab); + return 0; +} + +/* +** Print the current sqlite3_errmsg() value to stderr and return 1. +*/ +static int shellDatabaseError(sqlite3 *db){ + const char *zErr = sqlite3_errmsg(db); + fprintf(stderr, "Error: %s\n", zErr); + return 1; +} + +/* +** Print an out-of-memory message to stderr and return 1. +*/ +static int shellNomemError(void){ + fprintf(stderr, "Error: out of memory\n"); + return 1; +} + +/* +** If an input line begins with "." then invoke this routine to +** process that line. +** +** Return 1 on error, 2 to exit, and 0 otherwise. +*/ +static int do_meta_command(char *zLine, ShellState *p){ + int h = 1; + int nArg = 0; + int n, c; + int rc = 0; + char *azArg[50]; + + /* Parse the input line into tokens. + */ + while( zLine[h] && nArg=3 && strncmp(azArg[0], "backup", n)==0) + || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0) + ){ + const char *zDestFile = 0; + const char *zDb = 0; + sqlite3 *pDest; + sqlite3_backup *pBackup; + int j; + for(j=1; jdb, zDb); + if( pBackup==0 ){ + fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); + sqlite3_close(pDest); + return 1; + } + while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){} + sqlite3_backup_finish(pBackup); + if( rc==SQLITE_DONE ){ + rc = 0; + }else{ + fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); + rc = 1; + } + sqlite3_close(pDest); + }else + + if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){ + if( nArg==2 ){ + bail_on_error = booleanValue(azArg[1]); + }else{ + fprintf(stderr, "Usage: .bail on|off\n"); + rc = 1; + } + }else + + if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){ + if( nArg==2 ){ + if( booleanValue(azArg[1]) ){ + setBinaryMode(p->out); + }else{ + setTextMode(p->out); + } + }else{ + fprintf(stderr, "Usage: .binary on|off\n"); + rc = 1; + } + }else + + /* The undocumented ".breakpoint" command causes a call to the no-op + ** routine named test_breakpoint(). + */ + if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){ + test_breakpoint(); + }else + + if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){ + if( nArg==2 ){ + tryToClone(p, azArg[1]); + }else{ + fprintf(stderr, "Usage: .clone FILENAME\n"); + rc = 1; + } + }else + + if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){ + ShellState data; + char *zErrMsg = 0; + open_db(p, 0); + memcpy(&data, p, sizeof(data)); + data.showHeader = 1; + data.mode = MODE_Column; + data.colWidth[0] = 3; + data.colWidth[1] = 15; + data.colWidth[2] = 58; + data.cnt = 0; + sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg); + if( zErrMsg ){ + fprintf(stderr,"Error: %s\n", zErrMsg); + sqlite3_free(zErrMsg); + rc = 1; + } + }else + + if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){ + rc = shell_dbinfo_command(p, nArg, azArg); + }else + + if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){ + open_db(p, 0); + /* When playing back a "dump", the content might appear in an order + ** which causes immediate foreign key constraints to be violated. + ** So disable foreign-key constraint enforcement to prevent problems. */ + if( nArg!=1 && nArg!=2 ){ + fprintf(stderr, "Usage: .dump ?LIKE-PATTERN?\n"); + rc = 1; + goto meta_command_exit; + } + fprintf(p->out, "PRAGMA foreign_keys=OFF;\n"); + fprintf(p->out, "BEGIN TRANSACTION;\n"); + p->writableSchema = 0; + sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0); + p->nErr = 0; + if( nArg==1 ){ + run_schema_dump_query(p, + "SELECT name, type, sql FROM sqlite_master " + "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'" + ); + run_schema_dump_query(p, + "SELECT name, type, sql FROM sqlite_master " + "WHERE name=='sqlite_sequence'" + ); + run_table_dump_query(p, + "SELECT sql FROM sqlite_master " + "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0 + ); + }else{ + int i; + for(i=1; iwritableSchema ){ + fprintf(p->out, "PRAGMA writable_schema=OFF;\n"); + p->writableSchema = 0; + } + sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0); + sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0); + fprintf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n"); + }else + + if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){ + if( nArg==2 ){ + p->echoOn = booleanValue(azArg[1]); + }else{ + fprintf(stderr, "Usage: .echo on|off\n"); + rc = 1; + } + }else + + if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){ + if( nArg==2 ){ + p->autoEQP = booleanValue(azArg[1]); + }else{ + fprintf(stderr, "Usage: .eqp on|off\n"); + rc = 1; + } + }else + + if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){ + if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc); + rc = 2; + }else + + if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){ + int val = nArg>=2 ? booleanValue(azArg[1]) : 1; + if(val == 1) { + if(!p->normalMode.valid) { + p->normalMode.valid = 1; + p->normalMode.mode = p->mode; + p->normalMode.showHeader = p->showHeader; + memcpy(p->normalMode.colWidth,p->colWidth,sizeof(p->colWidth)); + } + /* We could put this code under the !p->explainValid + ** condition so that it does not execute if we are already in + ** explain mode. However, always executing it allows us an easy + ** was to reset to explain mode in case the user previously + ** did an .explain followed by a .width, .mode or .header + ** command. + */ + p->mode = MODE_Explain; + p->showHeader = 1; + memset(p->colWidth,0,sizeof(p->colWidth)); + p->colWidth[0] = 4; /* addr */ + p->colWidth[1] = 13; /* opcode */ + p->colWidth[2] = 4; /* P1 */ + p->colWidth[3] = 4; /* P2 */ + p->colWidth[4] = 4; /* P3 */ + p->colWidth[5] = 13; /* P4 */ + p->colWidth[6] = 2; /* P5 */ + p->colWidth[7] = 13; /* Comment */ + }else if (p->normalMode.valid) { + p->normalMode.valid = 0; + p->mode = p->normalMode.mode; + p->showHeader = p->normalMode.showHeader; + memcpy(p->colWidth,p->normalMode.colWidth,sizeof(p->colWidth)); + } + }else + + if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){ + ShellState data; + char *zErrMsg = 0; + int doStats = 0; + if( nArg!=1 ){ + fprintf(stderr, "Usage: .fullschema\n"); + rc = 1; + goto meta_command_exit; + } + open_db(p, 0); + memcpy(&data, p, sizeof(data)); + data.showHeader = 0; + data.mode = MODE_Semi; + rc = sqlite3_exec(p->db, + "SELECT sql FROM" + " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x" + " FROM sqlite_master UNION ALL" + " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) " + "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' " + "ORDER BY rowid", + callback, &data, &zErrMsg + ); + if( rc==SQLITE_OK ){ + sqlite3_stmt *pStmt; + rc = sqlite3_prepare_v2(p->db, + "SELECT rowid FROM sqlite_master" + " WHERE name GLOB 'sqlite_stat[134]'", + -1, &pStmt, 0); + doStats = sqlite3_step(pStmt)==SQLITE_ROW; + sqlite3_finalize(pStmt); + } + if( doStats==0 ){ + fprintf(p->out, "/* No STAT tables available */\n"); + }else{ + fprintf(p->out, "ANALYZE sqlite_master;\n"); + sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'", + callback, &data, &zErrMsg); + data.mode = MODE_Insert; + data.zDestTable = "sqlite_stat1"; + shell_exec(p->db, "SELECT * FROM sqlite_stat1", + shell_callback, &data,&zErrMsg); + data.zDestTable = "sqlite_stat3"; + shell_exec(p->db, "SELECT * FROM sqlite_stat3", + shell_callback, &data,&zErrMsg); + data.zDestTable = "sqlite_stat4"; + shell_exec(p->db, "SELECT * FROM sqlite_stat4", + shell_callback, &data, &zErrMsg); + fprintf(p->out, "ANALYZE sqlite_master;\n"); + } + }else + + if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){ + if( nArg==2 ){ + p->showHeader = booleanValue(azArg[1]); + }else{ + fprintf(stderr, "Usage: .headers on|off\n"); + rc = 1; + } + }else + + if( c=='h' && strncmp(azArg[0], "help", n)==0 ){ + fprintf(p->out, "%s", zHelp); + }else + + if( c=='i' && strncmp(azArg[0], "import", n)==0 ){ + char *zTable; /* Insert data into this table */ + char *zFile; /* Name of file to extra content from */ + sqlite3_stmt *pStmt = NULL; /* A statement */ + int nCol; /* Number of columns in the table */ + int nByte; /* Number of bytes in an SQL string */ + int i, j; /* Loop counters */ + int needCommit; /* True to COMMIT or ROLLBACK at end */ + int nSep; /* Number of bytes in p->colSeparator[] */ + char *zSql; /* An SQL statement */ + ImportCtx sCtx; /* Reader context */ + char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */ + int (SQLITE_CDECL *xCloser)(FILE*); /* Func to close file */ + + if( nArg!=3 ){ + fprintf(stderr, "Usage: .import FILE TABLE\n"); + goto meta_command_exit; + } + zFile = azArg[1]; + zTable = azArg[2]; + seenInterrupt = 0; + memset(&sCtx, 0, sizeof(sCtx)); + open_db(p, 0); + nSep = strlen30(p->colSeparator); + if( nSep==0 ){ + fprintf(stderr, "Error: non-null column separator required for import\n"); + return 1; + } + if( nSep>1 ){ + fprintf(stderr, "Error: multi-character column separators not allowed" + " for import\n"); + return 1; + } + nSep = strlen30(p->rowSeparator); + if( nSep==0 ){ + fprintf(stderr, "Error: non-null row separator required for import\n"); + return 1; + } + if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){ + /* When importing CSV (only), if the row separator is set to the + ** default output row separator, change it to the default input + ** row separator. This avoids having to maintain different input + ** and output row separators. */ + sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row); + nSep = strlen30(p->rowSeparator); + } + if( nSep>1 ){ + fprintf(stderr, "Error: multi-character row separators not allowed" + " for import\n"); + return 1; + } + sCtx.zFile = zFile; + sCtx.nLine = 1; + if( sCtx.zFile[0]=='|' ){ +#ifdef SQLITE_OMIT_POPEN + fprintf(stderr, "Error: pipes are not supported in this OS\n"); + return 1; +#else + sCtx.in = popen(sCtx.zFile+1, "r"); + sCtx.zFile = ""; + xCloser = pclose; +#endif + }else{ + sCtx.in = fopen(sCtx.zFile, "rb"); + xCloser = fclose; + } + if( p->mode==MODE_Ascii ){ + xRead = ascii_read_one_field; + }else{ + xRead = csv_read_one_field; + } + if( sCtx.in==0 ){ + fprintf(stderr, "Error: cannot open \"%s\"\n", zFile); + return 1; + } + sCtx.cColSep = p->colSeparator[0]; + sCtx.cRowSep = p->rowSeparator[0]; + zSql = sqlite3_mprintf("SELECT * FROM %s", zTable); + if( zSql==0 ){ + fprintf(stderr, "Error: out of memory\n"); + xCloser(sCtx.in); + return 1; + } + nByte = strlen30(zSql); + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + import_append_char(&sCtx, 0); /* To ensure sCtx.z is allocated */ + if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){ + char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable); + char cSep = '('; + while( xRead(&sCtx) ){ + zCreate = sqlite3_mprintf("%z%c\n \"%s\" TEXT", zCreate, cSep, sCtx.z); + cSep = ','; + if( sCtx.cTerm!=sCtx.cColSep ) break; + } + if( cSep=='(' ){ + sqlite3_free(zCreate); + sqlite3_free(sCtx.z); + xCloser(sCtx.in); + fprintf(stderr,"%s: empty file\n", sCtx.zFile); + return 1; + } + zCreate = sqlite3_mprintf("%z\n)", zCreate); + rc = sqlite3_exec(p->db, zCreate, 0, 0, 0); + sqlite3_free(zCreate); + if( rc ){ + fprintf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable, + sqlite3_errmsg(p->db)); + sqlite3_free(sCtx.z); + xCloser(sCtx.in); + return 1; + } + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + } + sqlite3_free(zSql); + if( rc ){ + if (pStmt) sqlite3_finalize(pStmt); + fprintf(stderr,"Error: %s\n", sqlite3_errmsg(p->db)); + xCloser(sCtx.in); + return 1; + } + nCol = sqlite3_column_count(pStmt); + sqlite3_finalize(pStmt); + pStmt = 0; + if( nCol==0 ) return 0; /* no columns, no error */ + zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 ); + if( zSql==0 ){ + fprintf(stderr, "Error: out of memory\n"); + xCloser(sCtx.in); + return 1; + } + sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable); + j = strlen30(zSql); + for(i=1; idb, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + if( rc ){ + fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); + if (pStmt) sqlite3_finalize(pStmt); + xCloser(sCtx.in); + return 1; + } + needCommit = sqlite3_get_autocommit(p->db); + if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0); + do{ + int startLine = sCtx.nLine; + for(i=0; imode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break; + sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT); + if( i=nCol ){ + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ){ + fprintf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile, startLine, + sqlite3_errmsg(p->db)); + } + } + }while( sCtx.cTerm!=EOF ); + + xCloser(sCtx.in); + sqlite3_free(sCtx.z); + sqlite3_finalize(pStmt); + if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0); + }else + + if( c=='i' && (strncmp(azArg[0], "indices", n)==0 + || strncmp(azArg[0], "indexes", n)==0) ){ + ShellState data; + char *zErrMsg = 0; + open_db(p, 0); + memcpy(&data, p, sizeof(data)); + data.showHeader = 0; + data.mode = MODE_List; + if( nArg==1 ){ + rc = sqlite3_exec(p->db, + "SELECT name FROM sqlite_master " + "WHERE type='index' AND name NOT LIKE 'sqlite_%' " + "UNION ALL " + "SELECT name FROM sqlite_temp_master " + "WHERE type='index' " + "ORDER BY 1", + callback, &data, &zErrMsg + ); + }else if( nArg==2 ){ + zShellStatic = azArg[1]; + rc = sqlite3_exec(p->db, + "SELECT name FROM sqlite_master " + "WHERE type='index' AND tbl_name LIKE shellstatic() " + "UNION ALL " + "SELECT name FROM sqlite_temp_master " + "WHERE type='index' AND tbl_name LIKE shellstatic() " + "ORDER BY 1", + callback, &data, &zErrMsg + ); + zShellStatic = 0; + }else{ + fprintf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n"); + rc = 1; + goto meta_command_exit; + } + if( zErrMsg ){ + fprintf(stderr,"Error: %s\n", zErrMsg); + sqlite3_free(zErrMsg); + rc = 1; + }else if( rc != SQLITE_OK ){ + fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n"); + rc = 1; + } + }else + +#ifdef SQLITE_ENABLE_IOTRACE + if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){ + SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...); + if( iotrace && iotrace!=stdout ) fclose(iotrace); + iotrace = 0; + if( nArg<2 ){ + sqlite3IoTrace = 0; + }else if( strcmp(azArg[1], "-")==0 ){ + sqlite3IoTrace = iotracePrintf; + iotrace = stdout; + }else{ + iotrace = fopen(azArg[1], "w"); + if( iotrace==0 ){ + fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]); + sqlite3IoTrace = 0; + rc = 1; + }else{ + sqlite3IoTrace = iotracePrintf; + } + } + }else +#endif + if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){ + static const struct { + const char *zLimitName; /* Name of a limit */ + int limitCode; /* Integer code for that limit */ + } aLimit[] = { + { "length", SQLITE_LIMIT_LENGTH }, + { "sql_length", SQLITE_LIMIT_SQL_LENGTH }, + { "column", SQLITE_LIMIT_COLUMN }, + { "expr_depth", SQLITE_LIMIT_EXPR_DEPTH }, + { "compound_select", SQLITE_LIMIT_COMPOUND_SELECT }, + { "vdbe_op", SQLITE_LIMIT_VDBE_OP }, + { "function_arg", SQLITE_LIMIT_FUNCTION_ARG }, + { "attached", SQLITE_LIMIT_ATTACHED }, + { "like_pattern_length", SQLITE_LIMIT_LIKE_PATTERN_LENGTH }, + { "variable_number", SQLITE_LIMIT_VARIABLE_NUMBER }, + { "trigger_depth", SQLITE_LIMIT_TRIGGER_DEPTH }, + { "worker_threads", SQLITE_LIMIT_WORKER_THREADS }, + }; + int i, n2; + open_db(p, 0); + if( nArg==1 ){ + for(i=0; idb, aLimit[i].limitCode, -1)); + } + }else if( nArg>3 ){ + fprintf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n"); + rc = 1; + goto meta_command_exit; + }else{ + int iLimit = -1; + n2 = strlen30(azArg[1]); + for(i=0; idb, aLimit[iLimit].limitCode, + (int)integerValue(azArg[2])); + } + printf("%20s %d\n", aLimit[iLimit].zLimitName, + sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1)); + } + }else + +#ifndef SQLITE_OMIT_LOAD_EXTENSION + if( c=='l' && strncmp(azArg[0], "load", n)==0 ){ + const char *zFile, *zProc; + char *zErrMsg = 0; + if( nArg<2 ){ + fprintf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n"); + rc = 1; + goto meta_command_exit; + } + zFile = azArg[1]; + zProc = nArg>=3 ? azArg[2] : 0; + open_db(p, 0); + rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg); + if( rc!=SQLITE_OK ){ + fprintf(stderr, "Error: %s\n", zErrMsg); + sqlite3_free(zErrMsg); + rc = 1; + } + }else +#endif + + if( c=='l' && strncmp(azArg[0], "log", n)==0 ){ + if( nArg!=2 ){ + fprintf(stderr, "Usage: .log FILENAME\n"); + rc = 1; + }else{ + const char *zFile = azArg[1]; + output_file_close(p->pLog); + p->pLog = output_file_open(zFile); + } + }else + + if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){ + const char *zMode = nArg>=2 ? azArg[1] : ""; + int n2 = (int)strlen(zMode); + int c2 = zMode[0]; + if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){ + p->mode = MODE_Line; + }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){ + p->mode = MODE_Column; + }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){ + p->mode = MODE_List; + }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){ + p->mode = MODE_Html; + }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){ + p->mode = MODE_Tcl; + sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space); + }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){ + p->mode = MODE_Csv; + sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma); + sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf); + }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){ + p->mode = MODE_List; + sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab); + }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){ + p->mode = MODE_Insert; + set_table_name(p, nArg>=3 ? azArg[2] : "table"); + }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){ + p->mode = MODE_Ascii; + sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit); + sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record); + }else { + fprintf(stderr,"Error: mode should be one of: " + "ascii column csv html insert line list tabs tcl\n"); + rc = 1; + } + }else + + if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){ + if( nArg==2 ){ + sqlite3_snprintf(sizeof(p->nullValue), p->nullValue, + "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]); + }else{ + fprintf(stderr, "Usage: .nullvalue STRING\n"); + rc = 1; + } + }else + + if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){ + sqlite3 *savedDb = p->db; + const char *zSavedFilename = p->zDbFilename; + char *zNewFilename = 0; + p->db = 0; + if( nArg>=2 ) zNewFilename = sqlite3_mprintf("%s", azArg[1]); + p->zDbFilename = zNewFilename; + open_db(p, 1); + if( p->db!=0 ){ + sqlite3_close(savedDb); + sqlite3_free(p->zFreeOnClose); + p->zFreeOnClose = zNewFilename; + }else{ + sqlite3_free(zNewFilename); + p->db = savedDb; + p->zDbFilename = zSavedFilename; + } + }else + + if( c=='o' + && (strncmp(azArg[0], "output", n)==0 || strncmp(azArg[0], "once", n)==0) + ){ + const char *zFile = nArg>=2 ? azArg[1] : "stdout"; + if( nArg>2 ){ + fprintf(stderr, "Usage: .%s FILE\n", azArg[0]); + rc = 1; + goto meta_command_exit; + } + if( n>1 && strncmp(azArg[0], "once", n)==0 ){ + if( nArg<2 ){ + fprintf(stderr, "Usage: .once FILE\n"); + rc = 1; + goto meta_command_exit; + } + p->outCount = 2; + }else{ + p->outCount = 0; + } + output_reset(p); + if( zFile[0]=='|' ){ +#ifdef SQLITE_OMIT_POPEN + fprintf(stderr,"Error: pipes are not supported in this OS\n"); + rc = 1; + p->out = stdout; +#else + p->out = popen(zFile + 1, "w"); + if( p->out==0 ){ + fprintf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1); + p->out = stdout; + rc = 1; + }else{ + sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); + } +#endif + }else{ + p->out = output_file_open(zFile); + if( p->out==0 ){ + if( strcmp(zFile,"off")!=0 ){ + fprintf(stderr,"Error: cannot write to \"%s\"\n", zFile); + } + p->out = stdout; + rc = 1; + } else { + sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile); + } + } + }else + + if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){ + int i; + for(i=1; i1 ) fprintf(p->out, " "); + fprintf(p->out, "%s", azArg[i]); + } + fprintf(p->out, "\n"); + }else + + if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){ + if( nArg >= 2) { + strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1); + } + if( nArg >= 3) { + strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1); + } + }else + + if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){ + rc = 2; + }else + + if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){ + FILE *alt; + if( nArg!=2 ){ + fprintf(stderr, "Usage: .read FILE\n"); + rc = 1; + goto meta_command_exit; + } + alt = fopen(azArg[1], "rb"); + if( alt==0 ){ + fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]); + rc = 1; + }else{ + rc = process_input(p, alt); + fclose(alt); + } + }else + + if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){ + const char *zSrcFile; + const char *zDb; + sqlite3 *pSrc; + sqlite3_backup *pBackup; + int nTimeout = 0; + + if( nArg==2 ){ + zSrcFile = azArg[1]; + zDb = "main"; + }else if( nArg==3 ){ + zSrcFile = azArg[2]; + zDb = azArg[1]; + }else{ + fprintf(stderr, "Usage: .restore ?DB? FILE\n"); + rc = 1; + goto meta_command_exit; + } + rc = sqlite3_open(zSrcFile, &pSrc); + if( rc!=SQLITE_OK ){ + fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile); + sqlite3_close(pSrc); + return 1; + } + open_db(p, 0); + pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main"); + if( pBackup==0 ){ + fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); + sqlite3_close(pSrc); + return 1; + } + while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK + || rc==SQLITE_BUSY ){ + if( rc==SQLITE_BUSY ){ + if( nTimeout++ >= 3 ) break; + sqlite3_sleep(100); + } + } + sqlite3_backup_finish(pBackup); + if( rc==SQLITE_DONE ){ + rc = 0; + }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){ + fprintf(stderr, "Error: source database is busy\n"); + rc = 1; + }else{ + fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); + rc = 1; + } + sqlite3_close(pSrc); + }else + + + if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){ + if( nArg==2 ){ + p->scanstatsOn = booleanValue(azArg[1]); +#ifndef SQLITE_ENABLE_STMT_SCANSTATUS + fprintf(stderr, "Warning: .scanstats not available in this build.\n"); +#endif + }else{ + fprintf(stderr, "Usage: .scanstats on|off\n"); + rc = 1; + } + }else + + if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){ + ShellState data; + char *zErrMsg = 0; + open_db(p, 0); + memcpy(&data, p, sizeof(data)); + data.showHeader = 0; + data.mode = MODE_Semi; + if( nArg==2 ){ + int i; + for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]); + if( strcmp(azArg[1],"sqlite_master")==0 ){ + char *new_argv[2], *new_colv[2]; + new_argv[0] = "CREATE TABLE sqlite_master (\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")"; + new_argv[1] = 0; + new_colv[0] = "sql"; + new_colv[1] = 0; + callback(&data, 1, new_argv, new_colv); + rc = SQLITE_OK; + }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){ + char *new_argv[2], *new_colv[2]; + new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")"; + new_argv[1] = 0; + new_colv[0] = "sql"; + new_colv[1] = 0; + callback(&data, 1, new_argv, new_colv); + rc = SQLITE_OK; + }else{ + zShellStatic = azArg[1]; + rc = sqlite3_exec(p->db, + "SELECT sql FROM " + " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x" + " FROM sqlite_master UNION ALL" + " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) " + "WHERE lower(tbl_name) LIKE shellstatic()" + " AND type!='meta' AND sql NOTNULL " + "ORDER BY rowid", + callback, &data, &zErrMsg); + zShellStatic = 0; + } + }else if( nArg==1 ){ + rc = sqlite3_exec(p->db, + "SELECT sql FROM " + " (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x" + " FROM sqlite_master UNION ALL" + " SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) " + "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' " + "ORDER BY rowid", + callback, &data, &zErrMsg + ); + }else{ + fprintf(stderr, "Usage: .schema ?LIKE-PATTERN?\n"); + rc = 1; + goto meta_command_exit; + } + if( zErrMsg ){ + fprintf(stderr,"Error: %s\n", zErrMsg); + sqlite3_free(zErrMsg); + rc = 1; + }else if( rc != SQLITE_OK ){ + fprintf(stderr,"Error: querying schema information\n"); + rc = 1; + }else{ + rc = 0; + } + }else + + +#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE) + if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){ + extern int sqlite3SelectTrace; + sqlite3SelectTrace = integerValue(azArg[1]); + }else +#endif + + +#ifdef SQLITE_DEBUG + /* Undocumented commands for internal testing. Subject to change + ** without notice. */ + if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){ + if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){ + int i, v; + for(i=1; iout, "%s: %d 0x%x\n", azArg[i], v, v); + } + } + if( strncmp(azArg[0]+9, "integer", n-9)==0 ){ + int i; sqlite3_int64 v; + for(i=1; iout, "%s", zBuf); + } + } + }else +#endif + + if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){ + if( nArg<2 || nArg>3 ){ + fprintf(stderr, "Usage: .separator COL ?ROW?\n"); + rc = 1; + } + if( nArg>=2 ){ + sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, + "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]); + } + if( nArg>=3 ){ + sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, + "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]); + } + }else + + if( c=='s' + && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0) + ){ + char *zCmd; + int i, x; + if( nArg<2 ){ + fprintf(stderr, "Usage: .system COMMAND\n"); + rc = 1; + goto meta_command_exit; + } + zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]); + for(i=2; iout,"%12.12s: %s\n","echo", p->echoOn ? "on" : "off"); + fprintf(p->out,"%12.12s: %s\n","eqp", p->autoEQP ? "on" : "off"); + fprintf(p->out,"%9.9s: %s\n","explain", p->normalMode.valid ? "on" :"off"); + fprintf(p->out,"%12.12s: %s\n","headers", p->showHeader ? "on" : "off"); + fprintf(p->out,"%12.12s: %s\n","mode", modeDescr[p->mode]); + fprintf(p->out,"%12.12s: ", "nullvalue"); + output_c_string(p->out, p->nullValue); + fprintf(p->out, "\n"); + fprintf(p->out,"%12.12s: %s\n","output", + strlen30(p->outfile) ? p->outfile : "stdout"); + fprintf(p->out,"%12.12s: ", "colseparator"); + output_c_string(p->out, p->colSeparator); + fprintf(p->out, "\n"); + fprintf(p->out,"%12.12s: ", "rowseparator"); + output_c_string(p->out, p->rowSeparator); + fprintf(p->out, "\n"); + fprintf(p->out,"%12.12s: %s\n","stats", p->statsOn ? "on" : "off"); + fprintf(p->out,"%12.12s: ","width"); + for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) { + fprintf(p->out,"%d ",p->colWidth[i]); + } + fprintf(p->out,"\n"); + }else + + if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){ + if( nArg==2 ){ + p->statsOn = booleanValue(azArg[1]); + }else{ + fprintf(stderr, "Usage: .stats on|off\n"); + rc = 1; + } + }else + + if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){ + sqlite3_stmt *pStmt; + char **azResult; + int nRow, nAlloc; + char *zSql = 0; + int ii; + open_db(p, 0); + rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0); + if( rc ) return shellDatabaseError(p->db); + + /* Create an SQL statement to query for the list of tables in the + ** main and all attached databases where the table name matches the + ** LIKE pattern bound to variable "?1". */ + zSql = sqlite3_mprintf( + "SELECT name FROM sqlite_master" + " WHERE type IN ('table','view')" + " AND name NOT LIKE 'sqlite_%%'" + " AND name LIKE ?1"); + while( zSql && sqlite3_step(pStmt)==SQLITE_ROW ){ + const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1); + if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue; + if( strcmp(zDbName,"temp")==0 ){ + zSql = sqlite3_mprintf( + "%z UNION ALL " + "SELECT 'temp.' || name FROM sqlite_temp_master" + " WHERE type IN ('table','view')" + " AND name NOT LIKE 'sqlite_%%'" + " AND name LIKE ?1", zSql); + }else{ + zSql = sqlite3_mprintf( + "%z UNION ALL " + "SELECT '%q.' || name FROM \"%w\".sqlite_master" + " WHERE type IN ('table','view')" + " AND name NOT LIKE 'sqlite_%%'" + " AND name LIKE ?1", zSql, zDbName, zDbName); + } + } + rc = sqlite3_finalize(pStmt); + if( zSql && rc==SQLITE_OK ){ + zSql = sqlite3_mprintf("%z ORDER BY 1", zSql); + if( zSql ) rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + } + sqlite3_free(zSql); + if( !zSql ) return shellNomemError(); + if( rc ) return shellDatabaseError(p->db); + + /* Run the SQL statement prepared by the above block. Store the results + ** as an array of nul-terminated strings in azResult[]. */ + nRow = nAlloc = 0; + azResult = 0; + if( nArg>1 ){ + sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT); + }else{ + sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC); + } + while( sqlite3_step(pStmt)==SQLITE_ROW ){ + if( nRow>=nAlloc ){ + char **azNew; + int n2 = nAlloc*2 + 10; + azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2); + if( azNew==0 ){ + rc = shellNomemError(); + break; + } + nAlloc = n2; + azResult = azNew; + } + azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0)); + if( 0==azResult[nRow] ){ + rc = shellNomemError(); + break; + } + nRow++; + } + if( sqlite3_finalize(pStmt)!=SQLITE_OK ){ + rc = shellDatabaseError(p->db); + } + + /* Pretty-print the contents of array azResult[] to the output */ + if( rc==0 && nRow>0 ){ + int len, maxlen = 0; + int i, j; + int nPrintCol, nPrintRow; + for(i=0; imaxlen ) maxlen = len; + } + nPrintCol = 80/(maxlen+2); + if( nPrintCol<1 ) nPrintCol = 1; + nPrintRow = (nRow + nPrintCol - 1)/nPrintCol; + for(i=0; iout, "%s%-*s", zSp, maxlen, azResult[j] ? azResult[j]:""); + } + fprintf(p->out, "\n"); + } + } + + for(ii=0; ii=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){ + static const struct { + const char *zCtrlName; /* Name of a test-control option */ + int ctrlCode; /* Integer code for that option */ + } aCtrl[] = { + { "prng_save", SQLITE_TESTCTRL_PRNG_SAVE }, + { "prng_restore", SQLITE_TESTCTRL_PRNG_RESTORE }, + { "prng_reset", SQLITE_TESTCTRL_PRNG_RESET }, + { "bitvec_test", SQLITE_TESTCTRL_BITVEC_TEST }, + { "fault_install", SQLITE_TESTCTRL_FAULT_INSTALL }, + { "benign_malloc_hooks", SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS }, + { "pending_byte", SQLITE_TESTCTRL_PENDING_BYTE }, + { "assert", SQLITE_TESTCTRL_ASSERT }, + { "always", SQLITE_TESTCTRL_ALWAYS }, + { "reserve", SQLITE_TESTCTRL_RESERVE }, + { "optimizations", SQLITE_TESTCTRL_OPTIMIZATIONS }, + { "iskeyword", SQLITE_TESTCTRL_ISKEYWORD }, + { "scratchmalloc", SQLITE_TESTCTRL_SCRATCHMALLOC }, + { "byteorder", SQLITE_TESTCTRL_BYTEORDER }, + { "never_corrupt", SQLITE_TESTCTRL_NEVER_CORRUPT }, + { "imposter", SQLITE_TESTCTRL_IMPOSTER }, + }; + int testctrl = -1; + int rc2 = 0; + int i, n2; + open_db(p, 0); + + /* convert testctrl text option to value. allow any unique prefix + ** of the option name, or a numerical value. */ + n2 = strlen30(azArg[1]); + for(i=0; iSQLITE_TESTCTRL_LAST) ){ + fprintf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]); + }else{ + switch(testctrl){ + + /* sqlite3_test_control(int, db, int) */ + case SQLITE_TESTCTRL_OPTIMIZATIONS: + case SQLITE_TESTCTRL_RESERVE: + if( nArg==3 ){ + int opt = (int)strtol(azArg[2], 0, 0); + rc2 = sqlite3_test_control(testctrl, p->db, opt); + fprintf(p->out, "%d (0x%08x)\n", rc2, rc2); + } else { + fprintf(stderr,"Error: testctrl %s takes a single int option\n", + azArg[1]); + } + break; + + /* sqlite3_test_control(int) */ + case SQLITE_TESTCTRL_PRNG_SAVE: + case SQLITE_TESTCTRL_PRNG_RESTORE: + case SQLITE_TESTCTRL_PRNG_RESET: + case SQLITE_TESTCTRL_BYTEORDER: + if( nArg==2 ){ + rc2 = sqlite3_test_control(testctrl); + fprintf(p->out, "%d (0x%08x)\n", rc2, rc2); + } else { + fprintf(stderr,"Error: testctrl %s takes no options\n", azArg[1]); + } + break; + + /* sqlite3_test_control(int, uint) */ + case SQLITE_TESTCTRL_PENDING_BYTE: + if( nArg==3 ){ + unsigned int opt = (unsigned int)integerValue(azArg[2]); + rc2 = sqlite3_test_control(testctrl, opt); + fprintf(p->out, "%d (0x%08x)\n", rc2, rc2); + } else { + fprintf(stderr,"Error: testctrl %s takes a single unsigned" + " int option\n", azArg[1]); + } + break; + + /* sqlite3_test_control(int, int) */ + case SQLITE_TESTCTRL_ASSERT: + case SQLITE_TESTCTRL_ALWAYS: + case SQLITE_TESTCTRL_NEVER_CORRUPT: + if( nArg==3 ){ + int opt = booleanValue(azArg[2]); + rc2 = sqlite3_test_control(testctrl, opt); + fprintf(p->out, "%d (0x%08x)\n", rc2, rc2); + } else { + fprintf(stderr,"Error: testctrl %s takes a single int option\n", + azArg[1]); + } + break; + + /* sqlite3_test_control(int, char *) */ +#ifdef SQLITE_N_KEYWORD + case SQLITE_TESTCTRL_ISKEYWORD: + if( nArg==3 ){ + const char *opt = azArg[2]; + rc2 = sqlite3_test_control(testctrl, opt); + fprintf(p->out, "%d (0x%08x)\n", rc2, rc2); + } else { + fprintf(stderr,"Error: testctrl %s takes a single char * option\n", + azArg[1]); + } + break; +#endif + + case SQLITE_TESTCTRL_IMPOSTER: + if( nArg==5 ){ + rc2 = sqlite3_test_control(testctrl, p->db, + azArg[2], + integerValue(azArg[3]), + integerValue(azArg[4])); + fprintf(p->out, "%d (0x%08x)\n", rc2, rc2); + }else{ + fprintf(stderr,"Usage: .testctrl imposter dbName onoff tnum\n"); + } + break; + + case SQLITE_TESTCTRL_BITVEC_TEST: + case SQLITE_TESTCTRL_FAULT_INSTALL: + case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: + case SQLITE_TESTCTRL_SCRATCHMALLOC: + default: + fprintf(stderr,"Error: CLI support for testctrl %s not implemented\n", + azArg[1]); + break; + } + } + }else + + if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){ + open_db(p, 0); + sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0); + }else + + if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){ + if( nArg==2 ){ + enableTimer = booleanValue(azArg[1]); + if( enableTimer && !HAS_TIMER ){ + fprintf(stderr, "Error: timer not available on this system.\n"); + enableTimer = 0; + } + }else{ + fprintf(stderr, "Usage: .timer on|off\n"); + rc = 1; + } + }else + + if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){ + open_db(p, 0); + if( nArg!=2 ){ + fprintf(stderr, "Usage: .trace FILE|off\n"); + rc = 1; + goto meta_command_exit; + } + output_file_close(p->traceOut); + p->traceOut = output_file_open(azArg[1]); +#if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT) + if( p->traceOut==0 ){ + sqlite3_trace(p->db, 0, 0); + }else{ + sqlite3_trace(p->db, sql_trace_callback, p->traceOut); + } +#endif + }else + +#if SQLITE_USER_AUTHENTICATION + if( c=='u' && strncmp(azArg[0], "user", n)==0 ){ + if( nArg<2 ){ + fprintf(stderr, "Usage: .user SUBCOMMAND ...\n"); + rc = 1; + goto meta_command_exit; + } + open_db(p, 0); + if( strcmp(azArg[1],"login")==0 ){ + if( nArg!=4 ){ + fprintf(stderr, "Usage: .user login USER PASSWORD\n"); + rc = 1; + goto meta_command_exit; + } + rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3], + (int)strlen(azArg[3])); + if( rc ){ + fprintf(stderr, "Authentication failed for user %s\n", azArg[2]); + rc = 1; + } + }else if( strcmp(azArg[1],"add")==0 ){ + if( nArg!=5 ){ + fprintf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n"); + rc = 1; + goto meta_command_exit; + } + rc = sqlite3_user_add(p->db, azArg[2], + azArg[3], (int)strlen(azArg[3]), + booleanValue(azArg[4])); + if( rc ){ + fprintf(stderr, "User-Add failed: %d\n", rc); + rc = 1; + } + }else if( strcmp(azArg[1],"edit")==0 ){ + if( nArg!=5 ){ + fprintf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n"); + rc = 1; + goto meta_command_exit; + } + rc = sqlite3_user_change(p->db, azArg[2], + azArg[3], (int)strlen(azArg[3]), + booleanValue(azArg[4])); + if( rc ){ + fprintf(stderr, "User-Edit failed: %d\n", rc); + rc = 1; + } + }else if( strcmp(azArg[1],"delete")==0 ){ + if( nArg!=3 ){ + fprintf(stderr, "Usage: .user delete USER\n"); + rc = 1; + goto meta_command_exit; + } + rc = sqlite3_user_delete(p->db, azArg[2]); + if( rc ){ + fprintf(stderr, "User-Delete failed: %d\n", rc); + rc = 1; + } + }else{ + fprintf(stderr, "Usage: .user login|add|edit|delete ...\n"); + rc = 1; + goto meta_command_exit; + } + }else +#endif /* SQLITE_USER_AUTHENTICATION */ + + if( c=='v' && strncmp(azArg[0], "version", n)==0 ){ + fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/, + sqlite3_libversion(), sqlite3_sourceid()); + }else + + if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){ + const char *zDbName = nArg==2 ? azArg[1] : "main"; + char *zVfsName = 0; + if( p->db ){ + sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName); + if( zVfsName ){ + fprintf(p->out, "%s\n", zVfsName); + sqlite3_free(zVfsName); + } + } + }else + +#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE) + if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){ + extern int sqlite3WhereTrace; + sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff; + }else +#endif + + if( c=='w' && strncmp(azArg[0], "width", n)==0 ){ + int j; + assert( nArg<=ArraySize(azArg) ); + for(j=1; jcolWidth); j++){ + p->colWidth[j-1] = (int)integerValue(azArg[j]); + } + }else + + { + fprintf(stderr, "Error: unknown command or invalid arguments: " + " \"%s\". Enter \".help\" for help\n", azArg[0]); + rc = 1; + } + +meta_command_exit: + if( p->outCount ){ + p->outCount--; + if( p->outCount==0 ) output_reset(p); + } + return rc; +} + +/* +** Return TRUE if a semicolon occurs anywhere in the first N characters +** of string z[]. +*/ +static int line_contains_semicolon(const char *z, int N){ + int i; + for(i=0; iout); + zLine = one_input_line(in, zLine, nSql>0); + if( zLine==0 ){ + /* End of input */ + if( stdin_is_interactive ) printf("\n"); + break; + } + if( seenInterrupt ){ + if( in!=0 ) break; + seenInterrupt = 0; + } + lineno++; + if( nSql==0 && _all_whitespace(zLine) ){ + if( p->echoOn ) printf("%s\n", zLine); + continue; + } + if( zLine && zLine[0]=='.' && nSql==0 ){ + if( p->echoOn ) printf("%s\n", zLine); + rc = do_meta_command(zLine, p); + if( rc==2 ){ /* exit requested */ + break; + }else if( rc ){ + errCnt++; + } + continue; + } + if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){ + memcpy(zLine,";",2); + } + nLine = strlen30(zLine); + if( nSql+nLine+2>=nAlloc ){ + nAlloc = nSql+nLine+100; + zSql = realloc(zSql, nAlloc); + if( zSql==0 ){ + fprintf(stderr, "Error: out of memory\n"); + exit(1); + } + } + nSqlPrior = nSql; + if( nSql==0 ){ + int i; + for(i=0; zLine[i] && IsSpace(zLine[i]); i++){} + assert( nAlloc>0 && zSql!=0 ); + memcpy(zSql, zLine+i, nLine+1-i); + startline = lineno; + nSql = nLine-i; + }else{ + zSql[nSql++] = '\n'; + memcpy(zSql+nSql, zLine, nLine+1); + nSql += nLine; + } + if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior) + && sqlite3_complete(zSql) ){ + p->cnt = 0; + open_db(p, 0); + if( p->backslashOn ) resolve_backslashes(zSql); + BEGIN_TIMER; + rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg); + END_TIMER; + if( rc || zErrMsg ){ + char zPrefix[100]; + if( in!=0 || !stdin_is_interactive ){ + sqlite3_snprintf(sizeof(zPrefix), zPrefix, + "Error: near line %d:", startline); + }else{ + sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:"); + } + if( zErrMsg!=0 ){ + fprintf(stderr, "%s %s\n", zPrefix, zErrMsg); + sqlite3_free(zErrMsg); + zErrMsg = 0; + }else{ + fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db)); + } + errCnt++; + } + nSql = 0; + if( p->outCount ){ + output_reset(p); + p->outCount = 0; + } + }else if( nSql && _all_whitespace(zSql) ){ + if( p->echoOn ) printf("%s\n", zSql); + nSql = 0; + } + } + if( nSql ){ + if( !_all_whitespace(zSql) ){ + fprintf(stderr, "Error: incomplete SQL: %s\n", zSql); + errCnt++; + } + } + free(zSql); + free(zLine); + return errCnt>0; +} + +/* +** Return a pathname which is the user's home directory. A +** 0 return indicates an error of some kind. +*/ +static char *find_home_dir(void){ + static char *home_dir = NULL; + if( home_dir ) return home_dir; + +#if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \ + && !defined(__RTP__) && !defined(_WRS_KERNEL) + { + struct passwd *pwent; + uid_t uid = getuid(); + if( (pwent=getpwuid(uid)) != NULL) { + home_dir = pwent->pw_dir; + } + } +#endif + +#if defined(_WIN32_WCE) + /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv() + */ + home_dir = "/"; +#else + +#if defined(_WIN32) || defined(WIN32) + if (!home_dir) { + home_dir = getenv("USERPROFILE"); + } +#endif + + if (!home_dir) { + home_dir = getenv("HOME"); + } + +#if defined(_WIN32) || defined(WIN32) + if (!home_dir) { + char *zDrive, *zPath; + int n; + zDrive = getenv("HOMEDRIVE"); + zPath = getenv("HOMEPATH"); + if( zDrive && zPath ){ + n = strlen30(zDrive) + strlen30(zPath) + 1; + home_dir = malloc( n ); + if( home_dir==0 ) return 0; + sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath); + return home_dir; + } + home_dir = "c:\\"; + } +#endif + +#endif /* !_WIN32_WCE */ + + if( home_dir ){ + int n = strlen30(home_dir) + 1; + char *z = malloc( n ); + if( z ) memcpy(z, home_dir, n); + home_dir = z; + } + + return home_dir; +} + +/* +** Read input from the file given by sqliterc_override. Or if that +** parameter is NULL, take input from ~/.sqliterc +** +** Returns the number of errors. +*/ +static void process_sqliterc( + ShellState *p, /* Configuration data */ + const char *sqliterc_override /* Name of config file. NULL to use default */ +){ + char *home_dir = NULL; + const char *sqliterc = sqliterc_override; + char *zBuf = 0; + FILE *in = NULL; + + if (sqliterc == NULL) { + home_dir = find_home_dir(); + if( home_dir==0 ){ + fprintf(stderr, "-- warning: cannot find home directory;" + " cannot read ~/.sqliterc\n"); + return; + } + sqlite3_initialize(); + zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir); + sqliterc = zBuf; + } + in = fopen(sqliterc,"rb"); + if( in ){ + if( stdin_is_interactive ){ + fprintf(stderr,"-- Loading resources from %s\n",sqliterc); + } + process_input(p,in); + fclose(in); + } + sqlite3_free(zBuf); +} + +/* +** Show available command line options +*/ +static const char zOptions[] = + " -ascii set output mode to 'ascii'\n" + " -bail stop after hitting an error\n" + " -batch force batch I/O\n" + " -column set output mode to 'column'\n" + " -cmd COMMAND run \"COMMAND\" before reading stdin\n" + " -csv set output mode to 'csv'\n" + " -echo print commands before execution\n" + " -init FILENAME read/process named file\n" + " -[no]header turn headers on or off\n" +#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) + " -heap SIZE Size of heap for memsys3 or memsys5\n" +#endif + " -help show this message\n" + " -html set output mode to HTML\n" + " -interactive force interactive I/O\n" + " -line set output mode to 'line'\n" + " -list set output mode to 'list'\n" + " -lookaside SIZE N use N entries of SZ bytes for lookaside memory\n" + " -mmap N default mmap size set to N\n" +#ifdef SQLITE_ENABLE_MULTIPLEX + " -multiplex enable the multiplexor VFS\n" +#endif + " -newline SEP set output row separator. Default: '\\n'\n" + " -nullvalue TEXT set text string for NULL values. Default ''\n" + " -pagecache SIZE N use N slots of SZ bytes each for page cache memory\n" + " -scratch SIZE N use N slots of SZ bytes each for scratch memory\n" + " -separator SEP set output column separator. Default: '|'\n" + " -stats print memory stats before each finalize\n" + " -version show SQLite version\n" + " -vfs NAME use NAME as the default VFS\n" +#ifdef SQLITE_ENABLE_VFSTRACE + " -vfstrace enable tracing of all VFS calls\n" +#endif +; +static void usage(int showDetail){ + fprintf(stderr, + "Usage: %s [OPTIONS] FILENAME [SQL]\n" + "FILENAME is the name of an SQLite database. A new database is created\n" + "if the file does not previously exist.\n", Argv0); + if( showDetail ){ + fprintf(stderr, "OPTIONS include:\n%s", zOptions); + }else{ + fprintf(stderr, "Use the -help option for additional information\n"); + } + exit(1); +} + +/* +** Initialize the state information in data +*/ +static void main_init(ShellState *data) { + memset(data, 0, sizeof(*data)); + data->mode = MODE_List; + memcpy(data->colSeparator,SEP_Column, 2); + memcpy(data->rowSeparator,SEP_Row, 2); + data->showHeader = 0; + data->shellFlgs = SHFLG_Lookaside; + sqlite3_config(SQLITE_CONFIG_URI, 1); + sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data); + sqlite3_config(SQLITE_CONFIG_MULTITHREAD); + sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> "); + sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> "); +} + +/* +** Output text to the console in a font that attracts extra attention. +*/ +#ifdef _WIN32 +static void printBold(const char *zText){ + HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE); + CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo; + GetConsoleScreenBufferInfo(out, &defaultScreenInfo); + SetConsoleTextAttribute(out, + FOREGROUND_RED|FOREGROUND_INTENSITY + ); + printf("%s", zText); + SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes); +} +#else +static void printBold(const char *zText){ + printf("\033[1m%s\033[0m", zText); +} +#endif + +/* +** Get the argument to an --option. Throw an error and die if no argument +** is available. +*/ +static char *cmdline_option_value(int argc, char **argv, int i){ + if( i==argc ){ + fprintf(stderr, "%s: Error: missing argument to %s\n", + argv[0], argv[argc-1]); + exit(1); + } + return argv[i]; +} + +int SQLITE_CDECL main(int argc, char **argv){ + char *zErrMsg = 0; + ShellState data; + const char *zInitFile = 0; + int i; + int rc = 0; + int warnInmemoryDb = 0; + int readStdin = 1; + int nCmd = 0; + char **azCmd = 0; + +#if USE_SYSTEM_SQLITE+0!=1 + if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){ + fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n", + sqlite3_sourceid(), SQLITE_SOURCE_ID); + exit(1); + } +#endif + setBinaryMode(stdin); + setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */ + Argv0 = argv[0]; + main_init(&data); + stdin_is_interactive = isatty(0); + + /* Make sure we have a valid signal handler early, before anything + ** else is done. + */ +#ifdef SIGINT + signal(SIGINT, interrupt_handler); +#endif + +#ifdef SQLITE_SHELL_DBNAME_PROC + { + /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name + ** of a C-function that will provide the name of the database file. Use + ** this compile-time option to embed this shell program in larger + ** applications. */ + extern void SQLITE_SHELL_DBNAME_PROC(const char**); + SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename); + warnInmemoryDb = 0; + } +#endif + + /* Do an initial pass through the command-line argument to locate + ** the name of the database file, the name of the initialization file, + ** the size of the alternative malloc heap, + ** and the first command to execute. + */ + for(i=1; i0x7fff0000 ) szHeap = 0x7fff0000; + sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64); +#endif + }else if( strcmp(z,"-scratch")==0 ){ + int n, sz; + sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); + if( sz>400000 ) sz = 400000; + if( sz<2500 ) sz = 2500; + n = (int)integerValue(cmdline_option_value(argc,argv,++i)); + if( n>10 ) n = 10; + if( n<1 ) n = 1; + sqlite3_config(SQLITE_CONFIG_SCRATCH, malloc(n*sz+1), sz, n); + data.shellFlgs |= SHFLG_Scratch; + }else if( strcmp(z,"-pagecache")==0 ){ + int n, sz; + sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); + if( sz>70000 ) sz = 70000; + if( sz<800 ) sz = 800; + n = (int)integerValue(cmdline_option_value(argc,argv,++i)); + if( n<10 ) n = 10; + sqlite3_config(SQLITE_CONFIG_PAGECACHE, malloc(n*sz+1), sz, n); + data.shellFlgs |= SHFLG_Pagecache; + }else if( strcmp(z,"-lookaside")==0 ){ + int n, sz; + sz = (int)integerValue(cmdline_option_value(argc,argv,++i)); + if( sz<0 ) sz = 0; + n = (int)integerValue(cmdline_option_value(argc,argv,++i)); + if( n<0 ) n = 0; + sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n); + if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside; +#ifdef SQLITE_ENABLE_VFSTRACE + }else if( strcmp(z,"-vfstrace")==0 ){ + extern int vfstrace_register( + const char *zTraceName, + const char *zOldVfsName, + int (*xOut)(const char*,void*), + void *pOutArg, + int makeDefault + ); + vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1); +#endif +#ifdef SQLITE_ENABLE_MULTIPLEX + }else if( strcmp(z,"-multiplex")==0 ){ + extern int sqlite3_multiple_initialize(const char*,int); + sqlite3_multiplex_initialize(0, 1); +#endif + }else if( strcmp(z,"-mmap")==0 ){ + sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i)); + sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz); + }else if( strcmp(z,"-vfs")==0 ){ + sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i)); + if( pVfs ){ + sqlite3_vfs_register(pVfs, 1); + }else{ + fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]); + exit(1); + } + } + } + if( data.zDbFilename==0 ){ +#ifndef SQLITE_OMIT_MEMORYDB + data.zDbFilename = ":memory:"; + warnInmemoryDb = argc==1; +#else + fprintf(stderr,"%s: Error: no database filename specified\n", Argv0); + return 1; +#endif + } + data.out = stdout; + + /* Go ahead and open the database file if it already exists. If the + ** file does not exist, delay opening it. This prevents empty database + ** files from being created if a user mistypes the database name argument + ** to the sqlite command-line tool. + */ + if( access(data.zDbFilename, 0)==0 ){ + open_db(&data, 0); + } + + /* Process the initialization file if there is one. If no -init option + ** is given on the command line, look for a file named ~/.sqliterc and + ** try to process it. + */ + process_sqliterc(&data,zInitFile); + + /* Make a second pass through the command-line argument and set + ** options. This second pass is delayed until after the initialization + ** file is processed so that the command-line arguments will override + ** settings in the initialization file. + */ + for(i=1; i +#include /* amalgamator: dontcache */ +#define OS_VXWORKS 1 +#define SQLITE_OS_OTHER 0 +#define SQLITE_HOMEGROWN_RECURSIVE_MUTEX 1 +#define SQLITE_OMIT_LOAD_EXTENSION 1 +#define SQLITE_ENABLE_LOCKING_STYLE 0 +#define HAVE_UTIME 1 +#else +/* This is not VxWorks. */ +#define OS_VXWORKS 0 +#endif /* defined(_WRS_KERNEL) */ + +/************** End of vxworks.h *********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* +** These #defines should enable >2GB file support on POSIX if the +** underlying operating system supports it. If the OS lacks +** large file support, or if the OS is windows, these should be no-ops. +** +** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any +** system #includes. Hence, this block of code must be the very first +** code in all source files. +** +** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch +** on the compiler command line. This is necessary if you are compiling +** on a recent machine (ex: Red Hat 7.2) but you want your code to work +** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2 +** without this option, LFS is enable. But LFS does not exist in the kernel +** in Red Hat 6.0, so the code won't work. Hence, for maximum binary +** portability you should omit LFS. +** +** The previous paragraph was written in 2005. (This paragraph is written +** on 2008-11-28.) These days, all Linux kernels support large files, so +** you should probably leave LFS enabled. But some embedded platforms might +** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful. +** +** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later. +*/ +#ifndef SQLITE_DISABLE_LFS +# define _LARGE_FILE 1 +# ifndef _FILE_OFFSET_BITS +# define _FILE_OFFSET_BITS 64 +# endif +# define _LARGEFILE_SOURCE 1 +#endif + +/* What version of GCC is being used. 0 means GCC is not being used */ +#ifdef __GNUC__ +# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__) +#else +# define GCC_VERSION 0 +#endif + +/* Needed for various definitions... */ +#if defined(__GNUC__) && !defined(_GNU_SOURCE) +# define _GNU_SOURCE +#endif + +#if defined(__OpenBSD__) && !defined(_BSD_SOURCE) +# define _BSD_SOURCE +#endif + +/* +** For MinGW, check to see if we can include the header file containing its +** version information, among other things. Normally, this internal MinGW +** header file would [only] be included automatically by other MinGW header +** files; however, the contained version information is now required by this +** header file to work around binary compatibility issues (see below) and +** this is the only known way to reliably obtain it. This entire #if block +** would be completely unnecessary if there was any other way of detecting +** MinGW via their preprocessor (e.g. if they customized their GCC to define +** some MinGW-specific macros). When compiling for MinGW, either the +** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be +** defined; otherwise, detection of conditions specific to MinGW will be +** disabled. +*/ +#if defined(_HAVE_MINGW_H) +# include "mingw.h" +#elif defined(_HAVE__MINGW_H) +# include "_mingw.h" +#endif + +/* +** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T +** define is required to maintain binary compatibility with the MSVC runtime +** library in use (e.g. for Windows XP). +*/ +#if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \ + defined(_WIN32) && !defined(_WIN64) && \ + defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \ + defined(__MSVCRT__) +# define _USE_32BIT_TIME_T +#endif + +/* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear +** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for +** MinGW. +*/ +/************** Include sqlite3.h in the middle of sqliteInt.h ***************/ +/************** Begin file sqlite3.h *****************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the SQLite library +** presents to client programs. If a C-function, structure, datatype, +** or constant definition does not appear in this file, then it is +** not a published API of SQLite, is subject to change without +** notice, and should not be referenced by programs that use SQLite. +** +** Some of the definitions that are in this file are marked as +** "experimental". Experimental interfaces are normally new +** features recently added to SQLite. We do not anticipate changes +** to experimental interfaces but reserve the right to make minor changes +** if experience from use "in the wild" suggest such changes are prudent. +** +** The official C-language API documentation for SQLite is derived +** from comments in this file. This file is the authoritative source +** on how SQLite interfaces are supposed to operate. +** +** The name of this file under configuration management is "sqlite.h.in". +** The makefile makes some minor changes to this file (such as inserting +** the version number) and changes its name to "sqlite3.h" as +** part of the build process. +*/ +#ifndef _SQLITE3_H_ +#define _SQLITE3_H_ +#include /* Needed for the definition of va_list */ + +/* +** Make sure we can call this stuff from C++. +*/ +#if 0 +extern "C" { +#endif + + +/* +** Provide the ability to override linkage features of the interface. +*/ +#ifndef SQLITE_EXTERN +# define SQLITE_EXTERN extern +#endif +#ifndef SQLITE_API +# define SQLITE_API +#endif +#ifndef SQLITE_CDECL +# define SQLITE_CDECL +#endif +#ifndef SQLITE_STDCALL +# define SQLITE_STDCALL +#endif + +/* +** These no-op macros are used in front of interfaces to mark those +** interfaces as either deprecated or experimental. New applications +** should not use deprecated interfaces - they are supported for backwards +** compatibility only. Application writers should be aware that +** experimental interfaces are subject to change in point releases. +** +** These macros used to resolve to various kinds of compiler magic that +** would generate warning messages when they were used. But that +** compiler magic ended up generating such a flurry of bug reports +** that we have taken it all out and gone back to using simple +** noop macros. +*/ +#define SQLITE_DEPRECATED +#define SQLITE_EXPERIMENTAL + +/* +** Ensure these symbols were not defined by some previous header file. +*/ +#ifdef SQLITE_VERSION +# undef SQLITE_VERSION +#endif +#ifdef SQLITE_VERSION_NUMBER +# undef SQLITE_VERSION_NUMBER +#endif + +/* +** CAPI3REF: Compile-Time Library Version Numbers +** +** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header +** evaluates to a string literal that is the SQLite version in the +** format "X.Y.Z" where X is the major version number (always 3 for +** SQLite3) and Y is the minor version number and Z is the release number.)^ +** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer +** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same +** numbers used in [SQLITE_VERSION].)^ +** The SQLITE_VERSION_NUMBER for any given release of SQLite will also +** be larger than the release from which it is derived. Either Y will +** be held constant and Z will be incremented or else Y will be incremented +** and Z will be reset to zero. +** +** Since version 3.6.18, SQLite source code has been stored in the +** Fossil configuration management +** system. ^The SQLITE_SOURCE_ID macro evaluates to +** a string which identifies a particular check-in of SQLite +** within its configuration management system. ^The SQLITE_SOURCE_ID +** string contains the date and time of the check-in (UTC) and an SHA1 +** hash of the entire source tree. +** +** See also: [sqlite3_libversion()], +** [sqlite3_libversion_number()], [sqlite3_sourceid()], +** [sqlite_version()] and [sqlite_source_id()]. +*/ +#define SQLITE_VERSION "3.9.2" +#define SQLITE_VERSION_NUMBER 3009002 +#define SQLITE_SOURCE_ID "2015-11-02 18:31:45 bda77dda9697c463c3d0704014d51627fceee328" + +/* +** CAPI3REF: Run-Time Library Version Numbers +** KEYWORDS: sqlite3_version, sqlite3_sourceid +** +** These interfaces provide the same information as the [SQLITE_VERSION], +** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros +** but are associated with the library instead of the header file. ^(Cautious +** programmers might include assert() statements in their application to +** verify that values returned by these interfaces match the macros in +** the header, and thus ensure that the application is +** compiled with matching library and header files. +** +** 
+** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
+** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
+** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
+**
)^ +** +** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION] +** macro. ^The sqlite3_libversion() function returns a pointer to the +** to the sqlite3_version[] string constant. The sqlite3_libversion() +** function is provided for use in DLLs since DLL users usually do not have +** direct access to string constants within the DLL. ^The +** sqlite3_libversion_number() function returns an integer equal to +** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns +** a pointer to a string constant whose value is the same as the +** [SQLITE_SOURCE_ID] C preprocessor macro. +** +** See also: [sqlite_version()] and [sqlite_source_id()]. +*/ +SQLITE_API const char sqlite3_version[] = SQLITE_VERSION; +SQLITE_API const char *SQLITE_STDCALL sqlite3_libversion(void); +SQLITE_API const char *SQLITE_STDCALL sqlite3_sourceid(void); +SQLITE_API int SQLITE_STDCALL sqlite3_libversion_number(void); + +/* +** CAPI3REF: Run-Time Library Compilation Options Diagnostics +** +** ^The sqlite3_compileoption_used() function returns 0 or 1 +** indicating whether the specified option was defined at +** compile time. ^The SQLITE_ prefix may be omitted from the +** option name passed to sqlite3_compileoption_used(). +** +** ^The sqlite3_compileoption_get() function allows iterating +** over the list of options that were defined at compile time by +** returning the N-th compile time option string. ^If N is out of range, +** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_ +** prefix is omitted from any strings returned by +** sqlite3_compileoption_get(). +** +** ^Support for the diagnostic functions sqlite3_compileoption_used() +** and sqlite3_compileoption_get() may be omitted by specifying the +** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time. +** +** See also: SQL functions [sqlite_compileoption_used()] and +** [sqlite_compileoption_get()] and the [compile_options pragma]. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +SQLITE_API int SQLITE_STDCALL sqlite3_compileoption_used(const char *zOptName); +SQLITE_API const char *SQLITE_STDCALL sqlite3_compileoption_get(int N); +#endif + +/* +** CAPI3REF: Test To See If The Library Is Threadsafe +** +** ^The sqlite3_threadsafe() function returns zero if and only if +** SQLite was compiled with mutexing code omitted due to the +** [SQLITE_THREADSAFE] compile-time option being set to 0. +** +** SQLite can be compiled with or without mutexes. When +** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes +** are enabled and SQLite is threadsafe. When the +** [SQLITE_THREADSAFE] macro is 0, +** the mutexes are omitted. Without the mutexes, it is not safe +** to use SQLite concurrently from more than one thread. +** +** Enabling mutexes incurs a measurable performance penalty. +** So if speed is of utmost importance, it makes sense to disable +** the mutexes. But for maximum safety, mutexes should be enabled. +** ^The default behavior is for mutexes to be enabled. +** +** This interface can be used by an application to make sure that the +** version of SQLite that it is linking against was compiled with +** the desired setting of the [SQLITE_THREADSAFE] macro. +** +** This interface only reports on the compile-time mutex setting +** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with +** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but +** can be fully or partially disabled using a call to [sqlite3_config()] +** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], +** or [SQLITE_CONFIG_SERIALIZED]. ^(The return value of the +** sqlite3_threadsafe() function shows only the compile-time setting of +** thread safety, not any run-time changes to that setting made by +** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() +** is unchanged by calls to sqlite3_config().)^ +** +** See the [threading mode] documentation for additional information. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_threadsafe(void); + +/* +** CAPI3REF: Database Connection Handle +** KEYWORDS: {database connection} {database connections} +** +** Each open SQLite database is represented by a pointer to an instance of +** the opaque structure named "sqlite3". It is useful to think of an sqlite3 +** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and +** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] +** and [sqlite3_close_v2()] are its destructors. There are many other +** interfaces (such as +** [sqlite3_prepare_v2()], [sqlite3_create_function()], and +** [sqlite3_busy_timeout()] to name but three) that are methods on an +** sqlite3 object. +*/ +typedef struct sqlite3 sqlite3; + +/* +** CAPI3REF: 64-Bit Integer Types +** KEYWORDS: sqlite_int64 sqlite_uint64 +** +** Because there is no cross-platform way to specify 64-bit integer types +** SQLite includes typedefs for 64-bit signed and unsigned integers. +** +** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. +** The sqlite_int64 and sqlite_uint64 types are supported for backwards +** compatibility only. +** +** ^The sqlite3_int64 and sqlite_int64 types can store integer values +** between -9223372036854775808 and +9223372036854775807 inclusive. ^The +** sqlite3_uint64 and sqlite_uint64 types can store integer values +** between 0 and +18446744073709551615 inclusive. +*/ +#ifdef SQLITE_INT64_TYPE + typedef SQLITE_INT64_TYPE sqlite_int64; + typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; +#elif defined(_MSC_VER) || defined(__BORLANDC__) + typedef __int64 sqlite_int64; + typedef unsigned __int64 sqlite_uint64; +#else + typedef long long int sqlite_int64; + typedef unsigned long long int sqlite_uint64; +#endif +typedef sqlite_int64 sqlite3_int64; +typedef sqlite_uint64 sqlite3_uint64; + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite3_int64 +#endif + +/* +** CAPI3REF: Closing A Database Connection +** DESTRUCTOR: sqlite3 +** +** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors +** for the [sqlite3] object. +** ^Calls to sqlite3_close() and sqlite3_close_v2() return [SQLITE_OK] if +** the [sqlite3] object is successfully destroyed and all associated +** resources are deallocated. +** +** ^If the database connection is associated with unfinalized prepared +** statements or unfinished sqlite3_backup objects then sqlite3_close() +** will leave the database connection open and return [SQLITE_BUSY]. +** ^If sqlite3_close_v2() is called with unfinalized prepared statements +** and/or unfinished sqlite3_backups, then the database connection becomes +** an unusable "zombie" which will automatically be deallocated when the +** last prepared statement is finalized or the last sqlite3_backup is +** finished. The sqlite3_close_v2() interface is intended for use with +** host languages that are garbage collected, and where the order in which +** destructors are called is arbitrary. +** +** Applications should [sqlite3_finalize | finalize] all [prepared statements], +** [sqlite3_blob_close | close] all [BLOB handles], and +** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated +** with the [sqlite3] object prior to attempting to close the object. ^If +** sqlite3_close_v2() is called on a [database connection] that still has +** outstanding [prepared statements], [BLOB handles], and/or +** [sqlite3_backup] objects then it returns [SQLITE_OK] and the deallocation +** of resources is deferred until all [prepared statements], [BLOB handles], +** and [sqlite3_backup] objects are also destroyed. +** +** ^If an [sqlite3] object is destroyed while a transaction is open, +** the transaction is automatically rolled back. +** +** The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(C)] +** must be either a NULL +** pointer or an [sqlite3] object pointer obtained +** from [sqlite3_open()], [sqlite3_open16()], or +** [sqlite3_open_v2()], and not previously closed. +** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer +** argument is a harmless no-op. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_close(sqlite3*); +SQLITE_API int SQLITE_STDCALL sqlite3_close_v2(sqlite3*); + +/* +** The type for a callback function. +** This is legacy and deprecated. It is included for historical +** compatibility and is not documented. +*/ +typedef int (*sqlite3_callback)(void*,int,char**, char**); + +/* +** CAPI3REF: One-Step Query Execution Interface +** METHOD: sqlite3 +** +** The sqlite3_exec() interface is a convenience wrapper around +** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], +** that allows an application to run multiple statements of SQL +** without having to use a lot of C code. +** +** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, +** semicolon-separate SQL statements passed into its 2nd argument, +** in the context of the [database connection] passed in as its 1st +** argument. ^If the callback function of the 3rd argument to +** sqlite3_exec() is not NULL, then it is invoked for each result row +** coming out of the evaluated SQL statements. ^The 4th argument to +** sqlite3_exec() is relayed through to the 1st argument of each +** callback invocation. ^If the callback pointer to sqlite3_exec() +** is NULL, then no callback is ever invoked and result rows are +** ignored. +** +** ^If an error occurs while evaluating the SQL statements passed into +** sqlite3_exec(), then execution of the current statement stops and +** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() +** is not NULL then any error message is written into memory obtained +** from [sqlite3_malloc()] and passed back through the 5th parameter. +** To avoid memory leaks, the application should invoke [sqlite3_free()] +** on error message strings returned through the 5th parameter of +** of sqlite3_exec() after the error message string is no longer needed. +** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors +** occur, then sqlite3_exec() sets the pointer in its 5th parameter to +** NULL before returning. +** +** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() +** routine returns SQLITE_ABORT without invoking the callback again and +** without running any subsequent SQL statements. +** +** ^The 2nd argument to the sqlite3_exec() callback function is the +** number of columns in the result. ^The 3rd argument to the sqlite3_exec() +** callback is an array of pointers to strings obtained as if from +** [sqlite3_column_text()], one for each column. ^If an element of a +** result row is NULL then the corresponding string pointer for the +** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the +** sqlite3_exec() callback is an array of pointers to strings where each +** entry represents the name of corresponding result column as obtained +** from [sqlite3_column_name()]. +** +** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer +** to an empty string, or a pointer that contains only whitespace and/or +** SQL comments, then no SQL statements are evaluated and the database +** is not changed. +** +** Restrictions: +** +**
    +**
  • The application must ensure that the 1st parameter to sqlite3_exec() +** is a valid and open [database connection]. +**
  • The application must not close the [database connection] specified by +** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running. +**
  • The application must not modify the SQL statement text passed into +** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running. +**
+*/ +SQLITE_API int SQLITE_STDCALL sqlite3_exec( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be evaluated */ + int (*callback)(void*,int,char**,char**), /* Callback function */ + void *, /* 1st argument to callback */ + char **errmsg /* Error msg written here */ +); + +/* +** CAPI3REF: Result Codes +** KEYWORDS: {result code definitions} +** +** Many SQLite functions return an integer result code from the set shown +** here in order to indicate success or failure. +** +** New error codes may be added in future versions of SQLite. +** +** See also: [extended result code definitions] +*/ +#define SQLITE_OK 0 /* Successful result */ +/* beginning-of-error-codes */ +#define SQLITE_ERROR 1 /* SQL error or missing database */ +#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ +#define SQLITE_PERM 3 /* Access permission denied */ +#define SQLITE_ABORT 4 /* Callback routine requested an abort */ +#define SQLITE_BUSY 5 /* The database file is locked */ +#define SQLITE_LOCKED 6 /* A table in the database is locked */ +#define SQLITE_NOMEM 7 /* A malloc() failed */ +#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ +#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ +#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ +#define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */ +#define SQLITE_FULL 13 /* Insertion failed because database is full */ +#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ +#define SQLITE_PROTOCOL 15 /* Database lock protocol error */ +#define SQLITE_EMPTY 16 /* Database is empty */ +#define SQLITE_SCHEMA 17 /* The database schema changed */ +#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ +#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ +#define SQLITE_MISMATCH 20 /* Data type mismatch */ +#define SQLITE_MISUSE 21 /* Library used incorrectly */ +#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ +#define SQLITE_AUTH 23 /* Authorization denied */ +#define SQLITE_FORMAT 24 /* Auxiliary database format error */ +#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ +#define SQLITE_NOTADB 26 /* File opened that is not a database file */ +#define SQLITE_NOTICE 27 /* Notifications from sqlite3_log() */ +#define SQLITE_WARNING 28 /* Warnings from sqlite3_log() */ +#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ +/* end-of-error-codes */ + +/* +** CAPI3REF: Extended Result Codes +** KEYWORDS: {extended result code definitions} +** +** In its default configuration, SQLite API routines return one of 30 integer +** [result codes]. However, experience has shown that many of +** these result codes are too coarse-grained. They do not provide as +** much information about problems as programmers might like. In an effort to +** address this, newer versions of SQLite (version 3.3.8 and later) include +** support for additional result codes that provide more detailed information +** about errors. These [extended result codes] are enabled or disabled +** on a per database connection basis using the +** [sqlite3_extended_result_codes()] API. Or, the extended code for +** the most recent error can be obtained using +** [sqlite3_extended_errcode()]. +*/ +#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) +#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) +#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) +#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) +#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) +#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) +#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) +#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) +#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) +#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) +#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) +#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) +#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) +#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) +#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) +#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) +#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) +#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8)) +#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8)) +#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8)) +#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8)) +#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8)) +#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8)) +#define SQLITE_IOERR_MMAP (SQLITE_IOERR | (24<<8)) +#define SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR | (25<<8)) +#define SQLITE_IOERR_CONVPATH (SQLITE_IOERR | (26<<8)) +#define SQLITE_IOERR_VNODE (SQLITE_IOERR | (27<<8)) +#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8)) +#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8)) +#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY | (2<<8)) +#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8)) +#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8)) +#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8)) +#define SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN | (4<<8)) +#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) +#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8)) +#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8)) +#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8)) +#define SQLITE_READONLY_DBMOVED (SQLITE_READONLY | (4<<8)) +#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8)) +#define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8)) +#define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8)) +#define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8)) +#define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8)) +#define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8)) +#define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8)) +#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8)) +#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8)) +#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8)) +#define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8)) +#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8)) +#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8)) +#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8)) +#define SQLITE_AUTH_USER (SQLITE_AUTH | (1<<8)) + +/* +** CAPI3REF: Flags For File Open Operations +** +** These bit values are intended for use in the +** 3rd parameter to the [sqlite3_open_v2()] interface and +** in the 4th parameter to the [sqlite3_vfs.xOpen] method. +*/ +#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */ +#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */ +#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */ +#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */ +#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */ +#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */ +#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */ +#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */ +#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */ +#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ +#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */ + +/* Reserved: 0x00F00000 */ + +/* +** CAPI3REF: Device Characteristics +** +** The xDeviceCharacteristics method of the [sqlite3_io_methods] +** object returns an integer which is a vector of these +** bit values expressing I/O characteristics of the mass storage +** device that holds the file that the [sqlite3_io_methods] +** refers to. +** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that +** after reboot following a crash or power loss, the only bytes in a +** file that were written at the application level might have changed +** and that adjacent bytes, even bytes within the same sector are +** guaranteed to be unchanged. The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN +** flag indicate that a file cannot be deleted when open. The +** SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on +** read-only media and cannot be changed even by processes with +** elevated privileges. +*/ +#define SQLITE_IOCAP_ATOMIC 0x00000001 +#define SQLITE_IOCAP_ATOMIC512 0x00000002 +#define SQLITE_IOCAP_ATOMIC1K 0x00000004 +#define SQLITE_IOCAP_ATOMIC2K 0x00000008 +#define SQLITE_IOCAP_ATOMIC4K 0x00000010 +#define SQLITE_IOCAP_ATOMIC8K 0x00000020 +#define SQLITE_IOCAP_ATOMIC16K 0x00000040 +#define SQLITE_IOCAP_ATOMIC32K 0x00000080 +#define SQLITE_IOCAP_ATOMIC64K 0x00000100 +#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 +#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 +#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800 +#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000 +#define SQLITE_IOCAP_IMMUTABLE 0x00002000 + +/* +** CAPI3REF: File Locking Levels +** +** SQLite uses one of these integer values as the second +** argument to calls it makes to the xLock() and xUnlock() methods +** of an [sqlite3_io_methods] object. +*/ +#define SQLITE_LOCK_NONE 0 +#define SQLITE_LOCK_SHARED 1 +#define SQLITE_LOCK_RESERVED 2 +#define SQLITE_LOCK_PENDING 3 +#define SQLITE_LOCK_EXCLUSIVE 4 + +/* +** CAPI3REF: Synchronization Type Flags +** +** When SQLite invokes the xSync() method of an +** [sqlite3_io_methods] object it uses a combination of +** these integer values as the second argument. +** +** When the SQLITE_SYNC_DATAONLY flag is used, it means that the +** sync operation only needs to flush data to mass storage. Inode +** information need not be flushed. If the lower four bits of the flag +** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics. +** If the lower four bits equal SQLITE_SYNC_FULL, that means +** to use Mac OS X style fullsync instead of fsync(). +** +** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags +** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL +** settings. The [synchronous pragma] determines when calls to the +** xSync VFS method occur and applies uniformly across all platforms. +** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how +** energetic or rigorous or forceful the sync operations are and +** only make a difference on Mac OSX for the default SQLite code. +** (Third-party VFS implementations might also make the distinction +** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the +** operating systems natively supported by SQLite, only Mac OSX +** cares about the difference.) +*/ +#define SQLITE_SYNC_NORMAL 0x00002 +#define SQLITE_SYNC_FULL 0x00003 +#define SQLITE_SYNC_DATAONLY 0x00010 + +/* +** CAPI3REF: OS Interface Open File Handle +** +** An [sqlite3_file] object represents an open file in the +** [sqlite3_vfs | OS interface layer]. Individual OS interface +** implementations will +** want to subclass this object by appending additional fields +** for their own use. The pMethods entry is a pointer to an +** [sqlite3_io_methods] object that defines methods for performing +** I/O operations on the open file. +*/ +typedef struct sqlite3_file sqlite3_file; +struct sqlite3_file { + const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ +}; + +/* +** CAPI3REF: OS Interface File Virtual Methods Object +** +** Every file opened by the [sqlite3_vfs.xOpen] method populates an +** [sqlite3_file] object (or, more commonly, a subclass of the +** [sqlite3_file] object) with a pointer to an instance of this object. +** This object defines the methods used to perform various operations +** against the open file represented by the [sqlite3_file] object. +** +** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element +** to a non-NULL pointer, then the sqlite3_io_methods.xClose method +** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed. The +** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen] +** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element +** to NULL. +** +** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or +** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). +** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] +** flag may be ORed in to indicate that only the data of the file +** and not its inode needs to be synced. +** +** The integer values to xLock() and xUnlock() are one of +**
    +**
  • [SQLITE_LOCK_NONE], +**
  • [SQLITE_LOCK_SHARED], +**
  • [SQLITE_LOCK_RESERVED], +**
  • [SQLITE_LOCK_PENDING], or +**
  • [SQLITE_LOCK_EXCLUSIVE]. +**
+** xLock() increases the lock. xUnlock() decreases the lock. +** The xCheckReservedLock() method checks whether any database connection, +** either in this process or in some other process, is holding a RESERVED, +** PENDING, or EXCLUSIVE lock on the file. It returns true +** if such a lock exists and false otherwise. +** +** The xFileControl() method is a generic interface that allows custom +** VFS implementations to directly control an open file using the +** [sqlite3_file_control()] interface. The second "op" argument is an +** integer opcode. The third argument is a generic pointer intended to +** point to a structure that may contain arguments or space in which to +** write return values. Potential uses for xFileControl() might be +** functions to enable blocking locks with timeouts, to change the +** locking strategy (for example to use dot-file locks), to inquire +** about the status of a lock, or to break stale locks. The SQLite +** core reserves all opcodes less than 100 for its own use. +** A [file control opcodes | list of opcodes] less than 100 is available. +** Applications that define a custom xFileControl method should use opcodes +** greater than 100 to avoid conflicts. VFS implementations should +** return [SQLITE_NOTFOUND] for file control opcodes that they do not +** recognize. +** +** The xSectorSize() method returns the sector size of the +** device that underlies the file. The sector size is the +** minimum write that can be performed without disturbing +** other bytes in the file. The xDeviceCharacteristics() +** method returns a bit vector describing behaviors of the +** underlying device: +** +**
    +**
  • [SQLITE_IOCAP_ATOMIC] +**
  • [SQLITE_IOCAP_ATOMIC512] +**
  • [SQLITE_IOCAP_ATOMIC1K] +**
  • [SQLITE_IOCAP_ATOMIC2K] +**
  • [SQLITE_IOCAP_ATOMIC4K] +**
  • [SQLITE_IOCAP_ATOMIC8K] +**
  • [SQLITE_IOCAP_ATOMIC16K] +**
  • [SQLITE_IOCAP_ATOMIC32K] +**
  • [SQLITE_IOCAP_ATOMIC64K] +**
  • [SQLITE_IOCAP_SAFE_APPEND] +**
  • [SQLITE_IOCAP_SEQUENTIAL] +**
+** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). +** +** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill +** in the unread portions of the buffer with zeros. A VFS that +** fails to zero-fill short reads might seem to work. However, +** failure to zero-fill short reads will eventually lead to +** database corruption. +*/ +typedef struct sqlite3_io_methods sqlite3_io_methods; +struct sqlite3_io_methods { + int iVersion; + int (*xClose)(sqlite3_file*); + int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); + int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); + int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); + int (*xSync)(sqlite3_file*, int flags); + int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); + int (*xLock)(sqlite3_file*, int); + int (*xUnlock)(sqlite3_file*, int); + int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); + int (*xFileControl)(sqlite3_file*, int op, void *pArg); + int (*xSectorSize)(sqlite3_file*); + int (*xDeviceCharacteristics)(sqlite3_file*); + /* Methods above are valid for version 1 */ + int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**); + int (*xShmLock)(sqlite3_file*, int offset, int n, int flags); + void (*xShmBarrier)(sqlite3_file*); + int (*xShmUnmap)(sqlite3_file*, int deleteFlag); + /* Methods above are valid for version 2 */ + int (*xFetch)(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); + int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p); + /* Methods above are valid for version 3 */ + /* Additional methods may be added in future releases */ +}; + +/* +** CAPI3REF: Standard File Control Opcodes +** KEYWORDS: {file control opcodes} {file control opcode} +** +** These integer constants are opcodes for the xFileControl method +** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] +** interface. +** +**
    +**
  • [[SQLITE_FCNTL_LOCKSTATE]] +** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This +** opcode causes the xFileControl method to write the current state of +** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], +** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) +** into an integer that the pArg argument points to. This capability +** is used during testing and is only available when the SQLITE_TEST +** compile-time option is used. +** +**
  • [[SQLITE_FCNTL_SIZE_HINT]] +** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS +** layer a hint of how large the database file will grow to be during the +** current transaction. This hint is not guaranteed to be accurate but it +** is often close. The underlying VFS might choose to preallocate database +** file space based on this hint in order to help writes to the database +** file run faster. +** +**
  • [[SQLITE_FCNTL_CHUNK_SIZE]] +** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS +** extends and truncates the database file in chunks of a size specified +** by the user. The fourth argument to [sqlite3_file_control()] should +** point to an integer (type int) containing the new chunk-size to use +** for the nominated database. Allocating database file space in large +** chunks (say 1MB at a time), may reduce file-system fragmentation and +** improve performance on some systems. +** +**
  • [[SQLITE_FCNTL_FILE_POINTER]] +** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer +** to the [sqlite3_file] object associated with a particular database +** connection. See the [sqlite3_file_control()] documentation for +** additional information. +** +**
  • [[SQLITE_FCNTL_SYNC_OMITTED]] +** No longer in use. +** +**
  • [[SQLITE_FCNTL_SYNC]] +** The [SQLITE_FCNTL_SYNC] opcode is generated internally by SQLite and +** sent to the VFS immediately before the xSync method is invoked on a +** database file descriptor. Or, if the xSync method is not invoked +** because the user has configured SQLite with +** [PRAGMA synchronous | PRAGMA synchronous=OFF] it is invoked in place +** of the xSync method. In most cases, the pointer argument passed with +** this file-control is NULL. However, if the database file is being synced +** as part of a multi-database commit, the argument points to a nul-terminated +** string containing the transactions master-journal file name. VFSes that +** do not need this signal should silently ignore this opcode. Applications +** should not call [sqlite3_file_control()] with this opcode as doing so may +** disrupt the operation of the specialized VFSes that do require it. +** +**
  • [[SQLITE_FCNTL_COMMIT_PHASETWO]] +** The [SQLITE_FCNTL_COMMIT_PHASETWO] opcode is generated internally by SQLite +** and sent to the VFS after a transaction has been committed immediately +** but before the database is unlocked. VFSes that do not need this signal +** should silently ignore this opcode. Applications should not call +** [sqlite3_file_control()] with this opcode as doing so may disrupt the +** operation of the specialized VFSes that do require it. +** +**
  • [[SQLITE_FCNTL_WIN32_AV_RETRY]] +** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic +** retry counts and intervals for certain disk I/O operations for the +** windows [VFS] in order to provide robustness in the presence of +** anti-virus programs. By default, the windows VFS will retry file read, +** file write, and file delete operations up to 10 times, with a delay +** of 25 milliseconds before the first retry and with the delay increasing +** by an additional 25 milliseconds with each subsequent retry. This +** opcode allows these two values (10 retries and 25 milliseconds of delay) +** to be adjusted. The values are changed for all database connections +** within the same process. The argument is a pointer to an array of two +** integers where the first integer i the new retry count and the second +** integer is the delay. If either integer is negative, then the setting +** is not changed but instead the prior value of that setting is written +** into the array entry, allowing the current retry settings to be +** interrogated. The zDbName parameter is ignored. +** +**
  • [[SQLITE_FCNTL_PERSIST_WAL]] +** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the +** persistent [WAL | Write Ahead Log] setting. By default, the auxiliary +** write ahead log and shared memory files used for transaction control +** are automatically deleted when the latest connection to the database +** closes. Setting persistent WAL mode causes those files to persist after +** close. Persisting the files is useful when other processes that do not +** have write permission on the directory containing the database file want +** to read the database file, as the WAL and shared memory files must exist +** in order for the database to be readable. The fourth parameter to +** [sqlite3_file_control()] for this opcode should be a pointer to an integer. +** That integer is 0 to disable persistent WAL mode or 1 to enable persistent +** WAL mode. If the integer is -1, then it is overwritten with the current +** WAL persistence setting. +** +**
  • [[SQLITE_FCNTL_POWERSAFE_OVERWRITE]] +** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the +** persistent "powersafe-overwrite" or "PSOW" setting. The PSOW setting +** determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the +** xDeviceCharacteristics methods. The fourth parameter to +** [sqlite3_file_control()] for this opcode should be a pointer to an integer. +** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage +** mode. If the integer is -1, then it is overwritten with the current +** zero-damage mode setting. +** +**
  • [[SQLITE_FCNTL_OVERWRITE]] +** ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening +** a write transaction to indicate that, unless it is rolled back for some +** reason, the entire database file will be overwritten by the current +** transaction. This is used by VACUUM operations. +** +**
  • [[SQLITE_FCNTL_VFSNAME]] +** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of +** all [VFSes] in the VFS stack. The names are of all VFS shims and the +** final bottom-level VFS are written into memory obtained from +** [sqlite3_malloc()] and the result is stored in the char* variable +** that the fourth parameter of [sqlite3_file_control()] points to. +** The caller is responsible for freeing the memory when done. As with +** all file-control actions, there is no guarantee that this will actually +** do anything. Callers should initialize the char* variable to a NULL +** pointer in case this file-control is not implemented. This file-control +** is intended for diagnostic use only. +** +**
  • [[SQLITE_FCNTL_PRAGMA]] +** ^Whenever a [PRAGMA] statement is parsed, an [SQLITE_FCNTL_PRAGMA] +** file control is sent to the open [sqlite3_file] object corresponding +** to the database file to which the pragma statement refers. ^The argument +** to the [SQLITE_FCNTL_PRAGMA] file control is an array of +** pointers to strings (char**) in which the second element of the array +** is the name of the pragma and the third element is the argument to the +** pragma or NULL if the pragma has no argument. ^The handler for an +** [SQLITE_FCNTL_PRAGMA] file control can optionally make the first element +** of the char** argument point to a string obtained from [sqlite3_mprintf()] +** or the equivalent and that string will become the result of the pragma or +** the error message if the pragma fails. ^If the +** [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal +** [PRAGMA] processing continues. ^If the [SQLITE_FCNTL_PRAGMA] +** file control returns [SQLITE_OK], then the parser assumes that the +** VFS has handled the PRAGMA itself and the parser generates a no-op +** prepared statement if result string is NULL, or that returns a copy +** of the result string if the string is non-NULL. +** ^If the [SQLITE_FCNTL_PRAGMA] file control returns +** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means +** that the VFS encountered an error while handling the [PRAGMA] and the +** compilation of the PRAGMA fails with an error. ^The [SQLITE_FCNTL_PRAGMA] +** file control occurs at the beginning of pragma statement analysis and so +** it is able to override built-in [PRAGMA] statements. +** +**
  • [[SQLITE_FCNTL_BUSYHANDLER]] +** ^The [SQLITE_FCNTL_BUSYHANDLER] +** file-control may be invoked by SQLite on the database file handle +** shortly after it is opened in order to provide a custom VFS with access +** to the connections busy-handler callback. The argument is of type (void **) +** - an array of two (void *) values. The first (void *) actually points +** to a function of type (int (*)(void *)). In order to invoke the connections +** busy-handler, this function should be invoked with the second (void *) in +** the array as the only argument. If it returns non-zero, then the operation +** should be retried. If it returns zero, the custom VFS should abandon the +** current operation. +** +**
  • [[SQLITE_FCNTL_TEMPFILENAME]] +** ^Application can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control +** to have SQLite generate a +** temporary filename using the same algorithm that is followed to generate +** temporary filenames for TEMP tables and other internal uses. The +** argument should be a char** which will be filled with the filename +** written into memory obtained from [sqlite3_malloc()]. The caller should +** invoke [sqlite3_free()] on the result to avoid a memory leak. +** +**
  • [[SQLITE_FCNTL_MMAP_SIZE]] +** The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the +** maximum number of bytes that will be used for memory-mapped I/O. +** The argument is a pointer to a value of type sqlite3_int64 that +** is an advisory maximum number of bytes in the file to memory map. The +** pointer is overwritten with the old value. The limit is not changed if +** the value originally pointed to is negative, and so the current limit +** can be queried by passing in a pointer to a negative number. This +** file-control is used internally to implement [PRAGMA mmap_size]. +** +**
  • [[SQLITE_FCNTL_TRACE]] +** The [SQLITE_FCNTL_TRACE] file control provides advisory information +** to the VFS about what the higher layers of the SQLite stack are doing. +** This file control is used by some VFS activity tracing [shims]. +** The argument is a zero-terminated string. Higher layers in the +** SQLite stack may generate instances of this file control if +** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled. +** +**
  • [[SQLITE_FCNTL_HAS_MOVED]] +** The [SQLITE_FCNTL_HAS_MOVED] file control interprets its argument as a +** pointer to an integer and it writes a boolean into that integer depending +** on whether or not the file has been renamed, moved, or deleted since it +** was first opened. +** +**
  • [[SQLITE_FCNTL_WIN32_SET_HANDLE]] +** The [SQLITE_FCNTL_WIN32_SET_HANDLE] opcode is used for debugging. This +** opcode causes the xFileControl method to swap the file handle with the one +** pointed to by the pArg argument. This capability is used during testing +** and only needs to be supported when SQLITE_TEST is defined. +** +**
  • [[SQLITE_FCNTL_WAL_BLOCK]] +** The [SQLITE_FCNTL_WAL_BLOCK] is a signal to the VFS layer that it might +** be advantageous to block on the next WAL lock if the lock is not immediately +** available. The WAL subsystem issues this signal during rare +** circumstances in order to fix a problem with priority inversion. +** Applications should not use this file-control. +** +**
  • [[SQLITE_FCNTL_ZIPVFS]] +** The [SQLITE_FCNTL_ZIPVFS] opcode is implemented by zipvfs only. All other +** VFS should return SQLITE_NOTFOUND for this opcode. +** +**
  • [[SQLITE_FCNTL_RBU]] +** The [SQLITE_FCNTL_RBU] opcode is implemented by the special VFS used by +** the RBU extension only. All other VFS should return SQLITE_NOTFOUND for +** this opcode. +**
+*/ +#define SQLITE_FCNTL_LOCKSTATE 1 +#define SQLITE_FCNTL_GET_LOCKPROXYFILE 2 +#define SQLITE_FCNTL_SET_LOCKPROXYFILE 3 +#define SQLITE_FCNTL_LAST_ERRNO 4 +#define SQLITE_FCNTL_SIZE_HINT 5 +#define SQLITE_FCNTL_CHUNK_SIZE 6 +#define SQLITE_FCNTL_FILE_POINTER 7 +#define SQLITE_FCNTL_SYNC_OMITTED 8 +#define SQLITE_FCNTL_WIN32_AV_RETRY 9 +#define SQLITE_FCNTL_PERSIST_WAL 10 +#define SQLITE_FCNTL_OVERWRITE 11 +#define SQLITE_FCNTL_VFSNAME 12 +#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13 +#define SQLITE_FCNTL_PRAGMA 14 +#define SQLITE_FCNTL_BUSYHANDLER 15 +#define SQLITE_FCNTL_TEMPFILENAME 16 +#define SQLITE_FCNTL_MMAP_SIZE 18 +#define SQLITE_FCNTL_TRACE 19 +#define SQLITE_FCNTL_HAS_MOVED 20 +#define SQLITE_FCNTL_SYNC 21 +#define SQLITE_FCNTL_COMMIT_PHASETWO 22 +#define SQLITE_FCNTL_WIN32_SET_HANDLE 23 +#define SQLITE_FCNTL_WAL_BLOCK 24 +#define SQLITE_FCNTL_ZIPVFS 25 +#define SQLITE_FCNTL_RBU 26 + +/* deprecated names */ +#define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE +#define SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE +#define SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO + + +/* +** CAPI3REF: Mutex Handle +** +** The mutex module within SQLite defines [sqlite3_mutex] to be an +** abstract type for a mutex object. The SQLite core never looks +** at the internal representation of an [sqlite3_mutex]. It only +** deals with pointers to the [sqlite3_mutex] object. +** +** Mutexes are created using [sqlite3_mutex_alloc()]. +*/ +typedef struct sqlite3_mutex sqlite3_mutex; + +/* +** CAPI3REF: OS Interface Object +** +** An instance of the sqlite3_vfs object defines the interface between +** the SQLite core and the underlying operating system. The "vfs" +** in the name of the object stands for "virtual file system". See +** the [VFS | VFS documentation] for further information. +** +** The value of the iVersion field is initially 1 but may be larger in +** future versions of SQLite. Additional fields may be appended to this +** object when the iVersion value is increased. Note that the structure +** of the sqlite3_vfs object changes in the transaction between +** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not +** modified. +** +** The szOsFile field is the size of the subclassed [sqlite3_file] +** structure used by this VFS. mxPathname is the maximum length of +** a pathname in this VFS. +** +** Registered sqlite3_vfs objects are kept on a linked list formed by +** the pNext pointer. The [sqlite3_vfs_register()] +** and [sqlite3_vfs_unregister()] interfaces manage this list +** in a thread-safe way. The [sqlite3_vfs_find()] interface +** searches the list. Neither the application code nor the VFS +** implementation should use the pNext pointer. +** +** The pNext field is the only field in the sqlite3_vfs +** structure that SQLite will ever modify. SQLite will only access +** or modify this field while holding a particular static mutex. +** The application should never modify anything within the sqlite3_vfs +** object once the object has been registered. +** +** The zName field holds the name of the VFS module. The name must +** be unique across all VFS modules. +** +** [[sqlite3_vfs.xOpen]] +** ^SQLite guarantees that the zFilename parameter to xOpen +** is either a NULL pointer or string obtained +** from xFullPathname() with an optional suffix added. +** ^If a suffix is added to the zFilename parameter, it will +** consist of a single "-" character followed by no more than +** 11 alphanumeric and/or "-" characters. +** ^SQLite further guarantees that +** the string will be valid and unchanged until xClose() is +** called. Because of the previous sentence, +** the [sqlite3_file] can safely store a pointer to the +** filename if it needs to remember the filename for some reason. +** If the zFilename parameter to xOpen is a NULL pointer then xOpen +** must invent its own temporary name for the file. ^Whenever the +** xFilename parameter is NULL it will also be the case that the +** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. +** +** The flags argument to xOpen() includes all bits set in +** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] +** or [sqlite3_open16()] is used, then flags includes at least +** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. +** If xOpen() opens a file read-only then it sets *pOutFlags to +** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. +** +** ^(SQLite will also add one of the following flags to the xOpen() +** call, depending on the object being opened: +** +**
    +**
  • [SQLITE_OPEN_MAIN_DB] +**
  • [SQLITE_OPEN_MAIN_JOURNAL] +**
  • [SQLITE_OPEN_TEMP_DB] +**
  • [SQLITE_OPEN_TEMP_JOURNAL] +**
  • [SQLITE_OPEN_TRANSIENT_DB] +**
  • [SQLITE_OPEN_SUBJOURNAL] +**
  • [SQLITE_OPEN_MASTER_JOURNAL] +**
  • [SQLITE_OPEN_WAL] +**
)^ +** +** The file I/O implementation can use the object type flags to +** change the way it deals with files. For example, an application +** that does not care about crash recovery or rollback might make +** the open of a journal file a no-op. Writes to this journal would +** also be no-ops, and any attempt to read the journal would return +** SQLITE_IOERR. Or the implementation might recognize that a database +** file will be doing page-aligned sector reads and writes in a random +** order and set up its I/O subsystem accordingly. +** +** SQLite might also add one of the following flags to the xOpen method: +** +**
    +**
  • [SQLITE_OPEN_DELETEONCLOSE] +**
  • [SQLITE_OPEN_EXCLUSIVE] +**
+** +** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be +** deleted when it is closed. ^The [SQLITE_OPEN_DELETEONCLOSE] +** will be set for TEMP databases and their journals, transient +** databases, and subjournals. +** +** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction +** with the [SQLITE_OPEN_CREATE] flag, which are both directly +** analogous to the O_EXCL and O_CREAT flags of the POSIX open() +** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the +** SQLITE_OPEN_CREATE, is used to indicate that file should always +** be created, and that it is an error if it already exists. +** It is not used to indicate the file should be opened +** for exclusive access. +** +** ^At least szOsFile bytes of memory are allocated by SQLite +** to hold the [sqlite3_file] structure passed as the third +** argument to xOpen. The xOpen method does not have to +** allocate the structure; it should just fill it in. Note that +** the xOpen method must set the sqlite3_file.pMethods to either +** a valid [sqlite3_io_methods] object or to NULL. xOpen must do +** this even if the open fails. SQLite expects that the sqlite3_file.pMethods +** element will be valid after xOpen returns regardless of the success +** or failure of the xOpen call. +** +** [[sqlite3_vfs.xAccess]] +** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] +** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to +** test whether a file is readable and writable, or [SQLITE_ACCESS_READ] +** to test whether a file is at least readable. The file can be a +** directory. +** +** ^SQLite will always allocate at least mxPathname+1 bytes for the +** output buffer xFullPathname. The exact size of the output buffer +** is also passed as a parameter to both methods. If the output buffer +** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is +** handled as a fatal error by SQLite, vfs implementations should endeavor +** to prevent this by setting mxPathname to a sufficiently large value. +** +** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64() +** interfaces are not strictly a part of the filesystem, but they are +** included in the VFS structure for completeness. +** The xRandomness() function attempts to return nBytes bytes +** of good-quality randomness into zOut. The return value is +** the actual number of bytes of randomness obtained. +** The xSleep() method causes the calling thread to sleep for at +** least the number of microseconds given. ^The xCurrentTime() +** method returns a Julian Day Number for the current date and time as +** a floating point value. +** ^The xCurrentTimeInt64() method returns, as an integer, the Julian +** Day Number multiplied by 86400000 (the number of milliseconds in +** a 24-hour day). +** ^SQLite will use the xCurrentTimeInt64() method to get the current +** date and time if that method is available (if iVersion is 2 or +** greater and the function pointer is not NULL) and will fall back +** to xCurrentTime() if xCurrentTimeInt64() is unavailable. +** +** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces +** are not used by the SQLite core. These optional interfaces are provided +** by some VFSes to facilitate testing of the VFS code. By overriding +** system calls with functions under its control, a test program can +** simulate faults and error conditions that would otherwise be difficult +** or impossible to induce. The set of system calls that can be overridden +** varies from one VFS to another, and from one version of the same VFS to the +** next. Applications that use these interfaces must be prepared for any +** or all of these interfaces to be NULL or for their behavior to change +** from one release to the next. Applications must not attempt to access +** any of these methods if the iVersion of the VFS is less than 3. +*/ +typedef struct sqlite3_vfs sqlite3_vfs; +typedef void (*sqlite3_syscall_ptr)(void); +struct sqlite3_vfs { + int iVersion; /* Structure version number (currently 3) */ + int szOsFile; /* Size of subclassed sqlite3_file */ + int mxPathname; /* Maximum file pathname length */ + sqlite3_vfs *pNext; /* Next registered VFS */ + const char *zName; /* Name of this virtual file system */ + void *pAppData; /* Pointer to application-specific data */ + int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, + int flags, int *pOutFlags); + int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); + int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); + int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); + void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); + void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); + void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void); + void (*xDlClose)(sqlite3_vfs*, void*); + int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); + int (*xSleep)(sqlite3_vfs*, int microseconds); + int (*xCurrentTime)(sqlite3_vfs*, double*); + int (*xGetLastError)(sqlite3_vfs*, int, char *); + /* + ** The methods above are in version 1 of the sqlite_vfs object + ** definition. Those that follow are added in version 2 or later + */ + int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*); + /* + ** The methods above are in versions 1 and 2 of the sqlite_vfs object. + ** Those below are for version 3 and greater. + */ + int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr); + sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName); + const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName); + /* + ** The methods above are in versions 1 through 3 of the sqlite_vfs object. + ** New fields may be appended in figure versions. The iVersion + ** value will increment whenever this happens. + */ +}; + +/* +** CAPI3REF: Flags for the xAccess VFS method +** +** These integer constants can be used as the third parameter to +** the xAccess method of an [sqlite3_vfs] object. They determine +** what kind of permissions the xAccess method is looking for. +** With SQLITE_ACCESS_EXISTS, the xAccess method +** simply checks whether the file exists. +** With SQLITE_ACCESS_READWRITE, the xAccess method +** checks whether the named directory is both readable and writable +** (in other words, if files can be added, removed, and renamed within +** the directory). +** The SQLITE_ACCESS_READWRITE constant is currently used only by the +** [temp_store_directory pragma], though this could change in a future +** release of SQLite. +** With SQLITE_ACCESS_READ, the xAccess method +** checks whether the file is readable. The SQLITE_ACCESS_READ constant is +** currently unused, though it might be used in a future release of +** SQLite. +*/ +#define SQLITE_ACCESS_EXISTS 0 +#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */ +#define SQLITE_ACCESS_READ 2 /* Unused */ + +/* +** CAPI3REF: Flags for the xShmLock VFS method +** +** These integer constants define the various locking operations +** allowed by the xShmLock method of [sqlite3_io_methods]. The +** following are the only legal combinations of flags to the +** xShmLock method: +** +**
    +**
  • SQLITE_SHM_LOCK | SQLITE_SHM_SHARED +**
  • SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE +**
  • SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED +**
  • SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE +**
+** +** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as +** was given on the corresponding lock. +** +** The xShmLock method can transition between unlocked and SHARED or +** between unlocked and EXCLUSIVE. It cannot transition between SHARED +** and EXCLUSIVE. +*/ +#define SQLITE_SHM_UNLOCK 1 +#define SQLITE_SHM_LOCK 2 +#define SQLITE_SHM_SHARED 4 +#define SQLITE_SHM_EXCLUSIVE 8 + +/* +** CAPI3REF: Maximum xShmLock index +** +** The xShmLock method on [sqlite3_io_methods] may use values +** between 0 and this upper bound as its "offset" argument. +** The SQLite core will never attempt to acquire or release a +** lock outside of this range +*/ +#define SQLITE_SHM_NLOCK 8 + + +/* +** CAPI3REF: Initialize The SQLite Library +** +** ^The sqlite3_initialize() routine initializes the +** SQLite library. ^The sqlite3_shutdown() routine +** deallocates any resources that were allocated by sqlite3_initialize(). +** These routines are designed to aid in process initialization and +** shutdown on embedded systems. Workstation applications using +** SQLite normally do not need to invoke either of these routines. +** +** A call to sqlite3_initialize() is an "effective" call if it is +** the first time sqlite3_initialize() is invoked during the lifetime of +** the process, or if it is the first time sqlite3_initialize() is invoked +** following a call to sqlite3_shutdown(). ^(Only an effective call +** of sqlite3_initialize() does any initialization. All other calls +** are harmless no-ops.)^ +** +** A call to sqlite3_shutdown() is an "effective" call if it is the first +** call to sqlite3_shutdown() since the last sqlite3_initialize(). ^(Only +** an effective call to sqlite3_shutdown() does any deinitialization. +** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^ +** +** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown() +** is not. The sqlite3_shutdown() interface must only be called from a +** single thread. All open [database connections] must be closed and all +** other SQLite resources must be deallocated prior to invoking +** sqlite3_shutdown(). +** +** Among other things, ^sqlite3_initialize() will invoke +** sqlite3_os_init(). Similarly, ^sqlite3_shutdown() +** will invoke sqlite3_os_end(). +** +** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success. +** ^If for some reason, sqlite3_initialize() is unable to initialize +** the library (perhaps it is unable to allocate a needed resource such +** as a mutex) it returns an [error code] other than [SQLITE_OK]. +** +** ^The sqlite3_initialize() routine is called internally by many other +** SQLite interfaces so that an application usually does not need to +** invoke sqlite3_initialize() directly. For example, [sqlite3_open()] +** calls sqlite3_initialize() so the SQLite library will be automatically +** initialized when [sqlite3_open()] is called if it has not be initialized +** already. ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT] +** compile-time option, then the automatic calls to sqlite3_initialize() +** are omitted and the application must call sqlite3_initialize() directly +** prior to using any other SQLite interface. For maximum portability, +** it is recommended that applications always invoke sqlite3_initialize() +** directly prior to using any other SQLite interface. Future releases +** of SQLite may require this. In other words, the behavior exhibited +** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the +** default behavior in some future release of SQLite. +** +** The sqlite3_os_init() routine does operating-system specific +** initialization of the SQLite library. The sqlite3_os_end() +** routine undoes the effect of sqlite3_os_init(). Typical tasks +** performed by these routines include allocation or deallocation +** of static resources, initialization of global variables, +** setting up a default [sqlite3_vfs] module, or setting up +** a default configuration using [sqlite3_config()]. +** +** The application should never invoke either sqlite3_os_init() +** or sqlite3_os_end() directly. The application should only invoke +** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init() +** interface is called automatically by sqlite3_initialize() and +** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate +** implementations for sqlite3_os_init() and sqlite3_os_end() +** are built into SQLite when it is compiled for Unix, Windows, or OS/2. +** When [custom builds | built for other platforms] +** (using the [SQLITE_OS_OTHER=1] compile-time +** option) the application must supply a suitable implementation for +** sqlite3_os_init() and sqlite3_os_end(). An application-supplied +** implementation of sqlite3_os_init() or sqlite3_os_end() +** must return [SQLITE_OK] on success and some other [error code] upon +** failure. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_initialize(void); +SQLITE_API int SQLITE_STDCALL sqlite3_shutdown(void); +SQLITE_API int SQLITE_STDCALL sqlite3_os_init(void); +SQLITE_API int SQLITE_STDCALL sqlite3_os_end(void); + +/* +** CAPI3REF: Configuring The SQLite Library +** +** The sqlite3_config() interface is used to make global configuration +** changes to SQLite in order to tune SQLite to the specific needs of +** the application. The default configuration is recommended for most +** applications and so this routine is usually not necessary. It is +** provided to support rare applications with unusual needs. +** +** The sqlite3_config() interface is not threadsafe. The application +** must ensure that no other SQLite interfaces are invoked by other +** threads while sqlite3_config() is running. +** +** The sqlite3_config() interface +** may only be invoked prior to library initialization using +** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. +** ^If sqlite3_config() is called after [sqlite3_initialize()] and before +** [sqlite3_shutdown()] then it will return SQLITE_MISUSE. +** Note, however, that ^sqlite3_config() can be called as part of the +** implementation of an application-defined [sqlite3_os_init()]. +** +** The first argument to sqlite3_config() is an integer +** [configuration option] that determines +** what property of SQLite is to be configured. Subsequent arguments +** vary depending on the [configuration option] +** in the first argument. +** +** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK]. +** ^If the option is unknown or SQLite is unable to set the option +** then this routine returns a non-zero [error code]. +*/ +SQLITE_API int SQLITE_CDECL sqlite3_config(int, ...); + +/* +** CAPI3REF: Configure database connections +** METHOD: sqlite3 +** +** The sqlite3_db_config() interface is used to make configuration +** changes to a [database connection]. The interface is similar to +** [sqlite3_config()] except that the changes apply to a single +** [database connection] (specified in the first argument). +** +** The second argument to sqlite3_db_config(D,V,...) is the +** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code +** that indicates what aspect of the [database connection] is being configured. +** Subsequent arguments vary depending on the configuration verb. +** +** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if +** the call is considered successful. +*/ +SQLITE_API int SQLITE_CDECL sqlite3_db_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Memory Allocation Routines +** +** An instance of this object defines the interface between SQLite +** and low-level memory allocation routines. +** +** This object is used in only one place in the SQLite interface. +** A pointer to an instance of this object is the argument to +** [sqlite3_config()] when the configuration option is +** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. +** By creating an instance of this object +** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) +** during configuration, an application can specify an alternative +** memory allocation subsystem for SQLite to use for all of its +** dynamic memory needs. +** +** Note that SQLite comes with several [built-in memory allocators] +** that are perfectly adequate for the overwhelming majority of applications +** and that this object is only useful to a tiny minority of applications +** with specialized memory allocation requirements. This object is +** also used during testing of SQLite in order to specify an alternative +** memory allocator that simulates memory out-of-memory conditions in +** order to verify that SQLite recovers gracefully from such +** conditions. +** +** The xMalloc, xRealloc, and xFree methods must work like the +** malloc(), realloc() and free() functions from the standard C library. +** ^SQLite guarantees that the second argument to +** xRealloc is always a value returned by a prior call to xRoundup. +** +** xSize should return the allocated size of a memory allocation +** previously obtained from xMalloc or xRealloc. The allocated size +** is always at least as big as the requested size but may be larger. +** +** The xRoundup method returns what would be the allocated size of +** a memory allocation given a particular requested size. Most memory +** allocators round up memory allocations at least to the next multiple +** of 8. Some allocators round up to a larger multiple or to a power of 2. +** Every memory allocation request coming in through [sqlite3_malloc()] +** or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0, +** that causes the corresponding memory allocation to fail. +** +** The xInit method initializes the memory allocator. For example, +** it might allocate any require mutexes or initialize internal data +** structures. The xShutdown method is invoked (indirectly) by +** [sqlite3_shutdown()] and should deallocate any resources acquired +** by xInit. The pAppData pointer is used as the only parameter to +** xInit and xShutdown. +** +** SQLite holds the [SQLITE_MUTEX_STATIC_MASTER] mutex when it invokes +** the xInit method, so the xInit method need not be threadsafe. The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. For all other methods, SQLite +** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the +** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which +** it is by default) and so the methods are automatically serialized. +** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other +** methods must be threadsafe or else make their own arrangements for +** serialization. +** +** SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +*/ +typedef struct sqlite3_mem_methods sqlite3_mem_methods; +struct sqlite3_mem_methods { + void *(*xMalloc)(int); /* Memory allocation function */ + void (*xFree)(void*); /* Free a prior allocation */ + void *(*xRealloc)(void*,int); /* Resize an allocation */ + int (*xSize)(void*); /* Return the size of an allocation */ + int (*xRoundup)(int); /* Round up request size to allocation size */ + int (*xInit)(void*); /* Initialize the memory allocator */ + void (*xShutdown)(void*); /* Deinitialize the memory allocator */ + void *pAppData; /* Argument to xInit() and xShutdown() */ +}; + +/* +** CAPI3REF: Configuration Options +** KEYWORDS: {configuration option} +** +** These constants are the available integer configuration options that +** can be passed as the first argument to the [sqlite3_config()] interface. +** +** New configuration options may be added in future releases of SQLite. +** Existing configuration options might be discontinued. Applications +** should check the return code from [sqlite3_config()] to make sure that +** the call worked. The [sqlite3_config()] interface will return a +** non-zero [error code] if a discontinued or unsupported configuration option +** is invoked. +** +**
+** [[SQLITE_CONFIG_SINGLETHREAD]]
SQLITE_CONFIG_SINGLETHREAD
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Single-thread. In other words, it disables +** all mutexing and puts SQLite into a mode where it can only be used +** by a single thread. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to change the [threading mode] from its default +** value of Single-thread and so [sqlite3_config()] will return +** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD +** configuration option.
+** +** [[SQLITE_CONFIG_MULTITHREAD]]
SQLITE_CONFIG_MULTITHREAD
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Multi-thread. In other words, it disables +** mutexing on [database connection] and [prepared statement] objects. +** The application is responsible for serializing access to +** [database connections] and [prepared statements]. But other mutexes +** are enabled so that SQLite will be safe to use in a multi-threaded +** environment as long as no two threads attempt to use the same +** [database connection] at the same time. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to set the Multi-thread [threading mode] and +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the +** SQLITE_CONFIG_MULTITHREAD configuration option.
+** +** [[SQLITE_CONFIG_SERIALIZED]]
SQLITE_CONFIG_SERIALIZED
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Serialized. In other words, this option enables +** all mutexes including the recursive +** mutexes on [database connection] and [prepared statement] objects. +** In this mode (which is the default when SQLite is compiled with +** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access +** to [database connections] and [prepared statements] so that the +** application is free to use the same [database connection] or the +** same [prepared statement] in different threads at the same time. +** ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to set the Serialized [threading mode] and +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the +** SQLITE_CONFIG_SERIALIZED configuration option.
+** +** [[SQLITE_CONFIG_MALLOC]]
SQLITE_CONFIG_MALLOC
+**
^(The SQLITE_CONFIG_MALLOC option takes a single argument which is +** a pointer to an instance of the [sqlite3_mem_methods] structure. +** The argument specifies +** alternative low-level memory allocation routines to be used in place of +** the memory allocation routines built into SQLite.)^ ^SQLite makes +** its own private copy of the content of the [sqlite3_mem_methods] structure +** before the [sqlite3_config()] call returns.
+** +** [[SQLITE_CONFIG_GETMALLOC]]
SQLITE_CONFIG_GETMALLOC
+**
^(The SQLITE_CONFIG_GETMALLOC option takes a single argument which +** is a pointer to an instance of the [sqlite3_mem_methods] structure. +** The [sqlite3_mem_methods] +** structure is filled with the currently defined memory allocation routines.)^ +** This option can be used to overload the default memory allocation +** routines with a wrapper that simulations memory allocation failure or +** tracks memory usage, for example.
+** +** [[SQLITE_CONFIG_MEMSTATUS]]
SQLITE_CONFIG_MEMSTATUS
+**
^The SQLITE_CONFIG_MEMSTATUS option takes single argument of type int, +** interpreted as a boolean, which enables or disables the collection of +** memory allocation statistics. ^(When memory allocation statistics are +** disabled, the following SQLite interfaces become non-operational: +**
    +**
  • [sqlite3_memory_used()] +**
  • [sqlite3_memory_highwater()] +**
  • [sqlite3_soft_heap_limit64()] +**
  • [sqlite3_status64()] +**
)^ +** ^Memory allocation statistics are enabled by default unless SQLite is +** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory +** allocation statistics are disabled by default. +**
+** +** [[SQLITE_CONFIG_SCRATCH]]
SQLITE_CONFIG_SCRATCH
+**
^The SQLITE_CONFIG_SCRATCH option specifies a static memory buffer +** that SQLite can use for scratch memory. ^(There are three arguments +** to SQLITE_CONFIG_SCRATCH: A pointer an 8-byte +** aligned memory buffer from which the scratch allocations will be +** drawn, the size of each scratch allocation (sz), +** and the maximum number of scratch allocations (N).)^ +** The first argument must be a pointer to an 8-byte aligned buffer +** of at least sz*N bytes of memory. +** ^SQLite will not use more than one scratch buffers per thread. +** ^SQLite will never request a scratch buffer that is more than 6 +** times the database page size. +** ^If SQLite needs needs additional +** scratch memory beyond what is provided by this configuration option, then +** [sqlite3_malloc()] will be used to obtain the memory needed.

+** ^When the application provides any amount of scratch memory using +** SQLITE_CONFIG_SCRATCH, SQLite avoids unnecessary large +** [sqlite3_malloc|heap allocations]. +** This can help [Robson proof|prevent memory allocation failures] due to heap +** fragmentation in low-memory embedded systems. +**

+** +** [[SQLITE_CONFIG_PAGECACHE]]
SQLITE_CONFIG_PAGECACHE
+**
^The SQLITE_CONFIG_PAGECACHE option specifies a static memory buffer +** that SQLite can use for the database page cache with the default page +** cache implementation. +** This configuration should not be used if an application-define page +** cache implementation is loaded using the [SQLITE_CONFIG_PCACHE2] +** configuration option. +** ^There are three arguments to SQLITE_CONFIG_PAGECACHE: A pointer to +** 8-byte aligned +** memory, the size of each page buffer (sz), and the number of pages (N). +** The sz argument should be the size of the largest database page +** (a power of two between 512 and 65536) plus some extra bytes for each +** page header. ^The number of extra bytes needed by the page header +** can be determined using the [SQLITE_CONFIG_PCACHE_HDRSZ] option +** to [sqlite3_config()]. +** ^It is harmless, apart from the wasted memory, +** for the sz parameter to be larger than necessary. The first +** argument should pointer to an 8-byte aligned block of memory that +** is at least sz*N bytes of memory, otherwise subsequent behavior is +** undefined. +** ^SQLite will use the memory provided by the first argument to satisfy its +** memory needs for the first N pages that it adds to cache. ^If additional +** page cache memory is needed beyond what is provided by this option, then +** SQLite goes to [sqlite3_malloc()] for the additional storage space.
+** +** [[SQLITE_CONFIG_HEAP]]
SQLITE_CONFIG_HEAP
+**
^The SQLITE_CONFIG_HEAP option specifies a static memory buffer +** that SQLite will use for all of its dynamic memory allocation needs +** beyond those provided for by [SQLITE_CONFIG_SCRATCH] and +** [SQLITE_CONFIG_PAGECACHE]. +** ^The SQLITE_CONFIG_HEAP option is only available if SQLite is compiled +** with either [SQLITE_ENABLE_MEMSYS3] or [SQLITE_ENABLE_MEMSYS5] and returns +** [SQLITE_ERROR] if invoked otherwise. +** ^There are three arguments to SQLITE_CONFIG_HEAP: +** An 8-byte aligned pointer to the memory, +** the number of bytes in the memory buffer, and the minimum allocation size. +** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts +** to using its default memory allocator (the system malloc() implementation), +** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. ^If the +** memory pointer is not NULL then the alternative memory +** allocator is engaged to handle all of SQLites memory allocation needs. +** The first pointer (the memory pointer) must be aligned to an 8-byte +** boundary or subsequent behavior of SQLite will be undefined. +** The minimum allocation size is capped at 2**12. Reasonable values +** for the minimum allocation size are 2**5 through 2**8.
+** +** [[SQLITE_CONFIG_MUTEX]]
SQLITE_CONFIG_MUTEX
+**
^(The SQLITE_CONFIG_MUTEX option takes a single argument which is a +** pointer to an instance of the [sqlite3_mutex_methods] structure. +** The argument specifies alternative low-level mutex routines to be used +** in place the mutex routines built into SQLite.)^ ^SQLite makes a copy of +** the content of the [sqlite3_mutex_methods] structure before the call to +** [sqlite3_config()] returns. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** the entire mutexing subsystem is omitted from the build and hence calls to +** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will +** return [SQLITE_ERROR].
+** +** [[SQLITE_CONFIG_GETMUTEX]]
SQLITE_CONFIG_GETMUTEX
+**
^(The SQLITE_CONFIG_GETMUTEX option takes a single argument which +** is a pointer to an instance of the [sqlite3_mutex_methods] structure. The +** [sqlite3_mutex_methods] +** structure is filled with the currently defined mutex routines.)^ +** This option can be used to overload the default mutex allocation +** routines with a wrapper used to track mutex usage for performance +** profiling or testing, for example. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** the entire mutexing subsystem is omitted from the build and hence calls to +** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will +** return [SQLITE_ERROR].
+** +** [[SQLITE_CONFIG_LOOKASIDE]]
SQLITE_CONFIG_LOOKASIDE
+**
^(The SQLITE_CONFIG_LOOKASIDE option takes two arguments that determine +** the default size of lookaside memory on each [database connection]. +** The first argument is the +** size of each lookaside buffer slot and the second is the number of +** slots allocated to each database connection.)^ ^(SQLITE_CONFIG_LOOKASIDE +** sets the default lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE] +** option to [sqlite3_db_config()] can be used to change the lookaside +** configuration on individual connections.)^
+** +** [[SQLITE_CONFIG_PCACHE2]]
SQLITE_CONFIG_PCACHE2
+**
^(The SQLITE_CONFIG_PCACHE2 option takes a single argument which is +** a pointer to an [sqlite3_pcache_methods2] object. This object specifies +** the interface to a custom page cache implementation.)^ +** ^SQLite makes a copy of the [sqlite3_pcache_methods2] object.
+** +** [[SQLITE_CONFIG_GETPCACHE2]]
SQLITE_CONFIG_GETPCACHE2
+**
^(The SQLITE_CONFIG_GETPCACHE2 option takes a single argument which +** is a pointer to an [sqlite3_pcache_methods2] object. SQLite copies of +** the current page cache implementation into that object.)^
+** +** [[SQLITE_CONFIG_LOG]]
SQLITE_CONFIG_LOG
+**
The SQLITE_CONFIG_LOG option is used to configure the SQLite +** global [error log]. +** (^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a +** function with a call signature of void(*)(void*,int,const char*), +** and a pointer to void. ^If the function pointer is not NULL, it is +** invoked by [sqlite3_log()] to process each logging event. ^If the +** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op. +** ^The void pointer that is the second argument to SQLITE_CONFIG_LOG is +** passed through as the first parameter to the application-defined logger +** function whenever that function is invoked. ^The second parameter to +** the logger function is a copy of the first parameter to the corresponding +** [sqlite3_log()] call and is intended to be a [result code] or an +** [extended result code]. ^The third parameter passed to the logger is +** log message after formatting via [sqlite3_snprintf()]. +** The SQLite logging interface is not reentrant; the logger function +** supplied by the application must not invoke any SQLite interface. +** In a multi-threaded application, the application-defined logger +** function must be threadsafe.
+** +** [[SQLITE_CONFIG_URI]]
SQLITE_CONFIG_URI +**
^(The SQLITE_CONFIG_URI option takes a single argument of type int. +** If non-zero, then URI handling is globally enabled. If the parameter is zero, +** then URI handling is globally disabled.)^ ^If URI handling is globally +** enabled, all filenames passed to [sqlite3_open()], [sqlite3_open_v2()], +** [sqlite3_open16()] or +** specified as part of [ATTACH] commands are interpreted as URIs, regardless +** of whether or not the [SQLITE_OPEN_URI] flag is set when the database +** connection is opened. ^If it is globally disabled, filenames are +** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the +** database connection is opened. ^(By default, URI handling is globally +** disabled. The default value may be changed by compiling with the +** [SQLITE_USE_URI] symbol defined.)^ +** +** [[SQLITE_CONFIG_COVERING_INDEX_SCAN]]
SQLITE_CONFIG_COVERING_INDEX_SCAN +**
^The SQLITE_CONFIG_COVERING_INDEX_SCAN option takes a single integer +** argument which is interpreted as a boolean in order to enable or disable +** the use of covering indices for full table scans in the query optimizer. +** ^The default setting is determined +** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on" +** if that compile-time option is omitted. +** The ability to disable the use of covering indices for full table scans +** is because some incorrectly coded legacy applications might malfunction +** when the optimization is enabled. Providing the ability to +** disable the optimization allows the older, buggy application code to work +** without change even with newer versions of SQLite. +** +** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]] +**
SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE +**
These options are obsolete and should not be used by new code. +** They are retained for backwards compatibility but are now no-ops. +**
+** +** [[SQLITE_CONFIG_SQLLOG]] +**
SQLITE_CONFIG_SQLLOG +**
This option is only available if sqlite is compiled with the +** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should +** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int). +** The second should be of type (void*). The callback is invoked by the library +** in three separate circumstances, identified by the value passed as the +** fourth parameter. If the fourth parameter is 0, then the database connection +** passed as the second argument has just been opened. The third argument +** points to a buffer containing the name of the main database file. If the +** fourth parameter is 1, then the SQL statement that the third parameter +** points to has just been executed. Or, if the fourth parameter is 2, then +** the connection being passed as the second parameter is being closed. The +** third parameter is passed NULL In this case. An example of using this +** configuration option can be seen in the "test_sqllog.c" source file in +** the canonical SQLite source tree.
+** +** [[SQLITE_CONFIG_MMAP_SIZE]] +**
SQLITE_CONFIG_MMAP_SIZE +**
^SQLITE_CONFIG_MMAP_SIZE takes two 64-bit integer (sqlite3_int64) values +** that are the default mmap size limit (the default setting for +** [PRAGMA mmap_size]) and the maximum allowed mmap size limit. +** ^The default setting can be overridden by each database connection using +** either the [PRAGMA mmap_size] command, or by using the +** [SQLITE_FCNTL_MMAP_SIZE] file control. ^(The maximum allowed mmap size +** will be silently truncated if necessary so that it does not exceed the +** compile-time maximum mmap size set by the +** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^ +** ^If either argument to this option is negative, then that argument is +** changed to its compile-time default. +** +** [[SQLITE_CONFIG_WIN32_HEAPSIZE]] +**
SQLITE_CONFIG_WIN32_HEAPSIZE +**
^The SQLITE_CONFIG_WIN32_HEAPSIZE option is only available if SQLite is +** compiled for Windows with the [SQLITE_WIN32_MALLOC] pre-processor macro +** defined. ^SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value +** that specifies the maximum size of the created heap. +** +** [[SQLITE_CONFIG_PCACHE_HDRSZ]] +**
SQLITE_CONFIG_PCACHE_HDRSZ +**
^The SQLITE_CONFIG_PCACHE_HDRSZ option takes a single parameter which +** is a pointer to an integer and writes into that integer the number of extra +** bytes per page required for each page in [SQLITE_CONFIG_PAGECACHE]. +** The amount of extra space required can change depending on the compiler, +** target platform, and SQLite version. +** +** [[SQLITE_CONFIG_PMASZ]] +**
SQLITE_CONFIG_PMASZ +**
^The SQLITE_CONFIG_PMASZ option takes a single parameter which +** is an unsigned integer and sets the "Minimum PMA Size" for the multithreaded +** sorter to that integer. The default minimum PMA Size is set by the +** [SQLITE_SORTER_PMASZ] compile-time option. New threads are launched +** to help with sort operations when multithreaded sorting +** is enabled (using the [PRAGMA threads] command) and the amount of content +** to be sorted exceeds the page size times the minimum of the +** [PRAGMA cache_size] setting and this value. +**
+*/ +#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ +#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ +#define SQLITE_CONFIG_SERIALIZED 3 /* nil */ +#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ +#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ +#define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */ +#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */ +#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */ +#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */ +#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ +#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ +/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ +#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */ +#define SQLITE_CONFIG_PCACHE 14 /* no-op */ +#define SQLITE_CONFIG_GETPCACHE 15 /* no-op */ +#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */ +#define SQLITE_CONFIG_URI 17 /* int */ +#define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */ +#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */ +#define SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */ +#define SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */ +#define SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int *psz */ +#define SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */ + +/* +** CAPI3REF: Database Connection Configuration Options +** +** These constants are the available integer configuration options that +** can be passed as the second argument to the [sqlite3_db_config()] interface. +** +** New configuration options may be added in future releases of SQLite. +** Existing configuration options might be discontinued. Applications +** should check the return code from [sqlite3_db_config()] to make sure that +** the call worked. ^The [sqlite3_db_config()] interface will return a +** non-zero [error code] if a discontinued or unsupported configuration option +** is invoked. +** +**
+**
SQLITE_DBCONFIG_LOOKASIDE
+**
^This option takes three additional arguments that determine the +** [lookaside memory allocator] configuration for the [database connection]. +** ^The first argument (the third parameter to [sqlite3_db_config()] is a +** pointer to a memory buffer to use for lookaside memory. +** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb +** may be NULL in which case SQLite will allocate the +** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the +** size of each lookaside buffer slot. ^The third argument is the number of +** slots. The size of the buffer in the first argument must be greater than +** or equal to the product of the second and third arguments. The buffer +** must be aligned to an 8-byte boundary. ^If the second argument to +** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally +** rounded down to the next smaller multiple of 8. ^(The lookaside memory +** configuration for a database connection can only be changed when that +** connection is not currently using lookaside memory, or in other words +** when the "current value" returned by +** [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero. +** Any attempt to change the lookaside memory configuration when lookaside +** memory is in use leaves the configuration unchanged and returns +** [SQLITE_BUSY].)^
+** +**
SQLITE_DBCONFIG_ENABLE_FKEY
+**
^This option is used to enable or disable the enforcement of +** [foreign key constraints]. There should be two additional arguments. +** The first argument is an integer which is 0 to disable FK enforcement, +** positive to enable FK enforcement or negative to leave FK enforcement +** unchanged. The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether FK enforcement is off or on +** following this call. The second parameter may be a NULL pointer, in +** which case the FK enforcement setting is not reported back.
+** +**
SQLITE_DBCONFIG_ENABLE_TRIGGER
+**
^This option is used to enable or disable [CREATE TRIGGER | triggers]. +** There should be two additional arguments. +** The first argument is an integer which is 0 to disable triggers, +** positive to enable triggers or negative to leave the setting unchanged. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether triggers are disabled or enabled +** following this call. The second parameter may be a NULL pointer, in +** which case the trigger setting is not reported back.
+** +**
+*/ +#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ +#define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */ + + +/* +** CAPI3REF: Enable Or Disable Extended Result Codes +** METHOD: sqlite3 +** +** ^The sqlite3_extended_result_codes() routine enables or disables the +** [extended result codes] feature of SQLite. ^The extended result +** codes are disabled by default for historical compatibility. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_extended_result_codes(sqlite3*, int onoff); + +/* +** CAPI3REF: Last Insert Rowid +** METHOD: sqlite3 +** +** ^Each entry in most SQLite tables (except for [WITHOUT ROWID] tables) +** has a unique 64-bit signed +** integer key called the [ROWID | "rowid"]. ^The rowid is always available +** as an undeclared column named ROWID, OID, or _ROWID_ as long as those +** names are not also used by explicitly declared columns. ^If +** the table has a column of type [INTEGER PRIMARY KEY] then that column +** is another alias for the rowid. +** +** ^The sqlite3_last_insert_rowid(D) interface returns the [rowid] of the +** most recent successful [INSERT] into a rowid table or [virtual table] +** on database connection D. +** ^Inserts into [WITHOUT ROWID] tables are not recorded. +** ^If no successful [INSERT]s into rowid tables +** have ever occurred on the database connection D, +** then sqlite3_last_insert_rowid(D) returns zero. +** +** ^(If an [INSERT] occurs within a trigger or within a [virtual table] +** method, then this routine will return the [rowid] of the inserted +** row as long as the trigger or virtual table method is running. +** But once the trigger or virtual table method ends, the value returned +** by this routine reverts to what it was before the trigger or virtual +** table method began.)^ +** +** ^An [INSERT] that fails due to a constraint violation is not a +** successful [INSERT] and does not change the value returned by this +** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, +** and INSERT OR ABORT make no changes to the return value of this +** routine when their insertion fails. ^(When INSERT OR REPLACE +** encounters a constraint violation, it does not fail. The +** INSERT continues to completion after deleting rows that caused +** the constraint problem so INSERT OR REPLACE will always change +** the return value of this interface.)^ +** +** ^For the purposes of this routine, an [INSERT] is considered to +** be successful even if it is subsequently rolled back. +** +** This function is accessible to SQL statements via the +** [last_insert_rowid() SQL function]. +** +** If a separate thread performs a new [INSERT] on the same +** database connection while the [sqlite3_last_insert_rowid()] +** function is running and thus changes the last insert [rowid], +** then the value returned by [sqlite3_last_insert_rowid()] is +** unpredictable and might not equal either the old or the new +** last insert [rowid]. +*/ +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_last_insert_rowid(sqlite3*); + +/* +** CAPI3REF: Count The Number Of Rows Modified +** METHOD: sqlite3 +** +** ^This function returns the number of rows modified, inserted or +** deleted by the most recently completed INSERT, UPDATE or DELETE +** statement on the database connection specified by the only parameter. +** ^Executing any other type of SQL statement does not modify the value +** returned by this function. +** +** ^Only changes made directly by the INSERT, UPDATE or DELETE statement are +** considered - auxiliary changes caused by [CREATE TRIGGER | triggers], +** [foreign key actions] or [REPLACE] constraint resolution are not counted. +** +** Changes to a view that are intercepted by +** [INSTEAD OF trigger | INSTEAD OF triggers] are not counted. ^The value +** returned by sqlite3_changes() immediately after an INSERT, UPDATE or +** DELETE statement run on a view is always zero. Only changes made to real +** tables are counted. +** +** Things are more complicated if the sqlite3_changes() function is +** executed while a trigger program is running. This may happen if the +** program uses the [changes() SQL function], or if some other callback +** function invokes sqlite3_changes() directly. Essentially: +** +**
    +**
  • ^(Before entering a trigger program the value returned by +** sqlite3_changes() function is saved. After the trigger program +** has finished, the original value is restored.)^ +** +**
  • ^(Within a trigger program each INSERT, UPDATE and DELETE +** statement sets the value returned by sqlite3_changes() +** upon completion as normal. Of course, this value will not include +** any changes performed by sub-triggers, as the sqlite3_changes() +** value will be saved and restored after each sub-trigger has run.)^ +**
+** +** ^This means that if the changes() SQL function (or similar) is used +** by the first INSERT, UPDATE or DELETE statement within a trigger, it +** returns the value as set when the calling statement began executing. +** ^If it is used by the second or subsequent such statement within a trigger +** program, the value returned reflects the number of rows modified by the +** previous INSERT, UPDATE or DELETE statement within the same trigger. +** +** See also the [sqlite3_total_changes()] interface, the +** [count_changes pragma], and the [changes() SQL function]. +** +** If a separate thread makes changes on the same database connection +** while [sqlite3_changes()] is running then the value returned +** is unpredictable and not meaningful. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_changes(sqlite3*); + +/* +** CAPI3REF: Total Number Of Rows Modified +** METHOD: sqlite3 +** +** ^This function returns the total number of rows inserted, modified or +** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed +** since the database connection was opened, including those executed as +** part of trigger programs. ^Executing any other type of SQL statement +** does not affect the value returned by sqlite3_total_changes(). +** +** ^Changes made as part of [foreign key actions] are included in the +** count, but those made as part of REPLACE constraint resolution are +** not. ^Changes to a view that are intercepted by INSTEAD OF triggers +** are not counted. +** +** See also the [sqlite3_changes()] interface, the +** [count_changes pragma], and the [total_changes() SQL function]. +** +** If a separate thread makes changes on the same database connection +** while [sqlite3_total_changes()] is running then the value +** returned is unpredictable and not meaningful. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_total_changes(sqlite3*); + +/* +** CAPI3REF: Interrupt A Long-Running Query +** METHOD: sqlite3 +** +** ^This function causes any pending database operation to abort and +** return at its earliest opportunity. This routine is typically +** called in response to a user action such as pressing "Cancel" +** or Ctrl-C where the user wants a long query operation to halt +** immediately. +** +** ^It is safe to call this routine from a thread different from the +** thread that is currently running the database operation. But it +** is not safe to call this routine with a [database connection] that +** is closed or might close before sqlite3_interrupt() returns. +** +** ^If an SQL operation is very nearly finished at the time when +** sqlite3_interrupt() is called, then it might not have an opportunity +** to be interrupted and might continue to completion. +** +** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT]. +** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE +** that is inside an explicit transaction, then the entire transaction +** will be rolled back automatically. +** +** ^The sqlite3_interrupt(D) call is in effect until all currently running +** SQL statements on [database connection] D complete. ^Any new SQL statements +** that are started after the sqlite3_interrupt() call and before the +** running statements reaches zero are interrupted as if they had been +** running prior to the sqlite3_interrupt() call. ^New SQL statements +** that are started after the running statement count reaches zero are +** not effected by the sqlite3_interrupt(). +** ^A call to sqlite3_interrupt(D) that occurs when there are no running +** SQL statements is a no-op and has no effect on SQL statements +** that are started after the sqlite3_interrupt() call returns. +** +** If the database connection closes while [sqlite3_interrupt()] +** is running then bad things will likely happen. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_interrupt(sqlite3*); + +/* +** CAPI3REF: Determine If An SQL Statement Is Complete +** +** These routines are useful during command-line input to determine if the +** currently entered text seems to form a complete SQL statement or +** if additional input is needed before sending the text into +** SQLite for parsing. ^These routines return 1 if the input string +** appears to be a complete SQL statement. ^A statement is judged to be +** complete if it ends with a semicolon token and is not a prefix of a +** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within +** string literals or quoted identifier names or comments are not +** independent tokens (they are part of the token in which they are +** embedded) and thus do not count as a statement terminator. ^Whitespace +** and comments that follow the final semicolon are ignored. +** +** ^These routines return 0 if the statement is incomplete. ^If a +** memory allocation fails, then SQLITE_NOMEM is returned. +** +** ^These routines do not parse the SQL statements thus +** will not detect syntactically incorrect SQL. +** +** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior +** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked +** automatically by sqlite3_complete16(). If that initialization fails, +** then the return value from sqlite3_complete16() will be non-zero +** regardless of whether or not the input SQL is complete.)^ +** +** The input to [sqlite3_complete()] must be a zero-terminated +** UTF-8 string. +** +** The input to [sqlite3_complete16()] must be a zero-terminated +** UTF-16 string in native byte order. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_complete(const char *sql); +SQLITE_API int SQLITE_STDCALL sqlite3_complete16(const void *sql); + +/* +** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors +** KEYWORDS: {busy-handler callback} {busy handler} +** METHOD: sqlite3 +** +** ^The sqlite3_busy_handler(D,X,P) routine sets a callback function X +** that might be invoked with argument P whenever +** an attempt is made to access a database table associated with +** [database connection] D when another thread +** or process has the table locked. +** The sqlite3_busy_handler() interface is used to implement +** [sqlite3_busy_timeout()] and [PRAGMA busy_timeout]. +** +** ^If the busy callback is NULL, then [SQLITE_BUSY] +** is returned immediately upon encountering the lock. ^If the busy callback +** is not NULL, then the callback might be invoked with two arguments. +** +** ^The first argument to the busy handler is a copy of the void* pointer which +** is the third argument to sqlite3_busy_handler(). ^The second argument to +** the busy handler callback is the number of times that the busy handler has +** been invoked previously for the same locking event. ^If the +** busy callback returns 0, then no additional attempts are made to +** access the database and [SQLITE_BUSY] is returned +** to the application. +** ^If the callback returns non-zero, then another attempt +** is made to access the database and the cycle repeats. +** +** The presence of a busy handler does not guarantee that it will be invoked +** when there is lock contention. ^If SQLite determines that invoking the busy +** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY] +** to the application instead of invoking the +** busy handler. +** Consider a scenario where one process is holding a read lock that +** it is trying to promote to a reserved lock and +** a second process is holding a reserved lock that it is trying +** to promote to an exclusive lock. The first process cannot proceed +** because it is blocked by the second and the second process cannot +** proceed because it is blocked by the first. If both processes +** invoke the busy handlers, neither will make any progress. Therefore, +** SQLite returns [SQLITE_BUSY] for the first process, hoping that this +** will induce the first process to release its read lock and allow +** the second process to proceed. +** +** ^The default busy callback is NULL. +** +** ^(There can only be a single busy handler defined for each +** [database connection]. Setting a new busy handler clears any +** previously set handler.)^ ^Note that calling [sqlite3_busy_timeout()] +** or evaluating [PRAGMA busy_timeout=N] will change the +** busy handler and thus clear any previously set busy handler. +** +** The busy callback should not take any actions which modify the +** database connection that invoked the busy handler. In other words, +** the busy handler is not reentrant. Any such actions +** result in undefined behavior. +** +** A busy handler must not close the database connection +** or [prepared statement] that invoked the busy handler. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); + +/* +** CAPI3REF: Set A Busy Timeout +** METHOD: sqlite3 +** +** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps +** for a specified amount of time when a table is locked. ^The handler +** will sleep multiple times until at least "ms" milliseconds of sleeping +** have accumulated. ^After at least "ms" milliseconds of sleeping, +** the handler returns 0 which causes [sqlite3_step()] to return +** [SQLITE_BUSY]. +** +** ^Calling this routine with an argument less than or equal to zero +** turns off all busy handlers. +** +** ^(There can only be a single busy handler for a particular +** [database connection] at any given moment. If another busy handler +** was defined (using [sqlite3_busy_handler()]) prior to calling +** this routine, that other busy handler is cleared.)^ +** +** See also: [PRAGMA busy_timeout] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_busy_timeout(sqlite3*, int ms); + +/* +** CAPI3REF: Convenience Routines For Running Queries +** METHOD: sqlite3 +** +** This is a legacy interface that is preserved for backwards compatibility. +** Use of this interface is not recommended. +** +** Definition: A result table is memory data structure created by the +** [sqlite3_get_table()] interface. A result table records the +** complete query results from one or more queries. +** +** The table conceptually has a number of rows and columns. But +** these numbers are not part of the result table itself. These +** numbers are obtained separately. Let N be the number of rows +** and M be the number of columns. +** +** A result table is an array of pointers to zero-terminated UTF-8 strings. +** There are (N+1)*M elements in the array. The first M pointers point +** to zero-terminated strings that contain the names of the columns. +** The remaining entries all point to query results. NULL values result +** in NULL pointers. All other values are in their UTF-8 zero-terminated +** string representation as returned by [sqlite3_column_text()]. +** +** A result table might consist of one or more memory allocations. +** It is not safe to pass a result table directly to [sqlite3_free()]. +** A result table should be deallocated using [sqlite3_free_table()]. +** +** ^(As an example of the result table format, suppose a query result +** is as follows: +** +** 
+**        Name        | Age
+**        -----------------------
+**        Alice       | 43
+**        Bob         | 28
+**        Cindy       | 21
+**
+** +** There are two column (M==2) and three rows (N==3). Thus the +** result table has 8 entries. Suppose the result table is stored +** in an array names azResult. Then azResult holds this content: +** +** 
+**        azResult[0] = "Name";
+**        azResult[1] = "Age";
+**        azResult[2] = "Alice";
+**        azResult[3] = "43";
+**        azResult[4] = "Bob";
+**        azResult[5] = "28";
+**        azResult[6] = "Cindy";
+**        azResult[7] = "21";
+**
)^ +** +** ^The sqlite3_get_table() function evaluates one or more +** semicolon-separated SQL statements in the zero-terminated UTF-8 +** string of its 2nd parameter and returns a result table to the +** pointer given in its 3rd parameter. +** +** After the application has finished with the result from sqlite3_get_table(), +** it must pass the result table pointer to sqlite3_free_table() in order to +** release the memory that was malloced. Because of the way the +** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling +** function must not try to call [sqlite3_free()] directly. Only +** [sqlite3_free_table()] is able to release the memory properly and safely. +** +** The sqlite3_get_table() interface is implemented as a wrapper around +** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access +** to any internal data structures of SQLite. It uses only the public +** interface defined here. As a consequence, errors that occur in the +** wrapper layer outside of the internal [sqlite3_exec()] call are not +** reflected in subsequent calls to [sqlite3_errcode()] or +** [sqlite3_errmsg()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_get_table( + sqlite3 *db, /* An open database */ + const char *zSql, /* SQL to be evaluated */ + char ***pazResult, /* Results of the query */ + int *pnRow, /* Number of result rows written here */ + int *pnColumn, /* Number of result columns written here */ + char **pzErrmsg /* Error msg written here */ +); +SQLITE_API void SQLITE_STDCALL sqlite3_free_table(char **result); + +/* +** CAPI3REF: Formatted String Printing Functions +** +** These routines are work-alikes of the "printf()" family of functions +** from the standard C library. +** These routines understand most of the common K&R formatting options, +** plus some additional non-standard formats, detailed below. +** Note that some of the more obscure formatting options from recent +** C-library standards are omitted from this implementation. +** +** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their +** results into memory obtained from [sqlite3_malloc()]. +** The strings returned by these two routines should be +** released by [sqlite3_free()]. ^Both routines return a +** NULL pointer if [sqlite3_malloc()] is unable to allocate enough +** memory to hold the resulting string. +** +** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from +** the standard C library. The result is written into the +** buffer supplied as the second parameter whose size is given by +** the first parameter. Note that the order of the +** first two parameters is reversed from snprintf().)^ This is an +** historical accident that cannot be fixed without breaking +** backwards compatibility. ^(Note also that sqlite3_snprintf() +** returns a pointer to its buffer instead of the number of +** characters actually written into the buffer.)^ We admit that +** the number of characters written would be a more useful return +** value but we cannot change the implementation of sqlite3_snprintf() +** now without breaking compatibility. +** +** ^As long as the buffer size is greater than zero, sqlite3_snprintf() +** guarantees that the buffer is always zero-terminated. ^The first +** parameter "n" is the total size of the buffer, including space for +** the zero terminator. So the longest string that can be completely +** written will be n-1 characters. +** +** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf(). +** +** These routines all implement some additional formatting +** options that are useful for constructing SQL statements. +** All of the usual printf() formatting options apply. In addition, there +** is are "%q", "%Q", "%w" and "%z" options. +** +** ^(The %q option works like %s in that it substitutes a nul-terminated +** string from the argument list. But %q also doubles every '\'' character. +** %q is designed for use inside a string literal.)^ By doubling each '\'' +** character it escapes that character and allows it to be inserted into +** the string. +** +** For example, assume the string variable zText contains text as follows: +** +** 
+**  char *zText = "It's a happy day!";
+**
+** +** One can use this text in an SQL statement as follows: +** +** 
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+**
+** +** Because the %q format string is used, the '\'' character in zText +** is escaped and the SQL generated is as follows: +** +** 
+**  INSERT INTO table1 VALUES('It''s a happy day!')
+**
+** +** This is correct. Had we used %s instead of %q, the generated SQL +** would have looked like this: +** +** 
+**  INSERT INTO table1 VALUES('It's a happy day!');
+**
+** +** This second example is an SQL syntax error. As a general rule you should +** always use %q instead of %s when inserting text into a string literal. +** +** ^(The %Q option works like %q except it also adds single quotes around +** the outside of the total string. Additionally, if the parameter in the +** argument list is a NULL pointer, %Q substitutes the text "NULL" (without +** single quotes).)^ So, for example, one could say: +** +** 
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+**
+** +** The code above will render a correct SQL statement in the zSQL +** variable even if the zText variable is a NULL pointer. +** +** ^(The "%w" formatting option is like "%q" except that it expects to +** be contained within double-quotes instead of single quotes, and it +** escapes the double-quote character instead of the single-quote +** character.)^ The "%w" formatting option is intended for safely inserting +** table and column names into a constructed SQL statement. +** +** ^(The "%z" formatting option works like "%s" but with the +** addition that after the string has been read and copied into +** the result, [sqlite3_free()] is called on the input string.)^ +*/ +SQLITE_API char *SQLITE_CDECL sqlite3_mprintf(const char*,...); +SQLITE_API char *SQLITE_STDCALL sqlite3_vmprintf(const char*, va_list); +SQLITE_API char *SQLITE_CDECL sqlite3_snprintf(int,char*,const char*, ...); +SQLITE_API char *SQLITE_STDCALL sqlite3_vsnprintf(int,char*,const char*, va_list); + +/* +** CAPI3REF: Memory Allocation Subsystem +** +** The SQLite core uses these three routines for all of its own +** internal memory allocation needs. "Core" in the previous sentence +** does not include operating-system specific VFS implementation. The +** Windows VFS uses native malloc() and free() for some operations. +** +** ^The sqlite3_malloc() routine returns a pointer to a block +** of memory at least N bytes in length, where N is the parameter. +** ^If sqlite3_malloc() is unable to obtain sufficient free +** memory, it returns a NULL pointer. ^If the parameter N to +** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns +** a NULL pointer. +** +** ^The sqlite3_malloc64(N) routine works just like +** sqlite3_malloc(N) except that N is an unsigned 64-bit integer instead +** of a signed 32-bit integer. +** +** ^Calling sqlite3_free() with a pointer previously returned +** by sqlite3_malloc() or sqlite3_realloc() releases that memory so +** that it might be reused. ^The sqlite3_free() routine is +** a no-op if is called with a NULL pointer. Passing a NULL pointer +** to sqlite3_free() is harmless. After being freed, memory +** should neither be read nor written. Even reading previously freed +** memory might result in a segmentation fault or other severe error. +** Memory corruption, a segmentation fault, or other severe error +** might result if sqlite3_free() is called with a non-NULL pointer that +** was not obtained from sqlite3_malloc() or sqlite3_realloc(). +** +** ^The sqlite3_realloc(X,N) interface attempts to resize a +** prior memory allocation X to be at least N bytes. +** ^If the X parameter to sqlite3_realloc(X,N) +** is a NULL pointer then its behavior is identical to calling +** sqlite3_malloc(N). +** ^If the N parameter to sqlite3_realloc(X,N) is zero or +** negative then the behavior is exactly the same as calling +** sqlite3_free(X). +** ^sqlite3_realloc(X,N) returns a pointer to a memory allocation +** of at least N bytes in size or NULL if insufficient memory is available. +** ^If M is the size of the prior allocation, then min(N,M) bytes +** of the prior allocation are copied into the beginning of buffer returned +** by sqlite3_realloc(X,N) and the prior allocation is freed. +** ^If sqlite3_realloc(X,N) returns NULL and N is positive, then the +** prior allocation is not freed. +** +** ^The sqlite3_realloc64(X,N) interfaces works the same as +** sqlite3_realloc(X,N) except that N is a 64-bit unsigned integer instead +** of a 32-bit signed integer. +** +** ^If X is a memory allocation previously obtained from sqlite3_malloc(), +** sqlite3_malloc64(), sqlite3_realloc(), or sqlite3_realloc64(), then +** sqlite3_msize(X) returns the size of that memory allocation in bytes. +** ^The value returned by sqlite3_msize(X) might be larger than the number +** of bytes requested when X was allocated. ^If X is a NULL pointer then +** sqlite3_msize(X) returns zero. If X points to something that is not +** the beginning of memory allocation, or if it points to a formerly +** valid memory allocation that has now been freed, then the behavior +** of sqlite3_msize(X) is undefined and possibly harmful. +** +** ^The memory returned by sqlite3_malloc(), sqlite3_realloc(), +** sqlite3_malloc64(), and sqlite3_realloc64() +** is always aligned to at least an 8 byte boundary, or to a +** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time +** option is used. +** +** In SQLite version 3.5.0 and 3.5.1, it was possible to define +** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in +** implementation of these routines to be omitted. That capability +** is no longer provided. Only built-in memory allocators can be used. +** +** Prior to SQLite version 3.7.10, the Windows OS interface layer called +** the system malloc() and free() directly when converting +** filenames between the UTF-8 encoding used by SQLite +** and whatever filename encoding is used by the particular Windows +** installation. Memory allocation errors were detected, but +** they were reported back as [SQLITE_CANTOPEN] or +** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. +** +** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()] +** must be either NULL or else pointers obtained from a prior +** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have +** not yet been released. +** +** The application must not read or write any part of +** a block of memory after it has been released using +** [sqlite3_free()] or [sqlite3_realloc()]. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_malloc(int); +SQLITE_API void *SQLITE_STDCALL sqlite3_malloc64(sqlite3_uint64); +SQLITE_API void *SQLITE_STDCALL sqlite3_realloc(void*, int); +SQLITE_API void *SQLITE_STDCALL sqlite3_realloc64(void*, sqlite3_uint64); +SQLITE_API void SQLITE_STDCALL sqlite3_free(void*); +SQLITE_API sqlite3_uint64 SQLITE_STDCALL sqlite3_msize(void*); + +/* +** CAPI3REF: Memory Allocator Statistics +** +** SQLite provides these two interfaces for reporting on the status +** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()] +** routines, which form the built-in memory allocation subsystem. +** +** ^The [sqlite3_memory_used()] routine returns the number of bytes +** of memory currently outstanding (malloced but not freed). +** ^The [sqlite3_memory_highwater()] routine returns the maximum +** value of [sqlite3_memory_used()] since the high-water mark +** was last reset. ^The values returned by [sqlite3_memory_used()] and +** [sqlite3_memory_highwater()] include any overhead +** added by SQLite in its implementation of [sqlite3_malloc()], +** but not overhead added by the any underlying system library +** routines that [sqlite3_malloc()] may call. +** +** ^The memory high-water mark is reset to the current value of +** [sqlite3_memory_used()] if and only if the parameter to +** [sqlite3_memory_highwater()] is true. ^The value returned +** by [sqlite3_memory_highwater(1)] is the high-water mark +** prior to the reset. +*/ +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_used(void); +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_highwater(int resetFlag); + +/* +** CAPI3REF: Pseudo-Random Number Generator +** +** SQLite contains a high-quality pseudo-random number generator (PRNG) used to +** select random [ROWID | ROWIDs] when inserting new records into a table that +** already uses the largest possible [ROWID]. The PRNG is also used for +** the build-in random() and randomblob() SQL functions. This interface allows +** applications to access the same PRNG for other purposes. +** +** ^A call to this routine stores N bytes of randomness into buffer P. +** ^The P parameter can be a NULL pointer. +** +** ^If this routine has not been previously called or if the previous +** call had N less than one or a NULL pointer for P, then the PRNG is +** seeded using randomness obtained from the xRandomness method of +** the default [sqlite3_vfs] object. +** ^If the previous call to this routine had an N of 1 or more and a +** non-NULL P then the pseudo-randomness is generated +** internally and without recourse to the [sqlite3_vfs] xRandomness +** method. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_randomness(int N, void *P); + +/* +** CAPI3REF: Compile-Time Authorization Callbacks +** METHOD: sqlite3 +** +** ^This routine registers an authorizer callback with a particular +** [database connection], supplied in the first argument. +** ^The authorizer callback is invoked as SQL statements are being compiled +** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], +** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. ^At various +** points during the compilation process, as logic is being created +** to perform various actions, the authorizer callback is invoked to +** see if those actions are allowed. ^The authorizer callback should +** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the +** specific action but allow the SQL statement to continue to be +** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be +** rejected with an error. ^If the authorizer callback returns +** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] +** then the [sqlite3_prepare_v2()] or equivalent call that triggered +** the authorizer will fail with an error message. +** +** When the callback returns [SQLITE_OK], that means the operation +** requested is ok. ^When the callback returns [SQLITE_DENY], the +** [sqlite3_prepare_v2()] or equivalent call that triggered the +** authorizer will fail with an error message explaining that +** access is denied. +** +** ^The first parameter to the authorizer callback is a copy of the third +** parameter to the sqlite3_set_authorizer() interface. ^The second parameter +** to the callback is an integer [SQLITE_COPY | action code] that specifies +** the particular action to be authorized. ^The third through sixth parameters +** to the callback are zero-terminated strings that contain additional +** details about the action to be authorized. +** +** ^If the action code is [SQLITE_READ] +** and the callback returns [SQLITE_IGNORE] then the +** [prepared statement] statement is constructed to substitute +** a NULL value in place of the table column that would have +** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE] +** return can be used to deny an untrusted user access to individual +** columns of a table. +** ^If the action code is [SQLITE_DELETE] and the callback returns +** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the +** [truncate optimization] is disabled and all rows are deleted individually. +** +** An authorizer is used when [sqlite3_prepare | preparing] +** SQL statements from an untrusted source, to ensure that the SQL statements +** do not try to access data they are not allowed to see, or that they do not +** try to execute malicious statements that damage the database. For +** example, an application may allow a user to enter arbitrary +** SQL queries for evaluation by a database. But the application does +** not want the user to be able to make arbitrary changes to the +** database. An authorizer could then be put in place while the +** user-entered SQL is being [sqlite3_prepare | prepared] that +** disallows everything except [SELECT] statements. +** +** Applications that need to process SQL from untrusted sources +** might also consider lowering resource limits using [sqlite3_limit()] +** and limiting database size using the [max_page_count] [PRAGMA] +** in addition to using an authorizer. +** +** ^(Only a single authorizer can be in place on a database connection +** at a time. Each call to sqlite3_set_authorizer overrides the +** previous call.)^ ^Disable the authorizer by installing a NULL callback. +** The authorizer is disabled by default. +** +** The authorizer callback must not do anything that will modify +** the database connection that invoked the authorizer callback. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the +** statement might be re-prepared during [sqlite3_step()] due to a +** schema change. Hence, the application should ensure that the +** correct authorizer callback remains in place during the [sqlite3_step()]. +** +** ^Note that the authorizer callback is invoked only during +** [sqlite3_prepare()] or its variants. Authorization is not +** performed during statement evaluation in [sqlite3_step()], unless +** as stated in the previous paragraph, sqlite3_step() invokes +** sqlite3_prepare_v2() to reprepare a statement after a schema change. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_set_authorizer( + sqlite3*, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pUserData +); + +/* +** CAPI3REF: Authorizer Return Codes +** +** The [sqlite3_set_authorizer | authorizer callback function] must +** return either [SQLITE_OK] or one of these two constants in order +** to signal SQLite whether or not the action is permitted. See the +** [sqlite3_set_authorizer | authorizer documentation] for additional +** information. +** +** Note that SQLITE_IGNORE is also used as a [conflict resolution mode] +** returned from the [sqlite3_vtab_on_conflict()] interface. +*/ +#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ +#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ + +/* +** CAPI3REF: Authorizer Action Codes +** +** The [sqlite3_set_authorizer()] interface registers a callback function +** that is invoked to authorize certain SQL statement actions. The +** second parameter to the callback is an integer code that specifies +** what action is being authorized. These are the integer action codes that +** the authorizer callback may be passed. +** +** These action code values signify what kind of operation is to be +** authorized. The 3rd and 4th parameters to the authorization +** callback function will be parameters or NULL depending on which of these +** codes is used as the second parameter. ^(The 5th parameter to the +** authorizer callback is the name of the database ("main", "temp", +** etc.) if applicable.)^ ^The 6th parameter to the authorizer callback +** is the name of the inner-most trigger or view that is responsible for +** the access attempt or NULL if this access attempt is directly from +** top-level SQL code. +*/ +/******************************************* 3rd ************ 4th ***********/ +#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ +#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ +#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ +#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ +#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ +#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ +#define SQLITE_DELETE 9 /* Table Name NULL */ +#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ +#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ +#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ +#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ +#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ +#define SQLITE_DROP_VIEW 17 /* View Name NULL */ +#define SQLITE_INSERT 18 /* Table Name NULL */ +#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ +#define SQLITE_READ 20 /* Table Name Column Name */ +#define SQLITE_SELECT 21 /* NULL NULL */ +#define SQLITE_TRANSACTION 22 /* Operation NULL */ +#define SQLITE_UPDATE 23 /* Table Name Column Name */ +#define SQLITE_ATTACH 24 /* Filename NULL */ +#define SQLITE_DETACH 25 /* Database Name NULL */ +#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ +#define SQLITE_REINDEX 27 /* Index Name NULL */ +#define SQLITE_ANALYZE 28 /* Table Name NULL */ +#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ +#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ +#define SQLITE_FUNCTION 31 /* NULL Function Name */ +#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */ +#define SQLITE_COPY 0 /* No longer used */ +#define SQLITE_RECURSIVE 33 /* NULL NULL */ + +/* +** CAPI3REF: Tracing And Profiling Functions +** METHOD: sqlite3 +** +** These routines register callback functions that can be used for +** tracing and profiling the execution of SQL statements. +** +** ^The callback function registered by sqlite3_trace() is invoked at +** various times when an SQL statement is being run by [sqlite3_step()]. +** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the +** SQL statement text as the statement first begins executing. +** ^(Additional sqlite3_trace() callbacks might occur +** as each triggered subprogram is entered. The callbacks for triggers +** contain a UTF-8 SQL comment that identifies the trigger.)^ +** +** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit +** the length of [bound parameter] expansion in the output of sqlite3_trace(). +** +** ^The callback function registered by sqlite3_profile() is invoked +** as each SQL statement finishes. ^The profile callback contains +** the original statement text and an estimate of wall-clock time +** of how long that statement took to run. ^The profile callback +** time is in units of nanoseconds, however the current implementation +** is only capable of millisecond resolution so the six least significant +** digits in the time are meaningless. Future versions of SQLite +** might provide greater resolution on the profiler callback. The +** sqlite3_profile() function is considered experimental and is +** subject to change in future versions of SQLite. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); +SQLITE_API SQLITE_EXPERIMENTAL void *SQLITE_STDCALL sqlite3_profile(sqlite3*, + void(*xProfile)(void*,const char*,sqlite3_uint64), void*); + +/* +** CAPI3REF: Query Progress Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback +** function X to be invoked periodically during long running calls to +** [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for +** database connection D. An example use for this +** interface is to keep a GUI updated during a large query. +** +** ^The parameter P is passed through as the only parameter to the +** callback function X. ^The parameter N is the approximate number of +** [virtual machine instructions] that are evaluated between successive +** invocations of the callback X. ^If N is less than one then the progress +** handler is disabled. +** +** ^Only a single progress handler may be defined at one time per +** [database connection]; setting a new progress handler cancels the +** old one. ^Setting parameter X to NULL disables the progress handler. +** ^The progress handler is also disabled by setting N to a value less +** than 1. +** +** ^If the progress callback returns non-zero, the operation is +** interrupted. This feature can be used to implement a +** "Cancel" button on a GUI progress dialog box. +** +** The progress handler callback must not do anything that will modify +** the database connection that invoked the progress handler. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); + +/* +** CAPI3REF: Opening A New Database Connection +** CONSTRUCTOR: sqlite3 +** +** ^These routines open an SQLite database file as specified by the +** filename argument. ^The filename argument is interpreted as UTF-8 for +** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte +** order for sqlite3_open16(). ^(A [database connection] handle is usually +** returned in *ppDb, even if an error occurs. The only exception is that +** if SQLite is unable to allocate memory to hold the [sqlite3] object, +** a NULL will be written into *ppDb instead of a pointer to the [sqlite3] +** object.)^ ^(If the database is opened (and/or created) successfully, then +** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The +** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain +** an English language description of the error following a failure of any +** of the sqlite3_open() routines. +** +** ^The default encoding will be UTF-8 for databases created using +** sqlite3_open() or sqlite3_open_v2(). ^The default encoding for databases +** created using sqlite3_open16() will be UTF-16 in the native byte order. +** +** Whether or not an error occurs when it is opened, resources +** associated with the [database connection] handle should be released by +** passing it to [sqlite3_close()] when it is no longer required. +** +** The sqlite3_open_v2() interface works like sqlite3_open() +** except that it accepts two additional parameters for additional control +** over the new database connection. ^(The flags parameter to +** sqlite3_open_v2() can take one of +** the following three values, optionally combined with the +** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE], +** [SQLITE_OPEN_PRIVATECACHE], and/or [SQLITE_OPEN_URI] flags:)^ +** +**
+** ^(
[SQLITE_OPEN_READONLY]
+**
The database is opened in read-only mode. If the database does not +** already exist, an error is returned.
)^ +** +** ^(
[SQLITE_OPEN_READWRITE]
+**
The database is opened for reading and writing if possible, or reading +** only if the file is write protected by the operating system. In either +** case the database must already exist, otherwise an error is returned.
)^ +** +** ^(
[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
+**
The database is opened for reading and writing, and is created if +** it does not already exist. This is the behavior that is always used for +** sqlite3_open() and sqlite3_open16().
)^ +**
+** +** If the 3rd parameter to sqlite3_open_v2() is not one of the +** combinations shown above optionally combined with other +** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits] +** then the behavior is undefined. +** +** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection +** opens in the multi-thread [threading mode] as long as the single-thread +** mode has not been set at compile-time or start-time. ^If the +** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens +** in the serialized [threading mode] unless single-thread was +** previously selected at compile-time or start-time. +** ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be +** eligible to use [shared cache mode], regardless of whether or not shared +** cache is enabled using [sqlite3_enable_shared_cache()]. ^The +** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not +** participate in [shared cache mode] even if it is enabled. +** +** ^The fourth parameter to sqlite3_open_v2() is the name of the +** [sqlite3_vfs] object that defines the operating system interface that +** the new database connection should use. ^If the fourth parameter is +** a NULL pointer then the default [sqlite3_vfs] object is used. +** +** ^If the filename is ":memory:", then a private, temporary in-memory database +** is created for the connection. ^This in-memory database will vanish when +** the database connection is closed. Future versions of SQLite might +** make use of additional special filenames that begin with the ":" character. +** It is recommended that when a database filename actually does begin with +** a ":" character you should prefix the filename with a pathname such as +** "./" to avoid ambiguity. +** +** ^If the filename is an empty string, then a private, temporary +** on-disk database will be created. ^This private database will be +** automatically deleted as soon as the database connection is closed. +** +** [[URI filenames in sqlite3_open()]]

URI Filenames

+** +** ^If [URI filename] interpretation is enabled, and the filename argument +** begins with "file:", then the filename is interpreted as a URI. ^URI +** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is +** set in the fourth argument to sqlite3_open_v2(), or if it has +** been enabled globally using the [SQLITE_CONFIG_URI] option with the +** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option. +** As of SQLite version 3.7.7, URI filename interpretation is turned off +** by default, but future releases of SQLite might enable URI filename +** interpretation by default. See "[URI filenames]" for additional +** information. +** +** URI filenames are parsed according to RFC 3986. ^If the URI contains an +** authority, then it must be either an empty string or the string +** "localhost". ^If the authority is not an empty string or "localhost", an +** error is returned to the caller. ^The fragment component of a URI, if +** present, is ignored. +** +** ^SQLite uses the path component of the URI as the name of the disk file +** which contains the database. ^If the path begins with a '/' character, +** then it is interpreted as an absolute path. ^If the path does not begin +** with a '/' (meaning that the authority section is omitted from the URI) +** then the path is interpreted as a relative path. +** ^(On windows, the first component of an absolute path +** is a drive specification (e.g. "C:").)^ +** +** [[core URI query parameters]] +** The query component of a URI may contain parameters that are interpreted +** either by SQLite itself, or by a [VFS | custom VFS implementation]. +** SQLite and its built-in [VFSes] interpret the +** following query parameters: +** +**
    +**
  • vfs: ^The "vfs" parameter may be used to specify the name of +** a VFS object that provides the operating system interface that should +** be used to access the database file on disk. ^If this option is set to +** an empty string the default VFS object is used. ^Specifying an unknown +** VFS is an error. ^If sqlite3_open_v2() is used and the vfs option is +** present, then the VFS specified by the option takes precedence over +** the value passed as the fourth parameter to sqlite3_open_v2(). +** +**
  • mode: ^(The mode parameter may be set to either "ro", "rw", +** "rwc", or "memory". Attempting to set it to any other value is +** an error)^. +** ^If "ro" is specified, then the database is opened for read-only +** access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the +** third argument to sqlite3_open_v2(). ^If the mode option is set to +** "rw", then the database is opened for read-write (but not create) +** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had +** been set. ^Value "rwc" is equivalent to setting both +** SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. ^If the mode option is +** set to "memory" then a pure [in-memory database] that never reads +** or writes from disk is used. ^It is an error to specify a value for +** the mode parameter that is less restrictive than that specified by +** the flags passed in the third parameter to sqlite3_open_v2(). +** +**
  • cache: ^The cache parameter may be set to either "shared" or +** "private". ^Setting it to "shared" is equivalent to setting the +** SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed to +** sqlite3_open_v2(). ^Setting the cache parameter to "private" is +** equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit. +** ^If sqlite3_open_v2() is used and the "cache" parameter is present in +** a URI filename, its value overrides any behavior requested by setting +** SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag. +** +**
  • psow: ^The psow parameter indicates whether or not the +** [powersafe overwrite] property does or does not apply to the +** storage media on which the database file resides. +** +**
  • nolock: ^The nolock parameter is a boolean query parameter +** which if set disables file locking in rollback journal modes. This +** is useful for accessing a database on a filesystem that does not +** support locking. Caution: Database corruption might result if two +** or more processes write to the same database and any one of those +** processes uses nolock=1. +** +**
  • immutable: ^The immutable parameter is a boolean query +** parameter that indicates that the database file is stored on +** read-only media. ^When immutable is set, SQLite assumes that the +** database file cannot be changed, even by a process with higher +** privilege, and so the database is opened read-only and all locking +** and change detection is disabled. Caution: Setting the immutable +** property on a database file that does in fact change can result +** in incorrect query results and/or [SQLITE_CORRUPT] errors. +** See also: [SQLITE_IOCAP_IMMUTABLE]. +** +**
+** +** ^Specifying an unknown parameter in the query component of a URI is not an +** error. Future versions of SQLite might understand additional query +** parameters. See "[query parameters with special meaning to SQLite]" for +** additional information. +** +** [[URI filename examples]]

URI filename examples

+** +**
+**
URI filenames Results +**
file:data.db +** Open the file "data.db" in the current directory. +**
file:/home/fred/data.db
+** file:///home/fred/data.db
+** file://localhost/home/fred/data.db
+** Open the database file "/home/fred/data.db". +**
file://darkstar/home/fred/data.db +** An error. "darkstar" is not a recognized authority. +**
+** file:///C:/Documents%20and%20Settings/fred/Desktop/data.db +** Windows only: Open the file "data.db" on fred's desktop on drive +** C:. Note that the %20 escaping in this example is not strictly +** necessary - space characters can be used literally +** in URI filenames. +**
file:data.db?mode=ro&cache=private +** Open file "data.db" in the current directory for read-only access. +** Regardless of whether or not shared-cache mode is enabled by +** default, use a private cache. +**
file:/home/fred/data.db?vfs=unix-dotfile +** Open file "/home/fred/data.db". Use the special VFS "unix-dotfile" +** that uses dot-files in place of posix advisory locking. +**
file:data.db?mode=readonly +** An error. "readonly" is not a valid option for the "mode" parameter. +**
+** +** ^URI hexadecimal escape sequences (%HH) are supported within the path and +** query components of a URI. A hexadecimal escape sequence consists of a +** percent sign - "%" - followed by exactly two hexadecimal digits +** specifying an octet value. ^Before the path or query components of a +** URI filename are interpreted, they are encoded using UTF-8 and all +** hexadecimal escape sequences replaced by a single byte containing the +** corresponding octet. If this process generates an invalid UTF-8 encoding, +** the results are undefined. +** +** Note to Windows users: The encoding used for the filename argument +** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever +** codepage is currently defined. Filenames containing international +** characters must be converted to UTF-8 prior to passing them into +** sqlite3_open() or sqlite3_open_v2(). +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling sqlite3_open() or sqlite3_open_v2(). Otherwise, various +** features that require the use of temporary files may fail. +** +** See also: [sqlite3_temp_directory] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_open( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +SQLITE_API int SQLITE_STDCALL sqlite3_open16( + const void *filename, /* Database filename (UTF-16) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +SQLITE_API int SQLITE_STDCALL sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +); + +/* +** CAPI3REF: Obtain Values For URI Parameters +** +** These are utility routines, useful to VFS implementations, that check +** to see if a database file was a URI that contained a specific query +** parameter, and if so obtains the value of that query parameter. +** +** If F is the database filename pointer passed into the xOpen() method of +** a VFS implementation when the flags parameter to xOpen() has one or +** more of the [SQLITE_OPEN_URI] or [SQLITE_OPEN_MAIN_DB] bits set and +** P is the name of the query parameter, then +** sqlite3_uri_parameter(F,P) returns the value of the P +** parameter if it exists or a NULL pointer if P does not appear as a +** query parameter on F. If P is a query parameter of F +** has no explicit value, then sqlite3_uri_parameter(F,P) returns +** a pointer to an empty string. +** +** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean +** parameter and returns true (1) or false (0) according to the value +** of P. The sqlite3_uri_boolean(F,P,B) routine returns true (1) if the +** value of query parameter P is one of "yes", "true", or "on" in any +** case or if the value begins with a non-zero number. The +** sqlite3_uri_boolean(F,P,B) routines returns false (0) if the value of +** query parameter P is one of "no", "false", or "off" in any case or +** if the value begins with a numeric zero. If P is not a query +** parameter on F or if the value of P is does not match any of the +** above, then sqlite3_uri_boolean(F,P,B) returns (B!=0). +** +** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a +** 64-bit signed integer and returns that integer, or D if P does not +** exist. If the value of P is something other than an integer, then +** zero is returned. +** +** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and +** sqlite3_uri_boolean(F,P,B) returns B. If F is not a NULL pointer and +** is not a database file pathname pointer that SQLite passed into the xOpen +** VFS method, then the behavior of this routine is undefined and probably +** undesirable. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_uri_parameter(const char *zFilename, const char *zParam); +SQLITE_API int SQLITE_STDCALL sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault); +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_uri_int64(const char*, const char*, sqlite3_int64); + + +/* +** CAPI3REF: Error Codes And Messages +** METHOD: sqlite3 +** +** ^If the most recent sqlite3_* API call associated with +** [database connection] D failed, then the sqlite3_errcode(D) interface +** returns the numeric [result code] or [extended result code] for that +** API call. +** If the most recent API call was successful, +** then the return value from sqlite3_errcode() is undefined. +** ^The sqlite3_extended_errcode() +** interface is the same except that it always returns the +** [extended result code] even when extended result codes are +** disabled. +** +** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language +** text that describes the error, as either UTF-8 or UTF-16 respectively. +** ^(Memory to hold the error message string is managed internally. +** The application does not need to worry about freeing the result. +** However, the error string might be overwritten or deallocated by +** subsequent calls to other SQLite interface functions.)^ +** +** ^The sqlite3_errstr() interface returns the English-language text +** that describes the [result code], as UTF-8. +** ^(Memory to hold the error message string is managed internally +** and must not be freed by the application)^. +** +** When the serialized [threading mode] is in use, it might be the +** case that a second error occurs on a separate thread in between +** the time of the first error and the call to these interfaces. +** When that happens, the second error will be reported since these +** interfaces always report the most recent result. To avoid +** this, each thread can obtain exclusive use of the [database connection] D +** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning +** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after +** all calls to the interfaces listed here are completed. +** +** If an interface fails with SQLITE_MISUSE, that means the interface +** was invoked incorrectly by the application. In that case, the +** error code and message may or may not be set. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_errcode(sqlite3 *db); +SQLITE_API int SQLITE_STDCALL sqlite3_extended_errcode(sqlite3 *db); +SQLITE_API const char *SQLITE_STDCALL sqlite3_errmsg(sqlite3*); +SQLITE_API const void *SQLITE_STDCALL sqlite3_errmsg16(sqlite3*); +SQLITE_API const char *SQLITE_STDCALL sqlite3_errstr(int); + +/* +** CAPI3REF: Prepared Statement Object +** KEYWORDS: {prepared statement} {prepared statements} +** +** An instance of this object represents a single SQL statement that +** has been compiled into binary form and is ready to be evaluated. +** +** Think of each SQL statement as a separate computer program. The +** original SQL text is source code. A prepared statement object +** is the compiled object code. All SQL must be converted into a +** prepared statement before it can be run. +** +** The life-cycle of a prepared statement object usually goes like this: +** +**

    +**
  1. Create the prepared statement object using [sqlite3_prepare_v2()]. +**
  2. Bind values to [parameters] using the sqlite3_bind_*() +** interfaces. +**
  3. Run the SQL by calling [sqlite3_step()] one or more times. +**
  4. Reset the prepared statement using [sqlite3_reset()] then go back +** to step 2. Do this zero or more times. +**
  5. Destroy the object using [sqlite3_finalize()]. +**
+*/ +typedef struct sqlite3_stmt sqlite3_stmt; + +/* +** CAPI3REF: Run-time Limits +** METHOD: sqlite3 +** +** ^(This interface allows the size of various constructs to be limited +** on a connection by connection basis. The first parameter is the +** [database connection] whose limit is to be set or queried. The +** second parameter is one of the [limit categories] that define a +** class of constructs to be size limited. The third parameter is the +** new limit for that construct.)^ +** +** ^If the new limit is a negative number, the limit is unchanged. +** ^(For each limit category SQLITE_LIMIT_NAME there is a +** [limits | hard upper bound] +** set at compile-time by a C preprocessor macro called +** [limits | SQLITE_MAX_NAME]. +** (The "_LIMIT_" in the name is changed to "_MAX_".))^ +** ^Attempts to increase a limit above its hard upper bound are +** silently truncated to the hard upper bound. +** +** ^Regardless of whether or not the limit was changed, the +** [sqlite3_limit()] interface returns the prior value of the limit. +** ^Hence, to find the current value of a limit without changing it, +** simply invoke this interface with the third parameter set to -1. +** +** Run-time limits are intended for use in applications that manage +** both their own internal database and also databases that are controlled +** by untrusted external sources. An example application might be a +** web browser that has its own databases for storing history and +** separate databases controlled by JavaScript applications downloaded +** off the Internet. The internal databases can be given the +** large, default limits. Databases managed by external sources can +** be given much smaller limits designed to prevent a denial of service +** attack. Developers might also want to use the [sqlite3_set_authorizer()] +** interface to further control untrusted SQL. The size of the database +** created by an untrusted script can be contained using the +** [max_page_count] [PRAGMA]. +** +** New run-time limit categories may be added in future releases. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_limit(sqlite3*, int id, int newVal); + +/* +** CAPI3REF: Run-Time Limit Categories +** KEYWORDS: {limit category} {*limit categories} +** +** These constants define various performance limits +** that can be lowered at run-time using [sqlite3_limit()]. +** The synopsis of the meanings of the various limits is shown below. +** Additional information is available at [limits | Limits in SQLite]. +** +**
+** [[SQLITE_LIMIT_LENGTH]] ^(
SQLITE_LIMIT_LENGTH
+**
The maximum size of any string or BLOB or table row, in bytes.
)^ +** +** [[SQLITE_LIMIT_SQL_LENGTH]] ^(
SQLITE_LIMIT_SQL_LENGTH
+**
The maximum length of an SQL statement, in bytes.
)^ +** +** [[SQLITE_LIMIT_COLUMN]] ^(
SQLITE_LIMIT_COLUMN
+**
The maximum number of columns in a table definition or in the +** result set of a [SELECT] or the maximum number of columns in an index +** or in an ORDER BY or GROUP BY clause.
)^ +** +** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(
SQLITE_LIMIT_EXPR_DEPTH
+**
The maximum depth of the parse tree on any expression.
)^ +** +** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(
SQLITE_LIMIT_COMPOUND_SELECT
+**
The maximum number of terms in a compound SELECT statement.
)^ +** +** [[SQLITE_LIMIT_VDBE_OP]] ^(
SQLITE_LIMIT_VDBE_OP
+**
The maximum number of instructions in a virtual machine program +** used to implement an SQL statement. This limit is not currently +** enforced, though that might be added in some future release of +** SQLite.
)^ +** +** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(
SQLITE_LIMIT_FUNCTION_ARG
+**
The maximum number of arguments on a function.
)^ +** +** [[SQLITE_LIMIT_ATTACHED]] ^(
SQLITE_LIMIT_ATTACHED
+**
The maximum number of [ATTACH | attached databases].)^
+** +** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]] +** ^(
SQLITE_LIMIT_LIKE_PATTERN_LENGTH
+**
The maximum length of the pattern argument to the [LIKE] or +** [GLOB] operators.
)^ +** +** [[SQLITE_LIMIT_VARIABLE_NUMBER]] +** ^(
SQLITE_LIMIT_VARIABLE_NUMBER
+**
The maximum index number of any [parameter] in an SQL statement.)^ +** +** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(
SQLITE_LIMIT_TRIGGER_DEPTH
+**
The maximum depth of recursion for triggers.
)^ +** +** [[SQLITE_LIMIT_WORKER_THREADS]] ^(
SQLITE_LIMIT_WORKER_THREADS
+**
The maximum number of auxiliary worker threads that a single +** [prepared statement] may start.
)^ +**
+*/ +#define SQLITE_LIMIT_LENGTH 0 +#define SQLITE_LIMIT_SQL_LENGTH 1 +#define SQLITE_LIMIT_COLUMN 2 +#define SQLITE_LIMIT_EXPR_DEPTH 3 +#define SQLITE_LIMIT_COMPOUND_SELECT 4 +#define SQLITE_LIMIT_VDBE_OP 5 +#define SQLITE_LIMIT_FUNCTION_ARG 6 +#define SQLITE_LIMIT_ATTACHED 7 +#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 +#define SQLITE_LIMIT_VARIABLE_NUMBER 9 +#define SQLITE_LIMIT_TRIGGER_DEPTH 10 +#define SQLITE_LIMIT_WORKER_THREADS 11 + +/* +** CAPI3REF: Compiling An SQL Statement +** KEYWORDS: {SQL statement compiler} +** METHOD: sqlite3 +** CONSTRUCTOR: sqlite3_stmt +** +** To execute an SQL query, it must first be compiled into a byte-code +** program using one of these routines. +** +** The first argument, "db", is a [database connection] obtained from a +** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or +** [sqlite3_open16()]. The database connection must not have been closed. +** +** The second argument, "zSql", is the statement to be compiled, encoded +** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() +** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2() +** use UTF-16. +** +** ^If the nByte argument is negative, then zSql is read up to the +** first zero terminator. ^If nByte is positive, then it is the +** number of bytes read from zSql. ^If nByte is zero, then no prepared +** statement is generated. +** If the caller knows that the supplied string is nul-terminated, then +** there is a small performance advantage to passing an nByte parameter that +** is the number of bytes in the input string including +** the nul-terminator. +** +** ^If pzTail is not NULL then *pzTail is made to point to the first byte +** past the end of the first SQL statement in zSql. These routines only +** compile the first statement in zSql, so *pzTail is left pointing to +** what remains uncompiled. +** +** ^*ppStmt is left pointing to a compiled [prepared statement] that can be +** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set +** to NULL. ^If the input text contains no SQL (if the input is an empty +** string or a comment) then *ppStmt is set to NULL. +** The calling procedure is responsible for deleting the compiled +** SQL statement using [sqlite3_finalize()] after it has finished with it. +** ppStmt may not be NULL. +** +** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK]; +** otherwise an [error code] is returned. +** +** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are +** recommended for all new programs. The two older interfaces are retained +** for backwards compatibility, but their use is discouraged. +** ^In the "v2" interfaces, the prepared statement +** that is returned (the [sqlite3_stmt] object) contains a copy of the +** original SQL text. This causes the [sqlite3_step()] interface to +** behave differently in three ways: +** +**
    +**
  1. +** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it +** always used to do, [sqlite3_step()] will automatically recompile the SQL +** statement and try to run it again. As many as [SQLITE_MAX_SCHEMA_RETRY] +** retries will occur before sqlite3_step() gives up and returns an error. +**
    2. +** +**
  2. +** ^When an error occurs, [sqlite3_step()] will return one of the detailed +** [error codes] or [extended error codes]. ^The legacy behavior was that +** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code +** and the application would have to make a second call to [sqlite3_reset()] +** in order to find the underlying cause of the problem. With the "v2" prepare +** interfaces, the underlying reason for the error is returned immediately. +**
    3. +** +**
  3. +** ^If the specific value bound to [parameter | host parameter] in the +** WHERE clause might influence the choice of query plan for a statement, +** then the statement will be automatically recompiled, as if there had been +** a schema change, on the first [sqlite3_step()] call following any change +** to the [sqlite3_bind_text | bindings] of that [parameter]. +** ^The specific value of WHERE-clause [parameter] might influence the +** choice of query plan if the parameter is the left-hand side of a [LIKE] +** or [GLOB] operator or if the parameter is compared to an indexed column +** and the [SQLITE_ENABLE_STAT3] compile-time option is enabled. +**
    4. +**
+*/ +SQLITE_API int SQLITE_STDCALL sqlite3_prepare( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int SQLITE_STDCALL sqlite3_prepare_v2( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int SQLITE_STDCALL sqlite3_prepare16( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int SQLITE_STDCALL sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); + +/* +** CAPI3REF: Retrieving Statement SQL +** METHOD: sqlite3_stmt +** +** ^This interface can be used to retrieve a saved copy of the original +** SQL text used to create a [prepared statement] if that statement was +** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()]. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_sql(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If An SQL Statement Writes The Database +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if +** and only if the [prepared statement] X makes no direct changes to +** the content of the database file. +** +** Note that [application-defined SQL functions] or +** [virtual tables] might change the database indirectly as a side effect. +** ^(For example, if an application defines a function "eval()" that +** calls [sqlite3_exec()], then the following SQL statement would +** change the database file through side-effects: +** +** 
+**    SELECT eval('DELETE FROM t1') FROM t2;
+**
+** +** But because the [SELECT] statement does not change the database file +** directly, sqlite3_stmt_readonly() would still return true.)^ +** +** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK], +** [SAVEPOINT], and [RELEASE] cause sqlite3_stmt_readonly() to return true, +** since the statements themselves do not actually modify the database but +** rather they control the timing of when other statements modify the +** database. ^The [ATTACH] and [DETACH] statements also cause +** sqlite3_stmt_readonly() to return true since, while those statements +** change the configuration of a database connection, they do not make +** changes to the content of the database files on disk. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_stmt_readonly(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If A Prepared Statement Has Been Reset +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the +** [prepared statement] S has been stepped at least once using +** [sqlite3_step(S)] but has neither run to completion (returned +** [SQLITE_DONE] from [sqlite3_step(S)]) nor +** been reset using [sqlite3_reset(S)]. ^The sqlite3_stmt_busy(S) +** interface returns false if S is a NULL pointer. If S is not a +** NULL pointer and is not a pointer to a valid [prepared statement] +** object, then the behavior is undefined and probably undesirable. +** +** This interface can be used in combination [sqlite3_next_stmt()] +** to locate all prepared statements associated with a database +** connection that are in need of being reset. This can be used, +** for example, in diagnostic routines to search for prepared +** statements that are holding a transaction open. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_stmt_busy(sqlite3_stmt*); + +/* +** CAPI3REF: Dynamically Typed Value Object +** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} +** +** SQLite uses the sqlite3_value object to represent all values +** that can be stored in a database table. SQLite uses dynamic typing +** for the values it stores. ^Values stored in sqlite3_value objects +** can be integers, floating point values, strings, BLOBs, or NULL. +** +** An sqlite3_value object may be either "protected" or "unprotected". +** Some interfaces require a protected sqlite3_value. Other interfaces +** will accept either a protected or an unprotected sqlite3_value. +** Every interface that accepts sqlite3_value arguments specifies +** whether or not it requires a protected sqlite3_value. The +** [sqlite3_value_dup()] interface can be used to construct a new +** protected sqlite3_value from an unprotected sqlite3_value. +** +** The terms "protected" and "unprotected" refer to whether or not +** a mutex is held. An internal mutex is held for a protected +** sqlite3_value object but no mutex is held for an unprotected +** sqlite3_value object. If SQLite is compiled to be single-threaded +** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0) +** or if SQLite is run in one of reduced mutex modes +** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD] +** then there is no distinction between protected and unprotected +** sqlite3_value objects and they can be used interchangeably. However, +** for maximum code portability it is recommended that applications +** still make the distinction between protected and unprotected +** sqlite3_value objects even when not strictly required. +** +** ^The sqlite3_value objects that are passed as parameters into the +** implementation of [application-defined SQL functions] are protected. +** ^The sqlite3_value object returned by +** [sqlite3_column_value()] is unprotected. +** Unprotected sqlite3_value objects may only be used with +** [sqlite3_result_value()] and [sqlite3_bind_value()]. +** The [sqlite3_value_blob | sqlite3_value_type()] family of +** interfaces require protected sqlite3_value objects. +*/ +typedef struct Mem sqlite3_value; + +/* +** CAPI3REF: SQL Function Context Object +** +** The context in which an SQL function executes is stored in an +** sqlite3_context object. ^A pointer to an sqlite3_context object +** is always first parameter to [application-defined SQL functions]. +** The application-defined SQL function implementation will pass this +** pointer through into calls to [sqlite3_result_int | sqlite3_result()], +** [sqlite3_aggregate_context()], [sqlite3_user_data()], +** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()], +** and/or [sqlite3_set_auxdata()]. +*/ +typedef struct sqlite3_context sqlite3_context; + +/* +** CAPI3REF: Binding Values To Prepared Statements +** KEYWORDS: {host parameter} {host parameters} {host parameter name} +** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} +** METHOD: sqlite3_stmt +** +** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants, +** literals may be replaced by a [parameter] that matches one of following +** templates: +** +**
    +**
  • ? +**
  • ?NNN +**
  • :VVV +**
  • @VVV +**
  • $VVV +**
+** +** In the templates above, NNN represents an integer literal, +** and VVV represents an alphanumeric identifier.)^ ^The values of these +** parameters (also called "host parameter names" or "SQL parameters") +** can be set using the sqlite3_bind_*() routines defined here. +** +** ^The first argument to the sqlite3_bind_*() routines is always +** a pointer to the [sqlite3_stmt] object returned from +** [sqlite3_prepare_v2()] or its variants. +** +** ^The second argument is the index of the SQL parameter to be set. +** ^The leftmost SQL parameter has an index of 1. ^When the same named +** SQL parameter is used more than once, second and subsequent +** occurrences have the same index as the first occurrence. +** ^The index for named parameters can be looked up using the +** [sqlite3_bind_parameter_index()] API if desired. ^The index +** for "?NNN" parameters is the value of NNN. +** ^The NNN value must be between 1 and the [sqlite3_limit()] +** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999). +** +** ^The third argument is the value to bind to the parameter. +** ^If the third parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** or sqlite3_bind_blob() is a NULL pointer then the fourth parameter +** is ignored and the end result is the same as sqlite3_bind_null(). +** +** ^(In those routines that have a fourth argument, its value is the +** number of bytes in the parameter. To be clear: the value is the +** number of bytes in the value, not the number of characters.)^ +** ^If the fourth parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** is negative, then the length of the string is +** the number of bytes up to the first zero terminator. +** If the fourth parameter to sqlite3_bind_blob() is negative, then +** the behavior is undefined. +** If a non-negative fourth parameter is provided to sqlite3_bind_text() +** or sqlite3_bind_text16() or sqlite3_bind_text64() then +** that parameter must be the byte offset +** where the NUL terminator would occur assuming the string were NUL +** terminated. If any NUL characters occur at byte offsets less than +** the value of the fourth parameter then the resulting string value will +** contain embedded NULs. The result of expressions involving strings +** with embedded NULs is undefined. +** +** ^The fifth argument to the BLOB and string binding interfaces +** is a destructor used to dispose of the BLOB or +** string after SQLite has finished with it. ^The destructor is called +** to dispose of the BLOB or string even if the call to bind API fails. +** ^If the fifth argument is +** the special value [SQLITE_STATIC], then SQLite assumes that the +** information is in static, unmanaged space and does not need to be freed. +** ^If the fifth argument has the value [SQLITE_TRANSIENT], then +** SQLite makes its own private copy of the data immediately, before +** the sqlite3_bind_*() routine returns. +** +** ^The sixth argument to sqlite3_bind_text64() must be one of +** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE] +** to specify the encoding of the text in the third parameter. If +** the sixth argument to sqlite3_bind_text64() is not one of the +** allowed values shown above, or if the text encoding is different +** from the encoding specified by the sixth parameter, then the behavior +** is undefined. +** +** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that +** is filled with zeroes. ^A zeroblob uses a fixed amount of memory +** (just an integer to hold its size) while it is being processed. +** Zeroblobs are intended to serve as placeholders for BLOBs whose +** content is later written using +** [sqlite3_blob_open | incremental BLOB I/O] routines. +** ^A negative value for the zeroblob results in a zero-length BLOB. +** +** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer +** for the [prepared statement] or with a prepared statement for which +** [sqlite3_step()] has been called more recently than [sqlite3_reset()], +** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_() +** routine is passed a [prepared statement] that has been finalized, the +** result is undefined and probably harmful. +** +** ^Bindings are not cleared by the [sqlite3_reset()] routine. +** ^Unbound parameters are interpreted as NULL. +** +** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an +** [error code] if anything goes wrong. +** ^[SQLITE_TOOBIG] might be returned if the size of a string or BLOB +** exceeds limits imposed by [sqlite3_limit]([SQLITE_LIMIT_LENGTH]) or +** [SQLITE_MAX_LENGTH]. +** ^[SQLITE_RANGE] is returned if the parameter +** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails. +** +** See also: [sqlite3_bind_parameter_count()], +** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64, + void(*)(void*)); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_double(sqlite3_stmt*, int, double); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_int(sqlite3_stmt*, int, int); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_null(sqlite3_stmt*, int); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*)); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64, + void(*)(void*), unsigned char encoding); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); +SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob64(sqlite3_stmt*, int, sqlite3_uint64); + +/* +** CAPI3REF: Number Of SQL Parameters +** METHOD: sqlite3_stmt +** +** ^This routine can be used to find the number of [SQL parameters] +** in a [prepared statement]. SQL parameters are tokens of the +** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as +** placeholders for values that are [sqlite3_bind_blob | bound] +** to the parameters at a later time. +** +** ^(This routine actually returns the index of the largest (rightmost) +** parameter. For all forms except ?NNN, this will correspond to the +** number of unique parameters. If parameters of the ?NNN form are used, +** there may be gaps in the list.)^ +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_name()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_count(sqlite3_stmt*); + +/* +** CAPI3REF: Name Of A Host Parameter +** METHOD: sqlite3_stmt +** +** ^The sqlite3_bind_parameter_name(P,N) interface returns +** the name of the N-th [SQL parameter] in the [prepared statement] P. +** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA" +** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA" +** respectively. +** In other words, the initial ":" or "$" or "@" or "?" +** is included as part of the name.)^ +** ^Parameters of the form "?" without a following integer have no name +** and are referred to as "nameless" or "anonymous parameters". +** +** ^The first host parameter has an index of 1, not 0. +** +** ^If the value N is out of range or if the N-th parameter is +** nameless, then NULL is returned. ^The returned string is +** always in UTF-8 encoding even if the named parameter was +** originally specified as UTF-16 in [sqlite3_prepare16()] or +** [sqlite3_prepare16_v2()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_bind_parameter_name(sqlite3_stmt*, int); + +/* +** CAPI3REF: Index Of A Parameter With A Given Name +** METHOD: sqlite3_stmt +** +** ^Return the index of an SQL parameter given its name. ^The +** index value returned is suitable for use as the second +** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero +** is returned if no matching parameter is found. ^The parameter +** name must be given in UTF-8 even if the original statement +** was prepared from UTF-16 text using [sqlite3_prepare16_v2()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_name()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); + +/* +** CAPI3REF: Reset All Bindings On A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset +** the [sqlite3_bind_blob | bindings] on a [prepared statement]. +** ^Use this routine to reset all host parameters to NULL. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_clear_bindings(sqlite3_stmt*); + +/* +** CAPI3REF: Number Of Columns In A Result Set +** METHOD: sqlite3_stmt +** +** ^Return the number of columns in the result set returned by the +** [prepared statement]. ^This routine returns 0 if pStmt is an SQL +** statement that does not return data (for example an [UPDATE]). +** +** See also: [sqlite3_data_count()] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_column_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Column Names In A Result Set +** METHOD: sqlite3_stmt +** +** ^These routines return the name assigned to a particular column +** in the result set of a [SELECT] statement. ^The sqlite3_column_name() +** interface returns a pointer to a zero-terminated UTF-8 string +** and sqlite3_column_name16() returns a pointer to a zero-terminated +** UTF-16 string. ^The first parameter is the [prepared statement] +** that implements the [SELECT] statement. ^The second parameter is the +** column number. ^The leftmost column is number 0. +** +** ^The returned string pointer is valid until either the [prepared statement] +** is destroyed by [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the next call to +** sqlite3_column_name() or sqlite3_column_name16() on the same column. +** +** ^If sqlite3_malloc() fails during the processing of either routine +** (for example during a conversion from UTF-8 to UTF-16) then a +** NULL pointer is returned. +** +** ^The name of a result column is the value of the "AS" clause for +** that column, if there is an AS clause. If there is no AS clause +** then the name of the column is unspecified and may change from +** one release of SQLite to the next. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_column_name(sqlite3_stmt*, int N); +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_name16(sqlite3_stmt*, int N); + +/* +** CAPI3REF: Source Of Data In A Query Result +** METHOD: sqlite3_stmt +** +** ^These routines provide a means to determine the database, table, and +** table column that is the origin of a particular result column in +** [SELECT] statement. +** ^The name of the database or table or column can be returned as +** either a UTF-8 or UTF-16 string. ^The _database_ routines return +** the database name, the _table_ routines return the table name, and +** the origin_ routines return the column name. +** ^The returned string is valid until the [prepared statement] is destroyed +** using [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the same information is requested +** again in a different encoding. +** +** ^The names returned are the original un-aliased names of the +** database, table, and column. +** +** ^The first argument to these interfaces is a [prepared statement]. +** ^These functions return information about the Nth result column returned by +** the statement, where N is the second function argument. +** ^The left-most column is column 0 for these routines. +** +** ^If the Nth column returned by the statement is an expression or +** subquery and is not a column value, then all of these functions return +** NULL. ^These routine might also return NULL if a memory allocation error +** occurs. ^Otherwise, they return the name of the attached database, table, +** or column that query result column was extracted from. +** +** ^As with all other SQLite APIs, those whose names end with "16" return +** UTF-16 encoded strings and the other functions return UTF-8. +** +** ^These APIs are only available if the library was compiled with the +** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol. +** +** If two or more threads call one or more of these routines against the same +** prepared statement and column at the same time then the results are +** undefined. +** +** If two or more threads call one or more +** [sqlite3_column_database_name | column metadata interfaces] +** for the same [prepared statement] and result column +** at the same time then the results are undefined. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_column_database_name(sqlite3_stmt*,int); +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_database_name16(sqlite3_stmt*,int); +SQLITE_API const char *SQLITE_STDCALL sqlite3_column_table_name(sqlite3_stmt*,int); +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_table_name16(sqlite3_stmt*,int); +SQLITE_API const char *SQLITE_STDCALL sqlite3_column_origin_name(sqlite3_stmt*,int); +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_origin_name16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Declared Datatype Of A Query Result +** METHOD: sqlite3_stmt +** +** ^(The first parameter is a [prepared statement]. +** If this statement is a [SELECT] statement and the Nth column of the +** returned result set of that [SELECT] is a table column (not an +** expression or subquery) then the declared type of the table +** column is returned.)^ ^If the Nth column of the result set is an +** expression or subquery, then a NULL pointer is returned. +** ^The returned string is always UTF-8 encoded. +** +** ^(For example, given the database schema: +** +** CREATE TABLE t1(c1 VARIANT); +** +** and the following statement to be compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** this routine would return the string "VARIANT" for the second result +** column (i==1), and a NULL pointer for the first result column (i==0).)^ +** +** ^SQLite uses dynamic run-time typing. ^So just because a column +** is declared to contain a particular type does not mean that the +** data stored in that column is of the declared type. SQLite is +** strongly typed, but the typing is dynamic not static. ^Type +** is associated with individual values, not with the containers +** used to hold those values. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_column_decltype(sqlite3_stmt*,int); +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_decltype16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Evaluate An SQL Statement +** METHOD: sqlite3_stmt +** +** After a [prepared statement] has been prepared using either +** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy +** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function +** must be called one or more times to evaluate the statement. +** +** The details of the behavior of the sqlite3_step() interface depend +** on whether the statement was prepared using the newer "v2" interface +** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy +** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the +** new "v2" interface is recommended for new applications but the legacy +** interface will continue to be supported. +** +** ^In the legacy interface, the return value will be either [SQLITE_BUSY], +** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. +** ^With the "v2" interface, any of the other [result codes] or +** [extended result codes] might be returned as well. +** +** ^[SQLITE_BUSY] means that the database engine was unable to acquire the +** database locks it needs to do its job. ^If the statement is a [COMMIT] +** or occurs outside of an explicit transaction, then you can retry the +** statement. If the statement is not a [COMMIT] and occurs within an +** explicit transaction then you should rollback the transaction before +** continuing. +** +** ^[SQLITE_DONE] means that the statement has finished executing +** successfully. sqlite3_step() should not be called again on this virtual +** machine without first calling [sqlite3_reset()] to reset the virtual +** machine back to its initial state. +** +** ^If the SQL statement being executed returns any data, then [SQLITE_ROW] +** is returned each time a new row of data is ready for processing by the +** caller. The values may be accessed using the [column access functions]. +** sqlite3_step() is called again to retrieve the next row of data. +** +** ^[SQLITE_ERROR] means that a run-time error (such as a constraint +** violation) has occurred. sqlite3_step() should not be called again on +** the VM. More information may be found by calling [sqlite3_errmsg()]. +** ^With the legacy interface, a more specific error code (for example, +** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) +** can be obtained by calling [sqlite3_reset()] on the +** [prepared statement]. ^In the "v2" interface, +** the more specific error code is returned directly by sqlite3_step(). +** +** [SQLITE_MISUSE] means that the this routine was called inappropriately. +** Perhaps it was called on a [prepared statement] that has +** already been [sqlite3_finalize | finalized] or on one that had +** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could +** be the case that the same database connection is being used by two or +** more threads at the same moment in time. +** +** For all versions of SQLite up to and including 3.6.23.1, a call to +** [sqlite3_reset()] was required after sqlite3_step() returned anything +** other than [SQLITE_ROW] before any subsequent invocation of +** sqlite3_step(). Failure to reset the prepared statement using +** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from +** sqlite3_step(). But after version 3.6.23.1, sqlite3_step() began +** calling [sqlite3_reset()] automatically in this circumstance rather +** than returning [SQLITE_MISUSE]. This is not considered a compatibility +** break because any application that ever receives an SQLITE_MISUSE error +** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option +** can be used to restore the legacy behavior. +** +** Goofy Interface Alert: In the legacy interface, the sqlite3_step() +** API always returns a generic error code, [SQLITE_ERROR], following any +** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call +** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the +** specific [error codes] that better describes the error. +** We admit that this is a goofy design. The problem has been fixed +** with the "v2" interface. If you prepare all of your SQL statements +** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead +** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, +** then the more specific [error codes] are returned directly +** by sqlite3_step(). The use of the "v2" interface is recommended. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_step(sqlite3_stmt*); + +/* +** CAPI3REF: Number of columns in a result set +** METHOD: sqlite3_stmt +** +** ^The sqlite3_data_count(P) interface returns the number of columns in the +** current row of the result set of [prepared statement] P. +** ^If prepared statement P does not have results ready to return +** (via calls to the [sqlite3_column_int | sqlite3_column_*()] of +** interfaces) then sqlite3_data_count(P) returns 0. +** ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer. +** ^The sqlite3_data_count(P) routine returns 0 if the previous call to +** [sqlite3_step](P) returned [SQLITE_DONE]. ^The sqlite3_data_count(P) +** will return non-zero if previous call to [sqlite3_step](P) returned +** [SQLITE_ROW], except in the case of the [PRAGMA incremental_vacuum] +** where it always returns zero since each step of that multi-step +** pragma returns 0 columns of data. +** +** See also: [sqlite3_column_count()] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_data_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Fundamental Datatypes +** KEYWORDS: SQLITE_TEXT +** +** ^(Every value in SQLite has one of five fundamental datatypes: +** +**
    +**
  • 64-bit signed integer +**
  • 64-bit IEEE floating point number +**
  • string +**
  • BLOB +**
  • NULL +**
)^ +** +** These constants are codes for each of those types. +** +** Note that the SQLITE_TEXT constant was also used in SQLite version 2 +** for a completely different meaning. Software that links against both +** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not +** SQLITE_TEXT. +*/ +#define SQLITE_INTEGER 1 +#define SQLITE_FLOAT 2 +#define SQLITE_BLOB 4 +#define SQLITE_NULL 5 +#ifdef SQLITE_TEXT +# undef SQLITE_TEXT +#else +# define SQLITE_TEXT 3 +#endif +#define SQLITE3_TEXT 3 + +/* +** CAPI3REF: Result Values From A Query +** KEYWORDS: {column access functions} +** METHOD: sqlite3_stmt +** +** ^These routines return information about a single column of the current +** result row of a query. ^In every case the first argument is a pointer +** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] +** that was returned from [sqlite3_prepare_v2()] or one of its variants) +** and the second argument is the index of the column for which information +** should be returned. ^The leftmost column of the result set has the index 0. +** ^The number of columns in the result can be determined using +** [sqlite3_column_count()]. +** +** If the SQL statement does not currently point to a valid row, or if the +** column index is out of range, the result is undefined. +** These routines may only be called when the most recent call to +** [sqlite3_step()] has returned [SQLITE_ROW] and neither +** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently. +** If any of these routines are called after [sqlite3_reset()] or +** [sqlite3_finalize()] or after [sqlite3_step()] has returned +** something other than [SQLITE_ROW], the results are undefined. +** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] +** are called from a different thread while any of these routines +** are pending, then the results are undefined. +** +** ^The sqlite3_column_type() routine returns the +** [SQLITE_INTEGER | datatype code] for the initial data type +** of the result column. ^The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value +** returned by sqlite3_column_type() is only meaningful if no type +** conversions have occurred as described below. After a type conversion, +** the value returned by sqlite3_column_type() is undefined. Future +** versions of SQLite may change the behavior of sqlite3_column_type() +** following a type conversion. +** +** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts +** the string to UTF-8 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes() uses +** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes() returns zero. +** +** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts +** the string to UTF-16 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes16() uses +** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes16() returns zero. +** +** ^The values returned by [sqlite3_column_bytes()] and +** [sqlite3_column_bytes16()] do not include the zero terminators at the end +** of the string. ^For clarity: the values returned by +** [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of +** bytes in the string, not the number of characters. +** +** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(), +** even empty strings, are always zero-terminated. ^The return +** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer. +** +** Warning: ^The object returned by [sqlite3_column_value()] is an +** [unprotected sqlite3_value] object. In a multithreaded environment, +** an unprotected sqlite3_value object may only be used safely with +** [sqlite3_bind_value()] and [sqlite3_result_value()]. +** If the [unprotected sqlite3_value] object returned by +** [sqlite3_column_value()] is used in any other way, including calls +** to routines like [sqlite3_value_int()], [sqlite3_value_text()], +** or [sqlite3_value_bytes()], the behavior is not threadsafe. +** +** These routines attempt to convert the value where appropriate. ^For +** example, if the internal representation is FLOAT and a text result +** is requested, [sqlite3_snprintf()] is used internally to perform the +** conversion automatically. ^(The following table details the conversions +** that are applied: +** +**
+** +**
Internal
Type 		Requested
Type 		Conversion +** +**
NULL INTEGER Result is 0 +**
NULL FLOAT Result is 0.0 +**
NULL TEXT Result is a NULL pointer +**
NULL BLOB Result is a NULL pointer +**
INTEGER FLOAT Convert from integer to float +**
INTEGER TEXT ASCII rendering of the integer +**
INTEGER BLOB Same as INTEGER->TEXT +**
FLOAT INTEGER [CAST] to INTEGER +**
FLOAT TEXT ASCII rendering of the float +**
FLOAT BLOB [CAST] to BLOB +**
TEXT INTEGER [CAST] to INTEGER +**
TEXT FLOAT [CAST] to REAL +**
TEXT BLOB No change +**
BLOB INTEGER [CAST] to INTEGER +**
BLOB FLOAT [CAST] to REAL +**
BLOB TEXT Add a zero terminator if needed +**
+**
)^ +** +** Note that when type conversions occur, pointers returned by prior +** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or +** sqlite3_column_text16() may be invalidated. +** Type conversions and pointer invalidations might occur +** in the following cases: +** +**
    +**
  • The initial content is a BLOB and sqlite3_column_text() or +** sqlite3_column_text16() is called. A zero-terminator might +** need to be added to the string.
    • +**
  • The initial content is UTF-8 text and sqlite3_column_bytes16() or +** sqlite3_column_text16() is called. The content must be converted +** to UTF-16.
    • +**
  • The initial content is UTF-16 text and sqlite3_column_bytes() or +** sqlite3_column_text() is called. The content must be converted +** to UTF-8.
    • +**
+** +** ^Conversions between UTF-16be and UTF-16le are always done in place and do +** not invalidate a prior pointer, though of course the content of the buffer +** that the prior pointer references will have been modified. Other kinds +** of conversion are done in place when it is possible, but sometimes they +** are not possible and in those cases prior pointers are invalidated. +** +** The safest policy is to invoke these routines +** in one of the following ways: +** +**
    +**
  • sqlite3_column_text() followed by sqlite3_column_bytes()
    • +**
  • sqlite3_column_blob() followed by sqlite3_column_bytes()
    • +**
  • sqlite3_column_text16() followed by sqlite3_column_bytes16()
    • +**
+** +** In other words, you should call sqlite3_column_text(), +** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result +** into the desired format, then invoke sqlite3_column_bytes() or +** sqlite3_column_bytes16() to find the size of the result. Do not mix calls +** to sqlite3_column_text() or sqlite3_column_blob() with calls to +** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() +** with calls to sqlite3_column_bytes(). +** +** ^The pointers returned are valid until a type conversion occurs as +** described above, or until [sqlite3_step()] or [sqlite3_reset()] or +** [sqlite3_finalize()] is called. ^The memory space used to hold strings +** and BLOBs is freed automatically. Do not pass the pointers returned +** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into +** [sqlite3_free()]. +** +** ^(If a memory allocation error occurs during the evaluation of any +** of these routines, a default value is returned. The default value +** is either the integer 0, the floating point number 0.0, or a NULL +** pointer. Subsequent calls to [sqlite3_errcode()] will return +** [SQLITE_NOMEM].)^ +*/ +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_blob(sqlite3_stmt*, int iCol); +SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes(sqlite3_stmt*, int iCol); +SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes16(sqlite3_stmt*, int iCol); +SQLITE_API double SQLITE_STDCALL sqlite3_column_double(sqlite3_stmt*, int iCol); +SQLITE_API int SQLITE_STDCALL sqlite3_column_int(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_column_int64(sqlite3_stmt*, int iCol); +SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_column_text(sqlite3_stmt*, int iCol); +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_text16(sqlite3_stmt*, int iCol); +SQLITE_API int SQLITE_STDCALL sqlite3_column_type(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_column_value(sqlite3_stmt*, int iCol); + +/* +** CAPI3REF: Destroy A Prepared Statement Object +** DESTRUCTOR: sqlite3_stmt +** +** ^The sqlite3_finalize() function is called to delete a [prepared statement]. +** ^If the most recent evaluation of the statement encountered no errors +** or if the statement is never been evaluated, then sqlite3_finalize() returns +** SQLITE_OK. ^If the most recent evaluation of statement S failed, then +** sqlite3_finalize(S) returns the appropriate [error code] or +** [extended error code]. +** +** ^The sqlite3_finalize(S) routine can be called at any point during +** the life cycle of [prepared statement] S: +** before statement S is ever evaluated, after +** one or more calls to [sqlite3_reset()], or after any call +** to [sqlite3_step()] regardless of whether or not the statement has +** completed execution. +** +** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op. +** +** The application must finalize every [prepared statement] in order to avoid +** resource leaks. It is a grievous error for the application to try to use +** a prepared statement after it has been finalized. Any use of a prepared +** statement after it has been finalized can result in undefined and +** undesirable behavior such as segfaults and heap corruption. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_finalize(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Reset A Prepared Statement Object +** METHOD: sqlite3_stmt +** +** The sqlite3_reset() function is called to reset a [prepared statement] +** object back to its initial state, ready to be re-executed. +** ^Any SQL statement variables that had values bound to them using +** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. +** Use [sqlite3_clear_bindings()] to reset the bindings. +** +** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S +** back to the beginning of its program. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE], +** or if [sqlite3_step(S)] has never before been called on S, +** then [sqlite3_reset(S)] returns [SQLITE_OK]. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S indicated an error, then +** [sqlite3_reset(S)] returns an appropriate [error code]. +** +** ^The [sqlite3_reset(S)] interface does not change the values +** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_reset(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Create Or Redefine SQL Functions +** KEYWORDS: {function creation routines} +** KEYWORDS: {application-defined SQL function} +** KEYWORDS: {application-defined SQL functions} +** METHOD: sqlite3 +** +** ^These functions (collectively known as "function creation routines") +** are used to add SQL functions or aggregates or to redefine the behavior +** of existing SQL functions or aggregates. The only differences between +** these routines are the text encoding expected for +** the second parameter (the name of the function being created) +** and the presence or absence of a destructor callback for +** the application data pointer. +** +** ^The first parameter is the [database connection] to which the SQL +** function is to be added. ^If an application uses more than one database +** connection then application-defined SQL functions must be added +** to each database connection separately. +** +** ^The second parameter is the name of the SQL function to be created or +** redefined. ^The length of the name is limited to 255 bytes in a UTF-8 +** representation, exclusive of the zero-terminator. ^Note that the name +** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes. +** ^Any attempt to create a function with a longer name +** will result in [SQLITE_MISUSE] being returned. +** +** ^The third parameter (nArg) +** is the number of arguments that the SQL function or +** aggregate takes. ^If this parameter is -1, then the SQL function or +** aggregate may take any number of arguments between 0 and the limit +** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third +** parameter is less than -1 or greater than 127 then the behavior is +** undefined. +** +** ^The fourth parameter, eTextRep, specifies what +** [SQLITE_UTF8 | text encoding] this SQL function prefers for +** its parameters. The application should set this parameter to +** [SQLITE_UTF16LE] if the function implementation invokes +** [sqlite3_value_text16le()] on an input, or [SQLITE_UTF16BE] if the +** implementation invokes [sqlite3_value_text16be()] on an input, or +** [SQLITE_UTF16] if [sqlite3_value_text16()] is used, or [SQLITE_UTF8] +** otherwise. ^The same SQL function may be registered multiple times using +** different preferred text encodings, with different implementations for +** each encoding. +** ^When multiple implementations of the same function are available, SQLite +** will pick the one that involves the least amount of data conversion. +** +** ^The fourth parameter may optionally be ORed with [SQLITE_DETERMINISTIC] +** to signal that the function will always return the same result given +** the same inputs within a single SQL statement. Most SQL functions are +** deterministic. The built-in [random()] SQL function is an example of a +** function that is not deterministic. The SQLite query planner is able to +** perform additional optimizations on deterministic functions, so use +** of the [SQLITE_DETERMINISTIC] flag is recommended where possible. +** +** ^(The fifth parameter is an arbitrary pointer. The implementation of the +** function can gain access to this pointer using [sqlite3_user_data()].)^ +** +** ^The sixth, seventh and eighth parameters, xFunc, xStep and xFinal, are +** pointers to C-language functions that implement the SQL function or +** aggregate. ^A scalar SQL function requires an implementation of the xFunc +** callback only; NULL pointers must be passed as the xStep and xFinal +** parameters. ^An aggregate SQL function requires an implementation of xStep +** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing +** SQL function or aggregate, pass NULL pointers for all three function +** callbacks. +** +** ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL, +** then it is destructor for the application data pointer. +** The destructor is invoked when the function is deleted, either by being +** overloaded or when the database connection closes.)^ +** ^The destructor is also invoked if the call to +** sqlite3_create_function_v2() fails. +** ^When the destructor callback of the tenth parameter is invoked, it +** is passed a single argument which is a copy of the application data +** pointer which was the fifth parameter to sqlite3_create_function_v2(). +** +** ^It is permitted to register multiple implementations of the same +** functions with the same name but with either differing numbers of +** arguments or differing preferred text encodings. ^SQLite will use +** the implementation that most closely matches the way in which the +** SQL function is used. ^A function implementation with a non-negative +** nArg parameter is a better match than a function implementation with +** a negative nArg. ^A function where the preferred text encoding +** matches the database encoding is a better +** match than a function where the encoding is different. +** ^A function where the encoding difference is between UTF16le and UTF16be +** is a closer match than a function where the encoding difference is +** between UTF8 and UTF16. +** +** ^Built-in functions may be overloaded by new application-defined functions. +** +** ^An application-defined function is permitted to call other +** SQLite interfaces. However, such calls must not +** close the database connection nor finalize or reset the prepared +** statement in which the function is running. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_create_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int SQLITE_STDCALL sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int SQLITE_STDCALL sqlite3_create_function_v2( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void(*xDestroy)(void*) +); + +/* +** CAPI3REF: Text Encodings +** +** These constant define integer codes that represent the various +** text encodings supported by SQLite. +*/ +#define SQLITE_UTF8 1 /* IMP: R-37514-35566 */ +#define SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */ +#define SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */ +#define SQLITE_UTF16 4 /* Use native byte order */ +#define SQLITE_ANY 5 /* Deprecated */ +#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ + +/* +** CAPI3REF: Function Flags +** +** These constants may be ORed together with the +** [SQLITE_UTF8 | preferred text encoding] as the fourth argument +** to [sqlite3_create_function()], [sqlite3_create_function16()], or +** [sqlite3_create_function_v2()]. +*/ +#define SQLITE_DETERMINISTIC 0x800 + +/* +** CAPI3REF: Deprecated Functions +** DEPRECATED +** +** These functions are [deprecated]. In order to maintain +** backwards compatibility with older code, these functions continue +** to be supported. However, new applications should avoid +** the use of these functions. To encourage programmers to avoid +** these functions, we will not explain what they do. +*/ +#ifndef SQLITE_OMIT_DEPRECATED +SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_aggregate_count(sqlite3_context*); +SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_expired(sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_global_recover(void); +SQLITE_API SQLITE_DEPRECATED void SQLITE_STDCALL sqlite3_thread_cleanup(void); +SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int), + void*,sqlite3_int64); +#endif + +/* +** CAPI3REF: Obtaining SQL Values +** METHOD: sqlite3_value +** +** The C-language implementation of SQL functions and aggregates uses +** this set of interface routines to access the parameter values on +** the function or aggregate. +** +** The xFunc (for scalar functions) or xStep (for aggregates) parameters +** to [sqlite3_create_function()] and [sqlite3_create_function16()] +** define callbacks that implement the SQL functions and aggregates. +** The 3rd parameter to these callbacks is an array of pointers to +** [protected sqlite3_value] objects. There is one [sqlite3_value] object for +** each parameter to the SQL function. These routines are used to +** extract values from the [sqlite3_value] objects. +** +** These routines work only with [protected sqlite3_value] objects. +** Any attempt to use these routines on an [unprotected sqlite3_value] +** object results in undefined behavior. +** +** ^These routines work just like the corresponding [column access functions] +** except that these routines take a single [protected sqlite3_value] object +** pointer instead of a [sqlite3_stmt*] pointer and an integer column number. +** +** ^The sqlite3_value_text16() interface extracts a UTF-16 string +** in the native byte-order of the host machine. ^The +** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces +** extract UTF-16 strings as big-endian and little-endian respectively. +** +** ^(The sqlite3_value_numeric_type() interface attempts to apply +** numeric affinity to the value. This means that an attempt is +** made to convert the value to an integer or floating point. If +** such a conversion is possible without loss of information (in other +** words, if the value is a string that looks like a number) +** then the conversion is performed. Otherwise no conversion occurs. +** The [SQLITE_INTEGER | datatype] after conversion is returned.)^ +** +** Please pay particular attention to the fact that the pointer returned +** from [sqlite3_value_blob()], [sqlite3_value_text()], or +** [sqlite3_value_text16()] can be invalidated by a subsequent call to +** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], +** or [sqlite3_value_text16()]. +** +** These routines must be called from the same thread as +** the SQL function that supplied the [sqlite3_value*] parameters. +*/ +SQLITE_API const void *SQLITE_STDCALL sqlite3_value_blob(sqlite3_value*); +SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes(sqlite3_value*); +SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes16(sqlite3_value*); +SQLITE_API double SQLITE_STDCALL sqlite3_value_double(sqlite3_value*); +SQLITE_API int SQLITE_STDCALL sqlite3_value_int(sqlite3_value*); +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_value_int64(sqlite3_value*); +SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_value_text(sqlite3_value*); +SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16(sqlite3_value*); +SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16le(sqlite3_value*); +SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16be(sqlite3_value*); +SQLITE_API int SQLITE_STDCALL sqlite3_value_type(sqlite3_value*); +SQLITE_API int SQLITE_STDCALL sqlite3_value_numeric_type(sqlite3_value*); + +/* +** CAPI3REF: Finding The Subtype Of SQL Values +** METHOD: sqlite3_value +** +** The sqlite3_value_subtype(V) function returns the subtype for +** an [application-defined SQL function] argument V. The subtype +** information can be used to pass a limited amount of context from +** one SQL function to another. Use the [sqlite3_result_subtype()] +** routine to set the subtype for the return value of an SQL function. +** +** SQLite makes no use of subtype itself. It merely passes the subtype +** from the result of one [application-defined SQL function] into the +** input of another. +*/ +SQLITE_API unsigned int SQLITE_STDCALL sqlite3_value_subtype(sqlite3_value*); + +/* +** CAPI3REF: Copy And Free SQL Values +** METHOD: sqlite3_value +** +** ^The sqlite3_value_dup(V) interface makes a copy of the [sqlite3_value] +** object D and returns a pointer to that copy. ^The [sqlite3_value] returned +** is a [protected sqlite3_value] object even if the input is not. +** ^The sqlite3_value_dup(V) interface returns NULL if V is NULL or if a +** memory allocation fails. +** +** ^The sqlite3_value_free(V) interface frees an [sqlite3_value] object +** previously obtained from [sqlite3_value_dup()]. ^If V is a NULL pointer +** then sqlite3_value_free(V) is a harmless no-op. +*/ +SQLITE_API SQLITE_EXPERIMENTAL sqlite3_value *SQLITE_STDCALL sqlite3_value_dup(const sqlite3_value*); +SQLITE_API SQLITE_EXPERIMENTAL void SQLITE_STDCALL sqlite3_value_free(sqlite3_value*); + +/* +** CAPI3REF: Obtain Aggregate Function Context +** METHOD: sqlite3_context +** +** Implementations of aggregate SQL functions use this +** routine to allocate memory for storing their state. +** +** ^The first time the sqlite3_aggregate_context(C,N) routine is called +** for a particular aggregate function, SQLite +** allocates N of memory, zeroes out that memory, and returns a pointer +** to the new memory. ^On second and subsequent calls to +** sqlite3_aggregate_context() for the same aggregate function instance, +** the same buffer is returned. Sqlite3_aggregate_context() is normally +** called once for each invocation of the xStep callback and then one +** last time when the xFinal callback is invoked. ^(When no rows match +** an aggregate query, the xStep() callback of the aggregate function +** implementation is never called and xFinal() is called exactly once. +** In those cases, sqlite3_aggregate_context() might be called for the +** first time from within xFinal().)^ +** +** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer +** when first called if N is less than or equal to zero or if a memory +** allocate error occurs. +** +** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is +** determined by the N parameter on first successful call. Changing the +** value of N in subsequent call to sqlite3_aggregate_context() within +** the same aggregate function instance will not resize the memory +** allocation.)^ Within the xFinal callback, it is customary to set +** N=0 in calls to sqlite3_aggregate_context(C,N) so that no +** pointless memory allocations occur. +** +** ^SQLite automatically frees the memory allocated by +** sqlite3_aggregate_context() when the aggregate query concludes. +** +** The first parameter must be a copy of the +** [sqlite3_context | SQL function context] that is the first parameter +** to the xStep or xFinal callback routine that implements the aggregate +** function. +** +** This routine must be called from the same thread in which +** the aggregate SQL function is running. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context*, int nBytes); + +/* +** CAPI3REF: User Data For Functions +** METHOD: sqlite3_context +** +** ^The sqlite3_user_data() interface returns a copy of +** the pointer that was the pUserData parameter (the 5th parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +** +** This routine must be called from the same thread in which +** the application-defined function is running. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_user_data(sqlite3_context*); + +/* +** CAPI3REF: Database Connection For Functions +** METHOD: sqlite3_context +** +** ^The sqlite3_context_db_handle() interface returns a copy of +** the pointer to the [database connection] (the 1st parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +*/ +SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_context_db_handle(sqlite3_context*); + +/* +** CAPI3REF: Function Auxiliary Data +** METHOD: sqlite3_context +** +** These functions may be used by (non-aggregate) SQL functions to +** associate metadata with argument values. If the same value is passed to +** multiple invocations of the same SQL function during query execution, under +** some circumstances the associated metadata may be preserved. An example +** of where this might be useful is in a regular-expression matching +** function. The compiled version of the regular expression can be stored as +** metadata associated with the pattern string. +** Then as long as the pattern string remains the same, +** the compiled regular expression can be reused on multiple +** invocations of the same function. +** +** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata +** associated by the sqlite3_set_auxdata() function with the Nth argument +** value to the application-defined function. ^If there is no metadata +** associated with the function argument, this sqlite3_get_auxdata() interface +** returns a NULL pointer. +** +** ^The sqlite3_set_auxdata(C,N,P,X) interface saves P as metadata for the N-th +** argument of the application-defined function. ^Subsequent +** calls to sqlite3_get_auxdata(C,N) return P from the most recent +** sqlite3_set_auxdata(C,N,P,X) call if the metadata is still valid or +** NULL if the metadata has been discarded. +** ^After each call to sqlite3_set_auxdata(C,N,P,X) where X is not NULL, +** SQLite will invoke the destructor function X with parameter P exactly +** once, when the metadata is discarded. +** SQLite is free to discard the metadata at any time, including:
    +**
  • when the corresponding function parameter changes, or +**
  • when [sqlite3_reset()] or [sqlite3_finalize()] is called for the +** SQL statement, or +**
  • when sqlite3_set_auxdata() is invoked again on the same parameter, or +**
  • during the original sqlite3_set_auxdata() call when a memory +** allocation error occurs.
)^ +** +** Note the last bullet in particular. The destructor X in +** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the +** sqlite3_set_auxdata() interface even returns. Hence sqlite3_set_auxdata() +** should be called near the end of the function implementation and the +** function implementation should not make any use of P after +** sqlite3_set_auxdata() has been called. +** +** ^(In practice, metadata is preserved between function calls for +** function parameters that are compile-time constants, including literal +** values and [parameters] and expressions composed from the same.)^ +** +** These routines must be called from the same thread in which +** the SQL function is running. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_get_auxdata(sqlite3_context*, int N); +SQLITE_API void SQLITE_STDCALL sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); + + +/* +** CAPI3REF: Constants Defining Special Destructor Behavior +** +** These are special values for the destructor that is passed in as the +** final argument to routines like [sqlite3_result_blob()]. ^If the destructor +** argument is SQLITE_STATIC, it means that the content pointer is constant +** and will never change. It does not need to be destroyed. ^The +** SQLITE_TRANSIENT value means that the content will likely change in +** the near future and that SQLite should make its own private copy of +** the content before returning. +** +** The typedef is necessary to work around problems in certain +** C++ compilers. +*/ +typedef void (*sqlite3_destructor_type)(void*); +#define SQLITE_STATIC ((sqlite3_destructor_type)0) +#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) + +/* +** CAPI3REF: Setting The Result Of An SQL Function +** METHOD: sqlite3_context +** +** These routines are used by the xFunc or xFinal callbacks that +** implement SQL functions and aggregates. See +** [sqlite3_create_function()] and [sqlite3_create_function16()] +** for additional information. +** +** These functions work very much like the [parameter binding] family of +** functions used to bind values to host parameters in prepared statements. +** Refer to the [SQL parameter] documentation for additional information. +** +** ^The sqlite3_result_blob() interface sets the result from +** an application-defined function to be the BLOB whose content is pointed +** to by the second parameter and which is N bytes long where N is the +** third parameter. +** +** ^The sqlite3_result_zeroblob(C,N) and sqlite3_result_zeroblob64(C,N) +** interfaces set the result of the application-defined function to be +** a BLOB containing all zero bytes and N bytes in size. +** +** ^The sqlite3_result_double() interface sets the result from +** an application-defined function to be a floating point value specified +** by its 2nd argument. +** +** ^The sqlite3_result_error() and sqlite3_result_error16() functions +** cause the implemented SQL function to throw an exception. +** ^SQLite uses the string pointed to by the +** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() +** as the text of an error message. ^SQLite interprets the error +** message string from sqlite3_result_error() as UTF-8. ^SQLite +** interprets the string from sqlite3_result_error16() as UTF-16 in native +** byte order. ^If the third parameter to sqlite3_result_error() +** or sqlite3_result_error16() is negative then SQLite takes as the error +** message all text up through the first zero character. +** ^If the third parameter to sqlite3_result_error() or +** sqlite3_result_error16() is non-negative then SQLite takes that many +** bytes (not characters) from the 2nd parameter as the error message. +** ^The sqlite3_result_error() and sqlite3_result_error16() +** routines make a private copy of the error message text before +** they return. Hence, the calling function can deallocate or +** modify the text after they return without harm. +** ^The sqlite3_result_error_code() function changes the error code +** returned by SQLite as a result of an error in a function. ^By default, +** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error() +** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. +** +** ^The sqlite3_result_error_toobig() interface causes SQLite to throw an +** error indicating that a string or BLOB is too long to represent. +** +** ^The sqlite3_result_error_nomem() interface causes SQLite to throw an +** error indicating that a memory allocation failed. +** +** ^The sqlite3_result_int() interface sets the return value +** of the application-defined function to be the 32-bit signed integer +** value given in the 2nd argument. +** ^The sqlite3_result_int64() interface sets the return value +** of the application-defined function to be the 64-bit signed integer +** value given in the 2nd argument. +** +** ^The sqlite3_result_null() interface sets the return value +** of the application-defined function to be NULL. +** +** ^The sqlite3_result_text(), sqlite3_result_text16(), +** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces +** set the return value of the application-defined function to be +** a text string which is represented as UTF-8, UTF-16 native byte order, +** UTF-16 little endian, or UTF-16 big endian, respectively. +** ^The sqlite3_result_text64() interface sets the return value of an +** application-defined function to be a text string in an encoding +** specified by the fifth (and last) parameter, which must be one +** of [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE]. +** ^SQLite takes the text result from the application from +** the 2nd parameter of the sqlite3_result_text* interfaces. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is negative, then SQLite takes result text from the 2nd parameter +** through the first zero character. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is non-negative, then as many bytes (not characters) of the text +** pointed to by the 2nd parameter are taken as the application-defined +** function result. If the 3rd parameter is non-negative, then it +** must be the byte offset into the string where the NUL terminator would +** appear if the string where NUL terminated. If any NUL characters occur +** in the string at a byte offset that is less than the value of the 3rd +** parameter, then the resulting string will contain embedded NULs and the +** result of expressions operating on strings with embedded NULs is undefined. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that +** function as the destructor on the text or BLOB result when it has +** finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces or to +** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite +** assumes that the text or BLOB result is in constant space and does not +** copy the content of the parameter nor call a destructor on the content +** when it has finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT +** then SQLite makes a copy of the result into space obtained from +** from [sqlite3_malloc()] before it returns. +** +** ^The sqlite3_result_value() interface sets the result of +** the application-defined function to be a copy of the +** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The +** sqlite3_result_value() interface makes a copy of the [sqlite3_value] +** so that the [sqlite3_value] specified in the parameter may change or +** be deallocated after sqlite3_result_value() returns without harm. +** ^A [protected sqlite3_value] object may always be used where an +** [unprotected sqlite3_value] object is required, so either +** kind of [sqlite3_value] object can be used with this interface. +** +** If these routines are called from within the different thread +** than the one containing the application-defined function that received +** the [sqlite3_context] pointer, the results are undefined. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void SQLITE_STDCALL sqlite3_result_blob64(sqlite3_context*,const void*, + sqlite3_uint64,void(*)(void*)); +SQLITE_API void SQLITE_STDCALL sqlite3_result_double(sqlite3_context*, double); +SQLITE_API void SQLITE_STDCALL sqlite3_result_error(sqlite3_context*, const char*, int); +SQLITE_API void SQLITE_STDCALL sqlite3_result_error16(sqlite3_context*, const void*, int); +SQLITE_API void SQLITE_STDCALL sqlite3_result_error_toobig(sqlite3_context*); +SQLITE_API void SQLITE_STDCALL sqlite3_result_error_nomem(sqlite3_context*); +SQLITE_API void SQLITE_STDCALL sqlite3_result_error_code(sqlite3_context*, int); +SQLITE_API void SQLITE_STDCALL sqlite3_result_int(sqlite3_context*, int); +SQLITE_API void SQLITE_STDCALL sqlite3_result_int64(sqlite3_context*, sqlite3_int64); +SQLITE_API void SQLITE_STDCALL sqlite3_result_null(sqlite3_context*); +SQLITE_API void SQLITE_STDCALL sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); +SQLITE_API void SQLITE_STDCALL sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64, + void(*)(void*), unsigned char encoding); +SQLITE_API void SQLITE_STDCALL sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void SQLITE_STDCALL sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void SQLITE_STDCALL sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void SQLITE_STDCALL sqlite3_result_value(sqlite3_context*, sqlite3_value*); +SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context*, int n); +SQLITE_API int SQLITE_STDCALL sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n); + + +/* +** CAPI3REF: Setting The Subtype Of An SQL Function +** METHOD: sqlite3_context +** +** The sqlite3_result_subtype(C,T) function causes the subtype of +** the result from the [application-defined SQL function] with +** [sqlite3_context] C to be the value T. Only the lower 8 bits +** of the subtype T are preserved in current versions of SQLite; +** higher order bits are discarded. +** The number of subtype bytes preserved by SQLite might increase +** in future releases of SQLite. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_result_subtype(sqlite3_context*,unsigned int); + +/* +** CAPI3REF: Define New Collating Sequences +** METHOD: sqlite3 +** +** ^These functions add, remove, or modify a [collation] associated +** with the [database connection] specified as the first argument. +** +** ^The name of the collation is a UTF-8 string +** for sqlite3_create_collation() and sqlite3_create_collation_v2() +** and a UTF-16 string in native byte order for sqlite3_create_collation16(). +** ^Collation names that compare equal according to [sqlite3_strnicmp()] are +** considered to be the same name. +** +** ^(The third argument (eTextRep) must be one of the constants: +**
    +**
  • [SQLITE_UTF8], +**
  • [SQLITE_UTF16LE], +**
  • [SQLITE_UTF16BE], +**
  • [SQLITE_UTF16], or +**
  • [SQLITE_UTF16_ALIGNED]. +**
)^ +** ^The eTextRep argument determines the encoding of strings passed +** to the collating function callback, xCallback. +** ^The [SQLITE_UTF16] and [SQLITE_UTF16_ALIGNED] values for eTextRep +** force strings to be UTF16 with native byte order. +** ^The [SQLITE_UTF16_ALIGNED] value for eTextRep forces strings to begin +** on an even byte address. +** +** ^The fourth argument, pArg, is an application data pointer that is passed +** through as the first argument to the collating function callback. +** +** ^The fifth argument, xCallback, is a pointer to the collating function. +** ^Multiple collating functions can be registered using the same name but +** with different eTextRep parameters and SQLite will use whichever +** function requires the least amount of data transformation. +** ^If the xCallback argument is NULL then the collating function is +** deleted. ^When all collating functions having the same name are deleted, +** that collation is no longer usable. +** +** ^The collating function callback is invoked with a copy of the pArg +** application data pointer and with two strings in the encoding specified +** by the eTextRep argument. The collating function must return an +** integer that is negative, zero, or positive +** if the first string is less than, equal to, or greater than the second, +** respectively. A collating function must always return the same answer +** given the same inputs. If two or more collating functions are registered +** to the same collation name (using different eTextRep values) then all +** must give an equivalent answer when invoked with equivalent strings. +** The collating function must obey the following properties for all +** strings A, B, and C: +** +**
    +**
  1. If A==B then B==A. +**
  2. If A==B and B==C then A==C. +**
  3. If A<B THEN B>A. +**
  4. If A<B and B<C then A<C. +**
+** +** If a collating function fails any of the above constraints and that +** collating function is registered and used, then the behavior of SQLite +** is undefined. +** +** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation() +** with the addition that the xDestroy callback is invoked on pArg when +** the collating function is deleted. +** ^Collating functions are deleted when they are overridden by later +** calls to the collation creation functions or when the +** [database connection] is closed using [sqlite3_close()]. +** +** ^The xDestroy callback is not called if the +** sqlite3_create_collation_v2() function fails. Applications that invoke +** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should +** check the return code and dispose of the application data pointer +** themselves rather than expecting SQLite to deal with it for them. +** This is different from every other SQLite interface. The inconsistency +** is unfortunate but cannot be changed without breaking backwards +** compatibility. +** +** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_create_collation( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); +SQLITE_API int SQLITE_STDCALL sqlite3_create_collation_v2( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDestroy)(void*) +); +SQLITE_API int SQLITE_STDCALL sqlite3_create_collation16( + sqlite3*, + const void *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); + +/* +** CAPI3REF: Collation Needed Callbacks +** METHOD: sqlite3 +** +** ^To avoid having to register all collation sequences before a database +** can be used, a single callback function may be registered with the +** [database connection] to be invoked whenever an undefined collation +** sequence is required. +** +** ^If the function is registered using the sqlite3_collation_needed() API, +** then it is passed the names of undefined collation sequences as strings +** encoded in UTF-8. ^If sqlite3_collation_needed16() is used, +** the names are passed as UTF-16 in machine native byte order. +** ^A call to either function replaces the existing collation-needed callback. +** +** ^(When the callback is invoked, the first argument passed is a copy +** of the second argument to sqlite3_collation_needed() or +** sqlite3_collation_needed16(). The second argument is the database +** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE], +** or [SQLITE_UTF16LE], indicating the most desirable form of the collation +** sequence function required. The fourth parameter is the name of the +** required collation sequence.)^ +** +** The callback function should register the desired collation using +** [sqlite3_create_collation()], [sqlite3_create_collation16()], or +** [sqlite3_create_collation_v2()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const char*) +); +SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed16( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const void*) +); + +#ifdef SQLITE_HAS_CODEC +/* +** Specify the key for an encrypted database. This routine should be +** called right after sqlite3_open(). +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_key( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The key */ +); +SQLITE_API int SQLITE_STDCALL sqlite3_key_v2( + sqlite3 *db, /* Database to be rekeyed */ + const char *zDbName, /* Name of the database */ + const void *pKey, int nKey /* The key */ +); + +/* +** Change the key on an open database. If the current database is not +** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the +** database is decrypted. +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_rekey( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The new key */ +); +SQLITE_API int SQLITE_STDCALL sqlite3_rekey_v2( + sqlite3 *db, /* Database to be rekeyed */ + const char *zDbName, /* Name of the database */ + const void *pKey, int nKey /* The new key */ +); + +/* +** Specify the activation key for a SEE database. Unless +** activated, none of the SEE routines will work. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_activate_see( + const char *zPassPhrase /* Activation phrase */ +); +#endif + +#ifdef SQLITE_ENABLE_CEROD +/* +** Specify the activation key for a CEROD database. Unless +** activated, none of the CEROD routines will work. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_activate_cerod( + const char *zPassPhrase /* Activation phrase */ +); +#endif + +/* +** CAPI3REF: Suspend Execution For A Short Time +** +** The sqlite3_sleep() function causes the current thread to suspend execution +** for at least a number of milliseconds specified in its parameter. +** +** If the operating system does not support sleep requests with +** millisecond time resolution, then the time will be rounded up to +** the nearest second. The number of milliseconds of sleep actually +** requested from the operating system is returned. +** +** ^SQLite implements this interface by calling the xSleep() +** method of the default [sqlite3_vfs] object. If the xSleep() method +** of the default VFS is not implemented correctly, or not implemented at +** all, then the behavior of sqlite3_sleep() may deviate from the description +** in the previous paragraphs. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_sleep(int); + +/* +** CAPI3REF: Name Of The Folder Holding Temporary Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all temporary files +** created by SQLite when using a built-in [sqlite3_vfs | VFS] +** will be placed in that directory.)^ ^If this variable +** is a NULL pointer, then SQLite performs a search for an appropriate +** temporary file directory. +** +** Applications are strongly discouraged from using this global variable. +** It is required to set a temporary folder on Windows Runtime (WinRT). +** But for all other platforms, it is highly recommended that applications +** neither read nor write this variable. This global variable is a relic +** that exists for backwards compatibility of legacy applications and should +** be avoided in new projects. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [temp_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [temp_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [temp_store_directory pragma] should be avoided. +** Except when requested by the [temp_store_directory pragma], SQLite +** does not free the memory that sqlite3_temp_directory points to. If +** the application wants that memory to be freed, it must do +** so itself, taking care to only do so after all [database connection] +** objects have been destroyed. +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling [sqlite3_open] or [sqlite3_open_v2]. Otherwise, various +** features that require the use of temporary files may fail. Here is an +** example of how to do this using C++ with the Windows Runtime: +** +** 
+** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
+**       TemporaryFolder->Path->Data();
+** char zPathBuf[MAX_PATH + 1];
+** memset(zPathBuf, 0, sizeof(zPathBuf));
+** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
+**       NULL, NULL);
+** sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);
+**
+*/ +SQLITE_API char *sqlite3_temp_directory; + +/* +** CAPI3REF: Name Of The Folder Holding Database Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all database files +** specified with a relative pathname and created or accessed by +** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed +** to be relative to that directory.)^ ^If this variable is a NULL +** pointer, then SQLite assumes that all database files specified +** with a relative pathname are relative to the current directory +** for the process. Only the windows VFS makes use of this global +** variable; it is ignored by the unix VFS. +** +** Changing the value of this variable while a database connection is +** open can result in a corrupt database. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [data_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [data_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [data_store_directory pragma] should be avoided. +*/ +SQLITE_API char *sqlite3_data_directory; + +/* +** CAPI3REF: Test For Auto-Commit Mode +** KEYWORDS: {autocommit mode} +** METHOD: sqlite3 +** +** ^The sqlite3_get_autocommit() interface returns non-zero or +** zero if the given database connection is or is not in autocommit mode, +** respectively. ^Autocommit mode is on by default. +** ^Autocommit mode is disabled by a [BEGIN] statement. +** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK]. +** +** If certain kinds of errors occur on a statement within a multi-statement +** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR], +** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the +** transaction might be rolled back automatically. The only way to +** find out whether SQLite automatically rolled back the transaction after +** an error is to use this function. +** +** If another thread changes the autocommit status of the database +** connection while this routine is running, then the return value +** is undefined. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_get_autocommit(sqlite3*); + +/* +** CAPI3REF: Find The Database Handle Of A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^The sqlite3_db_handle interface returns the [database connection] handle +** to which a [prepared statement] belongs. ^The [database connection] +** returned by sqlite3_db_handle is the same [database connection] +** that was the first argument +** to the [sqlite3_prepare_v2()] call (or its variants) that was used to +** create the statement in the first place. +*/ +SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_db_handle(sqlite3_stmt*); + +/* +** CAPI3REF: Return The Filename For A Database Connection +** METHOD: sqlite3 +** +** ^The sqlite3_db_filename(D,N) interface returns a pointer to a filename +** associated with database N of connection D. ^The main database file +** has the name "main". If there is no attached database N on the database +** connection D, or if database N is a temporary or in-memory database, then +** a NULL pointer is returned. +** +** ^The filename returned by this function is the output of the +** xFullPathname method of the [VFS]. ^In other words, the filename +** will be an absolute pathname, even if the filename used +** to open the database originally was a URI or relative pathname. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_db_filename(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Determine if a database is read-only +** METHOD: sqlite3 +** +** ^The sqlite3_db_readonly(D,N) interface returns 1 if the database N +** of connection D is read-only, 0 if it is read/write, or -1 if N is not +** the name of a database on connection D. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_db_readonly(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Find the next prepared statement +** METHOD: sqlite3 +** +** ^This interface returns a pointer to the next [prepared statement] after +** pStmt associated with the [database connection] pDb. ^If pStmt is NULL +** then this interface returns a pointer to the first prepared statement +** associated with the database connection pDb. ^If no prepared statement +** satisfies the conditions of this routine, it returns NULL. +** +** The [database connection] pointer D in a call to +** [sqlite3_next_stmt(D,S)] must refer to an open database +** connection and in particular must not be a NULL pointer. +*/ +SQLITE_API sqlite3_stmt *SQLITE_STDCALL sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Commit And Rollback Notification Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_commit_hook() interface registers a callback +** function to be invoked whenever a transaction is [COMMIT | committed]. +** ^Any callback set by a previous call to sqlite3_commit_hook() +** for the same database connection is overridden. +** ^The sqlite3_rollback_hook() interface registers a callback +** function to be invoked whenever a transaction is [ROLLBACK | rolled back]. +** ^Any callback set by a previous call to sqlite3_rollback_hook() +** for the same database connection is overridden. +** ^The pArg argument is passed through to the callback. +** ^If the callback on a commit hook function returns non-zero, +** then the commit is converted into a rollback. +** +** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions +** return the P argument from the previous call of the same function +** on the same [database connection] D, or NULL for +** the first call for each function on D. +** +** The commit and rollback hook callbacks are not reentrant. +** The callback implementation must not do anything that will modify +** the database connection that invoked the callback. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the commit +** or rollback hook in the first place. +** Note that running any other SQL statements, including SELECT statements, +** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify +** the database connections for the meaning of "modify" in this paragraph. +** +** ^Registering a NULL function disables the callback. +** +** ^When the commit hook callback routine returns zero, the [COMMIT] +** operation is allowed to continue normally. ^If the commit hook +** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK]. +** ^The rollback hook is invoked on a rollback that results from a commit +** hook returning non-zero, just as it would be with any other rollback. +** +** ^For the purposes of this API, a transaction is said to have been +** rolled back if an explicit "ROLLBACK" statement is executed, or +** an error or constraint causes an implicit rollback to occur. +** ^The rollback callback is not invoked if a transaction is +** automatically rolled back because the database connection is closed. +** +** See also the [sqlite3_update_hook()] interface. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); +SQLITE_API void *SQLITE_STDCALL sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); + +/* +** CAPI3REF: Data Change Notification Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_update_hook() interface registers a callback function +** with the [database connection] identified by the first argument +** to be invoked whenever a row is updated, inserted or deleted in +** a rowid table. +** ^Any callback set by a previous call to this function +** for the same database connection is overridden. +** +** ^The second argument is a pointer to the function to invoke when a +** row is updated, inserted or deleted in a rowid table. +** ^The first argument to the callback is a copy of the third argument +** to sqlite3_update_hook(). +** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE], +** or [SQLITE_UPDATE], depending on the operation that caused the callback +** to be invoked. +** ^The third and fourth arguments to the callback contain pointers to the +** database and table name containing the affected row. +** ^The final callback parameter is the [rowid] of the row. +** ^In the case of an update, this is the [rowid] after the update takes place. +** +** ^(The update hook is not invoked when internal system tables are +** modified (i.e. sqlite_master and sqlite_sequence).)^ +** ^The update hook is not invoked when [WITHOUT ROWID] tables are modified. +** +** ^In the current implementation, the update hook +** is not invoked when duplication rows are deleted because of an +** [ON CONFLICT | ON CONFLICT REPLACE] clause. ^Nor is the update hook +** invoked when rows are deleted using the [truncate optimization]. +** The exceptions defined in this paragraph might change in a future +** release of SQLite. +** +** The update hook implementation must not do anything that will modify +** the database connection that invoked the update hook. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the update hook. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^The sqlite3_update_hook(D,C,P) function +** returns the P argument from the previous call +** on the same [database connection] D, or NULL for +** the first call on D. +** +** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()] +** interfaces. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_update_hook( + sqlite3*, + void(*)(void *,int ,char const *,char const *,sqlite3_int64), + void* +); + +/* +** CAPI3REF: Enable Or Disable Shared Pager Cache +** +** ^(This routine enables or disables the sharing of the database cache +** and schema data structures between [database connection | connections] +** to the same database. Sharing is enabled if the argument is true +** and disabled if the argument is false.)^ +** +** ^Cache sharing is enabled and disabled for an entire process. +** This is a change as of SQLite version 3.5.0. In prior versions of SQLite, +** sharing was enabled or disabled for each thread separately. +** +** ^(The cache sharing mode set by this interface effects all subsequent +** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. +** Existing database connections continue use the sharing mode +** that was in effect at the time they were opened.)^ +** +** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled +** successfully. An [error code] is returned otherwise.)^ +** +** ^Shared cache is disabled by default. But this might change in +** future releases of SQLite. Applications that care about shared +** cache setting should set it explicitly. +** +** Note: This method is disabled on MacOS X 10.7 and iOS version 5.0 +** and will always return SQLITE_MISUSE. On those systems, +** shared cache mode should be enabled per-database connection via +** [sqlite3_open_v2()] with [SQLITE_OPEN_SHAREDCACHE]. +** +** This interface is threadsafe on processors where writing a +** 32-bit integer is atomic. +** +** See Also: [SQLite Shared-Cache Mode] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_enable_shared_cache(int); + +/* +** CAPI3REF: Attempt To Free Heap Memory +** +** ^The sqlite3_release_memory() interface attempts to free N bytes +** of heap memory by deallocating non-essential memory allocations +** held by the database library. Memory used to cache database +** pages to improve performance is an example of non-essential memory. +** ^sqlite3_release_memory() returns the number of bytes actually freed, +** which might be more or less than the amount requested. +** ^The sqlite3_release_memory() routine is a no-op returning zero +** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT]. +** +** See also: [sqlite3_db_release_memory()] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_release_memory(int); + +/* +** CAPI3REF: Free Memory Used By A Database Connection +** METHOD: sqlite3 +** +** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap +** memory as possible from database connection D. Unlike the +** [sqlite3_release_memory()] interface, this interface is in effect even +** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is +** omitted. +** +** See also: [sqlite3_release_memory()] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_db_release_memory(sqlite3*); + +/* +** CAPI3REF: Impose A Limit On Heap Size +** +** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the +** soft limit on the amount of heap memory that may be allocated by SQLite. +** ^SQLite strives to keep heap memory utilization below the soft heap +** limit by reducing the number of pages held in the page cache +** as heap memory usages approaches the limit. +** ^The soft heap limit is "soft" because even though SQLite strives to stay +** below the limit, it will exceed the limit rather than generate +** an [SQLITE_NOMEM] error. In other words, the soft heap limit +** is advisory only. +** +** ^The return value from sqlite3_soft_heap_limit64() is the size of +** the soft heap limit prior to the call, or negative in the case of an +** error. ^If the argument N is negative +** then no change is made to the soft heap limit. Hence, the current +** size of the soft heap limit can be determined by invoking +** sqlite3_soft_heap_limit64() with a negative argument. +** +** ^If the argument N is zero then the soft heap limit is disabled. +** +** ^(The soft heap limit is not enforced in the current implementation +** if one or more of following conditions are true: +** +**
    +**
  • The soft heap limit is set to zero. +**
  • Memory accounting is disabled using a combination of the +** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and +** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option. +**
  • An alternative page cache implementation is specified using +** [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...). +**
  • The page cache allocates from its own memory pool supplied +** by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than +** from the heap. +**
)^ +** +** Beginning with SQLite version 3.7.3, the soft heap limit is enforced +** regardless of whether or not the [SQLITE_ENABLE_MEMORY_MANAGEMENT] +** compile-time option is invoked. With [SQLITE_ENABLE_MEMORY_MANAGEMENT], +** the soft heap limit is enforced on every memory allocation. Without +** [SQLITE_ENABLE_MEMORY_MANAGEMENT], the soft heap limit is only enforced +** when memory is allocated by the page cache. Testing suggests that because +** the page cache is the predominate memory user in SQLite, most +** applications will achieve adequate soft heap limit enforcement without +** the use of [SQLITE_ENABLE_MEMORY_MANAGEMENT]. +** +** The circumstances under which SQLite will enforce the soft heap limit may +** changes in future releases of SQLite. +*/ +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_soft_heap_limit64(sqlite3_int64 N); + +/* +** CAPI3REF: Deprecated Soft Heap Limit Interface +** DEPRECATED +** +** This is a deprecated version of the [sqlite3_soft_heap_limit64()] +** interface. This routine is provided for historical compatibility +** only. All new applications should use the +** [sqlite3_soft_heap_limit64()] interface rather than this one. +*/ +SQLITE_API SQLITE_DEPRECATED void SQLITE_STDCALL sqlite3_soft_heap_limit(int N); + + +/* +** CAPI3REF: Extract Metadata About A Column Of A Table +** METHOD: sqlite3 +** +** ^(The sqlite3_table_column_metadata(X,D,T,C,....) routine returns +** information about column C of table T in database D +** on [database connection] X.)^ ^The sqlite3_table_column_metadata() +** interface returns SQLITE_OK and fills in the non-NULL pointers in +** the final five arguments with appropriate values if the specified +** column exists. ^The sqlite3_table_column_metadata() interface returns +** SQLITE_ERROR and if the specified column does not exist. +** ^If the column-name parameter to sqlite3_table_column_metadata() is a +** NULL pointer, then this routine simply checks for the existance of the +** table and returns SQLITE_OK if the table exists and SQLITE_ERROR if it +** does not. +** +** ^The column is identified by the second, third and fourth parameters to +** this function. ^(The second parameter is either the name of the database +** (i.e. "main", "temp", or an attached database) containing the specified +** table or NULL.)^ ^If it is NULL, then all attached databases are searched +** for the table using the same algorithm used by the database engine to +** resolve unqualified table references. +** +** ^The third and fourth parameters to this function are the table and column +** name of the desired column, respectively. +** +** ^Metadata is returned by writing to the memory locations passed as the 5th +** and subsequent parameters to this function. ^Any of these arguments may be +** NULL, in which case the corresponding element of metadata is omitted. +** +** ^(
+** +**
Parameter Output
Type 		Description +** +**
5th const char* Data type +**
6th const char* Name of default collation sequence +**
7th int True if column has a NOT NULL constraint +**
8th int True if column is part of the PRIMARY KEY +**
9th int True if column is [AUTOINCREMENT] +**
+**
)^ +** +** ^The memory pointed to by the character pointers returned for the +** declaration type and collation sequence is valid until the next +** call to any SQLite API function. +** +** ^If the specified table is actually a view, an [error code] is returned. +** +** ^If the specified column is "rowid", "oid" or "_rowid_" and the table +** is not a [WITHOUT ROWID] table and an +** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output +** parameters are set for the explicitly declared column. ^(If there is no +** [INTEGER PRIMARY KEY] column, then the outputs +** for the [rowid] are set as follows: +** +** 
+**     data type: "INTEGER"
+**     collation sequence: "BINARY"
+**     not null: 0
+**     primary key: 1
+**     auto increment: 0
+**
)^ +** +** ^This function causes all database schemas to be read from disk and +** parsed, if that has not already been done, and returns an error if +** any errors are encountered while loading the schema. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +); + +/* +** CAPI3REF: Load An Extension +** METHOD: sqlite3 +** +** ^This interface loads an SQLite extension library from the named file. +** +** ^The sqlite3_load_extension() interface attempts to load an +** [SQLite extension] library contained in the file zFile. If +** the file cannot be loaded directly, attempts are made to load +** with various operating-system specific extensions added. +** So for example, if "samplelib" cannot be loaded, then names like +** "samplelib.so" or "samplelib.dylib" or "samplelib.dll" might +** be tried also. +** +** ^The entry point is zProc. +** ^(zProc may be 0, in which case SQLite will try to come up with an +** entry point name on its own. It first tries "sqlite3_extension_init". +** If that does not work, it constructs a name "sqlite3_X_init" where the +** X is consists of the lower-case equivalent of all ASCII alphabetic +** characters in the filename from the last "/" to the first following +** "." and omitting any initial "lib".)^ +** ^The sqlite3_load_extension() interface returns +** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. +** ^If an error occurs and pzErrMsg is not 0, then the +** [sqlite3_load_extension()] interface shall attempt to +** fill *pzErrMsg with error message text stored in memory +** obtained from [sqlite3_malloc()]. The calling function +** should free this memory by calling [sqlite3_free()]. +** +** ^Extension loading must be enabled using +** [sqlite3_enable_load_extension()] prior to calling this API, +** otherwise an error will be returned. +** +** See also the [load_extension() SQL function]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Derived from zFile if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +); + +/* +** CAPI3REF: Enable Or Disable Extension Loading +** METHOD: sqlite3 +** +** ^So as not to open security holes in older applications that are +** unprepared to deal with [extension loading], and as a means of disabling +** [extension loading] while evaluating user-entered SQL, the following API +** is provided to turn the [sqlite3_load_extension()] mechanism on and off. +** +** ^Extension loading is off by default. +** ^Call the sqlite3_enable_load_extension() routine with onoff==1 +** to turn extension loading on and call it with onoff==0 to turn +** it back off again. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_enable_load_extension(sqlite3 *db, int onoff); + +/* +** CAPI3REF: Automatically Load Statically Linked Extensions +** +** ^This interface causes the xEntryPoint() function to be invoked for +** each new [database connection] that is created. The idea here is that +** xEntryPoint() is the entry point for a statically linked [SQLite extension] +** that is to be automatically loaded into all new database connections. +** +** ^(Even though the function prototype shows that xEntryPoint() takes +** no arguments and returns void, SQLite invokes xEntryPoint() with three +** arguments and expects and integer result as if the signature of the +** entry point where as follows: +** +** 
+**    int xEntryPoint(
+**      sqlite3 *db,
+**      const char **pzErrMsg,
+**      const struct sqlite3_api_routines *pThunk
+**    );
+**
)^ +** +** If the xEntryPoint routine encounters an error, it should make *pzErrMsg +** point to an appropriate error message (obtained from [sqlite3_mprintf()]) +** and return an appropriate [error code]. ^SQLite ensures that *pzErrMsg +** is NULL before calling the xEntryPoint(). ^SQLite will invoke +** [sqlite3_free()] on *pzErrMsg after xEntryPoint() returns. ^If any +** xEntryPoint() returns an error, the [sqlite3_open()], [sqlite3_open16()], +** or [sqlite3_open_v2()] call that provoked the xEntryPoint() will fail. +** +** ^Calling sqlite3_auto_extension(X) with an entry point X that is already +** on the list of automatic extensions is a harmless no-op. ^No entry point +** will be called more than once for each database connection that is opened. +** +** See also: [sqlite3_reset_auto_extension()] +** and [sqlite3_cancel_auto_extension()] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_auto_extension(void (*xEntryPoint)(void)); + +/* +** CAPI3REF: Cancel Automatic Extension Loading +** +** ^The [sqlite3_cancel_auto_extension(X)] interface unregisters the +** initialization routine X that was registered using a prior call to +** [sqlite3_auto_extension(X)]. ^The [sqlite3_cancel_auto_extension(X)] +** routine returns 1 if initialization routine X was successfully +** unregistered and it returns 0 if X was not on the list of initialization +** routines. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_cancel_auto_extension(void (*xEntryPoint)(void)); + +/* +** CAPI3REF: Reset Automatic Extension Loading +** +** ^This interface disables all automatic extensions previously +** registered using [sqlite3_auto_extension()]. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_reset_auto_extension(void); + +/* +** The interface to the virtual-table mechanism is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stabilizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** Structures used by the virtual table interface +*/ +typedef struct sqlite3_vtab sqlite3_vtab; +typedef struct sqlite3_index_info sqlite3_index_info; +typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; +typedef struct sqlite3_module sqlite3_module; + +/* +** CAPI3REF: Virtual Table Object +** KEYWORDS: sqlite3_module {virtual table module} +** +** This structure, sometimes called a "virtual table module", +** defines the implementation of a [virtual tables]. +** This structure consists mostly of methods for the module. +** +** ^A virtual table module is created by filling in a persistent +** instance of this structure and passing a pointer to that instance +** to [sqlite3_create_module()] or [sqlite3_create_module_v2()]. +** ^The registration remains valid until it is replaced by a different +** module or until the [database connection] closes. The content +** of this structure must not change while it is registered with +** any database connection. +*/ +struct sqlite3_module { + int iVersion; + int (*xCreate)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xConnect)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); + int (*xDisconnect)(sqlite3_vtab *pVTab); + int (*xDestroy)(sqlite3_vtab *pVTab); + int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); + int (*xClose)(sqlite3_vtab_cursor*); + int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, + int argc, sqlite3_value **argv); + int (*xNext)(sqlite3_vtab_cursor*); + int (*xEof)(sqlite3_vtab_cursor*); + int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); + int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); + int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); + int (*xBegin)(sqlite3_vtab *pVTab); + int (*xSync)(sqlite3_vtab *pVTab); + int (*xCommit)(sqlite3_vtab *pVTab); + int (*xRollback)(sqlite3_vtab *pVTab); + int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), + void **ppArg); + int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); + /* The methods above are in version 1 of the sqlite_module object. Those + ** below are for version 2 and greater. */ + int (*xSavepoint)(sqlite3_vtab *pVTab, int); + int (*xRelease)(sqlite3_vtab *pVTab, int); + int (*xRollbackTo)(sqlite3_vtab *pVTab, int); +}; + +/* +** CAPI3REF: Virtual Table Indexing Information +** KEYWORDS: sqlite3_index_info +** +** The sqlite3_index_info structure and its substructures is used as part +** of the [virtual table] interface to +** pass information into and receive the reply from the [xBestIndex] +** method of a [virtual table module]. The fields under **Inputs** are the +** inputs to xBestIndex and are read-only. xBestIndex inserts its +** results into the **Outputs** fields. +** +** ^(The aConstraint[] array records WHERE clause constraints of the form: +** +**
column OP expr
+** +** where OP is =, <, <=, >, or >=.)^ ^(The particular operator is +** stored in aConstraint[].op using one of the +** [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^ +** ^(The index of the column is stored in +** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the +** expr on the right-hand side can be evaluated (and thus the constraint +** is usable) and false if it cannot.)^ +** +** ^The optimizer automatically inverts terms of the form "expr OP column" +** and makes other simplifications to the WHERE clause in an attempt to +** get as many WHERE clause terms into the form shown above as possible. +** ^The aConstraint[] array only reports WHERE clause terms that are +** relevant to the particular virtual table being queried. +** +** ^Information about the ORDER BY clause is stored in aOrderBy[]. +** ^Each term of aOrderBy records a column of the ORDER BY clause. +** +** The [xBestIndex] method must fill aConstraintUsage[] with information +** about what parameters to pass to xFilter. ^If argvIndex>0 then +** the right-hand side of the corresponding aConstraint[] is evaluated +** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit +** is true, then the constraint is assumed to be fully handled by the +** virtual table and is not checked again by SQLite.)^ +** +** ^The idxNum and idxPtr values are recorded and passed into the +** [xFilter] method. +** ^[sqlite3_free()] is used to free idxPtr if and only if +** needToFreeIdxPtr is true. +** +** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in +** the correct order to satisfy the ORDER BY clause so that no separate +** sorting step is required. +** +** ^The estimatedCost value is an estimate of the cost of a particular +** strategy. A cost of N indicates that the cost of the strategy is similar +** to a linear scan of an SQLite table with N rows. A cost of log(N) +** indicates that the expense of the operation is similar to that of a +** binary search on a unique indexed field of an SQLite table with N rows. +** +** ^The estimatedRows value is an estimate of the number of rows that +** will be returned by the strategy. +** +** The xBestIndex method may optionally populate the idxFlags field with a +** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag - +** SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite +** assumes that the strategy may visit at most one row. +** +** Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then +** SQLite also assumes that if a call to the xUpdate() method is made as +** part of the same statement to delete or update a virtual table row and the +** implementation returns SQLITE_CONSTRAINT, then there is no need to rollback +** any database changes. In other words, if the xUpdate() returns +** SQLITE_CONSTRAINT, the database contents must be exactly as they were +** before xUpdate was called. By contrast, if SQLITE_INDEX_SCAN_UNIQUE is not +** set and xUpdate returns SQLITE_CONSTRAINT, any database changes made by +** the xUpdate method are automatically rolled back by SQLite. +** +** IMPORTANT: The estimatedRows field was added to the sqlite3_index_info +** structure for SQLite version 3.8.2. If a virtual table extension is +** used with an SQLite version earlier than 3.8.2, the results of attempting +** to read or write the estimatedRows field are undefined (but are likely +** to included crashing the application). The estimatedRows field should +** therefore only be used if [sqlite3_libversion_number()] returns a +** value greater than or equal to 3008002. Similarly, the idxFlags field +** was added for version 3.9.0. It may therefore only be used if +** sqlite3_libversion_number() returns a value greater than or equal to +** 3009000. +*/ +struct sqlite3_index_info { + /* Inputs */ + int nConstraint; /* Number of entries in aConstraint */ + struct sqlite3_index_constraint { + int iColumn; /* Column on left-hand side of constraint */ + unsigned char op; /* Constraint operator */ + unsigned char usable; /* True if this constraint is usable */ + int iTermOffset; /* Used internally - xBestIndex should ignore */ + } *aConstraint; /* Table of WHERE clause constraints */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + struct sqlite3_index_orderby { + int iColumn; /* Column number */ + unsigned char desc; /* True for DESC. False for ASC. */ + } *aOrderBy; /* The ORDER BY clause */ + /* Outputs */ + struct sqlite3_index_constraint_usage { + int argvIndex; /* if >0, constraint is part of argv to xFilter */ + unsigned char omit; /* Do not code a test for this constraint */ + } *aConstraintUsage; + int idxNum; /* Number used to identify the index */ + char *idxStr; /* String, possibly obtained from sqlite3_malloc */ + int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ + int orderByConsumed; /* True if output is already ordered */ + double estimatedCost; /* Estimated cost of using this index */ + /* Fields below are only available in SQLite 3.8.2 and later */ + sqlite3_int64 estimatedRows; /* Estimated number of rows returned */ + /* Fields below are only available in SQLite 3.9.0 and later */ + int idxFlags; /* Mask of SQLITE_INDEX_SCAN_* flags */ +}; + +/* +** CAPI3REF: Virtual Table Scan Flags +*/ +#define SQLITE_INDEX_SCAN_UNIQUE 1 /* Scan visits at most 1 row */ + +/* +** CAPI3REF: Virtual Table Constraint Operator Codes +** +** These macros defined the allowed values for the +** [sqlite3_index_info].aConstraint[].op field. Each value represents +** an operator that is part of a constraint term in the wHERE clause of +** a query that uses a [virtual table]. +*/ +#define SQLITE_INDEX_CONSTRAINT_EQ 2 +#define SQLITE_INDEX_CONSTRAINT_GT 4 +#define SQLITE_INDEX_CONSTRAINT_LE 8 +#define SQLITE_INDEX_CONSTRAINT_LT 16 +#define SQLITE_INDEX_CONSTRAINT_GE 32 +#define SQLITE_INDEX_CONSTRAINT_MATCH 64 + +/* +** CAPI3REF: Register A Virtual Table Implementation +** METHOD: sqlite3 +** +** ^These routines are used to register a new [virtual table module] name. +** ^Module names must be registered before +** creating a new [virtual table] using the module and before using a +** preexisting [virtual table] for the module. +** +** ^The module name is registered on the [database connection] specified +** by the first parameter. ^The name of the module is given by the +** second parameter. ^The third parameter is a pointer to +** the implementation of the [virtual table module]. ^The fourth +** parameter is an arbitrary client data pointer that is passed through +** into the [xCreate] and [xConnect] methods of the virtual table module +** when a new virtual table is be being created or reinitialized. +** +** ^The sqlite3_create_module_v2() interface has a fifth parameter which +** is a pointer to a destructor for the pClientData. ^SQLite will +** invoke the destructor function (if it is not NULL) when SQLite +** no longer needs the pClientData pointer. ^The destructor will also +** be invoked if the call to sqlite3_create_module_v2() fails. +** ^The sqlite3_create_module() +** interface is equivalent to sqlite3_create_module_v2() with a NULL +** destructor. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_create_module( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData /* Client data for xCreate/xConnect */ +); +SQLITE_API int SQLITE_STDCALL sqlite3_create_module_v2( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData, /* Client data for xCreate/xConnect */ + void(*xDestroy)(void*) /* Module destructor function */ +); + +/* +** CAPI3REF: Virtual Table Instance Object +** KEYWORDS: sqlite3_vtab +** +** Every [virtual table module] implementation uses a subclass +** of this object to describe a particular instance +** of the [virtual table]. Each subclass will +** be tailored to the specific needs of the module implementation. +** The purpose of this superclass is to define certain fields that are +** common to all module implementations. +** +** ^Virtual tables methods can set an error message by assigning a +** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should +** take care that any prior string is freed by a call to [sqlite3_free()] +** prior to assigning a new string to zErrMsg. ^After the error message +** is delivered up to the client application, the string will be automatically +** freed by sqlite3_free() and the zErrMsg field will be zeroed. +*/ +struct sqlite3_vtab { + const sqlite3_module *pModule; /* The module for this virtual table */ + int nRef; /* Number of open cursors */ + char *zErrMsg; /* Error message from sqlite3_mprintf() */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Virtual Table Cursor Object +** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor} +** +** Every [virtual table module] implementation uses a subclass of the +** following structure to describe cursors that point into the +** [virtual table] and are used +** to loop through the virtual table. Cursors are created using the +** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed +** by the [sqlite3_module.xClose | xClose] method. Cursors are used +** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods +** of the module. Each module implementation will define +** the content of a cursor structure to suit its own needs. +** +** This superclass exists in order to define fields of the cursor that +** are common to all implementations. +*/ +struct sqlite3_vtab_cursor { + sqlite3_vtab *pVtab; /* Virtual table of this cursor */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Declare The Schema Of A Virtual Table +** +** ^The [xCreate] and [xConnect] methods of a +** [virtual table module] call this interface +** to declare the format (the names and datatypes of the columns) of +** the virtual tables they implement. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_declare_vtab(sqlite3*, const char *zSQL); + +/* +** CAPI3REF: Overload A Function For A Virtual Table +** METHOD: sqlite3 +** +** ^(Virtual tables can provide alternative implementations of functions +** using the [xFindFunction] method of the [virtual table module]. +** But global versions of those functions +** must exist in order to be overloaded.)^ +** +** ^(This API makes sure a global version of a function with a particular +** name and number of parameters exists. If no such function exists +** before this API is called, a new function is created.)^ ^The implementation +** of the new function always causes an exception to be thrown. So +** the new function is not good for anything by itself. Its only +** purpose is to be a placeholder function that can be overloaded +** by a [virtual table]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); + +/* +** The interface to the virtual-table mechanism defined above (back up +** to a comment remarkably similar to this one) is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stabilizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** CAPI3REF: A Handle To An Open BLOB +** KEYWORDS: {BLOB handle} {BLOB handles} +** +** An instance of this object represents an open BLOB on which +** [sqlite3_blob_open | incremental BLOB I/O] can be performed. +** ^Objects of this type are created by [sqlite3_blob_open()] +** and destroyed by [sqlite3_blob_close()]. +** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces +** can be used to read or write small subsections of the BLOB. +** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes. +*/ +typedef struct sqlite3_blob sqlite3_blob; + +/* +** CAPI3REF: Open A BLOB For Incremental I/O +** METHOD: sqlite3 +** CONSTRUCTOR: sqlite3_blob +** +** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located +** in row iRow, column zColumn, table zTable in database zDb; +** in other words, the same BLOB that would be selected by: +** +** 
+**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
+**
)^ +** +** ^(Parameter zDb is not the filename that contains the database, but +** rather the symbolic name of the database. For attached databases, this is +** the name that appears after the AS keyword in the [ATTACH] statement. +** For the main database file, the database name is "main". For TEMP +** tables, the database name is "temp".)^ +** +** ^If the flags parameter is non-zero, then the BLOB is opened for read +** and write access. ^If the flags parameter is zero, the BLOB is opened for +** read-only access. +** +** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is stored +** in *ppBlob. Otherwise an [error code] is returned and, unless the error +** code is SQLITE_MISUSE, *ppBlob is set to NULL.)^ ^This means that, provided +** the API is not misused, it is always safe to call [sqlite3_blob_close()] +** on *ppBlob after this function it returns. +** +** This function fails with SQLITE_ERROR if any of the following are true: +**
    +**
  • ^(Database zDb does not exist)^, +**
  • ^(Table zTable does not exist within database zDb)^, +**
  • ^(Table zTable is a WITHOUT ROWID table)^, +**
  • ^(Column zColumn does not exist)^, +**
  • ^(Row iRow is not present in the table)^, +**
  • ^(The specified column of row iRow contains a value that is not +** a TEXT or BLOB value)^, +**
  • ^(Column zColumn is part of an index, PRIMARY KEY or UNIQUE +** constraint and the blob is being opened for read/write access)^, +**
  • ^([foreign key constraints | Foreign key constraints] are enabled, +** column zColumn is part of a [child key] definition and the blob is +** being opened for read/write access)^. +**
+** +** ^Unless it returns SQLITE_MISUSE, this function sets the +** [database connection] error code and message accessible via +** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions. +** +** +** ^(If the row that a BLOB handle points to is modified by an +** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects +** then the BLOB handle is marked as "expired". +** This is true if any column of the row is changed, even a column +** other than the one the BLOB handle is open on.)^ +** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for +** an expired BLOB handle fail with a return code of [SQLITE_ABORT]. +** ^(Changes written into a BLOB prior to the BLOB expiring are not +** rolled back by the expiration of the BLOB. Such changes will eventually +** commit if the transaction continues to completion.)^ +** +** ^Use the [sqlite3_blob_bytes()] interface to determine the size of +** the opened blob. ^The size of a blob may not be changed by this +** interface. Use the [UPDATE] SQL command to change the size of a +** blob. +** +** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces +** and the built-in [zeroblob] SQL function may be used to create a +** zero-filled blob to read or write using the incremental-blob interface. +** +** To avoid a resource leak, every open [BLOB handle] should eventually +** be released by a call to [sqlite3_blob_close()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_open( + sqlite3*, + const char *zDb, + const char *zTable, + const char *zColumn, + sqlite3_int64 iRow, + int flags, + sqlite3_blob **ppBlob +); + +/* +** CAPI3REF: Move a BLOB Handle to a New Row +** METHOD: sqlite3_blob +** +** ^This function is used to move an existing blob handle so that it points +** to a different row of the same database table. ^The new row is identified +** by the rowid value passed as the second argument. Only the row can be +** changed. ^The database, table and column on which the blob handle is open +** remain the same. Moving an existing blob handle to a new row can be +** faster than closing the existing handle and opening a new one. +** +** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] - +** it must exist and there must be either a blob or text value stored in +** the nominated column.)^ ^If the new row is not present in the table, or if +** it does not contain a blob or text value, or if another error occurs, an +** SQLite error code is returned and the blob handle is considered aborted. +** ^All subsequent calls to [sqlite3_blob_read()], [sqlite3_blob_write()] or +** [sqlite3_blob_reopen()] on an aborted blob handle immediately return +** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle +** always returns zero. +** +** ^This function sets the database handle error code and message. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64); + +/* +** CAPI3REF: Close A BLOB Handle +** DESTRUCTOR: sqlite3_blob +** +** ^This function closes an open [BLOB handle]. ^(The BLOB handle is closed +** unconditionally. Even if this routine returns an error code, the +** handle is still closed.)^ +** +** ^If the blob handle being closed was opened for read-write access, and if +** the database is in auto-commit mode and there are no other open read-write +** blob handles or active write statements, the current transaction is +** committed. ^If an error occurs while committing the transaction, an error +** code is returned and the transaction rolled back. +** +** Calling this function with an argument that is not a NULL pointer or an +** open blob handle results in undefined behaviour. ^Calling this routine +** with a null pointer (such as would be returned by a failed call to +** [sqlite3_blob_open()]) is a harmless no-op. ^Otherwise, if this function +** is passed a valid open blob handle, the values returned by the +** sqlite3_errcode() and sqlite3_errmsg() functions are set before returning. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_close(sqlite3_blob *); + +/* +** CAPI3REF: Return The Size Of An Open BLOB +** METHOD: sqlite3_blob +** +** ^Returns the size in bytes of the BLOB accessible via the +** successfully opened [BLOB handle] in its only argument. ^The +** incremental blob I/O routines can only read or overwriting existing +** blob content; they cannot change the size of a blob. +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_bytes(sqlite3_blob *); + +/* +** CAPI3REF: Read Data From A BLOB Incrementally +** METHOD: sqlite3_blob +** +** ^(This function is used to read data from an open [BLOB handle] into a +** caller-supplied buffer. N bytes of data are copied into buffer Z +** from the open BLOB, starting at offset iOffset.)^ +** +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is +** less than zero, [SQLITE_ERROR] is returned and no data is read. +** ^The size of the blob (and hence the maximum value of N+iOffset) +** can be determined using the [sqlite3_blob_bytes()] interface. +** +** ^An attempt to read from an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. +** +** ^(On success, sqlite3_blob_read() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_write()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset); + +/* +** CAPI3REF: Write Data Into A BLOB Incrementally +** METHOD: sqlite3_blob +** +** ^(This function is used to write data into an open [BLOB handle] from a +** caller-supplied buffer. N bytes of data are copied from the buffer Z +** into the open BLOB, starting at offset iOffset.)^ +** +** ^(On success, sqlite3_blob_write() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** ^Unless SQLITE_MISUSE is returned, this function sets the +** [database connection] error code and message accessible via +** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions. +** +** ^If the [BLOB handle] passed as the first argument was not opened for +** writing (the flags parameter to [sqlite3_blob_open()] was zero), +** this function returns [SQLITE_READONLY]. +** +** This function may only modify the contents of the BLOB; it is +** not possible to increase the size of a BLOB using this API. +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is written. The size of the +** BLOB (and hence the maximum value of N+iOffset) can be determined +** using the [sqlite3_blob_bytes()] interface. ^If N or iOffset are less +** than zero [SQLITE_ERROR] is returned and no data is written. +** +** ^An attempt to write to an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred +** before the [BLOB handle] expired are not rolled back by the +** expiration of the handle, though of course those changes might +** have been overwritten by the statement that expired the BLOB handle +** or by other independent statements. +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_read()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); + +/* +** CAPI3REF: Virtual File System Objects +** +** A virtual filesystem (VFS) is an [sqlite3_vfs] object +** that SQLite uses to interact +** with the underlying operating system. Most SQLite builds come with a +** single default VFS that is appropriate for the host computer. +** New VFSes can be registered and existing VFSes can be unregistered. +** The following interfaces are provided. +** +** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name. +** ^Names are case sensitive. +** ^Names are zero-terminated UTF-8 strings. +** ^If there is no match, a NULL pointer is returned. +** ^If zVfsName is NULL then the default VFS is returned. +** +** ^New VFSes are registered with sqlite3_vfs_register(). +** ^Each new VFS becomes the default VFS if the makeDflt flag is set. +** ^The same VFS can be registered multiple times without injury. +** ^To make an existing VFS into the default VFS, register it again +** with the makeDflt flag set. If two different VFSes with the +** same name are registered, the behavior is undefined. If a +** VFS is registered with a name that is NULL or an empty string, +** then the behavior is undefined. +** +** ^Unregister a VFS with the sqlite3_vfs_unregister() interface. +** ^(If the default VFS is unregistered, another VFS is chosen as +** the default. The choice for the new VFS is arbitrary.)^ +*/ +SQLITE_API sqlite3_vfs *SQLITE_STDCALL sqlite3_vfs_find(const char *zVfsName); +SQLITE_API int SQLITE_STDCALL sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); +SQLITE_API int SQLITE_STDCALL sqlite3_vfs_unregister(sqlite3_vfs*); + +/* +** CAPI3REF: Mutexes +** +** The SQLite core uses these routines for thread +** synchronization. Though they are intended for internal +** use by SQLite, code that links against SQLite is +** permitted to use any of these routines. +** +** The SQLite source code contains multiple implementations +** of these mutex routines. An appropriate implementation +** is selected automatically at compile-time. The following +** implementations are available in the SQLite core: +** +**
    +**
  • SQLITE_MUTEX_PTHREADS +**
  • SQLITE_MUTEX_W32 +**
  • SQLITE_MUTEX_NOOP +**
+** +** The SQLITE_MUTEX_NOOP implementation is a set of routines +** that does no real locking and is appropriate for use in +** a single-threaded application. The SQLITE_MUTEX_PTHREADS and +** SQLITE_MUTEX_W32 implementations are appropriate for use on Unix +** and Windows. +** +** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor +** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex +** implementation is included with the library. In this case the +** application must supply a custom mutex implementation using the +** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function +** before calling sqlite3_initialize() or any other public sqlite3_ +** function that calls sqlite3_initialize(). +** +** ^The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. ^The sqlite3_mutex_alloc() +** routine returns NULL if it is unable to allocate the requested +** mutex. The argument to sqlite3_mutex_alloc() must one of these +** integer constants: +** +**
    +**
  • SQLITE_MUTEX_FAST +**
  • SQLITE_MUTEX_RECURSIVE +**
  • SQLITE_MUTEX_STATIC_MASTER +**
  • SQLITE_MUTEX_STATIC_MEM +**
  • SQLITE_MUTEX_STATIC_OPEN +**
  • SQLITE_MUTEX_STATIC_PRNG +**
  • SQLITE_MUTEX_STATIC_LRU +**
  • SQLITE_MUTEX_STATIC_PMEM +**
  • SQLITE_MUTEX_STATIC_APP1 +**
  • SQLITE_MUTEX_STATIC_APP2 +**
  • SQLITE_MUTEX_STATIC_APP3 +**
  • SQLITE_MUTEX_STATIC_VFS1 +**
  • SQLITE_MUTEX_STATIC_VFS2 +**
  • SQLITE_MUTEX_STATIC_VFS3 +**
+** +** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) +** cause sqlite3_mutex_alloc() to create +** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. SQLite will only request a recursive mutex in +** cases where it really needs one. If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other +** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return +** a pointer to a static preexisting mutex. ^Nine static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. ^For the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +** +** ^The sqlite3_mutex_free() routine deallocates a previously +** allocated dynamic mutex. Attempting to deallocate a static +** mutex results in undefined behavior. +** +** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. ^If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK] +** upon successful entry. ^(Mutexes created using +** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. +** In such cases, the +** mutex must be exited an equal number of times before another thread +** can enter.)^ If the same thread tries to enter any mutex other +** than an SQLITE_MUTEX_RECURSIVE more than once, the behavior is undefined. +** +** ^(Some systems (for example, Windows 95) do not support the operation +** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() +** will always return SQLITE_BUSY. The SQLite core only ever uses +** sqlite3_mutex_try() as an optimization so this is acceptable +** behavior.)^ +** +** ^The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered by the +** calling thread or is not currently allocated. +** +** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or +** sqlite3_mutex_leave() is a NULL pointer, then all three routines +** behave as no-ops. +** +** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. +*/ +SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_mutex_alloc(int); +SQLITE_API void SQLITE_STDCALL sqlite3_mutex_free(sqlite3_mutex*); +SQLITE_API void SQLITE_STDCALL sqlite3_mutex_enter(sqlite3_mutex*); +SQLITE_API int SQLITE_STDCALL sqlite3_mutex_try(sqlite3_mutex*); +SQLITE_API void SQLITE_STDCALL sqlite3_mutex_leave(sqlite3_mutex*); + +/* +** CAPI3REF: Mutex Methods Object +** +** An instance of this structure defines the low-level routines +** used to allocate and use mutexes. +** +** Usually, the default mutex implementations provided by SQLite are +** sufficient, however the application has the option of substituting a custom +** implementation for specialized deployments or systems for which SQLite +** does not provide a suitable implementation. In this case, the application +** creates and populates an instance of this structure to pass +** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option. +** Additionally, an instance of this structure can be used as an +** output variable when querying the system for the current mutex +** implementation, using the [SQLITE_CONFIG_GETMUTEX] option. +** +** ^The xMutexInit method defined by this structure is invoked as +** part of system initialization by the sqlite3_initialize() function. +** ^The xMutexInit routine is called by SQLite exactly once for each +** effective call to [sqlite3_initialize()]. +** +** ^The xMutexEnd method defined by this structure is invoked as +** part of system shutdown by the sqlite3_shutdown() function. The +** implementation of this method is expected to release all outstanding +** resources obtained by the mutex methods implementation, especially +** those obtained by the xMutexInit method. ^The xMutexEnd() +** interface is invoked exactly once for each call to [sqlite3_shutdown()]. +** +** ^(The remaining seven methods defined by this structure (xMutexAlloc, +** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and +** xMutexNotheld) implement the following interfaces (respectively): +** +**
    +**
  • [sqlite3_mutex_alloc()]
    • +**
  • [sqlite3_mutex_free()]
    • +**
  • [sqlite3_mutex_enter()]
    • +**
  • [sqlite3_mutex_try()]
    • +**
  • [sqlite3_mutex_leave()]
    • +**
  • [sqlite3_mutex_held()]
    • +**
  • [sqlite3_mutex_notheld()]
    • +**
)^ +** +** The only difference is that the public sqlite3_XXX functions enumerated +** above silently ignore any invocations that pass a NULL pointer instead +** of a valid mutex handle. The implementations of the methods defined +** by this structure are not required to handle this case, the results +** of passing a NULL pointer instead of a valid mutex handle are undefined +** (i.e. it is acceptable to provide an implementation that segfaults if +** it is passed a NULL pointer). +** +** The xMutexInit() method must be threadsafe. It must be harmless to +** invoke xMutexInit() multiple times within the same process and without +** intervening calls to xMutexEnd(). Second and subsequent calls to +** xMutexInit() must be no-ops. +** +** xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()] +** and its associates). Similarly, xMutexAlloc() must not use SQLite memory +** allocation for a static mutex. ^However xMutexAlloc() may use SQLite +** memory allocation for a fast or recursive mutex. +** +** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is +** called, but only if the prior call to xMutexInit returned SQLITE_OK. +** If xMutexInit fails in any way, it is expected to clean up after itself +** prior to returning. +*/ +typedef struct sqlite3_mutex_methods sqlite3_mutex_methods; +struct sqlite3_mutex_methods { + int (*xMutexInit)(void); + int (*xMutexEnd)(void); + sqlite3_mutex *(*xMutexAlloc)(int); + void (*xMutexFree)(sqlite3_mutex *); + void (*xMutexEnter)(sqlite3_mutex *); + int (*xMutexTry)(sqlite3_mutex *); + void (*xMutexLeave)(sqlite3_mutex *); + int (*xMutexHeld)(sqlite3_mutex *); + int (*xMutexNotheld)(sqlite3_mutex *); +}; + +/* +** CAPI3REF: Mutex Verification Routines +** +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines +** are intended for use inside assert() statements. The SQLite core +** never uses these routines except inside an assert() and applications +** are advised to follow the lead of the core. The SQLite core only +** provides implementations for these routines when it is compiled +** with the SQLITE_DEBUG flag. External mutex implementations +** are only required to provide these routines if SQLITE_DEBUG is +** defined and if NDEBUG is not defined. +** +** These routines should return true if the mutex in their argument +** is held or not held, respectively, by the calling thread. +** +** The implementation is not required to provide versions of these +** routines that actually work. If the implementation does not provide working +** versions of these routines, it should at least provide stubs that always +** return true so that one does not get spurious assertion failures. +** +** If the argument to sqlite3_mutex_held() is a NULL pointer then +** the routine should return 1. This seems counter-intuitive since +** clearly the mutex cannot be held if it does not exist. But +** the reason the mutex does not exist is because the build is not +** using mutexes. And we do not want the assert() containing the +** call to sqlite3_mutex_held() to fail, so a non-zero return is +** the appropriate thing to do. The sqlite3_mutex_notheld() +** interface should also return 1 when given a NULL pointer. +*/ +#ifndef NDEBUG +SQLITE_API int SQLITE_STDCALL sqlite3_mutex_held(sqlite3_mutex*); +SQLITE_API int SQLITE_STDCALL sqlite3_mutex_notheld(sqlite3_mutex*); +#endif + +/* +** CAPI3REF: Mutex Types +** +** The [sqlite3_mutex_alloc()] interface takes a single argument +** which is one of these integer constants. +** +** The set of static mutexes may change from one SQLite release to the +** next. Applications that override the built-in mutex logic must be +** prepared to accommodate additional static mutexes. +*/ +#define SQLITE_MUTEX_FAST 0 +#define SQLITE_MUTEX_RECURSIVE 1 +#define SQLITE_MUTEX_STATIC_MASTER 2 +#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ +#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */ +#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */ +#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ +#define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */ +#define SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */ +#define SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */ +#define SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */ +#define SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */ +#define SQLITE_MUTEX_STATIC_VFS2 12 /* For use by extension VFS */ +#define SQLITE_MUTEX_STATIC_VFS3 13 /* For use by application VFS */ + +/* +** CAPI3REF: Retrieve the mutex for a database connection +** METHOD: sqlite3 +** +** ^This interface returns a pointer the [sqlite3_mutex] object that +** serializes access to the [database connection] given in the argument +** when the [threading mode] is Serialized. +** ^If the [threading mode] is Single-thread or Multi-thread then this +** routine returns a NULL pointer. +*/ +SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_db_mutex(sqlite3*); + +/* +** CAPI3REF: Low-Level Control Of Database Files +** METHOD: sqlite3 +** +** ^The [sqlite3_file_control()] interface makes a direct call to the +** xFileControl method for the [sqlite3_io_methods] object associated +** with a particular database identified by the second argument. ^The +** name of the database is "main" for the main database or "temp" for the +** TEMP database, or the name that appears after the AS keyword for +** databases that are added using the [ATTACH] SQL command. +** ^A NULL pointer can be used in place of "main" to refer to the +** main database file. +** ^The third and fourth parameters to this routine +** are passed directly through to the second and third parameters of +** the xFileControl method. ^The return value of the xFileControl +** method becomes the return value of this routine. +** +** ^The SQLITE_FCNTL_FILE_POINTER value for the op parameter causes +** a pointer to the underlying [sqlite3_file] object to be written into +** the space pointed to by the 4th parameter. ^The SQLITE_FCNTL_FILE_POINTER +** case is a short-circuit path which does not actually invoke the +** underlying sqlite3_io_methods.xFileControl method. +** +** ^If the second parameter (zDbName) does not match the name of any +** open database file, then SQLITE_ERROR is returned. ^This error +** code is not remembered and will not be recalled by [sqlite3_errcode()] +** or [sqlite3_errmsg()]. The underlying xFileControl method might +** also return SQLITE_ERROR. There is no way to distinguish between +** an incorrect zDbName and an SQLITE_ERROR return from the underlying +** xFileControl method. +** +** See also: [SQLITE_FCNTL_LOCKSTATE] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); + +/* +** CAPI3REF: Testing Interface +** +** ^The sqlite3_test_control() interface is used to read out internal +** state of SQLite and to inject faults into SQLite for testing +** purposes. ^The first parameter is an operation code that determines +** the number, meaning, and operation of all subsequent parameters. +** +** This interface is not for use by applications. It exists solely +** for verifying the correct operation of the SQLite library. Depending +** on how the SQLite library is compiled, this interface might not exist. +** +** The details of the operation codes, their meanings, the parameters +** they take, and what they do are all subject to change without notice. +** Unlike most of the SQLite API, this function is not guaranteed to +** operate consistently from one release to the next. +*/ +SQLITE_API int SQLITE_CDECL sqlite3_test_control(int op, ...); + +/* +** CAPI3REF: Testing Interface Operation Codes +** +** These constants are the valid operation code parameters used +** as the first argument to [sqlite3_test_control()]. +** +** These parameters and their meanings are subject to change +** without notice. These values are for testing purposes only. +** Applications should not use any of these parameters or the +** [sqlite3_test_control()] interface. +*/ +#define SQLITE_TESTCTRL_FIRST 5 +#define SQLITE_TESTCTRL_PRNG_SAVE 5 +#define SQLITE_TESTCTRL_PRNG_RESTORE 6 +#define SQLITE_TESTCTRL_PRNG_RESET 7 +#define SQLITE_TESTCTRL_BITVEC_TEST 8 +#define SQLITE_TESTCTRL_FAULT_INSTALL 9 +#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10 +#define SQLITE_TESTCTRL_PENDING_BYTE 11 +#define SQLITE_TESTCTRL_ASSERT 12 +#define SQLITE_TESTCTRL_ALWAYS 13 +#define SQLITE_TESTCTRL_RESERVE 14 +#define SQLITE_TESTCTRL_OPTIMIZATIONS 15 +#define SQLITE_TESTCTRL_ISKEYWORD 16 +#define SQLITE_TESTCTRL_SCRATCHMALLOC 17 +#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18 +#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */ +#define SQLITE_TESTCTRL_NEVER_CORRUPT 20 +#define SQLITE_TESTCTRL_VDBE_COVERAGE 21 +#define SQLITE_TESTCTRL_BYTEORDER 22 +#define SQLITE_TESTCTRL_ISINIT 23 +#define SQLITE_TESTCTRL_SORTER_MMAP 24 +#define SQLITE_TESTCTRL_IMPOSTER 25 +#define SQLITE_TESTCTRL_LAST 25 + +/* +** CAPI3REF: SQLite Runtime Status +** +** ^These interfaces are used to retrieve runtime status information +** about the performance of SQLite, and optionally to reset various +** highwater marks. ^The first argument is an integer code for +** the specific parameter to measure. ^(Recognized integer codes +** are of the form [status parameters | SQLITE_STATUS_...].)^ +** ^The current value of the parameter is returned into *pCurrent. +** ^The highest recorded value is returned in *pHighwater. ^If the +** resetFlag is true, then the highest record value is reset after +** *pHighwater is written. ^(Some parameters do not record the highest +** value. For those parameters +** nothing is written into *pHighwater and the resetFlag is ignored.)^ +** ^(Other parameters record only the highwater mark and not the current +** value. For these latter parameters nothing is written into *pCurrent.)^ +** +** ^The sqlite3_status() and sqlite3_status64() routines return +** SQLITE_OK on success and a non-zero [error code] on failure. +** +** If either the current value or the highwater mark is too large to +** be represented by a 32-bit integer, then the values returned by +** sqlite3_status() are undefined. +** +** See also: [sqlite3_db_status()] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); +SQLITE_API int SQLITE_STDCALL sqlite3_status64( + int op, + sqlite3_int64 *pCurrent, + sqlite3_int64 *pHighwater, + int resetFlag +); + + +/* +** CAPI3REF: Status Parameters +** KEYWORDS: {status parameters} +** +** These integer constants designate various run-time status parameters +** that can be returned by [sqlite3_status()]. +** +**
+** [[SQLITE_STATUS_MEMORY_USED]] ^(
SQLITE_STATUS_MEMORY_USED
+**
This parameter is the current amount of memory checked out +** using [sqlite3_malloc()], either directly or indirectly. The +** figure includes calls made to [sqlite3_malloc()] by the application +** and internal memory usage by the SQLite library. Scratch memory +** controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache +** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in +** this parameter. The amount returned is the sum of the allocation +** sizes as reported by the xSize method in [sqlite3_mem_methods].
)^ +** +** [[SQLITE_STATUS_MALLOC_SIZE]] ^(
SQLITE_STATUS_MALLOC_SIZE
+**
This parameter records the largest memory allocation request +** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their +** internal equivalents). Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_MALLOC_COUNT]] ^(
SQLITE_STATUS_MALLOC_COUNT
+**
This parameter records the number of separate memory allocations +** currently checked out.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_USED]] ^(
SQLITE_STATUS_PAGECACHE_USED
+**
This parameter returns the number of pages used out of the +** [pagecache memory allocator] that was configured using +** [SQLITE_CONFIG_PAGECACHE]. The +** value returned is in pages, not in bytes.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]] +** ^(
SQLITE_STATUS_PAGECACHE_OVERFLOW
+**
This parameter returns the number of bytes of page cache +** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE] +** buffer and where forced to overflow to [sqlite3_malloc()]. The +** returned value includes allocations that overflowed because they +** where too large (they were larger than the "sz" parameter to +** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because +** no space was left in the page cache.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(
SQLITE_STATUS_PAGECACHE_SIZE
+**
This parameter records the largest memory allocation request +** handed to [pagecache memory allocator]. Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_SCRATCH_USED]] ^(
SQLITE_STATUS_SCRATCH_USED
+**
This parameter returns the number of allocations used out of the +** [scratch memory allocator] configured using +** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not +** in bytes. Since a single thread may only have one scratch allocation +** outstanding at time, this parameter also reports the number of threads +** using scratch memory at the same time.
)^ +** +** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(
SQLITE_STATUS_SCRATCH_OVERFLOW
+**
This parameter returns the number of bytes of scratch memory +** allocation which could not be satisfied by the [SQLITE_CONFIG_SCRATCH] +** buffer and where forced to overflow to [sqlite3_malloc()]. The values +** returned include overflows because the requested allocation was too +** larger (that is, because the requested allocation was larger than the +** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer +** slots were available. +**
)^ +** +** [[SQLITE_STATUS_SCRATCH_SIZE]] ^(
SQLITE_STATUS_SCRATCH_SIZE
+**
This parameter records the largest memory allocation request +** handed to [scratch memory allocator]. Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_PARSER_STACK]] ^(
SQLITE_STATUS_PARSER_STACK
+**
This parameter records the deepest parser stack. It is only +** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].
)^ +**
+** +** New status parameters may be added from time to time. +*/ +#define SQLITE_STATUS_MEMORY_USED 0 +#define SQLITE_STATUS_PAGECACHE_USED 1 +#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2 +#define SQLITE_STATUS_SCRATCH_USED 3 +#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 +#define SQLITE_STATUS_MALLOC_SIZE 5 +#define SQLITE_STATUS_PARSER_STACK 6 +#define SQLITE_STATUS_PAGECACHE_SIZE 7 +#define SQLITE_STATUS_SCRATCH_SIZE 8 +#define SQLITE_STATUS_MALLOC_COUNT 9 + +/* +** CAPI3REF: Database Connection Status +** METHOD: sqlite3 +** +** ^This interface is used to retrieve runtime status information +** about a single [database connection]. ^The first argument is the +** database connection object to be interrogated. ^The second argument +** is an integer constant, taken from the set of +** [SQLITE_DBSTATUS options], that +** determines the parameter to interrogate. The set of +** [SQLITE_DBSTATUS options] is likely +** to grow in future releases of SQLite. +** +** ^The current value of the requested parameter is written into *pCur +** and the highest instantaneous value is written into *pHiwtr. ^If +** the resetFlg is true, then the highest instantaneous value is +** reset back down to the current value. +** +** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a +** non-zero [error code] on failure. +** +** See also: [sqlite3_status()] and [sqlite3_stmt_status()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); + +/* +** CAPI3REF: Status Parameters for database connections +** KEYWORDS: {SQLITE_DBSTATUS options} +** +** These constants are the available integer "verbs" that can be passed as +** the second argument to the [sqlite3_db_status()] interface. +** +** New verbs may be added in future releases of SQLite. Existing verbs +** might be discontinued. Applications should check the return code from +** [sqlite3_db_status()] to make sure that the call worked. +** The [sqlite3_db_status()] interface will return a non-zero error code +** if a discontinued or unsupported verb is invoked. +** +**
+** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(
SQLITE_DBSTATUS_LOOKASIDE_USED
+**
This parameter returns the number of lookaside memory slots currently +** checked out.
)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(
SQLITE_DBSTATUS_LOOKASIDE_HIT
+**
This parameter returns the number malloc attempts that were +** satisfied using lookaside memory. Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]] +** ^(
SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
+**
This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to the amount of +** memory requested being larger than the lookaside slot size. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]] +** ^(
SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
+**
This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to all lookaside +** memory already being in use. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_CACHE_USED]] ^(
SQLITE_DBSTATUS_CACHE_USED
+**
This parameter returns the approximate number of bytes of heap +** memory used by all pager caches associated with the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0. +** +** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(
SQLITE_DBSTATUS_SCHEMA_USED
+**
This parameter returns the approximate number of bytes of heap +** memory used to store the schema for all databases associated +** with the connection - main, temp, and any [ATTACH]-ed databases.)^ +** ^The full amount of memory used by the schemas is reported, even if the +** schema memory is shared with other database connections due to +** [shared cache mode] being enabled. +** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0. +** +** [[SQLITE_DBSTATUS_STMT_USED]] ^(
SQLITE_DBSTATUS_STMT_USED
+**
This parameter returns the approximate number of bytes of heap +** and lookaside memory used by all prepared statements associated with +** the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(
SQLITE_DBSTATUS_CACHE_HIT
+**
This parameter returns the number of pager cache hits that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT +** is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(
SQLITE_DBSTATUS_CACHE_MISS
+**
This parameter returns the number of pager cache misses that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS +** is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_WRITE]] ^(
SQLITE_DBSTATUS_CACHE_WRITE
+**
This parameter returns the number of dirty cache entries that have +** been written to disk. Specifically, the number of pages written to the +** wal file in wal mode databases, or the number of pages written to the +** database file in rollback mode databases. Any pages written as part of +** transaction rollback or database recovery operations are not included. +** If an IO or other error occurs while writing a page to disk, the effect +** on subsequent SQLITE_DBSTATUS_CACHE_WRITE requests is undefined.)^ ^The +** highwater mark associated with SQLITE_DBSTATUS_CACHE_WRITE is always 0. +**
+** +** [[SQLITE_DBSTATUS_DEFERRED_FKS]] ^(
SQLITE_DBSTATUS_DEFERRED_FKS
+**
This parameter returns zero for the current value if and only if +** all foreign key constraints (deferred or immediate) have been +** resolved.)^ ^The highwater mark is always 0. +**
+**
+*/ +#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 +#define SQLITE_DBSTATUS_CACHE_USED 1 +#define SQLITE_DBSTATUS_SCHEMA_USED 2 +#define SQLITE_DBSTATUS_STMT_USED 3 +#define SQLITE_DBSTATUS_LOOKASIDE_HIT 4 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6 +#define SQLITE_DBSTATUS_CACHE_HIT 7 +#define SQLITE_DBSTATUS_CACHE_MISS 8 +#define SQLITE_DBSTATUS_CACHE_WRITE 9 +#define SQLITE_DBSTATUS_DEFERRED_FKS 10 +#define SQLITE_DBSTATUS_MAX 10 /* Largest defined DBSTATUS */ + + +/* +** CAPI3REF: Prepared Statement Status +** METHOD: sqlite3_stmt +** +** ^(Each prepared statement maintains various +** [SQLITE_STMTSTATUS counters] that measure the number +** of times it has performed specific operations.)^ These counters can +** be used to monitor the performance characteristics of the prepared +** statements. For example, if the number of table steps greatly exceeds +** the number of table searches or result rows, that would tend to indicate +** that the prepared statement is using a full table scan rather than +** an index. +** +** ^(This interface is used to retrieve and reset counter values from +** a [prepared statement]. The first argument is the prepared statement +** object to be interrogated. The second argument +** is an integer code for a specific [SQLITE_STMTSTATUS counter] +** to be interrogated.)^ +** ^The current value of the requested counter is returned. +** ^If the resetFlg is true, then the counter is reset to zero after this +** interface call returns. +** +** See also: [sqlite3_status()] and [sqlite3_db_status()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); + +/* +** CAPI3REF: Status Parameters for prepared statements +** KEYWORDS: {SQLITE_STMTSTATUS counter} {SQLITE_STMTSTATUS counters} +** +** These preprocessor macros define integer codes that name counter +** values associated with the [sqlite3_stmt_status()] interface. +** The meanings of the various counters are as follows: +** +**
+** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]]
SQLITE_STMTSTATUS_FULLSCAN_STEP
+**
^This is the number of times that SQLite has stepped forward in +** a table as part of a full table scan. Large numbers for this counter +** may indicate opportunities for performance improvement through +** careful use of indices.
+** +** [[SQLITE_STMTSTATUS_SORT]]
SQLITE_STMTSTATUS_SORT
+**
^This is the number of sort operations that have occurred. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance through careful use of indices.
+** +** [[SQLITE_STMTSTATUS_AUTOINDEX]]
SQLITE_STMTSTATUS_AUTOINDEX
+**
^This is the number of rows inserted into transient indices that +** were created automatically in order to help joins run faster. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance by adding permanent indices that do not +** need to be reinitialized each time the statement is run.
+** +** [[SQLITE_STMTSTATUS_VM_STEP]]
SQLITE_STMTSTATUS_VM_STEP
+**
^This is the number of virtual machine operations executed +** by the prepared statement if that number is less than or equal +** to 2147483647. The number of virtual machine operations can be +** used as a proxy for the total work done by the prepared statement. +** If the number of virtual machine operations exceeds 2147483647 +** then the value returned by this statement status code is undefined. +**
+**
+*/ +#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 +#define SQLITE_STMTSTATUS_SORT 2 +#define SQLITE_STMTSTATUS_AUTOINDEX 3 +#define SQLITE_STMTSTATUS_VM_STEP 4 + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache type is opaque. It is implemented by +** the pluggable module. The SQLite core has no knowledge of +** its size or internal structure and never deals with the +** sqlite3_pcache object except by holding and passing pointers +** to the object. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache sqlite3_pcache; + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache_page object represents a single page in the +** page cache. The page cache will allocate instances of this +** object. Various methods of the page cache use pointers to instances +** of this object as parameters or as their return value. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache_page sqlite3_pcache_page; +struct sqlite3_pcache_page { + void *pBuf; /* The content of the page */ + void *pExtra; /* Extra information associated with the page */ +}; + +/* +** CAPI3REF: Application Defined Page Cache. +** KEYWORDS: {page cache} +** +** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can +** register an alternative page cache implementation by passing in an +** instance of the sqlite3_pcache_methods2 structure.)^ +** In many applications, most of the heap memory allocated by +** SQLite is used for the page cache. +** By implementing a +** custom page cache using this API, an application can better control +** the amount of memory consumed by SQLite, the way in which +** that memory is allocated and released, and the policies used to +** determine exactly which parts of a database file are cached and for +** how long. +** +** The alternative page cache mechanism is an +** extreme measure that is only needed by the most demanding applications. +** The built-in page cache is recommended for most uses. +** +** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an +** internal buffer by SQLite within the call to [sqlite3_config]. Hence +** the application may discard the parameter after the call to +** [sqlite3_config()] returns.)^ +** +** [[the xInit() page cache method]] +** ^(The xInit() method is called once for each effective +** call to [sqlite3_initialize()])^ +** (usually only once during the lifetime of the process). ^(The xInit() +** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^ +** The intent of the xInit() method is to set up global data structures +** required by the custom page cache implementation. +** ^(If the xInit() method is NULL, then the +** built-in default page cache is used instead of the application defined +** page cache.)^ +** +** [[the xShutdown() page cache method]] +** ^The xShutdown() method is called by [sqlite3_shutdown()]. +** It can be used to clean up +** any outstanding resources before process shutdown, if required. +** ^The xShutdown() method may be NULL. +** +** ^SQLite automatically serializes calls to the xInit method, +** so the xInit method need not be threadsafe. ^The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. All other methods must be threadsafe +** in multithreaded applications. +** +** ^SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +** +** [[the xCreate() page cache methods]] +** ^SQLite invokes the xCreate() method to construct a new cache instance. +** SQLite will typically create one cache instance for each open database file, +** though this is not guaranteed. ^The +** first parameter, szPage, is the size in bytes of the pages that must +** be allocated by the cache. ^szPage will always a power of two. ^The +** second parameter szExtra is a number of bytes of extra storage +** associated with each page cache entry. ^The szExtra parameter will +** a number less than 250. SQLite will use the +** extra szExtra bytes on each page to store metadata about the underlying +** database page on disk. The value passed into szExtra depends +** on the SQLite version, the target platform, and how SQLite was compiled. +** ^The third argument to xCreate(), bPurgeable, is true if the cache being +** created will be used to cache database pages of a file stored on disk, or +** false if it is used for an in-memory database. The cache implementation +** does not have to do anything special based with the value of bPurgeable; +** it is purely advisory. ^On a cache where bPurgeable is false, SQLite will +** never invoke xUnpin() except to deliberately delete a page. +** ^In other words, calls to xUnpin() on a cache with bPurgeable set to +** false will always have the "discard" flag set to true. +** ^Hence, a cache created with bPurgeable false will +** never contain any unpinned pages. +** +** [[the xCachesize() page cache method]] +** ^(The xCachesize() method may be called at any time by SQLite to set the +** suggested maximum cache-size (number of pages stored by) the cache +** instance passed as the first argument. This is the value configured using +** the SQLite "[PRAGMA cache_size]" command.)^ As with the bPurgeable +** parameter, the implementation is not required to do anything with this +** value; it is advisory only. +** +** [[the xPagecount() page cache methods]] +** The xPagecount() method must return the number of pages currently +** stored in the cache, both pinned and unpinned. +** +** [[the xFetch() page cache methods]] +** The xFetch() method locates a page in the cache and returns a pointer to +** an sqlite3_pcache_page object associated with that page, or a NULL pointer. +** The pBuf element of the returned sqlite3_pcache_page object will be a +** pointer to a buffer of szPage bytes used to store the content of a +** single database page. The pExtra element of sqlite3_pcache_page will be +** a pointer to the szExtra bytes of extra storage that SQLite has requested +** for each entry in the page cache. +** +** The page to be fetched is determined by the key. ^The minimum key value +** is 1. After it has been retrieved using xFetch, the page is considered +** to be "pinned". +** +** If the requested page is already in the page cache, then the page cache +** implementation must return a pointer to the page buffer with its content +** intact. If the requested page is not already in the cache, then the +** cache implementation should use the value of the createFlag +** parameter to help it determined what action to take: +** +** +**
createFlag Behavior when page is not already in cache +**
0 Do not allocate a new page. Return NULL. +**
1 Allocate a new page if it easy and convenient to do so. +** Otherwise return NULL. +**
2 Make every effort to allocate a new page. Only return +** NULL if allocating a new page is effectively impossible. +**
+** +** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1. SQLite +** will only use a createFlag of 2 after a prior call with a createFlag of 1 +** failed.)^ In between the to xFetch() calls, SQLite may +** attempt to unpin one or more cache pages by spilling the content of +** pinned pages to disk and synching the operating system disk cache. +** +** [[the xUnpin() page cache method]] +** ^xUnpin() is called by SQLite with a pointer to a currently pinned page +** as its second argument. If the third parameter, discard, is non-zero, +** then the page must be evicted from the cache. +** ^If the discard parameter is +** zero, then the page may be discarded or retained at the discretion of +** page cache implementation. ^The page cache implementation +** may choose to evict unpinned pages at any time. +** +** The cache must not perform any reference counting. A single +** call to xUnpin() unpins the page regardless of the number of prior calls +** to xFetch(). +** +** [[the xRekey() page cache methods]] +** The xRekey() method is used to change the key value associated with the +** page passed as the second argument. If the cache +** previously contains an entry associated with newKey, it must be +** discarded. ^Any prior cache entry associated with newKey is guaranteed not +** to be pinned. +** +** When SQLite calls the xTruncate() method, the cache must discard all +** existing cache entries with page numbers (keys) greater than or equal +** to the value of the iLimit parameter passed to xTruncate(). If any +** of these pages are pinned, they are implicitly unpinned, meaning that +** they can be safely discarded. +** +** [[the xDestroy() page cache method]] +** ^The xDestroy() method is used to delete a cache allocated by xCreate(). +** All resources associated with the specified cache should be freed. ^After +** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*] +** handle invalid, and will not use it with any other sqlite3_pcache_methods2 +** functions. +** +** [[the xShrink() page cache method]] +** ^SQLite invokes the xShrink() method when it wants the page cache to +** free up as much of heap memory as possible. The page cache implementation +** is not obligated to free any memory, but well-behaved implementations should +** do their best. +*/ +typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2; +struct sqlite3_pcache_methods2 { + int iVersion; + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int szExtra, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*, int discard); + void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*, + unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); + void (*xShrink)(sqlite3_pcache*); +}; + +/* +** This is the obsolete pcache_methods object that has now been replaced +** by sqlite3_pcache_methods2. This object is not used by SQLite. It is +** retained in the header file for backwards compatibility only. +*/ +typedef struct sqlite3_pcache_methods sqlite3_pcache_methods; +struct sqlite3_pcache_methods { + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, void*, int discard); + void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); +}; + + +/* +** CAPI3REF: Online Backup Object +** +** The sqlite3_backup object records state information about an ongoing +** online backup operation. ^The sqlite3_backup object is created by +** a call to [sqlite3_backup_init()] and is destroyed by a call to +** [sqlite3_backup_finish()]. +** +** See Also: [Using the SQLite Online Backup API] +*/ +typedef struct sqlite3_backup sqlite3_backup; + +/* +** CAPI3REF: Online Backup API. +** +** The backup API copies the content of one database into another. +** It is useful either for creating backups of databases or +** for copying in-memory databases to or from persistent files. +** +** See Also: [Using the SQLite Online Backup API] +** +** ^SQLite holds a write transaction open on the destination database file +** for the duration of the backup operation. +** ^The source database is read-locked only while it is being read; +** it is not locked continuously for the entire backup operation. +** ^Thus, the backup may be performed on a live source database without +** preventing other database connections from +** reading or writing to the source database while the backup is underway. +** +** ^(To perform a backup operation: +**
    +**
  1. sqlite3_backup_init() is called once to initialize the +** backup, +**
  2. sqlite3_backup_step() is called one or more times to transfer +** the data between the two databases, and finally +**
  3. sqlite3_backup_finish() is called to release all resources +** associated with the backup operation. +**
)^ +** There should be exactly one call to sqlite3_backup_finish() for each +** successful call to sqlite3_backup_init(). +** +** [[sqlite3_backup_init()]] sqlite3_backup_init() +** +** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the +** [database connection] associated with the destination database +** and the database name, respectively. +** ^The database name is "main" for the main database, "temp" for the +** temporary database, or the name specified after the AS keyword in +** an [ATTACH] statement for an attached database. +** ^The S and M arguments passed to +** sqlite3_backup_init(D,N,S,M) identify the [database connection] +** and database name of the source database, respectively. +** ^The source and destination [database connections] (parameters S and D) +** must be different or else sqlite3_backup_init(D,N,S,M) will fail with +** an error. +** +** ^A call to sqlite3_backup_init() will fail, returning SQLITE_ERROR, if +** there is already a read or read-write transaction open on the +** destination database. +** +** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is +** returned and an error code and error message are stored in the +** destination [database connection] D. +** ^The error code and message for the failed call to sqlite3_backup_init() +** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or +** [sqlite3_errmsg16()] functions. +** ^A successful call to sqlite3_backup_init() returns a pointer to an +** [sqlite3_backup] object. +** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and +** sqlite3_backup_finish() functions to perform the specified backup +** operation. +** +** [[sqlite3_backup_step()]] sqlite3_backup_step() +** +** ^Function sqlite3_backup_step(B,N) will copy up to N pages between +** the source and destination databases specified by [sqlite3_backup] object B. +** ^If N is negative, all remaining source pages are copied. +** ^If sqlite3_backup_step(B,N) successfully copies N pages and there +** are still more pages to be copied, then the function returns [SQLITE_OK]. +** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages +** from source to destination, then it returns [SQLITE_DONE]. +** ^If an error occurs while running sqlite3_backup_step(B,N), +** then an [error code] is returned. ^As well as [SQLITE_OK] and +** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY], +** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code. +** +** ^(The sqlite3_backup_step() might return [SQLITE_READONLY] if +**
    +**
  1. the destination database was opened read-only, or +**
  2. the destination database is using write-ahead-log journaling +** and the destination and source page sizes differ, or +**
  3. the destination database is an in-memory database and the +** destination and source page sizes differ. +**
)^ +** +** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then +** the [sqlite3_busy_handler | busy-handler function] +** is invoked (if one is specified). ^If the +** busy-handler returns non-zero before the lock is available, then +** [SQLITE_BUSY] is returned to the caller. ^In this case the call to +** sqlite3_backup_step() can be retried later. ^If the source +** [database connection] +** is being used to write to the source database when sqlite3_backup_step() +** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this +** case the call to sqlite3_backup_step() can be retried later on. ^(If +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or +** [SQLITE_READONLY] is returned, then +** there is no point in retrying the call to sqlite3_backup_step(). These +** errors are considered fatal.)^ The application must accept +** that the backup operation has failed and pass the backup operation handle +** to the sqlite3_backup_finish() to release associated resources. +** +** ^The first call to sqlite3_backup_step() obtains an exclusive lock +** on the destination file. ^The exclusive lock is not released until either +** sqlite3_backup_finish() is called or the backup operation is complete +** and sqlite3_backup_step() returns [SQLITE_DONE]. ^Every call to +** sqlite3_backup_step() obtains a [shared lock] on the source database that +** lasts for the duration of the sqlite3_backup_step() call. +** ^Because the source database is not locked between calls to +** sqlite3_backup_step(), the source database may be modified mid-way +** through the backup process. ^If the source database is modified by an +** external process or via a database connection other than the one being +** used by the backup operation, then the backup will be automatically +** restarted by the next call to sqlite3_backup_step(). ^If the source +** database is modified by the using the same database connection as is used +** by the backup operation, then the backup database is automatically +** updated at the same time. +** +** [[sqlite3_backup_finish()]] sqlite3_backup_finish() +** +** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the +** application wishes to abandon the backup operation, the application +** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish(). +** ^The sqlite3_backup_finish() interfaces releases all +** resources associated with the [sqlite3_backup] object. +** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any +** active write-transaction on the destination database is rolled back. +** The [sqlite3_backup] object is invalid +** and may not be used following a call to sqlite3_backup_finish(). +** +** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no +** sqlite3_backup_step() errors occurred, regardless or whether or not +** sqlite3_backup_step() completed. +** ^If an out-of-memory condition or IO error occurred during any prior +** sqlite3_backup_step() call on the same [sqlite3_backup] object, then +** sqlite3_backup_finish() returns the corresponding [error code]. +** +** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step() +** is not a permanent error and does not affect the return value of +** sqlite3_backup_finish(). +** +** [[sqlite3_backup_remaining()]] [[sqlite3_backup_pagecount()]] +** sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** +** ^The sqlite3_backup_remaining() routine returns the number of pages still +** to be backed up at the conclusion of the most recent sqlite3_backup_step(). +** ^The sqlite3_backup_pagecount() routine returns the total number of pages +** in the source database at the conclusion of the most recent +** sqlite3_backup_step(). +** ^(The values returned by these functions are only updated by +** sqlite3_backup_step(). If the source database is modified in a way that +** changes the size of the source database or the number of pages remaining, +** those changes are not reflected in the output of sqlite3_backup_pagecount() +** and sqlite3_backup_remaining() until after the next +** sqlite3_backup_step().)^ +** +** Concurrent Usage of Database Handles +** +** ^The source [database connection] may be used by the application for other +** purposes while a backup operation is underway or being initialized. +** ^If SQLite is compiled and configured to support threadsafe database +** connections, then the source database connection may be used concurrently +** from within other threads. +** +** However, the application must guarantee that the destination +** [database connection] is not passed to any other API (by any thread) after +** sqlite3_backup_init() is called and before the corresponding call to +** sqlite3_backup_finish(). SQLite does not currently check to see +** if the application incorrectly accesses the destination [database connection] +** and so no error code is reported, but the operations may malfunction +** nevertheless. Use of the destination database connection while a +** backup is in progress might also also cause a mutex deadlock. +** +** If running in [shared cache mode], the application must +** guarantee that the shared cache used by the destination database +** is not accessed while the backup is running. In practice this means +** that the application must guarantee that the disk file being +** backed up to is not accessed by any connection within the process, +** not just the specific connection that was passed to sqlite3_backup_init(). +** +** The [sqlite3_backup] object itself is partially threadsafe. Multiple +** threads may safely make multiple concurrent calls to sqlite3_backup_step(). +** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** APIs are not strictly speaking threadsafe. If they are invoked at the +** same time as another thread is invoking sqlite3_backup_step() it is +** possible that they return invalid values. +*/ +SQLITE_API sqlite3_backup *SQLITE_STDCALL sqlite3_backup_init( + sqlite3 *pDest, /* Destination database handle */ + const char *zDestName, /* Destination database name */ + sqlite3 *pSource, /* Source database handle */ + const char *zSourceName /* Source database name */ +); +SQLITE_API int SQLITE_STDCALL sqlite3_backup_step(sqlite3_backup *p, int nPage); +SQLITE_API int SQLITE_STDCALL sqlite3_backup_finish(sqlite3_backup *p); +SQLITE_API int SQLITE_STDCALL sqlite3_backup_remaining(sqlite3_backup *p); +SQLITE_API int SQLITE_STDCALL sqlite3_backup_pagecount(sqlite3_backup *p); + +/* +** CAPI3REF: Unlock Notification +** METHOD: sqlite3 +** +** ^When running in shared-cache mode, a database operation may fail with +** an [SQLITE_LOCKED] error if the required locks on the shared-cache or +** individual tables within the shared-cache cannot be obtained. See +** [SQLite Shared-Cache Mode] for a description of shared-cache locking. +** ^This API may be used to register a callback that SQLite will invoke +** when the connection currently holding the required lock relinquishes it. +** ^This API is only available if the library was compiled with the +** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined. +** +** See Also: [Using the SQLite Unlock Notification Feature]. +** +** ^Shared-cache locks are released when a database connection concludes +** its current transaction, either by committing it or rolling it back. +** +** ^When a connection (known as the blocked connection) fails to obtain a +** shared-cache lock and SQLITE_LOCKED is returned to the caller, the +** identity of the database connection (the blocking connection) that +** has locked the required resource is stored internally. ^After an +** application receives an SQLITE_LOCKED error, it may call the +** sqlite3_unlock_notify() method with the blocked connection handle as +** the first argument to register for a callback that will be invoked +** when the blocking connections current transaction is concluded. ^The +** callback is invoked from within the [sqlite3_step] or [sqlite3_close] +** call that concludes the blocking connections transaction. +** +** ^(If sqlite3_unlock_notify() is called in a multi-threaded application, +** there is a chance that the blocking connection will have already +** concluded its transaction by the time sqlite3_unlock_notify() is invoked. +** If this happens, then the specified callback is invoked immediately, +** from within the call to sqlite3_unlock_notify().)^ +** +** ^If the blocked connection is attempting to obtain a write-lock on a +** shared-cache table, and more than one other connection currently holds +** a read-lock on the same table, then SQLite arbitrarily selects one of +** the other connections to use as the blocking connection. +** +** ^(There may be at most one unlock-notify callback registered by a +** blocked connection. If sqlite3_unlock_notify() is called when the +** blocked connection already has a registered unlock-notify callback, +** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is +** called with a NULL pointer as its second argument, then any existing +** unlock-notify callback is canceled. ^The blocked connections +** unlock-notify callback may also be canceled by closing the blocked +** connection using [sqlite3_close()]. +** +** The unlock-notify callback is not reentrant. If an application invokes +** any sqlite3_xxx API functions from within an unlock-notify callback, a +** crash or deadlock may be the result. +** +** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always +** returns SQLITE_OK. +** +** Callback Invocation Details +** +** When an unlock-notify callback is registered, the application provides a +** single void* pointer that is passed to the callback when it is invoked. +** However, the signature of the callback function allows SQLite to pass +** it an array of void* context pointers. The first argument passed to +** an unlock-notify callback is a pointer to an array of void* pointers, +** and the second is the number of entries in the array. +** +** When a blocking connections transaction is concluded, there may be +** more than one blocked connection that has registered for an unlock-notify +** callback. ^If two or more such blocked connections have specified the +** same callback function, then instead of invoking the callback function +** multiple times, it is invoked once with the set of void* context pointers +** specified by the blocked connections bundled together into an array. +** This gives the application an opportunity to prioritize any actions +** related to the set of unblocked database connections. +** +** Deadlock Detection +** +** Assuming that after registering for an unlock-notify callback a +** database waits for the callback to be issued before taking any further +** action (a reasonable assumption), then using this API may cause the +** application to deadlock. For example, if connection X is waiting for +** connection Y's transaction to be concluded, and similarly connection +** Y is waiting on connection X's transaction, then neither connection +** will proceed and the system may remain deadlocked indefinitely. +** +** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock +** detection. ^If a given call to sqlite3_unlock_notify() would put the +** system in a deadlocked state, then SQLITE_LOCKED is returned and no +** unlock-notify callback is registered. The system is said to be in +** a deadlocked state if connection A has registered for an unlock-notify +** callback on the conclusion of connection B's transaction, and connection +** B has itself registered for an unlock-notify callback when connection +** A's transaction is concluded. ^Indirect deadlock is also detected, so +** the system is also considered to be deadlocked if connection B has +** registered for an unlock-notify callback on the conclusion of connection +** C's transaction, where connection C is waiting on connection A. ^Any +** number of levels of indirection are allowed. +** +** The "DROP TABLE" Exception +** +** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost +** always appropriate to call sqlite3_unlock_notify(). There is however, +** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement, +** SQLite checks if there are any currently executing SELECT statements +** that belong to the same connection. If there are, SQLITE_LOCKED is +** returned. In this case there is no "blocking connection", so invoking +** sqlite3_unlock_notify() results in the unlock-notify callback being +** invoked immediately. If the application then re-attempts the "DROP TABLE" +** or "DROP INDEX" query, an infinite loop might be the result. +** +** One way around this problem is to check the extended error code returned +** by an sqlite3_step() call. ^(If there is a blocking connection, then the +** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in +** the special "DROP TABLE/INDEX" case, the extended error code is just +** SQLITE_LOCKED.)^ +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_unlock_notify( + sqlite3 *pBlocked, /* Waiting connection */ + void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */ + void *pNotifyArg /* Argument to pass to xNotify */ +); + + +/* +** CAPI3REF: String Comparison +** +** ^The [sqlite3_stricmp()] and [sqlite3_strnicmp()] APIs allow applications +** and extensions to compare the contents of two buffers containing UTF-8 +** strings in a case-independent fashion, using the same definition of "case +** independence" that SQLite uses internally when comparing identifiers. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_stricmp(const char *, const char *); +SQLITE_API int SQLITE_STDCALL sqlite3_strnicmp(const char *, const char *, int); + +/* +** CAPI3REF: String Globbing +* +** ^The [sqlite3_strglob(P,X)] interface returns zero if string X matches +** the glob pattern P, and it returns non-zero if string X does not match +** the glob pattern P. ^The definition of glob pattern matching used in +** [sqlite3_strglob(P,X)] is the same as for the "X GLOB P" operator in the +** SQL dialect used by SQLite. ^The sqlite3_strglob(P,X) function is case +** sensitive. +** +** Note that this routine returns zero on a match and non-zero if the strings +** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_strglob(const char *zGlob, const char *zStr); + +/* +** CAPI3REF: Error Logging Interface +** +** ^The [sqlite3_log()] interface writes a message into the [error log] +** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()]. +** ^If logging is enabled, the zFormat string and subsequent arguments are +** used with [sqlite3_snprintf()] to generate the final output string. +** +** The sqlite3_log() interface is intended for use by extensions such as +** virtual tables, collating functions, and SQL functions. While there is +** nothing to prevent an application from calling sqlite3_log(), doing so +** is considered bad form. +** +** The zFormat string must not be NULL. +** +** To avoid deadlocks and other threading problems, the sqlite3_log() routine +** will not use dynamically allocated memory. The log message is stored in +** a fixed-length buffer on the stack. If the log message is longer than +** a few hundred characters, it will be truncated to the length of the +** buffer. +*/ +SQLITE_API void SQLITE_CDECL sqlite3_log(int iErrCode, const char *zFormat, ...); + +/* +** CAPI3REF: Write-Ahead Log Commit Hook +** METHOD: sqlite3 +** +** ^The [sqlite3_wal_hook()] function is used to register a callback that +** is invoked each time data is committed to a database in wal mode. +** +** ^(The callback is invoked by SQLite after the commit has taken place and +** the associated write-lock on the database released)^, so the implementation +** may read, write or [checkpoint] the database as required. +** +** ^The first parameter passed to the callback function when it is invoked +** is a copy of the third parameter passed to sqlite3_wal_hook() when +** registering the callback. ^The second is a copy of the database handle. +** ^The third parameter is the name of the database that was written to - +** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter +** is the number of pages currently in the write-ahead log file, +** including those that were just committed. +** +** The callback function should normally return [SQLITE_OK]. ^If an error +** code is returned, that error will propagate back up through the +** SQLite code base to cause the statement that provoked the callback +** to report an error, though the commit will have still occurred. If the +** callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value +** that does not correspond to any valid SQLite error code, the results +** are undefined. +** +** A single database handle may have at most a single write-ahead log callback +** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any +** previously registered write-ahead log callback. ^Note that the +** [sqlite3_wal_autocheckpoint()] interface and the +** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will +** those overwrite any prior [sqlite3_wal_hook()] settings. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_wal_hook( + sqlite3*, + int(*)(void *,sqlite3*,const char*,int), + void* +); + +/* +** CAPI3REF: Configure an auto-checkpoint +** METHOD: sqlite3 +** +** ^The [sqlite3_wal_autocheckpoint(D,N)] is a wrapper around +** [sqlite3_wal_hook()] that causes any database on [database connection] D +** to automatically [checkpoint] +** after committing a transaction if there are N or +** more frames in the [write-ahead log] file. ^Passing zero or +** a negative value as the nFrame parameter disables automatic +** checkpoints entirely. +** +** ^The callback registered by this function replaces any existing callback +** registered using [sqlite3_wal_hook()]. ^Likewise, registering a callback +** using [sqlite3_wal_hook()] disables the automatic checkpoint mechanism +** configured by this function. +** +** ^The [wal_autocheckpoint pragma] can be used to invoke this interface +** from SQL. +** +** ^Checkpoints initiated by this mechanism are +** [sqlite3_wal_checkpoint_v2|PASSIVE]. +** +** ^Every new [database connection] defaults to having the auto-checkpoint +** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT] +** pages. The use of this interface +** is only necessary if the default setting is found to be suboptimal +** for a particular application. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_wal_autocheckpoint(sqlite3 *db, int N); + +/* +** CAPI3REF: Checkpoint a database +** METHOD: sqlite3 +** +** ^(The sqlite3_wal_checkpoint(D,X) is equivalent to +** [sqlite3_wal_checkpoint_v2](D,X,[SQLITE_CHECKPOINT_PASSIVE],0,0).)^ +** +** In brief, sqlite3_wal_checkpoint(D,X) causes the content in the +** [write-ahead log] for database X on [database connection] D to be +** transferred into the database file and for the write-ahead log to +** be reset. See the [checkpointing] documentation for addition +** information. +** +** This interface used to be the only way to cause a checkpoint to +** occur. But then the newer and more powerful [sqlite3_wal_checkpoint_v2()] +** interface was added. This interface is retained for backwards +** compatibility and as a convenience for applications that need to manually +** start a callback but which do not need the full power (and corresponding +** complication) of [sqlite3_wal_checkpoint_v2()]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb); + +/* +** CAPI3REF: Checkpoint a database +** METHOD: sqlite3 +** +** ^(The sqlite3_wal_checkpoint_v2(D,X,M,L,C) interface runs a checkpoint +** operation on database X of [database connection] D in mode M. Status +** information is written back into integers pointed to by L and C.)^ +** ^(The M parameter must be a valid [checkpoint mode]:)^ +** +**
+**
SQLITE_CHECKPOINT_PASSIVE
+** ^Checkpoint as many frames as possible without waiting for any database +** readers or writers to finish, then sync the database file if all frames +** in the log were checkpointed. ^The [busy-handler callback] +** is never invoked in the SQLITE_CHECKPOINT_PASSIVE mode. +** ^On the other hand, passive mode might leave the checkpoint unfinished +** if there are concurrent readers or writers. +** +**
SQLITE_CHECKPOINT_FULL
+** ^This mode blocks (it invokes the +** [sqlite3_busy_handler|busy-handler callback]) until there is no +** database writer and all readers are reading from the most recent database +** snapshot. ^It then checkpoints all frames in the log file and syncs the +** database file. ^This mode blocks new database writers while it is pending, +** but new database readers are allowed to continue unimpeded. +** +**
SQLITE_CHECKPOINT_RESTART
+** ^This mode works the same way as SQLITE_CHECKPOINT_FULL with the addition +** that after checkpointing the log file it blocks (calls the +** [busy-handler callback]) +** until all readers are reading from the database file only. ^This ensures +** that the next writer will restart the log file from the beginning. +** ^Like SQLITE_CHECKPOINT_FULL, this mode blocks new +** database writer attempts while it is pending, but does not impede readers. +** +**
SQLITE_CHECKPOINT_TRUNCATE
+** ^This mode works the same way as SQLITE_CHECKPOINT_RESTART with the +** addition that it also truncates the log file to zero bytes just prior +** to a successful return. +**
+** +** ^If pnLog is not NULL, then *pnLog is set to the total number of frames in +** the log file or to -1 if the checkpoint could not run because +** of an error or because the database is not in [WAL mode]. ^If pnCkpt is not +** NULL,then *pnCkpt is set to the total number of checkpointed frames in the +** log file (including any that were already checkpointed before the function +** was called) or to -1 if the checkpoint could not run due to an error or +** because the database is not in WAL mode. ^Note that upon successful +** completion of an SQLITE_CHECKPOINT_TRUNCATE, the log file will have been +** truncated to zero bytes and so both *pnLog and *pnCkpt will be set to zero. +** +** ^All calls obtain an exclusive "checkpoint" lock on the database file. ^If +** any other process is running a checkpoint operation at the same time, the +** lock cannot be obtained and SQLITE_BUSY is returned. ^Even if there is a +** busy-handler configured, it will not be invoked in this case. +** +** ^The SQLITE_CHECKPOINT_FULL, RESTART and TRUNCATE modes also obtain the +** exclusive "writer" lock on the database file. ^If the writer lock cannot be +** obtained immediately, and a busy-handler is configured, it is invoked and +** the writer lock retried until either the busy-handler returns 0 or the lock +** is successfully obtained. ^The busy-handler is also invoked while waiting for +** database readers as described above. ^If the busy-handler returns 0 before +** the writer lock is obtained or while waiting for database readers, the +** checkpoint operation proceeds from that point in the same way as +** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible +** without blocking any further. ^SQLITE_BUSY is returned in this case. +** +** ^If parameter zDb is NULL or points to a zero length string, then the +** specified operation is attempted on all WAL databases [attached] to +** [database connection] db. In this case the +** values written to output parameters *pnLog and *pnCkpt are undefined. ^If +** an SQLITE_BUSY error is encountered when processing one or more of the +** attached WAL databases, the operation is still attempted on any remaining +** attached databases and SQLITE_BUSY is returned at the end. ^If any other +** error occurs while processing an attached database, processing is abandoned +** and the error code is returned to the caller immediately. ^If no error +** (SQLITE_BUSY or otherwise) is encountered while processing the attached +** databases, SQLITE_OK is returned. +** +** ^If database zDb is the name of an attached database that is not in WAL +** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If +** zDb is not NULL (or a zero length string) and is not the name of any +** attached database, SQLITE_ERROR is returned to the caller. +** +** ^Unless it returns SQLITE_MISUSE, +** the sqlite3_wal_checkpoint_v2() interface +** sets the error information that is queried by +** [sqlite3_errcode()] and [sqlite3_errmsg()]. +** +** ^The [PRAGMA wal_checkpoint] command can be used to invoke this interface +** from SQL. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint_v2( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of attached database (or NULL) */ + int eMode, /* SQLITE_CHECKPOINT_* value */ + int *pnLog, /* OUT: Size of WAL log in frames */ + int *pnCkpt /* OUT: Total number of frames checkpointed */ +); + +/* +** CAPI3REF: Checkpoint Mode Values +** KEYWORDS: {checkpoint mode} +** +** These constants define all valid values for the "checkpoint mode" passed +** as the third parameter to the [sqlite3_wal_checkpoint_v2()] interface. +** See the [sqlite3_wal_checkpoint_v2()] documentation for details on the +** meaning of each of these checkpoint modes. +*/ +#define SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */ +#define SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */ +#define SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for for readers */ +#define SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */ + +/* +** CAPI3REF: Virtual Table Interface Configuration +** +** This function may be called by either the [xConnect] or [xCreate] method +** of a [virtual table] implementation to configure +** various facets of the virtual table interface. +** +** If this interface is invoked outside the context of an xConnect or +** xCreate virtual table method then the behavior is undefined. +** +** At present, there is only one option that may be configured using +** this function. (See [SQLITE_VTAB_CONSTRAINT_SUPPORT].) Further options +** may be added in the future. +*/ +SQLITE_API int SQLITE_CDECL sqlite3_vtab_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Virtual Table Configuration Options +** +** These macros define the various options to the +** [sqlite3_vtab_config()] interface that [virtual table] implementations +** can use to customize and optimize their behavior. +** +**
+**
SQLITE_VTAB_CONSTRAINT_SUPPORT +**
Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported, +** where X is an integer. If X is zero, then the [virtual table] whose +** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not +** support constraints. In this configuration (which is the default) if +** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire +** statement is rolled back as if [ON CONFLICT | OR ABORT] had been +** specified as part of the users SQL statement, regardless of the actual +** ON CONFLICT mode specified. +** +** If X is non-zero, then the virtual table implementation guarantees +** that if [xUpdate] returns [SQLITE_CONSTRAINT], it will do so before +** any modifications to internal or persistent data structures have been made. +** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite +** is able to roll back a statement or database transaction, and abandon +** or continue processing the current SQL statement as appropriate. +** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns +** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode +** had been ABORT. +** +** Virtual table implementations that are required to handle OR REPLACE +** must do so within the [xUpdate] method. If a call to the +** [sqlite3_vtab_on_conflict()] function indicates that the current ON +** CONFLICT policy is REPLACE, the virtual table implementation should +** silently replace the appropriate rows within the xUpdate callback and +** return SQLITE_OK. Or, if this is not possible, it may return +** SQLITE_CONSTRAINT, in which case SQLite falls back to OR ABORT +** constraint handling. +**
+*/ +#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1 + +/* +** CAPI3REF: Determine The Virtual Table Conflict Policy +** +** This function may only be called from within a call to the [xUpdate] method +** of a [virtual table] implementation for an INSERT or UPDATE operation. ^The +** value returned is one of [SQLITE_ROLLBACK], [SQLITE_IGNORE], [SQLITE_FAIL], +** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode +** of the SQL statement that triggered the call to the [xUpdate] method of the +** [virtual table]. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_vtab_on_conflict(sqlite3 *); + +/* +** CAPI3REF: Conflict resolution modes +** KEYWORDS: {conflict resolution mode} +** +** These constants are returned by [sqlite3_vtab_on_conflict()] to +** inform a [virtual table] implementation what the [ON CONFLICT] mode +** is for the SQL statement being evaluated. +** +** Note that the [SQLITE_IGNORE] constant is also used as a potential +** return value from the [sqlite3_set_authorizer()] callback and that +** [SQLITE_ABORT] is also a [result code]. +*/ +#define SQLITE_ROLLBACK 1 +/* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */ +#define SQLITE_FAIL 3 +/* #define SQLITE_ABORT 4 // Also an error code */ +#define SQLITE_REPLACE 5 + +/* +** CAPI3REF: Prepared Statement Scan Status Opcodes +** KEYWORDS: {scanstatus options} +** +** The following constants can be used for the T parameter to the +** [sqlite3_stmt_scanstatus(S,X,T,V)] interface. Each constant designates a +** different metric for sqlite3_stmt_scanstatus() to return. +** +** When the value returned to V is a string, space to hold that string is +** managed by the prepared statement S and will be automatically freed when +** S is finalized. +** +**
+** [[SQLITE_SCANSTAT_NLOOP]]
SQLITE_SCANSTAT_NLOOP
+**
^The [sqlite3_int64] variable pointed to by the T parameter will be +** set to the total number of times that the X-th loop has run.
+** +** [[SQLITE_SCANSTAT_NVISIT]]
SQLITE_SCANSTAT_NVISIT
+**
^The [sqlite3_int64] variable pointed to by the T parameter will be set +** to the total number of rows examined by all iterations of the X-th loop.
+** +** [[SQLITE_SCANSTAT_EST]]
SQLITE_SCANSTAT_EST
+**
^The "double" variable pointed to by the T parameter will be set to the +** query planner's estimate for the average number of rows output from each +** iteration of the X-th loop. If the query planner's estimates was accurate, +** then this value will approximate the quotient NVISIT/NLOOP and the +** product of this value for all prior loops with the same SELECTID will +** be the NLOOP value for the current loop. +** +** [[SQLITE_SCANSTAT_NAME]]
SQLITE_SCANSTAT_NAME
+**
^The "const char *" variable pointed to by the T parameter will be set +** to a zero-terminated UTF-8 string containing the name of the index or table +** used for the X-th loop. +** +** [[SQLITE_SCANSTAT_EXPLAIN]]
SQLITE_SCANSTAT_EXPLAIN
+**
^The "const char *" variable pointed to by the T parameter will be set +** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN] +** description for the X-th loop. +** +** [[SQLITE_SCANSTAT_SELECTID]]
SQLITE_SCANSTAT_SELECT
+**
^The "int" variable pointed to by the T parameter will be set to the +** "select-id" for the X-th loop. The select-id identifies which query or +** subquery the loop is part of. The main query has a select-id of zero. +** The select-id is the same value as is output in the first column +** of an [EXPLAIN QUERY PLAN] query. +**
+*/ +#define SQLITE_SCANSTAT_NLOOP 0 +#define SQLITE_SCANSTAT_NVISIT 1 +#define SQLITE_SCANSTAT_EST 2 +#define SQLITE_SCANSTAT_NAME 3 +#define SQLITE_SCANSTAT_EXPLAIN 4 +#define SQLITE_SCANSTAT_SELECTID 5 + +/* +** CAPI3REF: Prepared Statement Scan Status +** METHOD: sqlite3_stmt +** +** This interface returns information about the predicted and measured +** performance for pStmt. Advanced applications can use this +** interface to compare the predicted and the measured performance and +** issue warnings and/or rerun [ANALYZE] if discrepancies are found. +** +** Since this interface is expected to be rarely used, it is only +** available if SQLite is compiled using the [SQLITE_ENABLE_STMT_SCANSTATUS] +** compile-time option. +** +** The "iScanStatusOp" parameter determines which status information to return. +** The "iScanStatusOp" must be one of the [scanstatus options] or the behavior +** of this interface is undefined. +** ^The requested measurement is written into a variable pointed to by +** the "pOut" parameter. +** Parameter "idx" identifies the specific loop to retrieve statistics for. +** Loops are numbered starting from zero. ^If idx is out of range - less than +** zero or greater than or equal to the total number of loops used to implement +** the statement - a non-zero value is returned and the variable that pOut +** points to is unchanged. +** +** ^Statistics might not be available for all loops in all statements. ^In cases +** where there exist loops with no available statistics, this function behaves +** as if the loop did not exist - it returns non-zero and leave the variable +** that pOut points to unchanged. +** +** See also: [sqlite3_stmt_scanstatus_reset()] +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_stmt_scanstatus( + sqlite3_stmt *pStmt, /* Prepared statement for which info desired */ + int idx, /* Index of loop to report on */ + int iScanStatusOp, /* Information desired. SQLITE_SCANSTAT_* */ + void *pOut /* Result written here */ +); + +/* +** CAPI3REF: Zero Scan-Status Counters +** METHOD: sqlite3_stmt +** +** ^Zero all [sqlite3_stmt_scanstatus()] related event counters. +** +** This API is only available if the library is built with pre-processor +** symbol [SQLITE_ENABLE_STMT_SCANSTATUS] defined. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_stmt_scanstatus_reset(sqlite3_stmt*); + + +/* +** Undo the hack that converts floating point types to integer for +** builds on processors without floating point support. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# undef double +#endif + +#if 0 +} /* End of the 'extern "C"' block */ +#endif +#endif /* _SQLITE3_H_ */ + +/* +** 2010 August 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +*/ + +#ifndef _SQLITE3RTREE_H_ +#define _SQLITE3RTREE_H_ + + +#if 0 +extern "C" { +#endif + +typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry; +typedef struct sqlite3_rtree_query_info sqlite3_rtree_query_info; + +/* The double-precision datatype used by RTree depends on the +** SQLITE_RTREE_INT_ONLY compile-time option. +*/ +#ifdef SQLITE_RTREE_INT_ONLY + typedef sqlite3_int64 sqlite3_rtree_dbl; +#else + typedef double sqlite3_rtree_dbl; +#endif + +/* +** Register a geometry callback named zGeom that can be used as part of an +** R-Tree geometry query as follows: +** +** SELECT ... FROM WHERE MATCH $zGeom(... params ...) +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_rtree_geometry_callback( + sqlite3 *db, + const char *zGeom, + int (*xGeom)(sqlite3_rtree_geometry*, int, sqlite3_rtree_dbl*,int*), + void *pContext +); + + +/* +** A pointer to a structure of the following type is passed as the first +** argument to callbacks registered using rtree_geometry_callback(). +*/ +struct sqlite3_rtree_geometry { + void *pContext; /* Copy of pContext passed to s_r_g_c() */ + int nParam; /* Size of array aParam[] */ + sqlite3_rtree_dbl *aParam; /* Parameters passed to SQL geom function */ + void *pUser; /* Callback implementation user data */ + void (*xDelUser)(void *); /* Called by SQLite to clean up pUser */ +}; + +/* +** Register a 2nd-generation geometry callback named zScore that can be +** used as part of an R-Tree geometry query as follows: +** +** SELECT ... FROM WHERE MATCH $zQueryFunc(... params ...) +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_rtree_query_callback( + sqlite3 *db, + const char *zQueryFunc, + int (*xQueryFunc)(sqlite3_rtree_query_info*), + void *pContext, + void (*xDestructor)(void*) +); + + +/* +** A pointer to a structure of the following type is passed as the +** argument to scored geometry callback registered using +** sqlite3_rtree_query_callback(). +** +** Note that the first 5 fields of this structure are identical to +** sqlite3_rtree_geometry. This structure is a subclass of +** sqlite3_rtree_geometry. +*/ +struct sqlite3_rtree_query_info { + void *pContext; /* pContext from when function registered */ + int nParam; /* Number of function parameters */ + sqlite3_rtree_dbl *aParam; /* value of function parameters */ + void *pUser; /* callback can use this, if desired */ + void (*xDelUser)(void*); /* function to free pUser */ + sqlite3_rtree_dbl *aCoord; /* Coordinates of node or entry to check */ + unsigned int *anQueue; /* Number of pending entries in the queue */ + int nCoord; /* Number of coordinates */ + int iLevel; /* Level of current node or entry */ + int mxLevel; /* The largest iLevel value in the tree */ + sqlite3_int64 iRowid; /* Rowid for current entry */ + sqlite3_rtree_dbl rParentScore; /* Score of parent node */ + int eParentWithin; /* Visibility of parent node */ + int eWithin; /* OUT: Visiblity */ + sqlite3_rtree_dbl rScore; /* OUT: Write the score here */ + /* The following fields are only available in 3.8.11 and later */ + sqlite3_value **apSqlParam; /* Original SQL values of parameters */ +}; + +/* +** Allowed values for sqlite3_rtree_query.eWithin and .eParentWithin. +*/ +#define NOT_WITHIN 0 /* Object completely outside of query region */ +#define PARTLY_WITHIN 1 /* Object partially overlaps query region */ +#define FULLY_WITHIN 2 /* Object fully contained within query region */ + + +#if 0 +} /* end of the 'extern "C"' block */ +#endif + +#endif /* ifndef _SQLITE3RTREE_H_ */ + +/* +** 2014 May 31 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** Interfaces to extend FTS5. Using the interfaces defined in this file, +** FTS5 may be extended with: +** +** * custom tokenizers, and +** * custom auxiliary functions. +*/ + + +#ifndef _FTS5_H +#define _FTS5_H + + +#if 0 +extern "C" { +#endif + +/************************************************************************* +** CUSTOM AUXILIARY FUNCTIONS +** +** Virtual table implementations may overload SQL functions by implementing +** the sqlite3_module.xFindFunction() method. +*/ + +typedef struct Fts5ExtensionApi Fts5ExtensionApi; +typedef struct Fts5Context Fts5Context; +typedef struct Fts5PhraseIter Fts5PhraseIter; + +typedef void (*fts5_extension_function)( + const Fts5ExtensionApi *pApi, /* API offered by current FTS version */ + Fts5Context *pFts, /* First arg to pass to pApi functions */ + sqlite3_context *pCtx, /* Context for returning result/error */ + int nVal, /* Number of values in apVal[] array */ + sqlite3_value **apVal /* Array of trailing arguments */ +); + +struct Fts5PhraseIter { + const unsigned char *a; + const unsigned char *b; +}; + +/* +** EXTENSION API FUNCTIONS +** +** xUserData(pFts): +** Return a copy of the context pointer the extension function was +** registered with. +** +** xColumnTotalSize(pFts, iCol, pnToken): +** If parameter iCol is less than zero, set output variable *pnToken +** to the total number of tokens in the FTS5 table. Or, if iCol is +** non-negative but less than the number of columns in the table, return +** the total number of tokens in column iCol, considering all rows in +** the FTS5 table. +** +** If parameter iCol is greater than or equal to the number of columns +** in the table, SQLITE_RANGE is returned. Or, if an error occurs (e.g. +** an OOM condition or IO error), an appropriate SQLite error code is +** returned. +** +** xColumnCount(pFts): +** Return the number of columns in the table. +** +** xColumnSize(pFts, iCol, pnToken): +** If parameter iCol is less than zero, set output variable *pnToken +** to the total number of tokens in the current row. Or, if iCol is +** non-negative but less than the number of columns in the table, set +** *pnToken to the number of tokens in column iCol of the current row. +** +** If parameter iCol is greater than or equal to the number of columns +** in the table, SQLITE_RANGE is returned. Or, if an error occurs (e.g. +** an OOM condition or IO error), an appropriate SQLite error code is +** returned. +** +** xColumnText: +** This function attempts to retrieve the text of column iCol of the +** current document. If successful, (*pz) is set to point to a buffer +** containing the text in utf-8 encoding, (*pn) is set to the size in bytes +** (not characters) of the buffer and SQLITE_OK is returned. Otherwise, +** if an error occurs, an SQLite error code is returned and the final values +** of (*pz) and (*pn) are undefined. +** +** xPhraseCount: +** Returns the number of phrases in the current query expression. +** +** xPhraseSize: +** Returns the number of tokens in phrase iPhrase of the query. Phrases +** are numbered starting from zero. +** +** xInstCount: +** Set *pnInst to the total number of occurrences of all phrases within +** the query within the current row. Return SQLITE_OK if successful, or +** an error code (i.e. SQLITE_NOMEM) if an error occurs. +** +** xInst: +** Query for the details of phrase match iIdx within the current row. +** Phrase matches are numbered starting from zero, so the iIdx argument +** should be greater than or equal to zero and smaller than the value +** output by xInstCount(). +** +** Returns SQLITE_OK if successful, or an error code (i.e. SQLITE_NOMEM) +** if an error occurs. +** +** xRowid: +** Returns the rowid of the current row. +** +** xTokenize: +** Tokenize text using the tokenizer belonging to the FTS5 table. +** +** xQueryPhrase(pFts5, iPhrase, pUserData, xCallback): +** This API function is used to query the FTS table for phrase iPhrase +** of the current query. Specifically, a query equivalent to: +** +** ... FROM ftstable WHERE ftstable MATCH $p ORDER BY rowid +** +** with $p set to a phrase equivalent to the phrase iPhrase of the +** current query is executed. For each row visited, the callback function +** passed as the fourth argument is invoked. The context and API objects +** passed to the callback function may be used to access the properties of +** each matched row. Invoking Api.xUserData() returns a copy of the pointer +** passed as the third argument to pUserData. +** +** If the callback function returns any value other than SQLITE_OK, the +** query is abandoned and the xQueryPhrase function returns immediately. +** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK. +** Otherwise, the error code is propagated upwards. +** +** If the query runs to completion without incident, SQLITE_OK is returned. +** Or, if some error occurs before the query completes or is aborted by +** the callback, an SQLite error code is returned. +** +** +** xSetAuxdata(pFts5, pAux, xDelete) +** +** Save the pointer passed as the second argument as the extension functions +** "auxiliary data". The pointer may then be retrieved by the current or any +** future invocation of the same fts5 extension function made as part of +** of the same MATCH query using the xGetAuxdata() API. +** +** Each extension function is allocated a single auxiliary data slot for +** each FTS query (MATCH expression). If the extension function is invoked +** more than once for a single FTS query, then all invocations share a +** single auxiliary data context. +** +** If there is already an auxiliary data pointer when this function is +** invoked, then it is replaced by the new pointer. If an xDelete callback +** was specified along with the original pointer, it is invoked at this +** point. +** +** The xDelete callback, if one is specified, is also invoked on the +** auxiliary data pointer after the FTS5 query has finished. +** +** If an error (e.g. an OOM condition) occurs within this function, an +** the auxiliary data is set to NULL and an error code returned. If the +** xDelete parameter was not NULL, it is invoked on the auxiliary data +** pointer before returning. +** +** +** xGetAuxdata(pFts5, bClear) +** +** Returns the current auxiliary data pointer for the fts5 extension +** function. See the xSetAuxdata() method for details. +** +** If the bClear argument is non-zero, then the auxiliary data is cleared +** (set to NULL) before this function returns. In this case the xDelete, +** if any, is not invoked. +** +** +** xRowCount(pFts5, pnRow) +** +** This function is used to retrieve the total number of rows in the table. +** In other words, the same value that would be returned by: +** +** SELECT count(*) FROM ftstable; +** +** xPhraseFirst() +** This function is used, along with type Fts5PhraseIter and the xPhraseNext +** method, to iterate through all instances of a single query phrase within +** the current row. This is the same information as is accessible via the +** xInstCount/xInst APIs. While the xInstCount/xInst APIs are more convenient +** to use, this API may be faster under some circumstances. To iterate +** through instances of phrase iPhrase, use the following code: +** +** Fts5PhraseIter iter; +** int iCol, iOff; +** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff); +** iOff>=0; +** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff) +** ){ +** // An instance of phrase iPhrase at offset iOff of column iCol +** } +** +** The Fts5PhraseIter structure is defined above. Applications should not +** modify this structure directly - it should only be used as shown above +** with the xPhraseFirst() and xPhraseNext() API methods. +** +** xPhraseNext() +** See xPhraseFirst above. +*/ +struct Fts5ExtensionApi { + int iVersion; /* Currently always set to 1 */ + + void *(*xUserData)(Fts5Context*); + + int (*xColumnCount)(Fts5Context*); + int (*xRowCount)(Fts5Context*, sqlite3_int64 *pnRow); + int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken); + + int (*xTokenize)(Fts5Context*, + const char *pText, int nText, /* Text to tokenize */ + void *pCtx, /* Context passed to xToken() */ + int (*xToken)(void*, int, const char*, int, int, int) /* Callback */ + ); + + int (*xPhraseCount)(Fts5Context*); + int (*xPhraseSize)(Fts5Context*, int iPhrase); + + int (*xInstCount)(Fts5Context*, int *pnInst); + int (*xInst)(Fts5Context*, int iIdx, int *piPhrase, int *piCol, int *piOff); + + sqlite3_int64 (*xRowid)(Fts5Context*); + int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn); + int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken); + + int (*xQueryPhrase)(Fts5Context*, int iPhrase, void *pUserData, + int(*)(const Fts5ExtensionApi*,Fts5Context*,void*) + ); + int (*xSetAuxdata)(Fts5Context*, void *pAux, void(*xDelete)(void*)); + void *(*xGetAuxdata)(Fts5Context*, int bClear); + + void (*xPhraseFirst)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*, int*); + void (*xPhraseNext)(Fts5Context*, Fts5PhraseIter*, int *piCol, int *piOff); +}; + +/* +** CUSTOM AUXILIARY FUNCTIONS +*************************************************************************/ + +/************************************************************************* +** CUSTOM TOKENIZERS +** +** Applications may also register custom tokenizer types. A tokenizer +** is registered by providing fts5 with a populated instance of the +** following structure. All structure methods must be defined, setting +** any member of the fts5_tokenizer struct to NULL leads to undefined +** behaviour. The structure methods are expected to function as follows: +** +** xCreate: +** This function is used to allocate and inititalize a tokenizer instance. +** A tokenizer instance is required to actually tokenize text. +** +** The first argument passed to this function is a copy of the (void*) +** pointer provided by the application when the fts5_tokenizer object +** was registered with FTS5 (the third argument to xCreateTokenizer()). +** The second and third arguments are an array of nul-terminated strings +** containing the tokenizer arguments, if any, specified following the +** tokenizer name as part of the CREATE VIRTUAL TABLE statement used +** to create the FTS5 table. +** +** The final argument is an output variable. If successful, (*ppOut) +** should be set to point to the new tokenizer handle and SQLITE_OK +** returned. If an error occurs, some value other than SQLITE_OK should +** be returned. In this case, fts5 assumes that the final value of *ppOut +** is undefined. +** +** xDelete: +** This function is invoked to delete a tokenizer handle previously +** allocated using xCreate(). Fts5 guarantees that this function will +** be invoked exactly once for each successful call to xCreate(). +** +** xTokenize: +** This function is expected to tokenize the nText byte string indicated +** by argument pText. pText may or may not be nul-terminated. The first +** argument passed to this function is a pointer to an Fts5Tokenizer object +** returned by an earlier call to xCreate(). +** +** The second argument indicates the reason that FTS5 is requesting +** tokenization of the supplied text. This is always one of the following +** four values: +** +**
  • FTS5_TOKENIZE_DOCUMENT - A document is being inserted into +** or removed from the FTS table. The tokenizer is being invoked to +** determine the set of tokens to add to (or delete from) the +** FTS index. +** +**
  • FTS5_TOKENIZE_QUERY - A MATCH query is being executed +** against the FTS index. The tokenizer is being called to tokenize +** a bareword or quoted string specified as part of the query. +** +**
  • (FTS5_TOKENIZE_QUERY | FTS5_TOKENIZE_PREFIX) - Same as +** FTS5_TOKENIZE_QUERY, except that the bareword or quoted string is +** followed by a "*" character, indicating that the last token +** returned by the tokenizer will be treated as a token prefix. +** +**
  • FTS5_TOKENIZE_AUX - The tokenizer is being invoked to +** satisfy an fts5_api.xTokenize() request made by an auxiliary +** function. Or an fts5_api.xColumnSize() request made by the same +** on a columnsize=0 database. +**
+** +** For each token in the input string, the supplied callback xToken() must +** be invoked. The first argument to it should be a copy of the pointer +** passed as the second argument to xTokenize(). The third and fourth +** arguments are a pointer to a buffer containing the token text, and the +** size of the token in bytes. The 4th and 5th arguments are the byte offsets +** of the first byte of and first byte immediately following the text from +** which the token is derived within the input. +** +** The second argument passed to the xToken() callback ("tflags") should +** normally be set to 0. The exception is if the tokenizer supports +** synonyms. In this case see the discussion below for details. +** +** FTS5 assumes the xToken() callback is invoked for each token in the +** order that they occur within the input text. +** +** If an xToken() callback returns any value other than SQLITE_OK, then +** the tokenization should be abandoned and the xTokenize() method should +** immediately return a copy of the xToken() return value. Or, if the +** input buffer is exhausted, xTokenize() should return SQLITE_OK. Finally, +** if an error occurs with the xTokenize() implementation itself, it +** may abandon the tokenization and return any error code other than +** SQLITE_OK or SQLITE_DONE. +** +** SYNONYM SUPPORT +** +** Custom tokenizers may also support synonyms. Consider a case in which a +** user wishes to query for a phrase such as "first place". Using the +** built-in tokenizers, the FTS5 query 'first + place' will match instances +** of "first place" within the document set, but not alternative forms +** such as "1st place". In some applications, it would be better to match +** all instances of "first place" or "1st place" regardless of which form +** the user specified in the MATCH query text. +** +** There are several ways to approach this in FTS5: +** +**
  1. By mapping all synonyms to a single token. In this case, the +** In the above example, this means that the tokenizer returns the +** same token for inputs "first" and "1st". Say that token is in +** fact "first", so that when the user inserts the document "I won +** 1st place" entries are added to the index for tokens "i", "won", +** "first" and "place". If the user then queries for '1st + place', +** the tokenizer substitutes "first" for "1st" and the query works +** as expected. +** +**
  2. By adding multiple synonyms for a single term to the FTS index. +** In this case, when tokenizing query text, the tokenizer may +** provide multiple synonyms for a single term within the document. +** FTS5 then queries the index for each synonym individually. For +** example, faced with the query: +** +** +** ... MATCH 'first place' +** +** the tokenizer offers both "1st" and "first" as synonyms for the +** first token in the MATCH query and FTS5 effectively runs a query +** similar to: +** +** +** ... MATCH '(first OR 1st) place' +** +** except that, for the purposes of auxiliary functions, the query +** still appears to contain just two phrases - "(first OR 1st)" +** being treated as a single phrase. +** +**
  3. By adding multiple synonyms for a single term to the FTS index. +** Using this method, when tokenizing document text, the tokenizer +** provides multiple synonyms for each token. So that when a +** document such as "I won first place" is tokenized, entries are +** added to the FTS index for "i", "won", "first", "1st" and +** "place". +** +** This way, even if the tokenizer does not provide synonyms +** when tokenizing query text (it should not - to do would be +** inefficient), it doesn't matter if the user queries for +** 'first + place' or '1st + place', as there are entires in the +** FTS index corresponding to both forms of the first token. +**
+** +** Whether it is parsing document or query text, any call to xToken that +** specifies a tflags argument with the FTS5_TOKEN_COLOCATED bit +** is considered to supply a synonym for the previous token. For example, +** when parsing the document "I won first place", a tokenizer that supports +** synonyms would call xToken() 5 times, as follows: +** +** +** xToken(pCtx, 0, "i", 1, 0, 1); +** xToken(pCtx, 0, "won", 3, 2, 5); +** xToken(pCtx, 0, "first", 5, 6, 11); +** xToken(pCtx, FTS5_TOKEN_COLOCATED, "1st", 3, 6, 11); +** xToken(pCtx, 0, "place", 5, 12, 17); +** +** +** It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time +** xToken() is called. Multiple synonyms may be specified for a single token +** by making multiple calls to xToken(FTS5_TOKEN_COLOCATED) in sequence. +** There is no limit to the number of synonyms that may be provided for a +** single token. +** +** In many cases, method (1) above is the best approach. It does not add +** extra data to the FTS index or require FTS5 to query for multiple terms, +** so it is efficient in terms of disk space and query speed. However, it +** does not support prefix queries very well. If, as suggested above, the +** token "first" is subsituted for "1st" by the tokenizer, then the query: +** +** +** ... MATCH '1s*' +** +** will not match documents that contain the token "1st" (as the tokenizer +** will probably not map "1s" to any prefix of "first"). +** +** For full prefix support, method (3) may be preferred. In this case, +** because the index contains entries for both "first" and "1st", prefix +** queries such as 'fi*' or '1s*' will match correctly. However, because +** extra entries are added to the FTS index, this method uses more space +** within the database. +** +** Method (2) offers a midpoint between (1) and (3). Using this method, +** a query such as '1s*' will match documents that contain the literal +** token "1st", but not "first" (assuming the tokenizer is not able to +** provide synonyms for prefixes). However, a non-prefix query like '1st' +** will match against "1st" and "first". This method does not require +** extra disk space, as no extra entries are added to the FTS index. +** On the other hand, it may require more CPU cycles to run MATCH queries, +** as separate queries of the FTS index are required for each synonym. +** +** When using methods (2) or (3), it is important that the tokenizer only +** provide synonyms when tokenizing document text (method (2)) or query +** text (method (3)), not both. Doing so will not cause any errors, but is +** inefficient. +*/ +typedef struct Fts5Tokenizer Fts5Tokenizer; +typedef struct fts5_tokenizer fts5_tokenizer; +struct fts5_tokenizer { + int (*xCreate)(void*, const char **azArg, int nArg, Fts5Tokenizer **ppOut); + void (*xDelete)(Fts5Tokenizer*); + int (*xTokenize)(Fts5Tokenizer*, + void *pCtx, + int flags, /* Mask of FTS5_TOKENIZE_* flags */ + const char *pText, int nText, + int (*xToken)( + void *pCtx, /* Copy of 2nd argument to xTokenize() */ + int tflags, /* Mask of FTS5_TOKEN_* flags */ + const char *pToken, /* Pointer to buffer containing token */ + int nToken, /* Size of token in bytes */ + int iStart, /* Byte offset of token within input text */ + int iEnd /* Byte offset of end of token within input text */ + ) + ); +}; + +/* Flags that may be passed as the third argument to xTokenize() */ +#define FTS5_TOKENIZE_QUERY 0x0001 +#define FTS5_TOKENIZE_PREFIX 0x0002 +#define FTS5_TOKENIZE_DOCUMENT 0x0004 +#define FTS5_TOKENIZE_AUX 0x0008 + +/* Flags that may be passed by the tokenizer implementation back to FTS5 +** as the third argument to the supplied xToken callback. */ +#define FTS5_TOKEN_COLOCATED 0x0001 /* Same position as prev. token */ + +/* +** END OF CUSTOM TOKENIZERS +*************************************************************************/ + +/************************************************************************* +** FTS5 EXTENSION REGISTRATION API +*/ +typedef struct fts5_api fts5_api; +struct fts5_api { + int iVersion; /* Currently always set to 2 */ + + /* Create a new tokenizer */ + int (*xCreateTokenizer)( + fts5_api *pApi, + const char *zName, + void *pContext, + fts5_tokenizer *pTokenizer, + void (*xDestroy)(void*) + ); + + /* Find an existing tokenizer */ + int (*xFindTokenizer)( + fts5_api *pApi, + const char *zName, + void **ppContext, + fts5_tokenizer *pTokenizer + ); + + /* Create a new auxiliary function */ + int (*xCreateFunction)( + fts5_api *pApi, + const char *zName, + void *pContext, + fts5_extension_function xFunction, + void (*xDestroy)(void*) + ); +}; + +/* +** END OF REGISTRATION API +*************************************************************************/ + +#if 0 +} /* end of the 'extern "C"' block */ +#endif + +#endif /* _FTS5_H */ + + + +/************** End of sqlite3.h *********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* +** Include the configuration header output by 'configure' if we're using the +** autoconf-based build +*/ +#ifdef _HAVE_SQLITE_CONFIG_H +#include "config.h" +#endif + +/************** Include sqliteLimit.h in the middle of sqliteInt.h ***********/ +/************** Begin file sqliteLimit.h *************************************/ +/* +** 2007 May 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file defines various limits of what SQLite can process. +*/ + +/* +** The maximum length of a TEXT or BLOB in bytes. This also +** limits the size of a row in a table or index. +** +** The hard limit is the ability of a 32-bit signed integer +** to count the size: 2^31-1 or 2147483647. +*/ +#ifndef SQLITE_MAX_LENGTH +# define SQLITE_MAX_LENGTH 1000000000 +#endif + +/* +** This is the maximum number of +** +** * Columns in a table +** * Columns in an index +** * Columns in a view +** * Terms in the SET clause of an UPDATE statement +** * Terms in the result set of a SELECT statement +** * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement. +** * Terms in the VALUES clause of an INSERT statement +** +** The hard upper limit here is 32676. Most database people will +** tell you that in a well-normalized database, you usually should +** not have more than a dozen or so columns in any table. And if +** that is the case, there is no point in having more than a few +** dozen values in any of the other situations described above. +*/ +#ifndef SQLITE_MAX_COLUMN +# define SQLITE_MAX_COLUMN 2000 +#endif + +/* +** The maximum length of a single SQL statement in bytes. +** +** It used to be the case that setting this value to zero would +** turn the limit off. That is no longer true. It is not possible +** to turn this limit off. +*/ +#ifndef SQLITE_MAX_SQL_LENGTH +# define SQLITE_MAX_SQL_LENGTH 1000000000 +#endif + +/* +** The maximum depth of an expression tree. This is limited to +** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might +** want to place more severe limits on the complexity of an +** expression. +** +** A value of 0 used to mean that the limit was not enforced. +** But that is no longer true. The limit is now strictly enforced +** at all times. +*/ +#ifndef SQLITE_MAX_EXPR_DEPTH +# define SQLITE_MAX_EXPR_DEPTH 1000 +#endif + +/* +** The maximum number of terms in a compound SELECT statement. +** The code generator for compound SELECT statements does one +** level of recursion for each term. A stack overflow can result +** if the number of terms is too large. In practice, most SQL +** never has more than 3 or 4 terms. Use a value of 0 to disable +** any limit on the number of terms in a compount SELECT. +*/ +#ifndef SQLITE_MAX_COMPOUND_SELECT +# define SQLITE_MAX_COMPOUND_SELECT 500 +#endif + +/* +** The maximum number of opcodes in a VDBE program. +** Not currently enforced. +*/ +#ifndef SQLITE_MAX_VDBE_OP +# define SQLITE_MAX_VDBE_OP 25000 +#endif + +/* +** The maximum number of arguments to an SQL function. +*/ +#ifndef SQLITE_MAX_FUNCTION_ARG +# define SQLITE_MAX_FUNCTION_ARG 127 +#endif + +/* +** The suggested maximum number of in-memory pages to use for +** the main database table and for temporary tables. +** +** IMPLEMENTATION-OF: R-31093-59126 The default suggested cache size +** is 2000 pages. +** IMPLEMENTATION-OF: R-48205-43578 The default suggested cache size can be +** altered using the SQLITE_DEFAULT_CACHE_SIZE compile-time options. +*/ +#ifndef SQLITE_DEFAULT_CACHE_SIZE +# define SQLITE_DEFAULT_CACHE_SIZE 2000 +#endif + +/* +** The default number of frames to accumulate in the log file before +** checkpointing the database in WAL mode. +*/ +#ifndef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT +# define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000 +#endif + +/* +** The maximum number of attached databases. This must be between 0 +** and 62. The upper bound on 62 is because a 64-bit integer bitmap +** is used internally to track attached databases. +*/ +#ifndef SQLITE_MAX_ATTACHED +# define SQLITE_MAX_ATTACHED 10 +#endif + + +/* +** The maximum value of a ?nnn wildcard that the parser will accept. +*/ +#ifndef SQLITE_MAX_VARIABLE_NUMBER +# define SQLITE_MAX_VARIABLE_NUMBER 999 +#endif + +/* Maximum page size. The upper bound on this value is 65536. This a limit +** imposed by the use of 16-bit offsets within each page. +** +** Earlier versions of SQLite allowed the user to change this value at +** compile time. This is no longer permitted, on the grounds that it creates +** a library that is technically incompatible with an SQLite library +** compiled with a different limit. If a process operating on a database +** with a page-size of 65536 bytes crashes, then an instance of SQLite +** compiled with the default page-size limit will not be able to rollback +** the aborted transaction. This could lead to database corruption. +*/ +#ifdef SQLITE_MAX_PAGE_SIZE +# undef SQLITE_MAX_PAGE_SIZE +#endif +#define SQLITE_MAX_PAGE_SIZE 65536 + + +/* +** The default size of a database page. +*/ +#ifndef SQLITE_DEFAULT_PAGE_SIZE +# define SQLITE_DEFAULT_PAGE_SIZE 1024 +#endif +#if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE +# undef SQLITE_DEFAULT_PAGE_SIZE +# define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE +#endif + +/* +** Ordinarily, if no value is explicitly provided, SQLite creates databases +** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain +** device characteristics (sector-size and atomic write() support), +** SQLite may choose a larger value. This constant is the maximum value +** SQLite will choose on its own. +*/ +#ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE +# define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192 +#endif +#if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE +# undef SQLITE_MAX_DEFAULT_PAGE_SIZE +# define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE +#endif + + +/* +** Maximum number of pages in one database file. +** +** This is really just the default value for the max_page_count pragma. +** This value can be lowered (or raised) at run-time using that the +** max_page_count macro. +*/ +#ifndef SQLITE_MAX_PAGE_COUNT +# define SQLITE_MAX_PAGE_COUNT 1073741823 +#endif + +/* +** Maximum length (in bytes) of the pattern in a LIKE or GLOB +** operator. +*/ +#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH +# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 +#endif + +/* +** Maximum depth of recursion for triggers. +** +** A value of 1 means that a trigger program will not be able to itself +** fire any triggers. A value of 0 means that no trigger programs at all +** may be executed. +*/ +#ifndef SQLITE_MAX_TRIGGER_DEPTH +# define SQLITE_MAX_TRIGGER_DEPTH 1000 +#endif + +/************** End of sqliteLimit.h *****************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* Disable nuisance warnings on Borland compilers */ +#if defined(__BORLANDC__) +#pragma warn -rch /* unreachable code */ +#pragma warn -ccc /* Condition is always true or false */ +#pragma warn -aus /* Assigned value is never used */ +#pragma warn -csu /* Comparing signed and unsigned */ +#pragma warn -spa /* Suspicious pointer arithmetic */ +#endif + +/* +** Include standard header files as necessary +*/ +#ifdef HAVE_STDINT_H +#include +#endif +#ifdef HAVE_INTTYPES_H +#include +#endif + +/* +** The following macros are used to cast pointers to integers and +** integers to pointers. The way you do this varies from one compiler +** to the next, so we have developed the following set of #if statements +** to generate appropriate macros for a wide range of compilers. +** +** The correct "ANSI" way to do this is to use the intptr_t type. +** Unfortunately, that typedef is not available on all compilers, or +** if it is available, it requires an #include of specific headers +** that vary from one machine to the next. +** +** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on +** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)). +** So we have to define the macros in different ways depending on the +** compiler. +*/ +#if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */ +# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X)) +#elif !defined(__GNUC__) /* Works for compilers other than LLVM */ +# define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X]) +# define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0)) +#elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */ +# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X)) +#else /* Generates a warning - but it always works */ +# define SQLITE_INT_TO_PTR(X) ((void*)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(X)) +#endif + +/* +** A macro to hint to the compiler that a function should not be +** inlined. +*/ +#if defined(__GNUC__) +# define SQLITE_NOINLINE __attribute__((noinline)) +#elif defined(_MSC_VER) && _MSC_VER>=1310 +# define SQLITE_NOINLINE __declspec(noinline) +#else +# define SQLITE_NOINLINE +#endif + +/* +** Make sure that the compiler intrinsics we desire are enabled when +** compiling with an appropriate version of MSVC unless prevented by +** the SQLITE_DISABLE_INTRINSIC define. +*/ +#if !defined(SQLITE_DISABLE_INTRINSIC) +# if defined(_MSC_VER) && _MSC_VER>=1300 +# if !defined(_WIN32_WCE) +# include +# pragma intrinsic(_byteswap_ushort) +# pragma intrinsic(_byteswap_ulong) +# pragma intrinsic(_ReadWriteBarrier) +# else +# include +# endif +# endif +#endif + +/* +** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2. +** 0 means mutexes are permanently disable and the library is never +** threadsafe. 1 means the library is serialized which is the highest +** level of threadsafety. 2 means the library is multithreaded - multiple +** threads can use SQLite as long as no two threads try to use the same +** database connection at the same time. +** +** Older versions of SQLite used an optional THREADSAFE macro. +** We support that for legacy. +*/ +#if !defined(SQLITE_THREADSAFE) +# if defined(THREADSAFE) +# define SQLITE_THREADSAFE THREADSAFE +# else +# define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */ +# endif +#endif + +/* +** Powersafe overwrite is on by default. But can be turned off using +** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option. +*/ +#ifndef SQLITE_POWERSAFE_OVERWRITE +# define SQLITE_POWERSAFE_OVERWRITE 1 +#endif + +/* +** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by +** default unless SQLite is compiled with SQLITE_DEFAULT_MEMSTATUS=0 in +** which case memory allocation statistics are disabled by default. +*/ +#if !defined(SQLITE_DEFAULT_MEMSTATUS) +# define SQLITE_DEFAULT_MEMSTATUS 1 +#endif + +/* +** Exactly one of the following macros must be defined in order to +** specify which memory allocation subsystem to use. +** +** SQLITE_SYSTEM_MALLOC // Use normal system malloc() +** SQLITE_WIN32_MALLOC // Use Win32 native heap API +** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails +** SQLITE_MEMDEBUG // Debugging version of system malloc() +** +** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the +** assert() macro is enabled, each call into the Win32 native heap subsystem +** will cause HeapValidate to be called. If heap validation should fail, an +** assertion will be triggered. +** +** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as +** the default. +*/ +#if defined(SQLITE_SYSTEM_MALLOC) \ + + defined(SQLITE_WIN32_MALLOC) \ + + defined(SQLITE_ZERO_MALLOC) \ + + defined(SQLITE_MEMDEBUG)>1 +# error "Two or more of the following compile-time configuration options\ + are defined but at most one is allowed:\ + SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\ + SQLITE_ZERO_MALLOC" +#endif +#if defined(SQLITE_SYSTEM_MALLOC) \ + + defined(SQLITE_WIN32_MALLOC) \ + + defined(SQLITE_ZERO_MALLOC) \ + + defined(SQLITE_MEMDEBUG)==0 +# define SQLITE_SYSTEM_MALLOC 1 +#endif + +/* +** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the +** sizes of memory allocations below this value where possible. +*/ +#if !defined(SQLITE_MALLOC_SOFT_LIMIT) +# define SQLITE_MALLOC_SOFT_LIMIT 1024 +#endif + +/* +** We need to define _XOPEN_SOURCE as follows in order to enable +** recursive mutexes on most Unix systems and fchmod() on OpenBSD. +** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit +** it. +*/ +#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) +# define _XOPEN_SOURCE 600 +#endif + +/* +** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that +** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true, +** make it true by defining or undefining NDEBUG. +** +** Setting NDEBUG makes the code smaller and faster by disabling the +** assert() statements in the code. So we want the default action +** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG +** is set. Thus NDEBUG becomes an opt-in rather than an opt-out +** feature. +*/ +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif +#if defined(NDEBUG) && defined(SQLITE_DEBUG) +# undef NDEBUG +#endif + +/* +** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on. +*/ +#if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG) +# define SQLITE_ENABLE_EXPLAIN_COMMENTS 1 +#endif + +/* +** The testcase() macro is used to aid in coverage testing. When +** doing coverage testing, the condition inside the argument to +** testcase() must be evaluated both true and false in order to +** get full branch coverage. The testcase() macro is inserted +** to help ensure adequate test coverage in places where simple +** condition/decision coverage is inadequate. For example, testcase() +** can be used to make sure boundary values are tested. For +** bitmask tests, testcase() can be used to make sure each bit +** is significant and used at least once. On switch statements +** where multiple cases go to the same block of code, testcase() +** can insure that all cases are evaluated. +** +*/ +#ifdef SQLITE_COVERAGE_TEST +SQLITE_PRIVATE void sqlite3Coverage(int); +# define testcase(X) if( X ){ sqlite3Coverage(__LINE__); } +#else +# define testcase(X) +#endif + +/* +** The TESTONLY macro is used to enclose variable declarations or +** other bits of code that are needed to support the arguments +** within testcase() and assert() macros. +*/ +#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST) +# define TESTONLY(X) X +#else +# define TESTONLY(X) +#endif + +/* +** Sometimes we need a small amount of code such as a variable initialization +** to setup for a later assert() statement. We do not want this code to +** appear when assert() is disabled. The following macro is therefore +** used to contain that setup code. The "VVA" acronym stands for +** "Verification, Validation, and Accreditation". In other words, the +** code within VVA_ONLY() will only run during verification processes. +*/ +#ifndef NDEBUG +# define VVA_ONLY(X) X +#else +# define VVA_ONLY(X) +#endif + +/* +** The ALWAYS and NEVER macros surround boolean expressions which +** are intended to always be true or false, respectively. Such +** expressions could be omitted from the code completely. But they +** are included in a few cases in order to enhance the resilience +** of SQLite to unexpected behavior - to make the code "self-healing" +** or "ductile" rather than being "brittle" and crashing at the first +** hint of unplanned behavior. +** +** In other words, ALWAYS and NEVER are added for defensive code. +** +** When doing coverage testing ALWAYS and NEVER are hard-coded to +** be true and false so that the unreachable code they specify will +** not be counted as untested code. +*/ +#if defined(SQLITE_COVERAGE_TEST) +# define ALWAYS(X) (1) +# define NEVER(X) (0) +#elif !defined(NDEBUG) +# define ALWAYS(X) ((X)?1:(assert(0),0)) +# define NEVER(X) ((X)?(assert(0),1):0) +#else +# define ALWAYS(X) (X) +# define NEVER(X) (X) +#endif + +/* +** Declarations used for tracing the operating system interfaces. +*/ +#if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \ + (defined(SQLITE_DEBUG) && SQLITE_OS_WIN) + extern int sqlite3OSTrace; +# define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X +# define SQLITE_HAVE_OS_TRACE +#else +# define OSTRACE(X) +# undef SQLITE_HAVE_OS_TRACE +#endif + +/* +** Is the sqlite3ErrName() function needed in the build? Currently, +** it is needed by "mutex_w32.c" (when debugging), "os_win.c" (when +** OSTRACE is enabled), and by several "test*.c" files (which are +** compiled using SQLITE_TEST). +*/ +#if defined(SQLITE_HAVE_OS_TRACE) || defined(SQLITE_TEST) || \ + (defined(SQLITE_DEBUG) && SQLITE_OS_WIN) +# define SQLITE_NEED_ERR_NAME +#else +# undef SQLITE_NEED_ERR_NAME +#endif + +/* +** Return true (non-zero) if the input is an integer that is too large +** to fit in 32-bits. This macro is used inside of various testcase() +** macros to verify that we have tested SQLite for large-file support. +*/ +#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0) + +/* +** The macro unlikely() is a hint that surrounds a boolean +** expression that is usually false. Macro likely() surrounds +** a boolean expression that is usually true. These hints could, +** in theory, be used by the compiler to generate better code, but +** currently they are just comments for human readers. +*/ +#define likely(X) (X) +#define unlikely(X) (X) + +/************** Include hash.h in the middle of sqliteInt.h ******************/ +/************** Begin file hash.h ********************************************/ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the header file for the generic hash-table implementation +** used in SQLite. +*/ +#ifndef _SQLITE_HASH_H_ +#define _SQLITE_HASH_H_ + +/* Forward declarations of structures. */ +typedef struct Hash Hash; +typedef struct HashElem HashElem; + +/* A complete hash table is an instance of the following structure. +** The internals of this structure are intended to be opaque -- client +** code should not attempt to access or modify the fields of this structure +** directly. Change this structure only by using the routines below. +** However, some of the "procedures" and "functions" for modifying and +** accessing this structure are really macros, so we can't really make +** this structure opaque. +** +** All elements of the hash table are on a single doubly-linked list. +** Hash.first points to the head of this list. +** +** There are Hash.htsize buckets. Each bucket points to a spot in +** the global doubly-linked list. The contents of the bucket are the +** element pointed to plus the next _ht.count-1 elements in the list. +** +** Hash.htsize and Hash.ht may be zero. In that case lookup is done +** by a linear search of the global list. For small tables, the +** Hash.ht table is never allocated because if there are few elements +** in the table, it is faster to do a linear search than to manage +** the hash table. +*/ +struct Hash { + unsigned int htsize; /* Number of buckets in the hash table */ + unsigned int count; /* Number of entries in this table */ + HashElem *first; /* The first element of the array */ + struct _ht { /* the hash table */ + int count; /* Number of entries with this hash */ + HashElem *chain; /* Pointer to first entry with this hash */ + } *ht; +}; + +/* Each element in the hash table is an instance of the following +** structure. All elements are stored on a single doubly-linked list. +** +** Again, this structure is intended to be opaque, but it can't really +** be opaque because it is used by macros. +*/ +struct HashElem { + HashElem *next, *prev; /* Next and previous elements in the table */ + void *data; /* Data associated with this element */ + const char *pKey; /* Key associated with this element */ +}; + +/* +** Access routines. To delete, insert a NULL pointer. +*/ +SQLITE_PRIVATE void sqlite3HashInit(Hash*); +SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, void *pData); +SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey); +SQLITE_PRIVATE void sqlite3HashClear(Hash*); + +/* +** Macros for looping over all elements of a hash table. The idiom is +** like this: +** +** Hash h; +** HashElem *p; +** ... +** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){ +** SomeStructure *pData = sqliteHashData(p); +** // do something with pData +** } +*/ +#define sqliteHashFirst(H) ((H)->first) +#define sqliteHashNext(E) ((E)->next) +#define sqliteHashData(E) ((E)->data) +/* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */ +/* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */ + +/* +** Number of entries in a hash table +*/ +/* #define sqliteHashCount(H) ((H)->count) // NOT USED */ + +#endif /* _SQLITE_HASH_H_ */ + +/************** End of hash.h ************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include parse.h in the middle of sqliteInt.h *****************/ +/************** Begin file parse.h *******************************************/ +#define TK_SEMI 1 +#define TK_EXPLAIN 2 +#define TK_QUERY 3 +#define TK_PLAN 4 +#define TK_BEGIN 5 +#define TK_TRANSACTION 6 +#define TK_DEFERRED 7 +#define TK_IMMEDIATE 8 +#define TK_EXCLUSIVE 9 +#define TK_COMMIT 10 +#define TK_END 11 +#define TK_ROLLBACK 12 +#define TK_SAVEPOINT 13 +#define TK_RELEASE 14 +#define TK_TO 15 +#define TK_TABLE 16 +#define TK_CREATE 17 +#define TK_IF 18 +#define TK_NOT 19 +#define TK_EXISTS 20 +#define TK_TEMP 21 +#define TK_LP 22 +#define TK_RP 23 +#define TK_AS 24 +#define TK_WITHOUT 25 +#define TK_COMMA 26 +#define TK_ID 27 +#define TK_INDEXED 28 +#define TK_ABORT 29 +#define TK_ACTION 30 +#define TK_AFTER 31 +#define TK_ANALYZE 32 +#define TK_ASC 33 +#define TK_ATTACH 34 +#define TK_BEFORE 35 +#define TK_BY 36 +#define TK_CASCADE 37 +#define TK_CAST 38 +#define TK_COLUMNKW 39 +#define TK_CONFLICT 40 +#define TK_DATABASE 41 +#define TK_DESC 42 +#define TK_DETACH 43 +#define TK_EACH 44 +#define TK_FAIL 45 +#define TK_FOR 46 +#define TK_IGNORE 47 +#define TK_INITIALLY 48 +#define TK_INSTEAD 49 +#define TK_LIKE_KW 50 +#define TK_MATCH 51 +#define TK_NO 52 +#define TK_KEY 53 +#define TK_OF 54 +#define TK_OFFSET 55 +#define TK_PRAGMA 56 +#define TK_RAISE 57 +#define TK_RECURSIVE 58 +#define TK_REPLACE 59 +#define TK_RESTRICT 60 +#define TK_ROW 61 +#define TK_TRIGGER 62 +#define TK_VACUUM 63 +#define TK_VIEW 64 +#define TK_VIRTUAL 65 +#define TK_WITH 66 +#define TK_REINDEX 67 +#define TK_RENAME 68 +#define TK_CTIME_KW 69 +#define TK_ANY 70 +#define TK_OR 71 +#define TK_AND 72 +#define TK_IS 73 +#define TK_BETWEEN 74 +#define TK_IN 75 +#define TK_ISNULL 76 +#define TK_NOTNULL 77 +#define TK_NE 78 +#define TK_EQ 79 +#define TK_GT 80 +#define TK_LE 81 +#define TK_LT 82 +#define TK_GE 83 +#define TK_ESCAPE 84 +#define TK_BITAND 85 +#define TK_BITOR 86 +#define TK_LSHIFT 87 +#define TK_RSHIFT 88 +#define TK_PLUS 89 +#define TK_MINUS 90 +#define TK_STAR 91 +#define TK_SLASH 92 +#define TK_REM 93 +#define TK_CONCAT 94 +#define TK_COLLATE 95 +#define TK_BITNOT 96 +#define TK_STRING 97 +#define TK_JOIN_KW 98 +#define TK_CONSTRAINT 99 +#define TK_DEFAULT 100 +#define TK_NULL 101 +#define TK_PRIMARY 102 +#define TK_UNIQUE 103 +#define TK_CHECK 104 +#define TK_REFERENCES 105 +#define TK_AUTOINCR 106 +#define TK_ON 107 +#define TK_INSERT 108 +#define TK_DELETE 109 +#define TK_UPDATE 110 +#define TK_SET 111 +#define TK_DEFERRABLE 112 +#define TK_FOREIGN 113 +#define TK_DROP 114 +#define TK_UNION 115 +#define TK_ALL 116 +#define TK_EXCEPT 117 +#define TK_INTERSECT 118 +#define TK_SELECT 119 +#define TK_VALUES 120 +#define TK_DISTINCT 121 +#define TK_DOT 122 +#define TK_FROM 123 +#define TK_JOIN 124 +#define TK_USING 125 +#define TK_ORDER 126 +#define TK_GROUP 127 +#define TK_HAVING 128 +#define TK_LIMIT 129 +#define TK_WHERE 130 +#define TK_INTO 131 +#define TK_INTEGER 132 +#define TK_FLOAT 133 +#define TK_BLOB 134 +#define TK_VARIABLE 135 +#define TK_CASE 136 +#define TK_WHEN 137 +#define TK_THEN 138 +#define TK_ELSE 139 +#define TK_INDEX 140 +#define TK_ALTER 141 +#define TK_ADD 142 +#define TK_TO_TEXT 143 +#define TK_TO_BLOB 144 +#define TK_TO_NUMERIC 145 +#define TK_TO_INT 146 +#define TK_TO_REAL 147 +#define TK_ISNOT 148 +#define TK_END_OF_FILE 149 +#define TK_ILLEGAL 150 +#define TK_SPACE 151 +#define TK_UNCLOSED_STRING 152 +#define TK_FUNCTION 153 +#define TK_COLUMN 154 +#define TK_AGG_FUNCTION 155 +#define TK_AGG_COLUMN 156 +#define TK_UMINUS 157 +#define TK_UPLUS 158 +#define TK_REGISTER 159 + +/************** End of parse.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +#include +#include +#include +#include +#include + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite_int64 +# define float sqlite_int64 +# define LONGDOUBLE_TYPE sqlite_int64 +# ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50) +# endif +# define SQLITE_OMIT_DATETIME_FUNCS 1 +# define SQLITE_OMIT_TRACE 1 +# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT +# undef SQLITE_HAVE_ISNAN +#endif +#ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (1e99) +#endif + +/* +** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0 +** afterward. Having this macro allows us to cause the C compiler +** to omit code used by TEMP tables without messy #ifndef statements. +*/ +#ifdef SQLITE_OMIT_TEMPDB +#define OMIT_TEMPDB 1 +#else +#define OMIT_TEMPDB 0 +#endif + +/* +** The "file format" number is an integer that is incremented whenever +** the VDBE-level file format changes. The following macros define the +** the default file format for new databases and the maximum file format +** that the library can read. +*/ +#define SQLITE_MAX_FILE_FORMAT 4 +#ifndef SQLITE_DEFAULT_FILE_FORMAT +# define SQLITE_DEFAULT_FILE_FORMAT 4 +#endif + +/* +** Determine whether triggers are recursive by default. This can be +** changed at run-time using a pragma. +*/ +#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS +# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0 +#endif + +/* +** Provide a default value for SQLITE_TEMP_STORE in case it is not specified +** on the command-line +*/ +#ifndef SQLITE_TEMP_STORE +# define SQLITE_TEMP_STORE 1 +# define SQLITE_TEMP_STORE_xc 1 /* Exclude from ctime.c */ +#endif + +/* +** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if +** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it +** to zero. +*/ +#if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0 +# undef SQLITE_MAX_WORKER_THREADS +# define SQLITE_MAX_WORKER_THREADS 0 +#endif +#ifndef SQLITE_MAX_WORKER_THREADS +# define SQLITE_MAX_WORKER_THREADS 8 +#endif +#ifndef SQLITE_DEFAULT_WORKER_THREADS +# define SQLITE_DEFAULT_WORKER_THREADS 0 +#endif +#if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS +# undef SQLITE_MAX_WORKER_THREADS +# define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS +#endif + +/* +** The default initial allocation for the pagecache when using separate +** pagecaches for each database connection. A positive number is the +** number of pages. A negative number N translations means that a buffer +** of -1024*N bytes is allocated and used for as many pages as it will hold. +*/ +#ifndef SQLITE_DEFAULT_PCACHE_INITSZ +# define SQLITE_DEFAULT_PCACHE_INITSZ 100 +#endif + + +/* +** GCC does not define the offsetof() macro so we'll have to do it +** ourselves. +*/ +#ifndef offsetof +#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) +#endif + +/* +** Macros to compute minimum and maximum of two numbers. +*/ +#define MIN(A,B) ((A)<(B)?(A):(B)) +#define MAX(A,B) ((A)>(B)?(A):(B)) + +/* +** Swap two objects of type TYPE. +*/ +#define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;} + +/* +** Check to see if this machine uses EBCDIC. (Yes, believe it or +** not, there are still machines out there that use EBCDIC.) +*/ +#if 'A' == '\301' +# define SQLITE_EBCDIC 1 +#else +# define SQLITE_ASCII 1 +#endif + +/* +** Integers of known sizes. These typedefs might change for architectures +** where the sizes very. Preprocessor macros are available so that the +** types can be conveniently redefined at compile-type. Like this: +** +** cc '-DUINTPTR_TYPE=long long int' ... +*/ +#ifndef UINT32_TYPE +# ifdef HAVE_UINT32_T +# define UINT32_TYPE uint32_t +# else +# define UINT32_TYPE unsigned int +# endif +#endif +#ifndef UINT16_TYPE +# ifdef HAVE_UINT16_T +# define UINT16_TYPE uint16_t +# else +# define UINT16_TYPE unsigned short int +# endif +#endif +#ifndef INT16_TYPE +# ifdef HAVE_INT16_T +# define INT16_TYPE int16_t +# else +# define INT16_TYPE short int +# endif +#endif +#ifndef UINT8_TYPE +# ifdef HAVE_UINT8_T +# define UINT8_TYPE uint8_t +# else +# define UINT8_TYPE unsigned char +# endif +#endif +#ifndef INT8_TYPE +# ifdef HAVE_INT8_T +# define INT8_TYPE int8_t +# else +# define INT8_TYPE signed char +# endif +#endif +#ifndef LONGDOUBLE_TYPE +# define LONGDOUBLE_TYPE long double +#endif +typedef sqlite_int64 i64; /* 8-byte signed integer */ +typedef sqlite_uint64 u64; /* 8-byte unsigned integer */ +typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ +typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ +typedef INT16_TYPE i16; /* 2-byte signed integer */ +typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ +typedef INT8_TYPE i8; /* 1-byte signed integer */ + +/* +** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value +** that can be stored in a u32 without loss of data. The value +** is 0x00000000ffffffff. But because of quirks of some compilers, we +** have to specify the value in the less intuitive manner shown: +*/ +#define SQLITE_MAX_U32 ((((u64)1)<<32)-1) + +/* +** The datatype used to store estimates of the number of rows in a +** table or index. This is an unsigned integer type. For 99.9% of +** the world, a 32-bit integer is sufficient. But a 64-bit integer +** can be used at compile-time if desired. +*/ +#ifdef SQLITE_64BIT_STATS + typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */ +#else + typedef u32 tRowcnt; /* 32-bit is the default */ +#endif + +/* +** Estimated quantities used for query planning are stored as 16-bit +** logarithms. For quantity X, the value stored is 10*log2(X). This +** gives a possible range of values of approximately 1.0e986 to 1e-986. +** But the allowed values are "grainy". Not every value is representable. +** For example, quantities 16 and 17 are both represented by a LogEst +** of 40. However, since LogEst quantities are suppose to be estimates, +** not exact values, this imprecision is not a problem. +** +** "LogEst" is short for "Logarithmic Estimate". +** +** Examples: +** 1 -> 0 20 -> 43 10000 -> 132 +** 2 -> 10 25 -> 46 25000 -> 146 +** 3 -> 16 100 -> 66 1000000 -> 199 +** 4 -> 20 1000 -> 99 1048576 -> 200 +** 10 -> 33 1024 -> 100 4294967296 -> 320 +** +** The LogEst can be negative to indicate fractional values. +** Examples: +** +** 0.5 -> -10 0.1 -> -33 0.0625 -> -40 +*/ +typedef INT16_TYPE LogEst; + +/* +** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer +*/ +#ifndef SQLITE_PTRSIZE +# if defined(__SIZEOF_POINTER__) +# define SQLITE_PTRSIZE __SIZEOF_POINTER__ +# elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(_M_ARM) || defined(__arm__) || defined(__x86) +# define SQLITE_PTRSIZE 4 +# else +# define SQLITE_PTRSIZE 8 +# endif +#endif + +/* +** Macros to determine whether the machine is big or little endian, +** and whether or not that determination is run-time or compile-time. +** +** For best performance, an attempt is made to guess at the byte-order +** using C-preprocessor macros. If that is unsuccessful, or if +** -DSQLITE_RUNTIME_BYTEORDER=1 is set, then byte-order is determined +** at run-time. +*/ +#ifdef SQLITE_AMALGAMATION +SQLITE_PRIVATE const int sqlite3one = 1; +#else +SQLITE_PRIVATE const int sqlite3one; +#endif +#if (defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ + defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ + defined(__arm__)) && !defined(SQLITE_RUNTIME_BYTEORDER) +# define SQLITE_BYTEORDER 1234 +# define SQLITE_BIGENDIAN 0 +# define SQLITE_LITTLEENDIAN 1 +# define SQLITE_UTF16NATIVE SQLITE_UTF16LE +#endif +#if (defined(sparc) || defined(__ppc__)) \ + && !defined(SQLITE_RUNTIME_BYTEORDER) +# define SQLITE_BYTEORDER 4321 +# define SQLITE_BIGENDIAN 1 +# define SQLITE_LITTLEENDIAN 0 +# define SQLITE_UTF16NATIVE SQLITE_UTF16BE +#endif +#if !defined(SQLITE_BYTEORDER) +# define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */ +# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0) +# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1) +# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) +#endif + +/* +** Constants for the largest and smallest possible 64-bit signed integers. +** These macros are designed to work correctly on both 32-bit and 64-bit +** compilers. +*/ +#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32)) +#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64) + +/* +** Round up a number to the next larger multiple of 8. This is used +** to force 8-byte alignment on 64-bit architectures. +*/ +#define ROUND8(x) (((x)+7)&~7) + +/* +** Round down to the nearest multiple of 8 +*/ +#define ROUNDDOWN8(x) ((x)&~7) + +/* +** Assert that the pointer X is aligned to an 8-byte boundary. This +** macro is used only within assert() to verify that the code gets +** all alignment restrictions correct. +** +** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the +** underlying malloc() implementation might return us 4-byte aligned +** pointers. In that case, only verify 4-byte alignment. +*/ +#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC +# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0) +#else +# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0) +#endif + +/* +** Disable MMAP on platforms where it is known to not work +*/ +#if defined(__OpenBSD__) || defined(__QNXNTO__) +# undef SQLITE_MAX_MMAP_SIZE +# define SQLITE_MAX_MMAP_SIZE 0 +#endif + +/* +** Default maximum size of memory used by memory-mapped I/O in the VFS +*/ +#ifdef __APPLE__ +# include +# if TARGET_OS_IPHONE +# undef SQLITE_MAX_MMAP_SIZE +# define SQLITE_MAX_MMAP_SIZE 0 +# endif +#endif +#ifndef SQLITE_MAX_MMAP_SIZE +# if defined(__linux__) \ + || defined(_WIN32) \ + || (defined(__APPLE__) && defined(__MACH__)) \ + || defined(__sun) \ + || defined(__FreeBSD__) \ + || defined(__DragonFly__) +# define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */ +# else +# define SQLITE_MAX_MMAP_SIZE 0 +# endif +# define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */ +#endif + +/* +** The default MMAP_SIZE is zero on all platforms. Or, even if a larger +** default MMAP_SIZE is specified at compile-time, make sure that it does +** not exceed the maximum mmap size. +*/ +#ifndef SQLITE_DEFAULT_MMAP_SIZE +# define SQLITE_DEFAULT_MMAP_SIZE 0 +# define SQLITE_DEFAULT_MMAP_SIZE_xc 1 /* Exclude from ctime.c */ +#endif +#if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE +# undef SQLITE_DEFAULT_MMAP_SIZE +# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE +#endif + +/* +** Only one of SQLITE_ENABLE_STAT3 or SQLITE_ENABLE_STAT4 can be defined. +** Priority is given to SQLITE_ENABLE_STAT4. If either are defined, also +** define SQLITE_ENABLE_STAT3_OR_STAT4 +*/ +#ifdef SQLITE_ENABLE_STAT4 +# undef SQLITE_ENABLE_STAT3 +# define SQLITE_ENABLE_STAT3_OR_STAT4 1 +#elif SQLITE_ENABLE_STAT3 +# define SQLITE_ENABLE_STAT3_OR_STAT4 1 +#elif SQLITE_ENABLE_STAT3_OR_STAT4 +# undef SQLITE_ENABLE_STAT3_OR_STAT4 +#endif + +/* +** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not +** the Select query generator tracing logic is turned on. +*/ +#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_SELECTTRACE) +# define SELECTTRACE_ENABLED 1 +#else +# define SELECTTRACE_ENABLED 0 +#endif + +/* +** An instance of the following structure is used to store the busy-handler +** callback for a given sqlite handle. +** +** The sqlite.busyHandler member of the sqlite struct contains the busy +** callback for the database handle. Each pager opened via the sqlite +** handle is passed a pointer to sqlite.busyHandler. The busy-handler +** callback is currently invoked only from within pager.c. +*/ +typedef struct BusyHandler BusyHandler; +struct BusyHandler { + int (*xFunc)(void *,int); /* The busy callback */ + void *pArg; /* First arg to busy callback */ + int nBusy; /* Incremented with each busy call */ +}; + +/* +** Name of the master database table. The master database table +** is a special table that holds the names and attributes of all +** user tables and indices. +*/ +#define MASTER_NAME "sqlite_master" +#define TEMP_MASTER_NAME "sqlite_temp_master" + +/* +** The root-page of the master database table. +*/ +#define MASTER_ROOT 1 + +/* +** The name of the schema table. +*/ +#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME) + +/* +** A convenience macro that returns the number of elements in +** an array. +*/ +#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0]))) + +/* +** Determine if the argument is a power of two +*/ +#define IsPowerOfTwo(X) (((X)&((X)-1))==0) + +/* +** The following value as a destructor means to use sqlite3DbFree(). +** The sqlite3DbFree() routine requires two parameters instead of the +** one parameter that destructors normally want. So we have to introduce +** this magic value that the code knows to handle differently. Any +** pointer will work here as long as it is distinct from SQLITE_STATIC +** and SQLITE_TRANSIENT. +*/ +#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize) + +/* +** When SQLITE_OMIT_WSD is defined, it means that the target platform does +** not support Writable Static Data (WSD) such as global and static variables. +** All variables must either be on the stack or dynamically allocated from +** the heap. When WSD is unsupported, the variable declarations scattered +** throughout the SQLite code must become constants instead. The SQLITE_WSD +** macro is used for this purpose. And instead of referencing the variable +** directly, we use its constant as a key to lookup the run-time allocated +** buffer that holds real variable. The constant is also the initializer +** for the run-time allocated buffer. +** +** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL +** macros become no-ops and have zero performance impact. +*/ +#ifdef SQLITE_OMIT_WSD + #define SQLITE_WSD const + #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v))) + #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config) +SQLITE_API int SQLITE_STDCALL sqlite3_wsd_init(int N, int J); +SQLITE_API void *SQLITE_STDCALL sqlite3_wsd_find(void *K, int L); +#else + #define SQLITE_WSD + #define GLOBAL(t,v) v + #define sqlite3GlobalConfig sqlite3Config +#endif + +/* +** The following macros are used to suppress compiler warnings and to +** make it clear to human readers when a function parameter is deliberately +** left unused within the body of a function. This usually happens when +** a function is called via a function pointer. For example the +** implementation of an SQL aggregate step callback may not use the +** parameter indicating the number of arguments passed to the aggregate, +** if it knows that this is enforced elsewhere. +** +** When a function parameter is not used at all within the body of a function, +** it is generally named "NotUsed" or "NotUsed2" to make things even clearer. +** However, these macros may also be used to suppress warnings related to +** parameters that may or may not be used depending on compilation options. +** For example those parameters only used in assert() statements. In these +** cases the parameters are named as per the usual conventions. +*/ +#define UNUSED_PARAMETER(x) (void)(x) +#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y) + +/* +** Forward references to structures +*/ +typedef struct AggInfo AggInfo; +typedef struct AuthContext AuthContext; +typedef struct AutoincInfo AutoincInfo; +typedef struct Bitvec Bitvec; +typedef struct CollSeq CollSeq; +typedef struct Column Column; +typedef struct Db Db; +typedef struct Schema Schema; +typedef struct Expr Expr; +typedef struct ExprList ExprList; +typedef struct ExprSpan ExprSpan; +typedef struct FKey FKey; +typedef struct FuncDestructor FuncDestructor; +typedef struct FuncDef FuncDef; +typedef struct FuncDefHash FuncDefHash; +typedef struct IdList IdList; +typedef struct Index Index; +typedef struct IndexSample IndexSample; +typedef struct KeyClass KeyClass; +typedef struct KeyInfo KeyInfo; +typedef struct Lookaside Lookaside; +typedef struct LookasideSlot LookasideSlot; +typedef struct Module Module; +typedef struct NameContext NameContext; +typedef struct Parse Parse; +typedef struct PrintfArguments PrintfArguments; +typedef struct RowSet RowSet; +typedef struct Savepoint Savepoint; +typedef struct Select Select; +typedef struct SQLiteThread SQLiteThread; +typedef struct SelectDest SelectDest; +typedef struct SrcList SrcList; +typedef struct StrAccum StrAccum; +typedef struct Table Table; +typedef struct TableLock TableLock; +typedef struct Token Token; +typedef struct TreeView TreeView; +typedef struct Trigger Trigger; +typedef struct TriggerPrg TriggerPrg; +typedef struct TriggerStep TriggerStep; +typedef struct UnpackedRecord UnpackedRecord; +typedef struct VTable VTable; +typedef struct VtabCtx VtabCtx; +typedef struct Walker Walker; +typedef struct WhereInfo WhereInfo; +typedef struct With With; + +/* +** Defer sourcing vdbe.h and btree.h until after the "u8" and +** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque +** pointer types (i.e. FuncDef) defined above. +*/ +/************** Include btree.h in the middle of sqliteInt.h *****************/ +/************** Begin file btree.h *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the sqlite B-Tree file +** subsystem. See comments in the source code for a detailed description +** of what each interface routine does. +*/ +#ifndef _BTREE_H_ +#define _BTREE_H_ + +/* TODO: This definition is just included so other modules compile. It +** needs to be revisited. +*/ +#define SQLITE_N_BTREE_META 16 + +/* +** If defined as non-zero, auto-vacuum is enabled by default. Otherwise +** it must be turned on for each database using "PRAGMA auto_vacuum = 1". +*/ +#ifndef SQLITE_DEFAULT_AUTOVACUUM + #define SQLITE_DEFAULT_AUTOVACUUM 0 +#endif + +#define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */ +#define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */ +#define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */ + +/* +** Forward declarations of structure +*/ +typedef struct Btree Btree; +typedef struct BtCursor BtCursor; +typedef struct BtShared BtShared; + + +SQLITE_PRIVATE int sqlite3BtreeOpen( + sqlite3_vfs *pVfs, /* VFS to use with this b-tree */ + const char *zFilename, /* Name of database file to open */ + sqlite3 *db, /* Associated database connection */ + Btree **ppBtree, /* Return open Btree* here */ + int flags, /* Flags */ + int vfsFlags /* Flags passed through to VFS open */ +); + +/* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the +** following values. +** +** NOTE: These values must match the corresponding PAGER_ values in +** pager.h. +*/ +#define BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */ +#define BTREE_MEMORY 2 /* This is an in-memory DB */ +#define BTREE_SINGLE 4 /* The file contains at most 1 b-tree */ +#define BTREE_UNORDERED 8 /* Use of a hash implementation is OK */ + +SQLITE_PRIVATE int sqlite3BtreeClose(Btree*); +SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree*,int); +#if SQLITE_MAX_MMAP_SIZE>0 +SQLITE_PRIVATE int sqlite3BtreeSetMmapLimit(Btree*,sqlite3_int64); +#endif +SQLITE_PRIVATE int sqlite3BtreeSetPagerFlags(Btree*,unsigned); +SQLITE_PRIVATE int sqlite3BtreeSyncDisabled(Btree*); +SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix); +SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree*); +SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree*,int); +SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree*); +SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeGetOptimalReserve(Btree*); +SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p); +SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *, int); +SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *); +SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster); +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree*, int); +SQLITE_PRIVATE int sqlite3BtreeCommit(Btree*); +SQLITE_PRIVATE int sqlite3BtreeRollback(Btree*,int,int); +SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, int*, int flags); +SQLITE_PRIVATE int sqlite3BtreeIsInTrans(Btree*); +SQLITE_PRIVATE int sqlite3BtreeIsInReadTrans(Btree*); +SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree*); +SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); +SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *pBtree); +SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock); +SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *, int, int); + +SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *); +SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *); +SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *, Btree *); + +SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *); + +/* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR +** of the flags shown below. +** +** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set. +** With BTREE_INTKEY, the table key is a 64-bit integer and arbitrary data +** is stored in the leaves. (BTREE_INTKEY is used for SQL tables.) With +** BTREE_BLOBKEY, the key is an arbitrary BLOB and no content is stored +** anywhere - the key is the content. (BTREE_BLOBKEY is used for SQL +** indices.) +*/ +#define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */ +#define BTREE_BLOBKEY 2 /* Table has keys only - no data */ + +SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree*, int, int*); +SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, int*); +SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree*, int, int); + +SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue); +SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value); + +SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p); + +/* +** The second parameter to sqlite3BtreeGetMeta or sqlite3BtreeUpdateMeta +** should be one of the following values. The integer values are assigned +** to constants so that the offset of the corresponding field in an +** SQLite database header may be found using the following formula: +** +** offset = 36 + (idx * 4) +** +** For example, the free-page-count field is located at byte offset 36 of +** the database file header. The incr-vacuum-flag field is located at +** byte offset 64 (== 36+4*7). +** +** The BTREE_DATA_VERSION value is not really a value stored in the header. +** It is a read-only number computed by the pager. But we merge it with +** the header value access routines since its access pattern is the same. +** Call it a "virtual meta value". +*/ +#define BTREE_FREE_PAGE_COUNT 0 +#define BTREE_SCHEMA_VERSION 1 +#define BTREE_FILE_FORMAT 2 +#define BTREE_DEFAULT_CACHE_SIZE 3 +#define BTREE_LARGEST_ROOT_PAGE 4 +#define BTREE_TEXT_ENCODING 5 +#define BTREE_USER_VERSION 6 +#define BTREE_INCR_VACUUM 7 +#define BTREE_APPLICATION_ID 8 +#define BTREE_DATA_VERSION 15 /* A virtual meta-value */ + +/* +** Values that may be OR'd together to form the second argument of an +** sqlite3BtreeCursorHints() call. +** +** The BTREE_BULKLOAD flag is set on index cursors when the index is going +** to be filled with content that is already in sorted order. +** +** The BTREE_SEEK_EQ flag is set on cursors that will get OP_SeekGE or +** OP_SeekLE opcodes for a range search, but where the range of entries +** selected will all have the same key. In other words, the cursor will +** be used only for equality key searches. +** +*/ +#define BTREE_BULKLOAD 0x00000001 /* Used to full index in sorted order */ +#define BTREE_SEEK_EQ 0x00000002 /* EQ seeks only - no range seeks */ + +SQLITE_PRIVATE int sqlite3BtreeCursor( + Btree*, /* BTree containing table to open */ + int iTable, /* Index of root page */ + int wrFlag, /* 1 for writing. 0 for read-only */ + struct KeyInfo*, /* First argument to compare function */ + BtCursor *pCursor /* Space to write cursor structure */ +); +SQLITE_PRIVATE int sqlite3BtreeCursorSize(void); +SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*); + +SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( + BtCursor*, + UnpackedRecord *pUnKey, + i64 intKey, + int bias, + int *pRes +); +SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor*, int*); +SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, int); +SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey, + const void *pData, int nData, + int nZero, int bias, int seekResult); +SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor*, i64 *pSize); +SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, u32 *pAmt); +SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, u32 *pAmt); +SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor*, u32 *pSize); +SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*); + +SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*); +SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*); + +SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *); +SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *); +SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBt, int iVersion); +SQLITE_PRIVATE void sqlite3BtreeCursorHints(BtCursor *, unsigned int mask); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor*, unsigned int mask); +#endif +SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *pBt); +SQLITE_PRIVATE int sqlite3HeaderSizeBtree(void); + +#ifndef NDEBUG +SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor*); +#endif + +#ifndef SQLITE_OMIT_BTREECOUNT +SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *, i64 *); +#endif + +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3BtreeCursorInfo(BtCursor*, int*, int); +SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*); +#endif + +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree*, int, int *, int *); +#endif + +/* +** If we are not using shared cache, then there is no need to +** use mutexes to access the BtShared structures. So make the +** Enter and Leave procedures no-ops. +*/ +#ifndef SQLITE_OMIT_SHARED_CACHE +SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*); +SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*); +#else +# define sqlite3BtreeEnter(X) +# define sqlite3BtreeEnterAll(X) +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE +SQLITE_PRIVATE int sqlite3BtreeSharable(Btree*); +SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*); +SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*); +#ifndef NDEBUG + /* These routines are used inside assert() statements only. */ +SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree*); +SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3*); +SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3*,int,Schema*); +#endif +#else + +# define sqlite3BtreeSharable(X) 0 +# define sqlite3BtreeLeave(X) +# define sqlite3BtreeEnterCursor(X) +# define sqlite3BtreeLeaveCursor(X) +# define sqlite3BtreeLeaveAll(X) + +# define sqlite3BtreeHoldsMutex(X) 1 +# define sqlite3BtreeHoldsAllMutexes(X) 1 +# define sqlite3SchemaMutexHeld(X,Y,Z) 1 +#endif + + +#endif /* _BTREE_H_ */ + +/************** End of btree.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include vdbe.h in the middle of sqliteInt.h ******************/ +/************** Begin file vdbe.h ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Header file for the Virtual DataBase Engine (VDBE) +** +** This header defines the interface to the virtual database engine +** or VDBE. The VDBE implements an abstract machine that runs a +** simple program to access and modify the underlying database. +*/ +#ifndef _SQLITE_VDBE_H_ +#define _SQLITE_VDBE_H_ +/* #include */ + +/* +** A single VDBE is an opaque structure named "Vdbe". Only routines +** in the source file sqliteVdbe.c are allowed to see the insides +** of this structure. +*/ +typedef struct Vdbe Vdbe; + +/* +** The names of the following types declared in vdbeInt.h are required +** for the VdbeOp definition. +*/ +typedef struct Mem Mem; +typedef struct SubProgram SubProgram; + +/* +** A single instruction of the virtual machine has an opcode +** and as many as three operands. The instruction is recorded +** as an instance of the following structure: +*/ +struct VdbeOp { + u8 opcode; /* What operation to perform */ + signed char p4type; /* One of the P4_xxx constants for p4 */ + u8 opflags; /* Mask of the OPFLG_* flags in opcodes.h */ + u8 p5; /* Fifth parameter is an unsigned character */ + int p1; /* First operand */ + int p2; /* Second parameter (often the jump destination) */ + int p3; /* The third parameter */ + union p4union { /* fourth parameter */ + int i; /* Integer value if p4type==P4_INT32 */ + void *p; /* Generic pointer */ + char *z; /* Pointer to data for string (char array) types */ + i64 *pI64; /* Used when p4type is P4_INT64 */ + double *pReal; /* Used when p4type is P4_REAL */ + FuncDef *pFunc; /* Used when p4type is P4_FUNCDEF */ + sqlite3_context *pCtx; /* Used when p4type is P4_FUNCCTX */ + CollSeq *pColl; /* Used when p4type is P4_COLLSEQ */ + Mem *pMem; /* Used when p4type is P4_MEM */ + VTable *pVtab; /* Used when p4type is P4_VTAB */ + KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */ + int *ai; /* Used when p4type is P4_INTARRAY */ + SubProgram *pProgram; /* Used when p4type is P4_SUBPROGRAM */ + int (*xAdvance)(BtCursor *, int *); + } p4; +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + char *zComment; /* Comment to improve readability */ +#endif +#ifdef VDBE_PROFILE + u32 cnt; /* Number of times this instruction was executed */ + u64 cycles; /* Total time spent executing this instruction */ +#endif +#ifdef SQLITE_VDBE_COVERAGE + int iSrcLine; /* Source-code line that generated this opcode */ +#endif +}; +typedef struct VdbeOp VdbeOp; + + +/* +** A sub-routine used to implement a trigger program. +*/ +struct SubProgram { + VdbeOp *aOp; /* Array of opcodes for sub-program */ + int nOp; /* Elements in aOp[] */ + int nMem; /* Number of memory cells required */ + int nCsr; /* Number of cursors required */ + int nOnce; /* Number of OP_Once instructions */ + void *token; /* id that may be used to recursive triggers */ + SubProgram *pNext; /* Next sub-program already visited */ +}; + +/* +** A smaller version of VdbeOp used for the VdbeAddOpList() function because +** it takes up less space. +*/ +struct VdbeOpList { + u8 opcode; /* What operation to perform */ + signed char p1; /* First operand */ + signed char p2; /* Second parameter (often the jump destination) */ + signed char p3; /* Third parameter */ +}; +typedef struct VdbeOpList VdbeOpList; + +/* +** Allowed values of VdbeOp.p4type +*/ +#define P4_NOTUSED 0 /* The P4 parameter is not used */ +#define P4_DYNAMIC (-1) /* Pointer to a string obtained from sqliteMalloc() */ +#define P4_STATIC (-2) /* Pointer to a static string */ +#define P4_COLLSEQ (-4) /* P4 is a pointer to a CollSeq structure */ +#define P4_FUNCDEF (-5) /* P4 is a pointer to a FuncDef structure */ +#define P4_KEYINFO (-6) /* P4 is a pointer to a KeyInfo structure */ +#define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */ +#define P4_TRANSIENT 0 /* P4 is a pointer to a transient string */ +#define P4_VTAB (-10) /* P4 is a pointer to an sqlite3_vtab structure */ +#define P4_MPRINTF (-11) /* P4 is a string obtained from sqlite3_mprintf() */ +#define P4_REAL (-12) /* P4 is a 64-bit floating point value */ +#define P4_INT64 (-13) /* P4 is a 64-bit signed integer */ +#define P4_INT32 (-14) /* P4 is a 32-bit signed integer */ +#define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */ +#define P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */ +#define P4_ADVANCE (-19) /* P4 is a pointer to BtreeNext() or BtreePrev() */ +#define P4_FUNCCTX (-20) /* P4 is a pointer to an sqlite3_context object */ + +/* Error message codes for OP_Halt */ +#define P5_ConstraintNotNull 1 +#define P5_ConstraintUnique 2 +#define P5_ConstraintCheck 3 +#define P5_ConstraintFK 4 + +/* +** The Vdbe.aColName array contains 5n Mem structures, where n is the +** number of columns of data returned by the statement. +*/ +#define COLNAME_NAME 0 +#define COLNAME_DECLTYPE 1 +#define COLNAME_DATABASE 2 +#define COLNAME_TABLE 3 +#define COLNAME_COLUMN 4 +#ifdef SQLITE_ENABLE_COLUMN_METADATA +# define COLNAME_N 5 /* Number of COLNAME_xxx symbols */ +#else +# ifdef SQLITE_OMIT_DECLTYPE +# define COLNAME_N 1 /* Store only the name */ +# else +# define COLNAME_N 2 /* Store the name and decltype */ +# endif +#endif + +/* +** The following macro converts a relative address in the p2 field +** of a VdbeOp structure into a negative number so that +** sqlite3VdbeAddOpList() knows that the address is relative. Calling +** the macro again restores the address. +*/ +#define ADDR(X) (-1-(X)) + +/* +** The makefile scans the vdbe.c source file and creates the "opcodes.h" +** header file that defines a number for each opcode used by the VDBE. +*/ +/************** Include opcodes.h in the middle of vdbe.h ********************/ +/************** Begin file opcodes.h *****************************************/ +/* Automatically generated. Do not edit */ +/* See the mkopcodeh.awk script for details */ +#define OP_Savepoint 1 +#define OP_AutoCommit 2 +#define OP_Transaction 3 +#define OP_SorterNext 4 +#define OP_PrevIfOpen 5 +#define OP_NextIfOpen 6 +#define OP_Prev 7 +#define OP_Next 8 +#define OP_Checkpoint 9 +#define OP_JournalMode 10 +#define OP_Vacuum 11 +#define OP_VFilter 12 /* synopsis: iplan=r[P3] zplan='P4' */ +#define OP_VUpdate 13 /* synopsis: data=r[P3@P2] */ +#define OP_Goto 14 +#define OP_Gosub 15 +#define OP_Return 16 +#define OP_InitCoroutine 17 +#define OP_EndCoroutine 18 +#define OP_Not 19 /* same as TK_NOT, synopsis: r[P2]= !r[P1] */ +#define OP_Yield 20 +#define OP_HaltIfNull 21 /* synopsis: if r[P3]=null halt */ +#define OP_Halt 22 +#define OP_Integer 23 /* synopsis: r[P2]=P1 */ +#define OP_Int64 24 /* synopsis: r[P2]=P4 */ +#define OP_String 25 /* synopsis: r[P2]='P4' (len=P1) */ +#define OP_Null 26 /* synopsis: r[P2..P3]=NULL */ +#define OP_SoftNull 27 /* synopsis: r[P1]=NULL */ +#define OP_Blob 28 /* synopsis: r[P2]=P4 (len=P1) */ +#define OP_Variable 29 /* synopsis: r[P2]=parameter(P1,P4) */ +#define OP_Move 30 /* synopsis: r[P2@P3]=r[P1@P3] */ +#define OP_Copy 31 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */ +#define OP_SCopy 32 /* synopsis: r[P2]=r[P1] */ +#define OP_ResultRow 33 /* synopsis: output=r[P1@P2] */ +#define OP_CollSeq 34 +#define OP_Function0 35 /* synopsis: r[P3]=func(r[P2@P5]) */ +#define OP_Function 36 /* synopsis: r[P3]=func(r[P2@P5]) */ +#define OP_AddImm 37 /* synopsis: r[P1]=r[P1]+P2 */ +#define OP_MustBeInt 38 +#define OP_RealAffinity 39 +#define OP_Cast 40 /* synopsis: affinity(r[P1]) */ +#define OP_Permutation 41 +#define OP_Compare 42 /* synopsis: r[P1@P3] <-> r[P2@P3] */ +#define OP_Jump 43 +#define OP_Once 44 +#define OP_If 45 +#define OP_IfNot 46 +#define OP_Column 47 /* synopsis: r[P3]=PX */ +#define OP_Affinity 48 /* synopsis: affinity(r[P1@P2]) */ +#define OP_MakeRecord 49 /* synopsis: r[P3]=mkrec(r[P1@P2]) */ +#define OP_Count 50 /* synopsis: r[P2]=count() */ +#define OP_ReadCookie 51 +#define OP_SetCookie 52 +#define OP_ReopenIdx 53 /* synopsis: root=P2 iDb=P3 */ +#define OP_OpenRead 54 /* synopsis: root=P2 iDb=P3 */ +#define OP_OpenWrite 55 /* synopsis: root=P2 iDb=P3 */ +#define OP_OpenAutoindex 56 /* synopsis: nColumn=P2 */ +#define OP_OpenEphemeral 57 /* synopsis: nColumn=P2 */ +#define OP_SorterOpen 58 +#define OP_SequenceTest 59 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */ +#define OP_OpenPseudo 60 /* synopsis: P3 columns in r[P2] */ +#define OP_Close 61 +#define OP_ColumnsUsed 62 +#define OP_SeekLT 63 /* synopsis: key=r[P3@P4] */ +#define OP_SeekLE 64 /* synopsis: key=r[P3@P4] */ +#define OP_SeekGE 65 /* synopsis: key=r[P3@P4] */ +#define OP_SeekGT 66 /* synopsis: key=r[P3@P4] */ +#define OP_Seek 67 /* synopsis: intkey=r[P2] */ +#define OP_NoConflict 68 /* synopsis: key=r[P3@P4] */ +#define OP_NotFound 69 /* synopsis: key=r[P3@P4] */ +#define OP_Found 70 /* synopsis: key=r[P3@P4] */ +#define OP_Or 71 /* same as TK_OR, synopsis: r[P3]=(r[P1] || r[P2]) */ +#define OP_And 72 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */ +#define OP_NotExists 73 /* synopsis: intkey=r[P3] */ +#define OP_Sequence 74 /* synopsis: r[P2]=cursor[P1].ctr++ */ +#define OP_NewRowid 75 /* synopsis: r[P2]=rowid */ +#define OP_IsNull 76 /* same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */ +#define OP_NotNull 77 /* same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */ +#define OP_Ne 78 /* same as TK_NE, synopsis: if r[P1]!=r[P3] goto P2 */ +#define OP_Eq 79 /* same as TK_EQ, synopsis: if r[P1]==r[P3] goto P2 */ +#define OP_Gt 80 /* same as TK_GT, synopsis: if r[P1]>r[P3] goto P2 */ +#define OP_Le 81 /* same as TK_LE, synopsis: if r[P1]<=r[P3] goto P2 */ +#define OP_Lt 82 /* same as TK_LT, synopsis: if r[P1]=r[P3] goto P2 */ +#define OP_Insert 84 /* synopsis: intkey=r[P3] data=r[P2] */ +#define OP_BitAnd 85 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */ +#define OP_BitOr 86 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */ +#define OP_ShiftLeft 87 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<>r[P1] */ +#define OP_Add 89 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */ +#define OP_Subtract 90 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */ +#define OP_Multiply 91 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */ +#define OP_Divide 92 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */ +#define OP_Remainder 93 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */ +#define OP_Concat 94 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */ +#define OP_InsertInt 95 /* synopsis: intkey=P3 data=r[P2] */ +#define OP_BitNot 96 /* same as TK_BITNOT, synopsis: r[P1]= ~r[P1] */ +#define OP_String8 97 /* same as TK_STRING, synopsis: r[P2]='P4' */ +#define OP_Delete 98 +#define OP_ResetCount 99 +#define OP_SorterCompare 100 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */ +#define OP_SorterData 101 /* synopsis: r[P2]=data */ +#define OP_RowKey 102 /* synopsis: r[P2]=key */ +#define OP_RowData 103 /* synopsis: r[P2]=data */ +#define OP_Rowid 104 /* synopsis: r[P2]=rowid */ +#define OP_NullRow 105 +#define OP_Last 106 +#define OP_SorterSort 107 +#define OP_Sort 108 +#define OP_Rewind 109 +#define OP_SorterInsert 110 +#define OP_IdxInsert 111 /* synopsis: key=r[P2] */ +#define OP_IdxDelete 112 /* synopsis: key=r[P2@P3] */ +#define OP_IdxRowid 113 /* synopsis: r[P2]=rowid */ +#define OP_IdxLE 114 /* synopsis: key=r[P3@P4] */ +#define OP_IdxGT 115 /* synopsis: key=r[P3@P4] */ +#define OP_IdxLT 116 /* synopsis: key=r[P3@P4] */ +#define OP_IdxGE 117 /* synopsis: key=r[P3@P4] */ +#define OP_Destroy 118 +#define OP_Clear 119 +#define OP_ResetSorter 120 +#define OP_CreateIndex 121 /* synopsis: r[P2]=root iDb=P1 */ +#define OP_CreateTable 122 /* synopsis: r[P2]=root iDb=P1 */ +#define OP_ParseSchema 123 +#define OP_LoadAnalysis 124 +#define OP_DropTable 125 +#define OP_DropIndex 126 +#define OP_DropTrigger 127 +#define OP_IntegrityCk 128 +#define OP_RowSetAdd 129 /* synopsis: rowset(P1)=r[P2] */ +#define OP_RowSetRead 130 /* synopsis: r[P3]=rowset(P1) */ +#define OP_RowSetTest 131 /* synopsis: if r[P3] in rowset(P1) goto P2 */ +#define OP_Program 132 +#define OP_Real 133 /* same as TK_FLOAT, synopsis: r[P2]=P4 */ +#define OP_Param 134 +#define OP_FkCounter 135 /* synopsis: fkctr[P1]+=P2 */ +#define OP_FkIfZero 136 /* synopsis: if fkctr[P1]==0 goto P2 */ +#define OP_MemMax 137 /* synopsis: r[P1]=max(r[P1],r[P2]) */ +#define OP_IfPos 138 /* synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */ +#define OP_SetIfNotPos 139 /* synopsis: if r[P1]<=0 then r[P2]=P3 */ +#define OP_IfNotZero 140 /* synopsis: if r[P1]!=0 then r[P1]-=P3, goto P2 */ +#define OP_DecrJumpZero 141 /* synopsis: if (--r[P1])==0 goto P2 */ +#define OP_JumpZeroIncr 142 /* synopsis: if (r[P1]++)==0 ) goto P2 */ +#define OP_AggStep0 143 /* synopsis: accum=r[P3] step(r[P2@P5]) */ +#define OP_AggStep 144 /* synopsis: accum=r[P3] step(r[P2@P5]) */ +#define OP_AggFinal 145 /* synopsis: accum=r[P1] N=P2 */ +#define OP_IncrVacuum 146 +#define OP_Expire 147 +#define OP_TableLock 148 /* synopsis: iDb=P1 root=P2 write=P3 */ +#define OP_VBegin 149 +#define OP_VCreate 150 +#define OP_VDestroy 151 +#define OP_VOpen 152 +#define OP_VColumn 153 /* synopsis: r[P3]=vcolumn(P2) */ +#define OP_VNext 154 +#define OP_VRename 155 +#define OP_Pagecount 156 +#define OP_MaxPgcnt 157 +#define OP_Init 158 /* synopsis: Start at P2 */ +#define OP_Noop 159 +#define OP_Explain 160 + + +/* Properties such as "out2" or "jump" that are specified in +** comments following the "case" for each opcode in the vdbe.c +** are encoded into bitvectors as follows: +*/ +#define OPFLG_JUMP 0x0001 /* jump: P2 holds jmp target */ +#define OPFLG_IN1 0x0002 /* in1: P1 is an input */ +#define OPFLG_IN2 0x0004 /* in2: P2 is an input */ +#define OPFLG_IN3 0x0008 /* in3: P3 is an input */ +#define OPFLG_OUT2 0x0010 /* out2: P2 is an output */ +#define OPFLG_OUT3 0x0020 /* out3: P3 is an output */ +#define OPFLG_INITIALIZER {\ +/* 0 */ 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,\ +/* 8 */ 0x01, 0x00, 0x10, 0x00, 0x01, 0x00, 0x01, 0x01,\ +/* 16 */ 0x02, 0x01, 0x02, 0x12, 0x03, 0x08, 0x00, 0x10,\ +/* 24 */ 0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00,\ +/* 32 */ 0x10, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x02,\ +/* 40 */ 0x02, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x00,\ +/* 48 */ 0x00, 0x00, 0x10, 0x10, 0x08, 0x00, 0x00, 0x00,\ +/* 56 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,\ +/* 64 */ 0x09, 0x09, 0x09, 0x04, 0x09, 0x09, 0x09, 0x26,\ +/* 72 */ 0x26, 0x09, 0x10, 0x10, 0x03, 0x03, 0x0b, 0x0b,\ +/* 80 */ 0x0b, 0x0b, 0x0b, 0x0b, 0x00, 0x26, 0x26, 0x26,\ +/* 88 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x00,\ +/* 96 */ 0x12, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 104 */ 0x10, 0x00, 0x01, 0x01, 0x01, 0x01, 0x04, 0x04,\ +/* 112 */ 0x00, 0x10, 0x01, 0x01, 0x01, 0x01, 0x10, 0x00,\ +/* 120 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 128 */ 0x00, 0x06, 0x23, 0x0b, 0x01, 0x10, 0x10, 0x00,\ +/* 136 */ 0x01, 0x04, 0x03, 0x06, 0x03, 0x03, 0x03, 0x00,\ +/* 144 */ 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 152 */ 0x00, 0x00, 0x01, 0x00, 0x10, 0x10, 0x01, 0x00,\ +/* 160 */ 0x00,} + +/************** End of opcodes.h *********************************************/ +/************** Continuing where we left off in vdbe.h ***********************/ + +/* +** Prototypes for the VDBE interface. See comments on the implementation +** for a description of what each of these routines does. +*/ +SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse*); +SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe*,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe*,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeGoto(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeLoadString(Vdbe*,int,const char*); +SQLITE_PRIVATE void sqlite3VdbeMultiLoad(Vdbe*,int,const char*,...); +SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8(Vdbe*,int,int,int,int,const u8*,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp, int iLineno); +SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*); +SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe*, u32 addr, u8); +SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1); +SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2); +SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3); +SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5); +SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr); +SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr); +SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe*, u8 op); +SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N); +SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse*, Index*); +SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int); +SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int); +SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3*,Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,Parse*); +SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int); +SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *, int); +#endif +SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*)); +SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*); +SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int); +SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*); +SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*); +SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe*, int, u8); +SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int); +#ifndef SQLITE_OMIT_TRACE +SQLITE_PRIVATE char *sqlite3VdbeExpandSql(Vdbe*, const char*); +#endif +SQLITE_PRIVATE int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*); + +SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,UnpackedRecord*); +SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*); +SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(int, const void *, UnpackedRecord *, int); +SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(KeyInfo *, char *, int, char **); + +typedef int (*RecordCompare)(int,const void*,UnpackedRecord*); +SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord*); + +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *); +#endif + +/* Use SQLITE_ENABLE_COMMENTS to enable generation of extra comments on +** each VDBE opcode. +** +** Use the SQLITE_ENABLE_MODULE_COMMENTS macro to see some extra no-op +** comments in VDBE programs that show key decision points in the code +** generator. +*/ +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...); +# define VdbeComment(X) sqlite3VdbeComment X +SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...); +# define VdbeNoopComment(X) sqlite3VdbeNoopComment X +# ifdef SQLITE_ENABLE_MODULE_COMMENTS +# define VdbeModuleComment(X) sqlite3VdbeNoopComment X +# else +# define VdbeModuleComment(X) +# endif +#else +# define VdbeComment(X) +# define VdbeNoopComment(X) +# define VdbeModuleComment(X) +#endif + +/* +** The VdbeCoverage macros are used to set a coverage testing point +** for VDBE branch instructions. The coverage testing points are line +** numbers in the sqlite3.c source file. VDBE branch coverage testing +** only works with an amalagmation build. That's ok since a VDBE branch +** coverage build designed for testing the test suite only. No application +** should ever ship with VDBE branch coverage measuring turned on. +** +** VdbeCoverage(v) // Mark the previously coded instruction +** // as a branch +** +** VdbeCoverageIf(v, conditional) // Mark previous if conditional true +** +** VdbeCoverageAlwaysTaken(v) // Previous branch is always taken +** +** VdbeCoverageNeverTaken(v) // Previous branch is never taken +** +** Every VDBE branch operation must be tagged with one of the macros above. +** If not, then when "make test" is run with -DSQLITE_VDBE_COVERAGE and +** -DSQLITE_DEBUG then an ALWAYS() will fail in the vdbeTakeBranch() +** routine in vdbe.c, alerting the developer to the missed tag. +*/ +#ifdef SQLITE_VDBE_COVERAGE +SQLITE_PRIVATE void sqlite3VdbeSetLineNumber(Vdbe*,int); +# define VdbeCoverage(v) sqlite3VdbeSetLineNumber(v,__LINE__) +# define VdbeCoverageIf(v,x) if(x)sqlite3VdbeSetLineNumber(v,__LINE__) +# define VdbeCoverageAlwaysTaken(v) sqlite3VdbeSetLineNumber(v,2); +# define VdbeCoverageNeverTaken(v) sqlite3VdbeSetLineNumber(v,1); +# define VDBE_OFFSET_LINENO(x) (__LINE__+x) +#else +# define VdbeCoverage(v) +# define VdbeCoverageIf(v,x) +# define VdbeCoverageAlwaysTaken(v) +# define VdbeCoverageNeverTaken(v) +# define VDBE_OFFSET_LINENO(x) 0 +#endif + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +SQLITE_PRIVATE void sqlite3VdbeScanStatus(Vdbe*, int, int, int, LogEst, const char*); +#else +# define sqlite3VdbeScanStatus(a,b,c,d,e) +#endif + +#endif + +/************** End of vdbe.h ************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include pager.h in the middle of sqliteInt.h *****************/ +/************** Begin file pager.h *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the sqlite page cache +** subsystem. The page cache subsystem reads and writes a file a page +** at a time and provides a journal for rollback. +*/ + +#ifndef _PAGER_H_ +#define _PAGER_H_ + +/* +** Default maximum size for persistent journal files. A negative +** value means no limit. This value may be overridden using the +** sqlite3PagerJournalSizeLimit() API. See also "PRAGMA journal_size_limit". +*/ +#ifndef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT + #define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1 +#endif + +/* +** The type used to represent a page number. The first page in a file +** is called page 1. 0 is used to represent "not a page". +*/ +typedef u32 Pgno; + +/* +** Each open file is managed by a separate instance of the "Pager" structure. +*/ +typedef struct Pager Pager; + +/* +** Handle type for pages. +*/ +typedef struct PgHdr DbPage; + +/* +** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is +** reserved for working around a windows/posix incompatibility). It is +** used in the journal to signify that the remainder of the journal file +** is devoted to storing a master journal name - there are no more pages to +** roll back. See comments for function writeMasterJournal() in pager.c +** for details. +*/ +#define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1)) + +/* +** Allowed values for the flags parameter to sqlite3PagerOpen(). +** +** NOTE: These values must match the corresponding BTREE_ values in btree.h. +*/ +#define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */ +#define PAGER_MEMORY 0x0002 /* In-memory database */ + +/* +** Valid values for the second argument to sqlite3PagerLockingMode(). +*/ +#define PAGER_LOCKINGMODE_QUERY -1 +#define PAGER_LOCKINGMODE_NORMAL 0 +#define PAGER_LOCKINGMODE_EXCLUSIVE 1 + +/* +** Numeric constants that encode the journalmode. +*/ +#define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */ +#define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */ +#define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */ +#define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */ +#define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */ +#define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */ +#define PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */ + +/* +** Flags that make up the mask passed to sqlite3PagerAcquire(). +*/ +#define PAGER_GET_NOCONTENT 0x01 /* Do not load data from disk */ +#define PAGER_GET_READONLY 0x02 /* Read-only page is acceptable */ + +/* +** Flags for sqlite3PagerSetFlags() +*/ +#define PAGER_SYNCHRONOUS_OFF 0x01 /* PRAGMA synchronous=OFF */ +#define PAGER_SYNCHRONOUS_NORMAL 0x02 /* PRAGMA synchronous=NORMAL */ +#define PAGER_SYNCHRONOUS_FULL 0x03 /* PRAGMA synchronous=FULL */ +#define PAGER_SYNCHRONOUS_MASK 0x03 /* Mask for three values above */ +#define PAGER_FULLFSYNC 0x04 /* PRAGMA fullfsync=ON */ +#define PAGER_CKPT_FULLFSYNC 0x08 /* PRAGMA checkpoint_fullfsync=ON */ +#define PAGER_CACHESPILL 0x10 /* PRAGMA cache_spill=ON */ +#define PAGER_FLAGS_MASK 0x1c /* All above except SYNCHRONOUS */ + +/* +** The remainder of this file contains the declarations of the functions +** that make up the Pager sub-system API. See source code comments for +** a detailed description of each routine. +*/ + +/* Open and close a Pager connection. */ +SQLITE_PRIVATE int sqlite3PagerOpen( + sqlite3_vfs*, + Pager **ppPager, + const char*, + int, + int, + int, + void(*)(DbPage*) +); +SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager*, int, unsigned char*); + +/* Functions used to configure a Pager object. */ +SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *); +SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u32*, int); +#ifdef SQLITE_HAS_CODEC +SQLITE_PRIVATE void sqlite3PagerAlignReserve(Pager*,Pager*); +#endif +SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager*, int); +SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int); +SQLITE_PRIVATE void sqlite3PagerSetMmapLimit(Pager *, sqlite3_int64); +SQLITE_PRIVATE void sqlite3PagerShrink(Pager*); +SQLITE_PRIVATE void sqlite3PagerSetFlags(Pager*,unsigned); +SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *, int); +SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *, int); +SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager*); +SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager*); +SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64); +SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager*); + +/* Functions used to obtain and release page references. */ +SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag); +#define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0) +SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno); +SQLITE_PRIVATE void sqlite3PagerRef(DbPage*); +SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*); +SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage*); + +/* Operations on page references. */ +SQLITE_PRIVATE int sqlite3PagerWrite(DbPage*); +SQLITE_PRIVATE void sqlite3PagerDontWrite(DbPage*); +SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int); +SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage*); +SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *); +SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *); + +/* Functions used to manage pager transactions and savepoints. */ +SQLITE_PRIVATE void sqlite3PagerPagecount(Pager*, int*); +SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int); +SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, int); +SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager*); +SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zMaster); +SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*); +SQLITE_PRIVATE int sqlite3PagerRollback(Pager*); +SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n); +SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint); +SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager); + +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int, int*, int*); +SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen); +SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager); +#endif + +#ifdef SQLITE_ENABLE_ZIPVFS +SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager); +#endif + +/* Functions used to query pager state and configuration. */ +SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*); +SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager*); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*); +#endif +SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager*); +SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager*, int); +SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager*); +SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*); +SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*); +SQLITE_PRIVATE int sqlite3PagerNosync(Pager*); +SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*); +SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager*); +SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *, int, int, int *); +SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *); +SQLITE_PRIVATE int sqlite3SectorSize(sqlite3_file *); + +/* Functions used to truncate the database file. */ +SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno); + +SQLITE_PRIVATE void sqlite3PagerRekey(DbPage*, Pgno, u16); + +#if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_WAL) +SQLITE_PRIVATE void *sqlite3PagerCodec(DbPage *); +#endif + +/* Functions to support testing and debugging. */ +#if !defined(NDEBUG) || defined(SQLITE_TEST) +SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*); +SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage*); +#endif +#ifdef SQLITE_TEST +SQLITE_PRIVATE int *sqlite3PagerStats(Pager*); +SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*); + void disable_simulated_io_errors(void); + void enable_simulated_io_errors(void); +#else +# define disable_simulated_io_errors() +# define enable_simulated_io_errors() +#endif + +#endif /* _PAGER_H_ */ + +/************** End of pager.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include pcache.h in the middle of sqliteInt.h ****************/ +/************** Begin file pcache.h ******************************************/ +/* +** 2008 August 05 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the sqlite page cache +** subsystem. +*/ + +#ifndef _PCACHE_H_ + +typedef struct PgHdr PgHdr; +typedef struct PCache PCache; + +/* +** Every page in the cache is controlled by an instance of the following +** structure. +*/ +struct PgHdr { + sqlite3_pcache_page *pPage; /* Pcache object page handle */ + void *pData; /* Page data */ + void *pExtra; /* Extra content */ + PgHdr *pDirty; /* Transient list of dirty pages */ + Pager *pPager; /* The pager this page is part of */ + Pgno pgno; /* Page number for this page */ +#ifdef SQLITE_CHECK_PAGES + u32 pageHash; /* Hash of page content */ +#endif + u16 flags; /* PGHDR flags defined below */ + + /********************************************************************** + ** Elements above are public. All that follows is private to pcache.c + ** and should not be accessed by other modules. + */ + i16 nRef; /* Number of users of this page */ + PCache *pCache; /* Cache that owns this page */ + + PgHdr *pDirtyNext; /* Next element in list of dirty pages */ + PgHdr *pDirtyPrev; /* Previous element in list of dirty pages */ +}; + +/* Bit values for PgHdr.flags */ +#define PGHDR_CLEAN 0x001 /* Page not on the PCache.pDirty list */ +#define PGHDR_DIRTY 0x002 /* Page is on the PCache.pDirty list */ +#define PGHDR_WRITEABLE 0x004 /* Journaled and ready to modify */ +#define PGHDR_NEED_SYNC 0x008 /* Fsync the rollback journal before + ** writing this page to the database */ +#define PGHDR_NEED_READ 0x010 /* Content is unread */ +#define PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */ +#define PGHDR_MMAP 0x040 /* This is an mmap page object */ + +/* Initialize and shutdown the page cache subsystem */ +SQLITE_PRIVATE int sqlite3PcacheInitialize(void); +SQLITE_PRIVATE void sqlite3PcacheShutdown(void); + +/* Page cache buffer management: +** These routines implement SQLITE_CONFIG_PAGECACHE. +*/ +SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *, int sz, int n); + +/* Create a new pager cache. +** Under memory stress, invoke xStress to try to make pages clean. +** Only clean and unpinned pages can be reclaimed. +*/ +SQLITE_PRIVATE int sqlite3PcacheOpen( + int szPage, /* Size of every page */ + int szExtra, /* Extra space associated with each page */ + int bPurgeable, /* True if pages are on backing store */ + int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */ + void *pStress, /* Argument to xStress */ + PCache *pToInit /* Preallocated space for the PCache */ +); + +/* Modify the page-size after the cache has been created. */ +SQLITE_PRIVATE int sqlite3PcacheSetPageSize(PCache *, int); + +/* Return the size in bytes of a PCache object. Used to preallocate +** storage space. +*/ +SQLITE_PRIVATE int sqlite3PcacheSize(void); + +/* One release per successful fetch. Page is pinned until released. +** Reference counted. +*/ +SQLITE_PRIVATE sqlite3_pcache_page *sqlite3PcacheFetch(PCache*, Pgno, int createFlag); +SQLITE_PRIVATE int sqlite3PcacheFetchStress(PCache*, Pgno, sqlite3_pcache_page**); +SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish(PCache*, Pgno, sqlite3_pcache_page *pPage); +SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*); + +SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*); /* Remove page from cache */ +SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*); /* Make sure page is marked dirty */ +SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */ +SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */ + +/* Change a page number. Used by incr-vacuum. */ +SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno); + +/* Remove all pages with pgno>x. Reset the cache if x==0 */ +SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x); + +/* Get a list of all dirty pages in the cache, sorted by page number */ +SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache*); + +/* Reset and close the cache object */ +SQLITE_PRIVATE void sqlite3PcacheClose(PCache*); + +/* Clear flags from pages of the page cache */ +SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *); + +/* Discard the contents of the cache */ +SQLITE_PRIVATE void sqlite3PcacheClear(PCache*); + +/* Return the total number of outstanding page references */ +SQLITE_PRIVATE int sqlite3PcacheRefCount(PCache*); + +/* Increment the reference count of an existing page */ +SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*); + +SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr*); + +/* Return the total number of pages stored in the cache */ +SQLITE_PRIVATE int sqlite3PcachePagecount(PCache*); + +#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG) +/* Iterate through all dirty pages currently stored in the cache. This +** interface is only available if SQLITE_CHECK_PAGES is defined when the +** library is built. +*/ +SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)); +#endif + +/* Set and get the suggested cache-size for the specified pager-cache. +** +** If no global maximum is configured, then the system attempts to limit +** the total number of pages cached by purgeable pager-caches to the sum +** of the suggested cache-sizes. +*/ +SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *, int); +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *); +#endif + +/* Free up as much memory as possible from the page cache */ +SQLITE_PRIVATE void sqlite3PcacheShrink(PCache*); + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT +/* Try to return memory used by the pcache module to the main memory heap */ +SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int); +#endif + +#ifdef SQLITE_TEST +SQLITE_PRIVATE void sqlite3PcacheStats(int*,int*,int*,int*); +#endif + +SQLITE_PRIVATE void sqlite3PCacheSetDefault(void); + +/* Return the header size */ +SQLITE_PRIVATE int sqlite3HeaderSizePcache(void); +SQLITE_PRIVATE int sqlite3HeaderSizePcache1(void); + +#endif /* _PCACHE_H_ */ + +/************** End of pcache.h **********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/************** Include os.h in the middle of sqliteInt.h ********************/ +/************** Begin file os.h **********************************************/ +/* +** 2001 September 16 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This header file (together with is companion C source-code file +** "os.c") attempt to abstract the underlying operating system so that +** the SQLite library will work on both POSIX and windows systems. +** +** This header file is #include-ed by sqliteInt.h and thus ends up +** being included by every source file. +*/ +#ifndef _SQLITE_OS_H_ +#define _SQLITE_OS_H_ + +/* +** Attempt to automatically detect the operating system and setup the +** necessary pre-processor macros for it. +*/ +/************** Include os_setup.h in the middle of os.h *********************/ +/************** Begin file os_setup.h ****************************************/ +/* +** 2013 November 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains pre-processor directives related to operating system +** detection and/or setup. +*/ +#ifndef _OS_SETUP_H_ +#define _OS_SETUP_H_ + +/* +** Figure out if we are dealing with Unix, Windows, or some other operating +** system. +** +** After the following block of preprocess macros, all of SQLITE_OS_UNIX, +** SQLITE_OS_WIN, and SQLITE_OS_OTHER will defined to either 1 or 0. One of +** the three will be 1. The other two will be 0. +*/ +#if defined(SQLITE_OS_OTHER) +# if SQLITE_OS_OTHER==1 +# undef SQLITE_OS_UNIX +# define SQLITE_OS_UNIX 0 +# undef SQLITE_OS_WIN +# define SQLITE_OS_WIN 0 +# else +# undef SQLITE_OS_OTHER +# endif +#endif +#if !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_OTHER) +# define SQLITE_OS_OTHER 0 +# ifndef SQLITE_OS_WIN +# if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || \ + defined(__MINGW32__) || defined(__BORLANDC__) +# define SQLITE_OS_WIN 1 +# define SQLITE_OS_UNIX 0 +# else +# define SQLITE_OS_WIN 0 +# define SQLITE_OS_UNIX 1 +# endif +# else +# define SQLITE_OS_UNIX 0 +# endif +#else +# ifndef SQLITE_OS_WIN +# define SQLITE_OS_WIN 0 +# endif +#endif + +#endif /* _OS_SETUP_H_ */ + +/************** End of os_setup.h ********************************************/ +/************** Continuing where we left off in os.h *************************/ + +/* If the SET_FULLSYNC macro is not defined above, then make it +** a no-op +*/ +#ifndef SET_FULLSYNC +# define SET_FULLSYNC(x,y) +#endif + +/* +** The default size of a disk sector +*/ +#ifndef SQLITE_DEFAULT_SECTOR_SIZE +# define SQLITE_DEFAULT_SECTOR_SIZE 4096 +#endif + +/* +** Temporary files are named starting with this prefix followed by 16 random +** alphanumeric characters, and no file extension. They are stored in the +** OS's standard temporary file directory, and are deleted prior to exit. +** If sqlite is being embedded in another program, you may wish to change the +** prefix to reflect your program's name, so that if your program exits +** prematurely, old temporary files can be easily identified. This can be done +** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line. +** +** 2006-10-31: The default prefix used to be "sqlite_". But then +** Mcafee started using SQLite in their anti-virus product and it +** started putting files with the "sqlite" name in the c:/temp folder. +** This annoyed many windows users. Those users would then do a +** Google search for "sqlite", find the telephone numbers of the +** developers and call to wake them up at night and complain. +** For this reason, the default name prefix is changed to be "sqlite" +** spelled backwards. So the temp files are still identified, but +** anybody smart enough to figure out the code is also likely smart +** enough to know that calling the developer will not help get rid +** of the file. +*/ +#ifndef SQLITE_TEMP_FILE_PREFIX +# define SQLITE_TEMP_FILE_PREFIX "etilqs_" +#endif + +/* +** The following values may be passed as the second argument to +** sqlite3OsLock(). The various locks exhibit the following semantics: +** +** SHARED: Any number of processes may hold a SHARED lock simultaneously. +** RESERVED: A single process may hold a RESERVED lock on a file at +** any time. Other processes may hold and obtain new SHARED locks. +** PENDING: A single process may hold a PENDING lock on a file at +** any one time. Existing SHARED locks may persist, but no new +** SHARED locks may be obtained by other processes. +** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks. +** +** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a +** process that requests an EXCLUSIVE lock may actually obtain a PENDING +** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to +** sqlite3OsLock(). +*/ +#define NO_LOCK 0 +#define SHARED_LOCK 1 +#define RESERVED_LOCK 2 +#define PENDING_LOCK 3 +#define EXCLUSIVE_LOCK 4 + +/* +** File Locking Notes: (Mostly about windows but also some info for Unix) +** +** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because +** those functions are not available. So we use only LockFile() and +** UnlockFile(). +** +** LockFile() prevents not just writing but also reading by other processes. +** A SHARED_LOCK is obtained by locking a single randomly-chosen +** byte out of a specific range of bytes. The lock byte is obtained at +** random so two separate readers can probably access the file at the +** same time, unless they are unlucky and choose the same lock byte. +** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range. +** There can only be one writer. A RESERVED_LOCK is obtained by locking +** a single byte of the file that is designated as the reserved lock byte. +** A PENDING_LOCK is obtained by locking a designated byte different from +** the RESERVED_LOCK byte. +** +** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available, +** which means we can use reader/writer locks. When reader/writer locks +** are used, the lock is placed on the same range of bytes that is used +** for probabilistic locking in Win95/98/ME. Hence, the locking scheme +** will support two or more Win95 readers or two or more WinNT readers. +** But a single Win95 reader will lock out all WinNT readers and a single +** WinNT reader will lock out all other Win95 readers. +** +** The following #defines specify the range of bytes used for locking. +** SHARED_SIZE is the number of bytes available in the pool from which +** a random byte is selected for a shared lock. The pool of bytes for +** shared locks begins at SHARED_FIRST. +** +** The same locking strategy and +** byte ranges are used for Unix. This leaves open the possibility of having +** clients on win95, winNT, and unix all talking to the same shared file +** and all locking correctly. To do so would require that samba (or whatever +** tool is being used for file sharing) implements locks correctly between +** windows and unix. I'm guessing that isn't likely to happen, but by +** using the same locking range we are at least open to the possibility. +** +** Locking in windows is manditory. For this reason, we cannot store +** actual data in the bytes used for locking. The pager never allocates +** the pages involved in locking therefore. SHARED_SIZE is selected so +** that all locks will fit on a single page even at the minimum page size. +** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE +** is set high so that we don't have to allocate an unused page except +** for very large databases. But one should test the page skipping logic +** by setting PENDING_BYTE low and running the entire regression suite. +** +** Changing the value of PENDING_BYTE results in a subtly incompatible +** file format. Depending on how it is changed, you might not notice +** the incompatibility right away, even running a full regression test. +** The default location of PENDING_BYTE is the first byte past the +** 1GB boundary. +** +*/ +#ifdef SQLITE_OMIT_WSD +# define PENDING_BYTE (0x40000000) +#else +# define PENDING_BYTE sqlite3PendingByte +#endif +#define RESERVED_BYTE (PENDING_BYTE+1) +#define SHARED_FIRST (PENDING_BYTE+2) +#define SHARED_SIZE 510 + +/* +** Wrapper around OS specific sqlite3_os_init() function. +*/ +SQLITE_PRIVATE int sqlite3OsInit(void); + +/* +** Functions for accessing sqlite3_file methods +*/ +SQLITE_PRIVATE int sqlite3OsClose(sqlite3_file*); +SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset); +SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset); +SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file*, i64 size); +SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file*, i64 *pSize); +SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut); +SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*); +SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file*,int,void*); +#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0 +SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id); +SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id); +SQLITE_PRIVATE int sqlite3OsShmMap(sqlite3_file *,int,int,int,void volatile **); +SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int, int, int); +SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id); +SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int); +SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64, int, void **); +SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *, i64, void *); + + +/* +** Functions for accessing sqlite3_vfs methods +*/ +SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *); +SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *, const char *, int); +SQLITE_PRIVATE int sqlite3OsAccess(sqlite3_vfs *, const char *, int, int *pResOut); +SQLITE_PRIVATE int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *); +#ifndef SQLITE_OMIT_LOAD_EXTENSION +SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *, const char *); +SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *, int, char *); +SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *, void *, const char *))(void); +SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *, void *); +#endif /* SQLITE_OMIT_LOAD_EXTENSION */ +SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *, int, char *); +SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *, int); +SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *, sqlite3_int64*); + +/* +** Convenience functions for opening and closing files using +** sqlite3_malloc() to obtain space for the file-handle structure. +*/ +SQLITE_PRIVATE int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*); +SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *); + +#endif /* _SQLITE_OS_H_ */ + +/************** End of os.h **************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include mutex.h in the middle of sqliteInt.h *****************/ +/************** Begin file mutex.h *******************************************/ +/* +** 2007 August 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the common header for all mutex implementations. +** The sqliteInt.h header #includes this file so that it is available +** to all source files. We break it out in an effort to keep the code +** better organized. +** +** NOTE: source files should *not* #include this header file directly. +** Source files should #include the sqliteInt.h file and let that file +** include this one indirectly. +*/ + + +/* +** Figure out what version of the code to use. The choices are +** +** SQLITE_MUTEX_OMIT No mutex logic. Not even stubs. The +** mutexes implementation cannot be overridden +** at start-time. +** +** SQLITE_MUTEX_NOOP For single-threaded applications. No +** mutual exclusion is provided. But this +** implementation can be overridden at +** start-time. +** +** SQLITE_MUTEX_PTHREADS For multi-threaded applications on Unix. +** +** SQLITE_MUTEX_W32 For multi-threaded applications on Win32. +*/ +#if !SQLITE_THREADSAFE +# define SQLITE_MUTEX_OMIT +#endif +#if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP) +# if SQLITE_OS_UNIX +# define SQLITE_MUTEX_PTHREADS +# elif SQLITE_OS_WIN +# define SQLITE_MUTEX_W32 +# else +# define SQLITE_MUTEX_NOOP +# endif +#endif + +#ifdef SQLITE_MUTEX_OMIT +/* +** If this is a no-op implementation, implement everything as macros. +*/ +#define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8) +#define sqlite3_mutex_free(X) +#define sqlite3_mutex_enter(X) +#define sqlite3_mutex_try(X) SQLITE_OK +#define sqlite3_mutex_leave(X) +#define sqlite3_mutex_held(X) ((void)(X),1) +#define sqlite3_mutex_notheld(X) ((void)(X),1) +#define sqlite3MutexAlloc(X) ((sqlite3_mutex*)8) +#define sqlite3MutexInit() SQLITE_OK +#define sqlite3MutexEnd() +#define MUTEX_LOGIC(X) +#else +#define MUTEX_LOGIC(X) X +#endif /* defined(SQLITE_MUTEX_OMIT) */ + +/************** End of mutex.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + + +/* +** Each database file to be accessed by the system is an instance +** of the following structure. There are normally two of these structures +** in the sqlite.aDb[] array. aDb[0] is the main database file and +** aDb[1] is the database file used to hold temporary tables. Additional +** databases may be attached. +*/ +struct Db { + char *zName; /* Name of this database */ + Btree *pBt; /* The B*Tree structure for this database file */ + u8 safety_level; /* How aggressive at syncing data to disk */ + Schema *pSchema; /* Pointer to database schema (possibly shared) */ +}; + +/* +** An instance of the following structure stores a database schema. +** +** Most Schema objects are associated with a Btree. The exception is +** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing. +** In shared cache mode, a single Schema object can be shared by multiple +** Btrees that refer to the same underlying BtShared object. +** +** Schema objects are automatically deallocated when the last Btree that +** references them is destroyed. The TEMP Schema is manually freed by +** sqlite3_close(). +* +** A thread must be holding a mutex on the corresponding Btree in order +** to access Schema content. This implies that the thread must also be +** holding a mutex on the sqlite3 connection pointer that owns the Btree. +** For a TEMP Schema, only the connection mutex is required. +*/ +struct Schema { + int schema_cookie; /* Database schema version number for this file */ + int iGeneration; /* Generation counter. Incremented with each change */ + Hash tblHash; /* All tables indexed by name */ + Hash idxHash; /* All (named) indices indexed by name */ + Hash trigHash; /* All triggers indexed by name */ + Hash fkeyHash; /* All foreign keys by referenced table name */ + Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */ + u8 file_format; /* Schema format version for this file */ + u8 enc; /* Text encoding used by this database */ + u16 schemaFlags; /* Flags associated with this schema */ + int cache_size; /* Number of pages to use in the cache */ +}; + +/* +** These macros can be used to test, set, or clear bits in the +** Db.pSchema->flags field. +*/ +#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P)) +#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0) +#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P) +#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P) + +/* +** Allowed values for the DB.pSchema->flags field. +** +** The DB_SchemaLoaded flag is set after the database schema has been +** read into internal hash tables. +** +** DB_UnresetViews means that one or more views have column names that +** have been filled out. If the schema changes, these column names might +** changes and so the view will need to be reset. +*/ +#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */ +#define DB_UnresetViews 0x0002 /* Some views have defined column names */ +#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */ + +/* +** The number of different kinds of things that can be limited +** using the sqlite3_limit() interface. +*/ +#define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1) + +/* +** Lookaside malloc is a set of fixed-size buffers that can be used +** to satisfy small transient memory allocation requests for objects +** associated with a particular database connection. The use of +** lookaside malloc provides a significant performance enhancement +** (approx 10%) by avoiding numerous malloc/free requests while parsing +** SQL statements. +** +** The Lookaside structure holds configuration information about the +** lookaside malloc subsystem. Each available memory allocation in +** the lookaside subsystem is stored on a linked list of LookasideSlot +** objects. +** +** Lookaside allocations are only allowed for objects that are associated +** with a particular database connection. Hence, schema information cannot +** be stored in lookaside because in shared cache mode the schema information +** is shared by multiple database connections. Therefore, while parsing +** schema information, the Lookaside.bEnabled flag is cleared so that +** lookaside allocations are not used to construct the schema objects. +*/ +struct Lookaside { + u16 sz; /* Size of each buffer in bytes */ + u8 bEnabled; /* False to disable new lookaside allocations */ + u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */ + int nOut; /* Number of buffers currently checked out */ + int mxOut; /* Highwater mark for nOut */ + int anStat[3]; /* 0: hits. 1: size misses. 2: full misses */ + LookasideSlot *pFree; /* List of available buffers */ + void *pStart; /* First byte of available memory space */ + void *pEnd; /* First byte past end of available space */ +}; +struct LookasideSlot { + LookasideSlot *pNext; /* Next buffer in the list of free buffers */ +}; + +/* +** A hash table for function definitions. +** +** Hash each FuncDef structure into one of the FuncDefHash.a[] slots. +** Collisions are on the FuncDef.pHash chain. +*/ +struct FuncDefHash { + FuncDef *a[23]; /* Hash table for functions */ +}; + +#ifdef SQLITE_USER_AUTHENTICATION +/* +** Information held in the "sqlite3" database connection object and used +** to manage user authentication. +*/ +typedef struct sqlite3_userauth sqlite3_userauth; +struct sqlite3_userauth { + u8 authLevel; /* Current authentication level */ + int nAuthPW; /* Size of the zAuthPW in bytes */ + char *zAuthPW; /* Password used to authenticate */ + char *zAuthUser; /* User name used to authenticate */ +}; + +/* Allowed values for sqlite3_userauth.authLevel */ +#define UAUTH_Unknown 0 /* Authentication not yet checked */ +#define UAUTH_Fail 1 /* User authentication failed */ +#define UAUTH_User 2 /* Authenticated as a normal user */ +#define UAUTH_Admin 3 /* Authenticated as an administrator */ + +/* Functions used only by user authorization logic */ +SQLITE_PRIVATE int sqlite3UserAuthTable(const char*); +SQLITE_PRIVATE int sqlite3UserAuthCheckLogin(sqlite3*,const char*,u8*); +SQLITE_PRIVATE void sqlite3UserAuthInit(sqlite3*); +SQLITE_PRIVATE void sqlite3CryptFunc(sqlite3_context*,int,sqlite3_value**); + +#endif /* SQLITE_USER_AUTHENTICATION */ + +/* +** typedef for the authorization callback function. +*/ +#ifdef SQLITE_USER_AUTHENTICATION + typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*, + const char*, const char*); +#else + typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*, + const char*); +#endif + + +/* +** Each database connection is an instance of the following structure. +*/ +struct sqlite3 { + sqlite3_vfs *pVfs; /* OS Interface */ + struct Vdbe *pVdbe; /* List of active virtual machines */ + CollSeq *pDfltColl; /* The default collating sequence (BINARY) */ + sqlite3_mutex *mutex; /* Connection mutex */ + Db *aDb; /* All backends */ + int nDb; /* Number of backends currently in use */ + int flags; /* Miscellaneous flags. See below */ + i64 lastRowid; /* ROWID of most recent insert (see above) */ + i64 szMmap; /* Default mmap_size setting */ + unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */ + int errCode; /* Most recent error code (SQLITE_*) */ + int errMask; /* & result codes with this before returning */ + u16 dbOptFlags; /* Flags to enable/disable optimizations */ + u8 enc; /* Text encoding */ + u8 autoCommit; /* The auto-commit flag. */ + u8 temp_store; /* 1: file 2: memory 0: default */ + u8 mallocFailed; /* True if we have seen a malloc failure */ + u8 dfltLockMode; /* Default locking-mode for attached dbs */ + signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */ + u8 suppressErr; /* Do not issue error messages if true */ + u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */ + u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */ + int nextPagesize; /* Pagesize after VACUUM if >0 */ + u32 magic; /* Magic number for detect library misuse */ + int nChange; /* Value returned by sqlite3_changes() */ + int nTotalChange; /* Value returned by sqlite3_total_changes() */ + int aLimit[SQLITE_N_LIMIT]; /* Limits */ + int nMaxSorterMmap; /* Maximum size of regions mapped by sorter */ + struct sqlite3InitInfo { /* Information used during initialization */ + int newTnum; /* Rootpage of table being initialized */ + u8 iDb; /* Which db file is being initialized */ + u8 busy; /* TRUE if currently initializing */ + u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */ + u8 imposterTable; /* Building an imposter table */ + } init; + int nVdbeActive; /* Number of VDBEs currently running */ + int nVdbeRead; /* Number of active VDBEs that read or write */ + int nVdbeWrite; /* Number of active VDBEs that read and write */ + int nVdbeExec; /* Number of nested calls to VdbeExec() */ + int nVDestroy; /* Number of active OP_VDestroy operations */ + int nExtension; /* Number of loaded extensions */ + void **aExtension; /* Array of shared library handles */ + void (*xTrace)(void*,const char*); /* Trace function */ + void *pTraceArg; /* Argument to the trace function */ + void (*xProfile)(void*,const char*,u64); /* Profiling function */ + void *pProfileArg; /* Argument to profile function */ + void *pCommitArg; /* Argument to xCommitCallback() */ + int (*xCommitCallback)(void*); /* Invoked at every commit. */ + void *pRollbackArg; /* Argument to xRollbackCallback() */ + void (*xRollbackCallback)(void*); /* Invoked at every commit. */ + void *pUpdateArg; + void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64); +#ifndef SQLITE_OMIT_WAL + int (*xWalCallback)(void *, sqlite3 *, const char *, int); + void *pWalArg; +#endif + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*); + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*); + void *pCollNeededArg; + sqlite3_value *pErr; /* Most recent error message */ + union { + volatile int isInterrupted; /* True if sqlite3_interrupt has been called */ + double notUsed1; /* Spacer */ + } u1; + Lookaside lookaside; /* Lookaside malloc configuration */ +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth; /* Access authorization function */ + void *pAuthArg; /* 1st argument to the access auth function */ +#endif +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + int (*xProgress)(void *); /* The progress callback */ + void *pProgressArg; /* Argument to the progress callback */ + unsigned nProgressOps; /* Number of opcodes for progress callback */ +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + int nVTrans; /* Allocated size of aVTrans */ + Hash aModule; /* populated by sqlite3_create_module() */ + VtabCtx *pVtabCtx; /* Context for active vtab connect/create */ + VTable **aVTrans; /* Virtual tables with open transactions */ + VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */ +#endif + FuncDefHash aFunc; /* Hash table of connection functions */ + Hash aCollSeq; /* All collating sequences */ + BusyHandler busyHandler; /* Busy callback */ + Db aDbStatic[2]; /* Static space for the 2 default backends */ + Savepoint *pSavepoint; /* List of active savepoints */ + int busyTimeout; /* Busy handler timeout, in msec */ + int nSavepoint; /* Number of non-transaction savepoints */ + int nStatement; /* Number of nested statement-transactions */ + i64 nDeferredCons; /* Net deferred constraints this transaction. */ + i64 nDeferredImmCons; /* Net deferred immediate constraints */ + int *pnBytesFreed; /* If not NULL, increment this in DbFree() */ +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY + /* The following variables are all protected by the STATIC_MASTER + ** mutex, not by sqlite3.mutex. They are used by code in notify.c. + ** + ** When X.pUnlockConnection==Y, that means that X is waiting for Y to + ** unlock so that it can proceed. + ** + ** When X.pBlockingConnection==Y, that means that something that X tried + ** tried to do recently failed with an SQLITE_LOCKED error due to locks + ** held by Y. + */ + sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */ + sqlite3 *pUnlockConnection; /* Connection to watch for unlock */ + void *pUnlockArg; /* Argument to xUnlockNotify */ + void (*xUnlockNotify)(void **, int); /* Unlock notify callback */ + sqlite3 *pNextBlocked; /* Next in list of all blocked connections */ +#endif +#ifdef SQLITE_USER_AUTHENTICATION + sqlite3_userauth auth; /* User authentication information */ +#endif +}; + +/* +** A macro to discover the encoding of a database. +*/ +#define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc) +#define ENC(db) ((db)->enc) + +/* +** Possible values for the sqlite3.flags. +*/ +#define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */ +#define SQLITE_InternChanges 0x00000002 /* Uncommitted Hash table changes */ +#define SQLITE_FullFSync 0x00000004 /* Use full fsync on the backend */ +#define SQLITE_CkptFullFSync 0x00000008 /* Use full fsync for checkpoint */ +#define SQLITE_CacheSpill 0x00000010 /* OK to spill pager cache */ +#define SQLITE_FullColNames 0x00000020 /* Show full column names on SELECT */ +#define SQLITE_ShortColNames 0x00000040 /* Show short columns names */ +#define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */ + /* DELETE, or UPDATE and return */ + /* the count using a callback. */ +#define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */ + /* result set is empty */ +#define SQLITE_SqlTrace 0x00000200 /* Debug print SQL as it executes */ +#define SQLITE_VdbeListing 0x00000400 /* Debug listings of VDBE programs */ +#define SQLITE_WriteSchema 0x00000800 /* OK to update SQLITE_MASTER */ +#define SQLITE_VdbeAddopTrace 0x00001000 /* Trace sqlite3VdbeAddOp() calls */ +#define SQLITE_IgnoreChecks 0x00002000 /* Do not enforce check constraints */ +#define SQLITE_ReadUncommitted 0x0004000 /* For shared-cache mode */ +#define SQLITE_LegacyFileFmt 0x00008000 /* Create new databases in format 1 */ +#define SQLITE_RecoveryMode 0x00010000 /* Ignore schema errors */ +#define SQLITE_ReverseOrder 0x00020000 /* Reverse unordered SELECTs */ +#define SQLITE_RecTriggers 0x00040000 /* Enable recursive triggers */ +#define SQLITE_ForeignKeys 0x00080000 /* Enforce foreign key constraints */ +#define SQLITE_AutoIndex 0x00100000 /* Enable automatic indexes */ +#define SQLITE_PreferBuiltin 0x00200000 /* Preference to built-in funcs */ +#define SQLITE_LoadExtension 0x00400000 /* Enable load_extension */ +#define SQLITE_EnableTrigger 0x00800000 /* True to enable triggers */ +#define SQLITE_DeferFKs 0x01000000 /* Defer all FK constraints */ +#define SQLITE_QueryOnly 0x02000000 /* Disable database changes */ +#define SQLITE_VdbeEQP 0x04000000 /* Debug EXPLAIN QUERY PLAN */ +#define SQLITE_Vacuum 0x08000000 /* Currently in a VACUUM */ +#define SQLITE_CellSizeCk 0x10000000 /* Check btree cell sizes on load */ + + +/* +** Bits of the sqlite3.dbOptFlags field that are used by the +** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to +** selectively disable various optimizations. +*/ +#define SQLITE_QueryFlattener 0x0001 /* Query flattening */ +#define SQLITE_ColumnCache 0x0002 /* Column cache */ +#define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */ +#define SQLITE_FactorOutConst 0x0008 /* Constant factoring */ +/* not used 0x0010 // Was: SQLITE_IdxRealAsInt */ +#define SQLITE_DistinctOpt 0x0020 /* DISTINCT using indexes */ +#define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */ +#define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */ +#define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */ +#define SQLITE_Transitive 0x0200 /* Transitive constraints */ +#define SQLITE_OmitNoopJoin 0x0400 /* Omit unused tables in joins */ +#define SQLITE_Stat34 0x0800 /* Use STAT3 or STAT4 data */ +#define SQLITE_AllOpts 0xffff /* All optimizations */ + +/* +** Macros for testing whether or not optimizations are enabled or disabled. +*/ +#ifndef SQLITE_OMIT_BUILTIN_TEST +#define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0) +#define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0) +#else +#define OptimizationDisabled(db, mask) 0 +#define OptimizationEnabled(db, mask) 1 +#endif + +/* +** Return true if it OK to factor constant expressions into the initialization +** code. The argument is a Parse object for the code generator. +*/ +#define ConstFactorOk(P) ((P)->okConstFactor) + +/* +** Possible values for the sqlite.magic field. +** The numbers are obtained at random and have no special meaning, other +** than being distinct from one another. +*/ +#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */ +#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */ +#define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */ +#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */ +#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ +#define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */ + +/* +** Each SQL function is defined by an instance of the following +** structure. A pointer to this structure is stored in the sqlite.aFunc +** hash table. When multiple functions have the same name, the hash table +** points to a linked list of these structures. +*/ +struct FuncDef { + i16 nArg; /* Number of arguments. -1 means unlimited */ + u16 funcFlags; /* Some combination of SQLITE_FUNC_* */ + void *pUserData; /* User data parameter */ + FuncDef *pNext; /* Next function with same name */ + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */ + void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */ + void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */ + char *zName; /* SQL name of the function. */ + FuncDef *pHash; /* Next with a different name but the same hash */ + FuncDestructor *pDestructor; /* Reference counted destructor function */ +}; + +/* +** This structure encapsulates a user-function destructor callback (as +** configured using create_function_v2()) and a reference counter. When +** create_function_v2() is called to create a function with a destructor, +** a single object of this type is allocated. FuncDestructor.nRef is set to +** the number of FuncDef objects created (either 1 or 3, depending on whether +** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor +** member of each of the new FuncDef objects is set to point to the allocated +** FuncDestructor. +** +** Thereafter, when one of the FuncDef objects is deleted, the reference +** count on this object is decremented. When it reaches 0, the destructor +** is invoked and the FuncDestructor structure freed. +*/ +struct FuncDestructor { + int nRef; + void (*xDestroy)(void *); + void *pUserData; +}; + +/* +** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF +** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. There +** are assert() statements in the code to verify this. +*/ +#define SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */ +#define SQLITE_FUNC_LIKE 0x0004 /* Candidate for the LIKE optimization */ +#define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */ +#define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */ +#define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/ +#define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */ +#define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */ +#define SQLITE_FUNC_COUNT 0x0100 /* Built-in count(*) aggregate */ +#define SQLITE_FUNC_COALESCE 0x0200 /* Built-in coalesce() or ifnull() */ +#define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */ +#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */ +#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */ +#define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a + ** single query - might change over time */ + +/* +** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are +** used to create the initializers for the FuncDef structures. +** +** FUNCTION(zName, nArg, iArg, bNC, xFunc) +** Used to create a scalar function definition of a function zName +** implemented by C function xFunc that accepts nArg arguments. The +** value passed as iArg is cast to a (void*) and made available +** as the user-data (sqlite3_user_data()) for the function. If +** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set. +** +** VFUNCTION(zName, nArg, iArg, bNC, xFunc) +** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag. +** +** DFUNCTION(zName, nArg, iArg, bNC, xFunc) +** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and +** adds the SQLITE_FUNC_SLOCHNG flag. Used for date & time functions +** and functions like sqlite_version() that can change, but not during +** a single query. +** +** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal) +** Used to create an aggregate function definition implemented by +** the C functions xStep and xFinal. The first four parameters +** are interpreted in the same way as the first 4 parameters to +** FUNCTION(). +** +** LIKEFUNC(zName, nArg, pArg, flags) +** Used to create a scalar function definition of a function zName +** that accepts nArg arguments and is implemented by a call to C +** function likeFunc. Argument pArg is cast to a (void *) and made +** available as the function user-data (sqlite3_user_data()). The +** FuncDef.flags variable is set to the value passed as the flags +** parameter. +*/ +#define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0} +#define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0} +#define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0} +#define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ + {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0} +#define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + pArg, 0, xFunc, 0, 0, #zName, 0, 0} +#define LIKEFUNC(zName, nArg, arg, flags) \ + {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \ + (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0} +#define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \ + {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \ + SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0} +#define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \ + {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \ + SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0} + +/* +** All current savepoints are stored in a linked list starting at +** sqlite3.pSavepoint. The first element in the list is the most recently +** opened savepoint. Savepoints are added to the list by the vdbe +** OP_Savepoint instruction. +*/ +struct Savepoint { + char *zName; /* Savepoint name (nul-terminated) */ + i64 nDeferredCons; /* Number of deferred fk violations */ + i64 nDeferredImmCons; /* Number of deferred imm fk. */ + Savepoint *pNext; /* Parent savepoint (if any) */ +}; + +/* +** The following are used as the second parameter to sqlite3Savepoint(), +** and as the P1 argument to the OP_Savepoint instruction. +*/ +#define SAVEPOINT_BEGIN 0 +#define SAVEPOINT_RELEASE 1 +#define SAVEPOINT_ROLLBACK 2 + + +/* +** Each SQLite module (virtual table definition) is defined by an +** instance of the following structure, stored in the sqlite3.aModule +** hash table. +*/ +struct Module { + const sqlite3_module *pModule; /* Callback pointers */ + const char *zName; /* Name passed to create_module() */ + void *pAux; /* pAux passed to create_module() */ + void (*xDestroy)(void *); /* Module destructor function */ + Table *pEpoTab; /* Eponymous table for this module */ +}; + +/* +** information about each column of an SQL table is held in an instance +** of this structure. +*/ +struct Column { + char *zName; /* Name of this column */ + Expr *pDflt; /* Default value of this column */ + char *zDflt; /* Original text of the default value */ + char *zType; /* Data type for this column */ + char *zColl; /* Collating sequence. If NULL, use the default */ + u8 notNull; /* An OE_ code for handling a NOT NULL constraint */ + char affinity; /* One of the SQLITE_AFF_... values */ + u8 szEst; /* Estimated size of this column. INT==1 */ + u8 colFlags; /* Boolean properties. See COLFLAG_ defines below */ +}; + +/* Allowed values for Column.colFlags: +*/ +#define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */ +#define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */ + +/* +** A "Collating Sequence" is defined by an instance of the following +** structure. Conceptually, a collating sequence consists of a name and +** a comparison routine that defines the order of that sequence. +** +** If CollSeq.xCmp is NULL, it means that the +** collating sequence is undefined. Indices built on an undefined +** collating sequence may not be read or written. +*/ +struct CollSeq { + char *zName; /* Name of the collating sequence, UTF-8 encoded */ + u8 enc; /* Text encoding handled by xCmp() */ + void *pUser; /* First argument to xCmp() */ + int (*xCmp)(void*,int, const void*, int, const void*); + void (*xDel)(void*); /* Destructor for pUser */ +}; + +/* +** A sort order can be either ASC or DESC. +*/ +#define SQLITE_SO_ASC 0 /* Sort in ascending order */ +#define SQLITE_SO_DESC 1 /* Sort in ascending order */ +#define SQLITE_SO_UNDEFINED -1 /* No sort order specified */ + +/* +** Column affinity types. +** +** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and +** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve +** the speed a little by numbering the values consecutively. +** +** But rather than start with 0 or 1, we begin with 'A'. That way, +** when multiple affinity types are concatenated into a string and +** used as the P4 operand, they will be more readable. +** +** Note also that the numeric types are grouped together so that testing +** for a numeric type is a single comparison. And the BLOB type is first. +*/ +#define SQLITE_AFF_BLOB 'A' +#define SQLITE_AFF_TEXT 'B' +#define SQLITE_AFF_NUMERIC 'C' +#define SQLITE_AFF_INTEGER 'D' +#define SQLITE_AFF_REAL 'E' + +#define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC) + +/* +** The SQLITE_AFF_MASK values masks off the significant bits of an +** affinity value. +*/ +#define SQLITE_AFF_MASK 0x47 + +/* +** Additional bit values that can be ORed with an affinity without +** changing the affinity. +** +** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL. +** It causes an assert() to fire if either operand to a comparison +** operator is NULL. It is added to certain comparison operators to +** prove that the operands are always NOT NULL. +*/ +#define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */ +#define SQLITE_STOREP2 0x20 /* Store result in reg[P2] rather than jump */ +#define SQLITE_NULLEQ 0x80 /* NULL=NULL */ +#define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */ + +/* +** An object of this type is created for each virtual table present in +** the database schema. +** +** If the database schema is shared, then there is one instance of this +** structure for each database connection (sqlite3*) that uses the shared +** schema. This is because each database connection requires its own unique +** instance of the sqlite3_vtab* handle used to access the virtual table +** implementation. sqlite3_vtab* handles can not be shared between +** database connections, even when the rest of the in-memory database +** schema is shared, as the implementation often stores the database +** connection handle passed to it via the xConnect() or xCreate() method +** during initialization internally. This database connection handle may +** then be used by the virtual table implementation to access real tables +** within the database. So that they appear as part of the callers +** transaction, these accesses need to be made via the same database +** connection as that used to execute SQL operations on the virtual table. +** +** All VTable objects that correspond to a single table in a shared +** database schema are initially stored in a linked-list pointed to by +** the Table.pVTable member variable of the corresponding Table object. +** When an sqlite3_prepare() operation is required to access the virtual +** table, it searches the list for the VTable that corresponds to the +** database connection doing the preparing so as to use the correct +** sqlite3_vtab* handle in the compiled query. +** +** When an in-memory Table object is deleted (for example when the +** schema is being reloaded for some reason), the VTable objects are not +** deleted and the sqlite3_vtab* handles are not xDisconnect()ed +** immediately. Instead, they are moved from the Table.pVTable list to +** another linked list headed by the sqlite3.pDisconnect member of the +** corresponding sqlite3 structure. They are then deleted/xDisconnected +** next time a statement is prepared using said sqlite3*. This is done +** to avoid deadlock issues involving multiple sqlite3.mutex mutexes. +** Refer to comments above function sqlite3VtabUnlockList() for an +** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect +** list without holding the corresponding sqlite3.mutex mutex. +** +** The memory for objects of this type is always allocated by +** sqlite3DbMalloc(), using the connection handle stored in VTable.db as +** the first argument. +*/ +struct VTable { + sqlite3 *db; /* Database connection associated with this table */ + Module *pMod; /* Pointer to module implementation */ + sqlite3_vtab *pVtab; /* Pointer to vtab instance */ + int nRef; /* Number of pointers to this structure */ + u8 bConstraint; /* True if constraints are supported */ + int iSavepoint; /* Depth of the SAVEPOINT stack */ + VTable *pNext; /* Next in linked list (see above) */ +}; + +/* +** The schema for each SQL table and view is represented in memory +** by an instance of the following structure. +*/ +struct Table { + char *zName; /* Name of the table or view */ + Column *aCol; /* Information about each column */ + Index *pIndex; /* List of SQL indexes on this table. */ + Select *pSelect; /* NULL for tables. Points to definition if a view. */ + FKey *pFKey; /* Linked list of all foreign keys in this table */ + char *zColAff; /* String defining the affinity of each column */ + ExprList *pCheck; /* All CHECK constraints */ + /* ... also used as column name list in a VIEW */ + int tnum; /* Root BTree page for this table */ + i16 iPKey; /* If not negative, use aCol[iPKey] as the rowid */ + i16 nCol; /* Number of columns in this table */ + u16 nRef; /* Number of pointers to this Table */ + LogEst nRowLogEst; /* Estimated rows in table - from sqlite_stat1 table */ + LogEst szTabRow; /* Estimated size of each table row in bytes */ +#ifdef SQLITE_ENABLE_COSTMULT + LogEst costMult; /* Cost multiplier for using this table */ +#endif + u8 tabFlags; /* Mask of TF_* values */ + u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ +#ifndef SQLITE_OMIT_ALTERTABLE + int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */ +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + int nModuleArg; /* Number of arguments to the module */ + char **azModuleArg; /* 0: module 1: schema 2: vtab name 3...: args */ + VTable *pVTable; /* List of VTable objects. */ +#endif + Trigger *pTrigger; /* List of triggers stored in pSchema */ + Schema *pSchema; /* Schema that contains this table */ + Table *pNextZombie; /* Next on the Parse.pZombieTab list */ +}; + +/* +** Allowed values for Table.tabFlags. +** +** TF_OOOHidden applies to virtual tables that have hidden columns that are +** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING +** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden, +** the TF_OOOHidden attribute would apply in this case. Such tables require +** special handling during INSERT processing. +*/ +#define TF_Readonly 0x01 /* Read-only system table */ +#define TF_Ephemeral 0x02 /* An ephemeral table */ +#define TF_HasPrimaryKey 0x04 /* Table has a primary key */ +#define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */ +#define TF_Virtual 0x10 /* Is a virtual table */ +#define TF_WithoutRowid 0x20 /* No rowid. PRIMARY KEY is the key */ +#define TF_NoVisibleRowid 0x40 /* No user-visible "rowid" column */ +#define TF_OOOHidden 0x80 /* Out-of-Order hidden columns */ + + +/* +** Test to see whether or not a table is a virtual table. This is +** done as a macro so that it will be optimized out when virtual +** table support is omitted from the build. +*/ +#ifndef SQLITE_OMIT_VIRTUALTABLE +# define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0) +# define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) +#else +# define IsVirtual(X) 0 +# define IsHiddenColumn(X) 0 +#endif + +/* Does the table have a rowid */ +#define HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0) +#define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0) + +/* +** Each foreign key constraint is an instance of the following structure. +** +** A foreign key is associated with two tables. The "from" table is +** the table that contains the REFERENCES clause that creates the foreign +** key. The "to" table is the table that is named in the REFERENCES clause. +** Consider this example: +** +** CREATE TABLE ex1( +** a INTEGER PRIMARY KEY, +** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) +** ); +** +** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". +** Equivalent names: +** +** from-table == child-table +** to-table == parent-table +** +** Each REFERENCES clause generates an instance of the following structure +** which is attached to the from-table. The to-table need not exist when +** the from-table is created. The existence of the to-table is not checked. +** +** The list of all parents for child Table X is held at X.pFKey. +** +** A list of all children for a table named Z (which might not even exist) +** is held in Schema.fkeyHash with a hash key of Z. +*/ +struct FKey { + Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */ + FKey *pNextFrom; /* Next FKey with the same in pFrom. Next parent of pFrom */ + char *zTo; /* Name of table that the key points to (aka: Parent) */ + FKey *pNextTo; /* Next with the same zTo. Next child of zTo. */ + FKey *pPrevTo; /* Previous with the same zTo */ + int nCol; /* Number of columns in this key */ + /* EV: R-30323-21917 */ + u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ + u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */ + Trigger *apTrigger[2];/* Triggers for aAction[] actions */ + struct sColMap { /* Mapping of columns in pFrom to columns in zTo */ + int iFrom; /* Index of column in pFrom */ + char *zCol; /* Name of column in zTo. If NULL use PRIMARY KEY */ + } aCol[1]; /* One entry for each of nCol columns */ +}; + +/* +** SQLite supports many different ways to resolve a constraint +** error. ROLLBACK processing means that a constraint violation +** causes the operation in process to fail and for the current transaction +** to be rolled back. ABORT processing means the operation in process +** fails and any prior changes from that one operation are backed out, +** but the transaction is not rolled back. FAIL processing means that +** the operation in progress stops and returns an error code. But prior +** changes due to the same operation are not backed out and no rollback +** occurs. IGNORE means that the particular row that caused the constraint +** error is not inserted or updated. Processing continues and no error +** is returned. REPLACE means that preexisting database rows that caused +** a UNIQUE constraint violation are removed so that the new insert or +** update can proceed. Processing continues and no error is reported. +** +** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys. +** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the +** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign +** key is set to NULL. CASCADE means that a DELETE or UPDATE of the +** referenced table row is propagated into the row that holds the +** foreign key. +** +** The following symbolic values are used to record which type +** of action to take. +*/ +#define OE_None 0 /* There is no constraint to check */ +#define OE_Rollback 1 /* Fail the operation and rollback the transaction */ +#define OE_Abort 2 /* Back out changes but do no rollback transaction */ +#define OE_Fail 3 /* Stop the operation but leave all prior changes */ +#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */ +#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */ + +#define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ +#define OE_SetNull 7 /* Set the foreign key value to NULL */ +#define OE_SetDflt 8 /* Set the foreign key value to its default */ +#define OE_Cascade 9 /* Cascade the changes */ + +#define OE_Default 10 /* Do whatever the default action is */ + + +/* +** An instance of the following structure is passed as the first +** argument to sqlite3VdbeKeyCompare and is used to control the +** comparison of the two index keys. +** +** Note that aSortOrder[] and aColl[] have nField+1 slots. There +** are nField slots for the columns of an index then one extra slot +** for the rowid at the end. +*/ +struct KeyInfo { + u32 nRef; /* Number of references to this KeyInfo object */ + u8 enc; /* Text encoding - one of the SQLITE_UTF* values */ + u16 nField; /* Number of key columns in the index */ + u16 nXField; /* Number of columns beyond the key columns */ + sqlite3 *db; /* The database connection */ + u8 *aSortOrder; /* Sort order for each column. */ + CollSeq *aColl[1]; /* Collating sequence for each term of the key */ +}; + +/* +** An instance of the following structure holds information about a +** single index record that has already been parsed out into individual +** values. +** +** A record is an object that contains one or more fields of data. +** Records are used to store the content of a table row and to store +** the key of an index. A blob encoding of a record is created by +** the OP_MakeRecord opcode of the VDBE and is disassembled by the +** OP_Column opcode. +** +** This structure holds a record that has already been disassembled +** into its constituent fields. +** +** The r1 and r2 member variables are only used by the optimized comparison +** functions vdbeRecordCompareInt() and vdbeRecordCompareString(). +*/ +struct UnpackedRecord { + KeyInfo *pKeyInfo; /* Collation and sort-order information */ + u16 nField; /* Number of entries in apMem[] */ + i8 default_rc; /* Comparison result if keys are equal */ + u8 errCode; /* Error detected by xRecordCompare (CORRUPT or NOMEM) */ + Mem *aMem; /* Values */ + int r1; /* Value to return if (lhs > rhs) */ + int r2; /* Value to return if (rhs < lhs) */ +}; + + +/* +** Each SQL index is represented in memory by an +** instance of the following structure. +** +** The columns of the table that are to be indexed are described +** by the aiColumn[] field of this structure. For example, suppose +** we have the following table and index: +** +** CREATE TABLE Ex1(c1 int, c2 int, c3 text); +** CREATE INDEX Ex2 ON Ex1(c3,c1); +** +** In the Table structure describing Ex1, nCol==3 because there are +** three columns in the table. In the Index structure describing +** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. +** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the +** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. +** The second column to be indexed (c1) has an index of 0 in +** Ex1.aCol[], hence Ex2.aiColumn[1]==0. +** +** The Index.onError field determines whether or not the indexed columns +** must be unique and what to do if they are not. When Index.onError=OE_None, +** it means this is not a unique index. Otherwise it is a unique index +** and the value of Index.onError indicate the which conflict resolution +** algorithm to employ whenever an attempt is made to insert a non-unique +** element. +** +** While parsing a CREATE TABLE or CREATE INDEX statement in order to +** generate VDBE code (as opposed to parsing one read from an sqlite_master +** table as part of parsing an existing database schema), transient instances +** of this structure may be created. In this case the Index.tnum variable is +** used to store the address of a VDBE instruction, not a database page +** number (it cannot - the database page is not allocated until the VDBE +** program is executed). See convertToWithoutRowidTable() for details. +*/ +struct Index { + char *zName; /* Name of this index */ + i16 *aiColumn; /* Which columns are used by this index. 1st is 0 */ + LogEst *aiRowLogEst; /* From ANALYZE: Est. rows selected by each column */ + Table *pTable; /* The SQL table being indexed */ + char *zColAff; /* String defining the affinity of each column */ + Index *pNext; /* The next index associated with the same table */ + Schema *pSchema; /* Schema containing this index */ + u8 *aSortOrder; /* for each column: True==DESC, False==ASC */ + char **azColl; /* Array of collation sequence names for index */ + Expr *pPartIdxWhere; /* WHERE clause for partial indices */ + ExprList *aColExpr; /* Column expressions */ + int tnum; /* DB Page containing root of this index */ + LogEst szIdxRow; /* Estimated average row size in bytes */ + u16 nKeyCol; /* Number of columns forming the key */ + u16 nColumn; /* Number of columns stored in the index */ + u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + unsigned idxType:2; /* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */ + unsigned bUnordered:1; /* Use this index for == or IN queries only */ + unsigned uniqNotNull:1; /* True if UNIQUE and NOT NULL for all columns */ + unsigned isResized:1; /* True if resizeIndexObject() has been called */ + unsigned isCovering:1; /* True if this is a covering index */ + unsigned noSkipScan:1; /* Do not try to use skip-scan if true */ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + int nSample; /* Number of elements in aSample[] */ + int nSampleCol; /* Size of IndexSample.anEq[] and so on */ + tRowcnt *aAvgEq; /* Average nEq values for keys not in aSample */ + IndexSample *aSample; /* Samples of the left-most key */ + tRowcnt *aiRowEst; /* Non-logarithmic stat1 data for this index */ + tRowcnt nRowEst0; /* Non-logarithmic number of rows in the index */ +#endif +}; + +/* +** Allowed values for Index.idxType +*/ +#define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */ +#define SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */ +#define SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */ + +/* Return true if index X is a PRIMARY KEY index */ +#define IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY) + +/* Return true if index X is a UNIQUE index */ +#define IsUniqueIndex(X) ((X)->onError!=OE_None) + +/* The Index.aiColumn[] values are normally positive integer. But +** there are some negative values that have special meaning: +*/ +#define XN_ROWID (-1) /* Indexed column is the rowid */ +#define XN_EXPR (-2) /* Indexed column is an expression */ + +/* +** Each sample stored in the sqlite_stat3 table is represented in memory +** using a structure of this type. See documentation at the top of the +** analyze.c source file for additional information. +*/ +struct IndexSample { + void *p; /* Pointer to sampled record */ + int n; /* Size of record in bytes */ + tRowcnt *anEq; /* Est. number of rows where the key equals this sample */ + tRowcnt *anLt; /* Est. number of rows where key is less than this sample */ + tRowcnt *anDLt; /* Est. number of distinct keys less than this sample */ +}; + +/* +** Each token coming out of the lexer is an instance of +** this structure. Tokens are also used as part of an expression. +** +** Note if Token.z==0 then Token.dyn and Token.n are undefined and +** may contain random values. Do not make any assumptions about Token.dyn +** and Token.n when Token.z==0. +*/ +struct Token { + const char *z; /* Text of the token. Not NULL-terminated! */ + unsigned int n; /* Number of characters in this token */ +}; + +/* +** An instance of this structure contains information needed to generate +** code for a SELECT that contains aggregate functions. +** +** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a +** pointer to this structure. The Expr.iColumn field is the index in +** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate +** code for that node. +** +** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the +** original Select structure that describes the SELECT statement. These +** fields do not need to be freed when deallocating the AggInfo structure. +*/ +struct AggInfo { + u8 directMode; /* Direct rendering mode means take data directly + ** from source tables rather than from accumulators */ + u8 useSortingIdx; /* In direct mode, reference the sorting index rather + ** than the source table */ + int sortingIdx; /* Cursor number of the sorting index */ + int sortingIdxPTab; /* Cursor number of pseudo-table */ + int nSortingColumn; /* Number of columns in the sorting index */ + int mnReg, mxReg; /* Range of registers allocated for aCol and aFunc */ + ExprList *pGroupBy; /* The group by clause */ + struct AggInfo_col { /* For each column used in source tables */ + Table *pTab; /* Source table */ + int iTable; /* Cursor number of the source table */ + int iColumn; /* Column number within the source table */ + int iSorterColumn; /* Column number in the sorting index */ + int iMem; /* Memory location that acts as accumulator */ + Expr *pExpr; /* The original expression */ + } *aCol; + int nColumn; /* Number of used entries in aCol[] */ + int nAccumulator; /* Number of columns that show through to the output. + ** Additional columns are used only as parameters to + ** aggregate functions */ + struct AggInfo_func { /* For each aggregate function */ + Expr *pExpr; /* Expression encoding the function */ + FuncDef *pFunc; /* The aggregate function implementation */ + int iMem; /* Memory location that acts as accumulator */ + int iDistinct; /* Ephemeral table used to enforce DISTINCT */ + } *aFunc; + int nFunc; /* Number of entries in aFunc[] */ +}; + +/* +** The datatype ynVar is a signed integer, either 16-bit or 32-bit. +** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater +** than 32767 we have to make it 32-bit. 16-bit is preferred because +** it uses less memory in the Expr object, which is a big memory user +** in systems with lots of prepared statements. And few applications +** need more than about 10 or 20 variables. But some extreme users want +** to have prepared statements with over 32767 variables, and for them +** the option is available (at compile-time). +*/ +#if SQLITE_MAX_VARIABLE_NUMBER<=32767 +typedef i16 ynVar; +#else +typedef int ynVar; +#endif + +/* +** Each node of an expression in the parse tree is an instance +** of this structure. +** +** Expr.op is the opcode. The integer parser token codes are reused +** as opcodes here. For example, the parser defines TK_GE to be an integer +** code representing the ">=" operator. This same integer code is reused +** to represent the greater-than-or-equal-to operator in the expression +** tree. +** +** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB, +** or TK_STRING), then Expr.token contains the text of the SQL literal. If +** the expression is a variable (TK_VARIABLE), then Expr.token contains the +** variable name. Finally, if the expression is an SQL function (TK_FUNCTION), +** then Expr.token contains the name of the function. +** +** Expr.pRight and Expr.pLeft are the left and right subexpressions of a +** binary operator. Either or both may be NULL. +** +** Expr.x.pList is a list of arguments if the expression is an SQL function, +** a CASE expression or an IN expression of the form " IN (, ...)". +** Expr.x.pSelect is used if the expression is a sub-select or an expression of +** the form " IN (SELECT ...)". If the EP_xIsSelect bit is set in the +** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is +** valid. +** +** An expression of the form ID or ID.ID refers to a column in a table. +** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is +** the integer cursor number of a VDBE cursor pointing to that table and +** Expr.iColumn is the column number for the specific column. If the +** expression is used as a result in an aggregate SELECT, then the +** value is also stored in the Expr.iAgg column in the aggregate so that +** it can be accessed after all aggregates are computed. +** +** If the expression is an unbound variable marker (a question mark +** character '?' in the original SQL) then the Expr.iTable holds the index +** number for that variable. +** +** If the expression is a subquery then Expr.iColumn holds an integer +** register number containing the result of the subquery. If the +** subquery gives a constant result, then iTable is -1. If the subquery +** gives a different answer at different times during statement processing +** then iTable is the address of a subroutine that computes the subquery. +** +** If the Expr is of type OP_Column, and the table it is selecting from +** is a disk table or the "old.*" pseudo-table, then pTab points to the +** corresponding table definition. +** +** ALLOCATION NOTES: +** +** Expr objects can use a lot of memory space in database schema. To +** help reduce memory requirements, sometimes an Expr object will be +** truncated. And to reduce the number of memory allocations, sometimes +** two or more Expr objects will be stored in a single memory allocation, +** together with Expr.zToken strings. +** +** If the EP_Reduced and EP_TokenOnly flags are set when +** an Expr object is truncated. When EP_Reduced is set, then all +** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees +** are contained within the same memory allocation. Note, however, that +** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately +** allocated, regardless of whether or not EP_Reduced is set. +*/ +struct Expr { + u8 op; /* Operation performed by this node */ + char affinity; /* The affinity of the column or 0 if not a column */ + u32 flags; /* Various flags. EP_* See below */ + union { + char *zToken; /* Token value. Zero terminated and dequoted */ + int iValue; /* Non-negative integer value if EP_IntValue */ + } u; + + /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no + ** space is allocated for the fields below this point. An attempt to + ** access them will result in a segfault or malfunction. + *********************************************************************/ + + Expr *pLeft; /* Left subnode */ + Expr *pRight; /* Right subnode */ + union { + ExprList *pList; /* op = IN, EXISTS, SELECT, CASE, FUNCTION, BETWEEN */ + Select *pSelect; /* EP_xIsSelect and op = IN, EXISTS, SELECT */ + } x; + + /* If the EP_Reduced flag is set in the Expr.flags mask, then no + ** space is allocated for the fields below this point. An attempt to + ** access them will result in a segfault or malfunction. + *********************************************************************/ + +#if SQLITE_MAX_EXPR_DEPTH>0 + int nHeight; /* Height of the tree headed by this node */ +#endif + int iTable; /* TK_COLUMN: cursor number of table holding column + ** TK_REGISTER: register number + ** TK_TRIGGER: 1 -> new, 0 -> old + ** EP_Unlikely: 134217728 times likelihood */ + ynVar iColumn; /* TK_COLUMN: column index. -1 for rowid. + ** TK_VARIABLE: variable number (always >= 1). */ + i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */ + i16 iRightJoinTable; /* If EP_FromJoin, the right table of the join */ + u8 op2; /* TK_REGISTER: original value of Expr.op + ** TK_COLUMN: the value of p5 for OP_Column + ** TK_AGG_FUNCTION: nesting depth */ + AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */ + Table *pTab; /* Table for TK_COLUMN expressions. */ +}; + +/* +** The following are the meanings of bits in the Expr.flags field. +*/ +#define EP_FromJoin 0x000001 /* Originates in ON/USING clause of outer join */ +#define EP_Agg 0x000002 /* Contains one or more aggregate functions */ +#define EP_Resolved 0x000004 /* IDs have been resolved to COLUMNs */ +#define EP_Error 0x000008 /* Expression contains one or more errors */ +#define EP_Distinct 0x000010 /* Aggregate function with DISTINCT keyword */ +#define EP_VarSelect 0x000020 /* pSelect is correlated, not constant */ +#define EP_DblQuoted 0x000040 /* token.z was originally in "..." */ +#define EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */ +#define EP_Collate 0x000100 /* Tree contains a TK_COLLATE operator */ +#define EP_Generic 0x000200 /* Ignore COLLATE or affinity on this tree */ +#define EP_IntValue 0x000400 /* Integer value contained in u.iValue */ +#define EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */ +#define EP_Skip 0x001000 /* COLLATE, AS, or UNLIKELY */ +#define EP_Reduced 0x002000 /* Expr struct EXPR_REDUCEDSIZE bytes only */ +#define EP_TokenOnly 0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */ +#define EP_Static 0x008000 /* Held in memory not obtained from malloc() */ +#define EP_MemToken 0x010000 /* Need to sqlite3DbFree() Expr.zToken */ +#define EP_NoReduce 0x020000 /* Cannot EXPRDUP_REDUCE this Expr */ +#define EP_Unlikely 0x040000 /* unlikely() or likelihood() function */ +#define EP_ConstFunc 0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */ +#define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */ +#define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */ +#define EP_Alias 0x400000 /* Is an alias for a result set column */ + +/* +** Combinations of two or more EP_* flags +*/ +#define EP_Propagate (EP_Collate|EP_Subquery) /* Propagate these bits up tree */ + +/* +** These macros can be used to test, set, or clear bits in the +** Expr.flags field. +*/ +#define ExprHasProperty(E,P) (((E)->flags&(P))!=0) +#define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P)) +#define ExprSetProperty(E,P) (E)->flags|=(P) +#define ExprClearProperty(E,P) (E)->flags&=~(P) + +/* The ExprSetVVAProperty() macro is used for Verification, Validation, +** and Accreditation only. It works like ExprSetProperty() during VVA +** processes but is a no-op for delivery. +*/ +#ifdef SQLITE_DEBUG +# define ExprSetVVAProperty(E,P) (E)->flags|=(P) +#else +# define ExprSetVVAProperty(E,P) +#endif + +/* +** Macros to determine the number of bytes required by a normal Expr +** struct, an Expr struct with the EP_Reduced flag set in Expr.flags +** and an Expr struct with the EP_TokenOnly flag set. +*/ +#define EXPR_FULLSIZE sizeof(Expr) /* Full size */ +#define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */ +#define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */ + +/* +** Flags passed to the sqlite3ExprDup() function. See the header comment +** above sqlite3ExprDup() for details. +*/ +#define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */ + +/* +** A list of expressions. Each expression may optionally have a +** name. An expr/name combination can be used in several ways, such +** as the list of "expr AS ID" fields following a "SELECT" or in the +** list of "ID = expr" items in an UPDATE. A list of expressions can +** also be used as the argument to a function, in which case the a.zName +** field is not used. +** +** By default the Expr.zSpan field holds a human-readable description of +** the expression that is used in the generation of error messages and +** column labels. In this case, Expr.zSpan is typically the text of a +** column expression as it exists in a SELECT statement. However, if +** the bSpanIsTab flag is set, then zSpan is overloaded to mean the name +** of the result column in the form: DATABASE.TABLE.COLUMN. This later +** form is used for name resolution with nested FROM clauses. +*/ +struct ExprList { + int nExpr; /* Number of expressions on the list */ + struct ExprList_item { /* For each expression in the list */ + Expr *pExpr; /* The list of expressions */ + char *zName; /* Token associated with this expression */ + char *zSpan; /* Original text of the expression */ + u8 sortOrder; /* 1 for DESC or 0 for ASC */ + unsigned done :1; /* A flag to indicate when processing is finished */ + unsigned bSpanIsTab :1; /* zSpan holds DB.TABLE.COLUMN */ + unsigned reusable :1; /* Constant expression is reusable */ + union { + struct { + u16 iOrderByCol; /* For ORDER BY, column number in result set */ + u16 iAlias; /* Index into Parse.aAlias[] for zName */ + } x; + int iConstExprReg; /* Register in which Expr value is cached */ + } u; + } *a; /* Alloc a power of two greater or equal to nExpr */ +}; + +/* +** An instance of this structure is used by the parser to record both +** the parse tree for an expression and the span of input text for an +** expression. +*/ +struct ExprSpan { + Expr *pExpr; /* The expression parse tree */ + const char *zStart; /* First character of input text */ + const char *zEnd; /* One character past the end of input text */ +}; + +/* +** An instance of this structure can hold a simple list of identifiers, +** such as the list "a,b,c" in the following statements: +** +** INSERT INTO t(a,b,c) VALUES ...; +** CREATE INDEX idx ON t(a,b,c); +** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...; +** +** The IdList.a.idx field is used when the IdList represents the list of +** column names after a table name in an INSERT statement. In the statement +** +** INSERT INTO t(a,b,c) ... +** +** If "a" is the k-th column of table "t", then IdList.a[0].idx==k. +*/ +struct IdList { + struct IdList_item { + char *zName; /* Name of the identifier */ + int idx; /* Index in some Table.aCol[] of a column named zName */ + } *a; + int nId; /* Number of identifiers on the list */ +}; + +/* +** The bitmask datatype defined below is used for various optimizations. +** +** Changing this from a 64-bit to a 32-bit type limits the number of +** tables in a join to 32 instead of 64. But it also reduces the size +** of the library by 738 bytes on ix86. +*/ +typedef u64 Bitmask; + +/* +** The number of bits in a Bitmask. "BMS" means "BitMask Size". +*/ +#define BMS ((int)(sizeof(Bitmask)*8)) + +/* +** A bit in a Bitmask +*/ +#define MASKBIT(n) (((Bitmask)1)<<(n)) +#define MASKBIT32(n) (((unsigned int)1)<<(n)) + +/* +** The following structure describes the FROM clause of a SELECT statement. +** Each table or subquery in the FROM clause is a separate element of +** the SrcList.a[] array. +** +** With the addition of multiple database support, the following structure +** can also be used to describe a particular table such as the table that +** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL, +** such a table must be a simple name: ID. But in SQLite, the table can +** now be identified by a database name, a dot, then the table name: ID.ID. +** +** The jointype starts out showing the join type between the current table +** and the next table on the list. The parser builds the list this way. +** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each +** jointype expresses the join between the table and the previous table. +** +** In the colUsed field, the high-order bit (bit 63) is set if the table +** contains more than 63 columns and the 64-th or later column is used. +*/ +struct SrcList { + int nSrc; /* Number of tables or subqueries in the FROM clause */ + u32 nAlloc; /* Number of entries allocated in a[] below */ + struct SrcList_item { + Schema *pSchema; /* Schema to which this item is fixed */ + char *zDatabase; /* Name of database holding this table */ + char *zName; /* Name of the table */ + char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */ + Table *pTab; /* An SQL table corresponding to zName */ + Select *pSelect; /* A SELECT statement used in place of a table name */ + int addrFillSub; /* Address of subroutine to manifest a subquery */ + int regReturn; /* Register holding return address of addrFillSub */ + int regResult; /* Registers holding results of a co-routine */ + struct { + u8 jointype; /* Type of join between this able and the previous */ + unsigned notIndexed :1; /* True if there is a NOT INDEXED clause */ + unsigned isIndexedBy :1; /* True if there is an INDEXED BY clause */ + unsigned isTabFunc :1; /* True if table-valued-function syntax */ + unsigned isCorrelated :1; /* True if sub-query is correlated */ + unsigned viaCoroutine :1; /* Implemented as a co-routine */ + unsigned isRecursive :1; /* True for recursive reference in WITH */ + } fg; +#ifndef SQLITE_OMIT_EXPLAIN + u8 iSelectId; /* If pSelect!=0, the id of the sub-select in EQP */ +#endif + int iCursor; /* The VDBE cursor number used to access this table */ + Expr *pOn; /* The ON clause of a join */ + IdList *pUsing; /* The USING clause of a join */ + Bitmask colUsed; /* Bit N (1<" clause */ + ExprList *pFuncArg; /* Arguments to table-valued-function */ + } u1; + Index *pIBIndex; /* Index structure corresponding to u1.zIndexedBy */ + } a[1]; /* One entry for each identifier on the list */ +}; + +/* +** Permitted values of the SrcList.a.jointype field +*/ +#define JT_INNER 0x0001 /* Any kind of inner or cross join */ +#define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */ +#define JT_NATURAL 0x0004 /* True for a "natural" join */ +#define JT_LEFT 0x0008 /* Left outer join */ +#define JT_RIGHT 0x0010 /* Right outer join */ +#define JT_OUTER 0x0020 /* The "OUTER" keyword is present */ +#define JT_ERROR 0x0040 /* unknown or unsupported join type */ + + +/* +** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin() +** and the WhereInfo.wctrlFlags member. +*/ +#define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */ +#define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */ +#define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */ +#define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */ +#define WHERE_DUPLICATES_OK 0x0008 /* Ok to return a row more than once */ +#define WHERE_OMIT_OPEN_CLOSE 0x0010 /* Table cursors are already open */ +#define WHERE_FORCE_TABLE 0x0020 /* Do not use an index-only search */ +#define WHERE_ONETABLE_ONLY 0x0040 /* Only code the 1st table in pTabList */ +#define WHERE_NO_AUTOINDEX 0x0080 /* Disallow automatic indexes */ +#define WHERE_GROUPBY 0x0100 /* pOrderBy is really a GROUP BY */ +#define WHERE_DISTINCTBY 0x0200 /* pOrderby is really a DISTINCT clause */ +#define WHERE_WANT_DISTINCT 0x0400 /* All output needs to be distinct */ +#define WHERE_SORTBYGROUP 0x0800 /* Support sqlite3WhereIsSorted() */ +#define WHERE_REOPEN_IDX 0x1000 /* Try to use OP_ReopenIdx */ +#define WHERE_ONEPASS_MULTIROW 0x2000 /* ONEPASS is ok with multiple rows */ + +/* Allowed return values from sqlite3WhereIsDistinct() +*/ +#define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */ +#define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */ +#define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */ +#define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */ + +/* +** A NameContext defines a context in which to resolve table and column +** names. The context consists of a list of tables (the pSrcList) field and +** a list of named expression (pEList). The named expression list may +** be NULL. The pSrc corresponds to the FROM clause of a SELECT or +** to the table being operated on by INSERT, UPDATE, or DELETE. The +** pEList corresponds to the result set of a SELECT and is NULL for +** other statements. +** +** NameContexts can be nested. When resolving names, the inner-most +** context is searched first. If no match is found, the next outer +** context is checked. If there is still no match, the next context +** is checked. This process continues until either a match is found +** or all contexts are check. When a match is found, the nRef member of +** the context containing the match is incremented. +** +** Each subquery gets a new NameContext. The pNext field points to the +** NameContext in the parent query. Thus the process of scanning the +** NameContext list corresponds to searching through successively outer +** subqueries looking for a match. +*/ +struct NameContext { + Parse *pParse; /* The parser */ + SrcList *pSrcList; /* One or more tables used to resolve names */ + ExprList *pEList; /* Optional list of result-set columns */ + AggInfo *pAggInfo; /* Information about aggregates at this level */ + NameContext *pNext; /* Next outer name context. NULL for outermost */ + int nRef; /* Number of names resolved by this context */ + int nErr; /* Number of errors encountered while resolving names */ + u16 ncFlags; /* Zero or more NC_* flags defined below */ +}; + +/* +** Allowed values for the NameContext, ncFlags field. +** +** Note: NC_MinMaxAgg must have the same value as SF_MinMaxAgg and +** SQLITE_FUNC_MINMAX. +** +*/ +#define NC_AllowAgg 0x0001 /* Aggregate functions are allowed here */ +#define NC_HasAgg 0x0002 /* One or more aggregate functions seen */ +#define NC_IsCheck 0x0004 /* True if resolving names in a CHECK constraint */ +#define NC_InAggFunc 0x0008 /* True if analyzing arguments to an agg func */ +#define NC_PartIdx 0x0010 /* True if resolving a partial index WHERE */ +#define NC_IdxExpr 0x0020 /* True if resolving columns of CREATE INDEX */ +#define NC_MinMaxAgg 0x1000 /* min/max aggregates seen. See note above */ + +/* +** An instance of the following structure contains all information +** needed to generate code for a single SELECT statement. +** +** nLimit is set to -1 if there is no LIMIT clause. nOffset is set to 0. +** If there is a LIMIT clause, the parser sets nLimit to the value of the +** limit and nOffset to the value of the offset (or 0 if there is not +** offset). But later on, nLimit and nOffset become the memory locations +** in the VDBE that record the limit and offset counters. +** +** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes. +** These addresses must be stored so that we can go back and fill in +** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor +** the number of columns in P2 can be computed at the same time +** as the OP_OpenEphm instruction is coded because not +** enough information about the compound query is known at that point. +** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences +** for the result set. The KeyInfo for addrOpenEphm[2] contains collating +** sequences for the ORDER BY clause. +*/ +struct Select { + ExprList *pEList; /* The fields of the result */ + u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */ + u16 selFlags; /* Various SF_* values */ + int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */ +#if SELECTTRACE_ENABLED + char zSelName[12]; /* Symbolic name of this SELECT use for debugging */ +#endif + int addrOpenEphm[2]; /* OP_OpenEphem opcodes related to this select */ + u64 nSelectRow; /* Estimated number of result rows */ + SrcList *pSrc; /* The FROM clause */ + Expr *pWhere; /* The WHERE clause */ + ExprList *pGroupBy; /* The GROUP BY clause */ + Expr *pHaving; /* The HAVING clause */ + ExprList *pOrderBy; /* The ORDER BY clause */ + Select *pPrior; /* Prior select in a compound select statement */ + Select *pNext; /* Next select to the left in a compound */ + Expr *pLimit; /* LIMIT expression. NULL means not used. */ + Expr *pOffset; /* OFFSET expression. NULL means not used. */ + With *pWith; /* WITH clause attached to this select. Or NULL. */ +}; + +/* +** Allowed values for Select.selFlags. The "SF" prefix stands for +** "Select Flag". +*/ +#define SF_Distinct 0x0001 /* Output should be DISTINCT */ +#define SF_All 0x0002 /* Includes the ALL keyword */ +#define SF_Resolved 0x0004 /* Identifiers have been resolved */ +#define SF_Aggregate 0x0008 /* Contains aggregate functions */ +#define SF_UsesEphemeral 0x0010 /* Uses the OpenEphemeral opcode */ +#define SF_Expanded 0x0020 /* sqlite3SelectExpand() called on this */ +#define SF_HasTypeInfo 0x0040 /* FROM subqueries have Table metadata */ +#define SF_Compound 0x0080 /* Part of a compound query */ +#define SF_Values 0x0100 /* Synthesized from VALUES clause */ +#define SF_MultiValue 0x0200 /* Single VALUES term with multiple rows */ +#define SF_NestedFrom 0x0400 /* Part of a parenthesized FROM clause */ +#define SF_MaybeConvert 0x0800 /* Need convertCompoundSelectToSubquery() */ +#define SF_MinMaxAgg 0x1000 /* Aggregate containing min() or max() */ +#define SF_Recursive 0x2000 /* The recursive part of a recursive CTE */ +#define SF_Converted 0x4000 /* By convertCompoundSelectToSubquery() */ + + +/* +** The results of a SELECT can be distributed in several ways, as defined +** by one of the following macros. The "SRT" prefix means "SELECT Result +** Type". +** +** SRT_Union Store results as a key in a temporary index +** identified by pDest->iSDParm. +** +** SRT_Except Remove results from the temporary index pDest->iSDParm. +** +** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result +** set is not empty. +** +** SRT_Discard Throw the results away. This is used by SELECT +** statements within triggers whose only purpose is +** the side-effects of functions. +** +** All of the above are free to ignore their ORDER BY clause. Those that +** follow must honor the ORDER BY clause. +** +** SRT_Output Generate a row of output (using the OP_ResultRow +** opcode) for each row in the result set. +** +** SRT_Mem Only valid if the result is a single column. +** Store the first column of the first result row +** in register pDest->iSDParm then abandon the rest +** of the query. This destination implies "LIMIT 1". +** +** SRT_Set The result must be a single column. Store each +** row of result as the key in table pDest->iSDParm. +** Apply the affinity pDest->affSdst before storing +** results. Used to implement "IN (SELECT ...)". +** +** SRT_EphemTab Create an temporary table pDest->iSDParm and store +** the result there. The cursor is left open after +** returning. This is like SRT_Table except that +** this destination uses OP_OpenEphemeral to create +** the table first. +** +** SRT_Coroutine Generate a co-routine that returns a new row of +** results each time it is invoked. The entry point +** of the co-routine is stored in register pDest->iSDParm +** and the result row is stored in pDest->nDest registers +** starting with pDest->iSdst. +** +** SRT_Table Store results in temporary table pDest->iSDParm. +** SRT_Fifo This is like SRT_EphemTab except that the table +** is assumed to already be open. SRT_Fifo has +** the additional property of being able to ignore +** the ORDER BY clause. +** +** SRT_DistFifo Store results in a temporary table pDest->iSDParm. +** But also use temporary table pDest->iSDParm+1 as +** a record of all prior results and ignore any duplicate +** rows. Name means: "Distinct Fifo". +** +** SRT_Queue Store results in priority queue pDest->iSDParm (really +** an index). Append a sequence number so that all entries +** are distinct. +** +** SRT_DistQueue Store results in priority queue pDest->iSDParm only if +** the same record has never been stored before. The +** index at pDest->iSDParm+1 hold all prior stores. +*/ +#define SRT_Union 1 /* Store result as keys in an index */ +#define SRT_Except 2 /* Remove result from a UNION index */ +#define SRT_Exists 3 /* Store 1 if the result is not empty */ +#define SRT_Discard 4 /* Do not save the results anywhere */ +#define SRT_Fifo 5 /* Store result as data with an automatic rowid */ +#define SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */ +#define SRT_Queue 7 /* Store result in an queue */ +#define SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */ + +/* The ORDER BY clause is ignored for all of the above */ +#define IgnorableOrderby(X) ((X->eDest)<=SRT_DistQueue) + +#define SRT_Output 9 /* Output each row of result */ +#define SRT_Mem 10 /* Store result in a memory cell */ +#define SRT_Set 11 /* Store results as keys in an index */ +#define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */ +#define SRT_Coroutine 13 /* Generate a single row of result */ +#define SRT_Table 14 /* Store result as data with an automatic rowid */ + +/* +** An instance of this object describes where to put of the results of +** a SELECT statement. +*/ +struct SelectDest { + u8 eDest; /* How to dispose of the results. On of SRT_* above. */ + char affSdst; /* Affinity used when eDest==SRT_Set */ + int iSDParm; /* A parameter used by the eDest disposal method */ + int iSdst; /* Base register where results are written */ + int nSdst; /* Number of registers allocated */ + ExprList *pOrderBy; /* Key columns for SRT_Queue and SRT_DistQueue */ +}; + +/* +** During code generation of statements that do inserts into AUTOINCREMENT +** tables, the following information is attached to the Table.u.autoInc.p +** pointer of each autoincrement table to record some side information that +** the code generator needs. We have to keep per-table autoincrement +** information in case inserts are down within triggers. Triggers do not +** normally coordinate their activities, but we do need to coordinate the +** loading and saving of autoincrement information. +*/ +struct AutoincInfo { + AutoincInfo *pNext; /* Next info block in a list of them all */ + Table *pTab; /* Table this info block refers to */ + int iDb; /* Index in sqlite3.aDb[] of database holding pTab */ + int regCtr; /* Memory register holding the rowid counter */ +}; + +/* +** Size of the column cache +*/ +#ifndef SQLITE_N_COLCACHE +# define SQLITE_N_COLCACHE 10 +#endif + +/* +** At least one instance of the following structure is created for each +** trigger that may be fired while parsing an INSERT, UPDATE or DELETE +** statement. All such objects are stored in the linked list headed at +** Parse.pTriggerPrg and deleted once statement compilation has been +** completed. +** +** A Vdbe sub-program that implements the body and WHEN clause of trigger +** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of +** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable. +** The Parse.pTriggerPrg list never contains two entries with the same +** values for both pTrigger and orconf. +** +** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns +** accessed (or set to 0 for triggers fired as a result of INSERT +** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to +** a mask of new.* columns used by the program. +*/ +struct TriggerPrg { + Trigger *pTrigger; /* Trigger this program was coded from */ + TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */ + SubProgram *pProgram; /* Program implementing pTrigger/orconf */ + int orconf; /* Default ON CONFLICT policy */ + u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */ +}; + +/* +** The yDbMask datatype for the bitmask of all attached databases. +*/ +#if SQLITE_MAX_ATTACHED>30 + typedef unsigned char yDbMask[(SQLITE_MAX_ATTACHED+9)/8]; +# define DbMaskTest(M,I) (((M)[(I)/8]&(1<<((I)&7)))!=0) +# define DbMaskZero(M) memset((M),0,sizeof(M)) +# define DbMaskSet(M,I) (M)[(I)/8]|=(1<<((I)&7)) +# define DbMaskAllZero(M) sqlite3DbMaskAllZero(M) +# define DbMaskNonZero(M) (sqlite3DbMaskAllZero(M)==0) +#else + typedef unsigned int yDbMask; +# define DbMaskTest(M,I) (((M)&(((yDbMask)1)<<(I)))!=0) +# define DbMaskZero(M) (M)=0 +# define DbMaskSet(M,I) (M)|=(((yDbMask)1)<<(I)) +# define DbMaskAllZero(M) (M)==0 +# define DbMaskNonZero(M) (M)!=0 +#endif + +/* +** An SQL parser context. A copy of this structure is passed through +** the parser and down into all the parser action routine in order to +** carry around information that is global to the entire parse. +** +** The structure is divided into two parts. When the parser and code +** generate call themselves recursively, the first part of the structure +** is constant but the second part is reset at the beginning and end of +** each recursion. +** +** The nTableLock and aTableLock variables are only used if the shared-cache +** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are +** used to store the set of table-locks required by the statement being +** compiled. Function sqlite3TableLock() is used to add entries to the +** list. +*/ +struct Parse { + sqlite3 *db; /* The main database structure */ + char *zErrMsg; /* An error message */ + Vdbe *pVdbe; /* An engine for executing database bytecode */ + int rc; /* Return code from execution */ + u8 colNamesSet; /* TRUE after OP_ColumnName has been issued to pVdbe */ + u8 checkSchema; /* Causes schema cookie check after an error */ + u8 nested; /* Number of nested calls to the parser/code generator */ + u8 nTempReg; /* Number of temporary registers in aTempReg[] */ + u8 isMultiWrite; /* True if statement may modify/insert multiple rows */ + u8 mayAbort; /* True if statement may throw an ABORT exception */ + u8 hasCompound; /* Need to invoke convertCompoundSelectToSubquery() */ + u8 okConstFactor; /* OK to factor out constants */ + int aTempReg[8]; /* Holding area for temporary registers */ + int nRangeReg; /* Size of the temporary register block */ + int iRangeReg; /* First register in temporary register block */ + int nErr; /* Number of errors seen */ + int nTab; /* Number of previously allocated VDBE cursors */ + int nMem; /* Number of memory cells used so far */ + int nSet; /* Number of sets used so far */ + int nOnce; /* Number of OP_Once instructions so far */ + int nOpAlloc; /* Number of slots allocated for Vdbe.aOp[] */ + int iFixedOp; /* Never back out opcodes iFixedOp-1 or earlier */ + int ckBase; /* Base register of data during check constraints */ + int iSelfTab; /* Table of an index whose exprs are being coded */ + int iCacheLevel; /* ColCache valid when aColCache[].iLevel<=iCacheLevel */ + int iCacheCnt; /* Counter used to generate aColCache[].lru values */ + int nLabel; /* Number of labels used */ + int *aLabel; /* Space to hold the labels */ + struct yColCache { + int iTable; /* Table cursor number */ + i16 iColumn; /* Table column number */ + u8 tempReg; /* iReg is a temp register that needs to be freed */ + int iLevel; /* Nesting level */ + int iReg; /* Reg with value of this column. 0 means none. */ + int lru; /* Least recently used entry has the smallest value */ + } aColCache[SQLITE_N_COLCACHE]; /* One for each column cache entry */ + ExprList *pConstExpr;/* Constant expressions */ + Token constraintName;/* Name of the constraint currently being parsed */ + yDbMask writeMask; /* Start a write transaction on these databases */ + yDbMask cookieMask; /* Bitmask of schema verified databases */ + int cookieValue[SQLITE_MAX_ATTACHED+2]; /* Values of cookies to verify */ + int regRowid; /* Register holding rowid of CREATE TABLE entry */ + int regRoot; /* Register holding root page number for new objects */ + int nMaxArg; /* Max args passed to user function by sub-program */ +#if SELECTTRACE_ENABLED + int nSelect; /* Number of SELECT statements seen */ + int nSelectIndent; /* How far to indent SELECTTRACE() output */ +#endif +#ifndef SQLITE_OMIT_SHARED_CACHE + int nTableLock; /* Number of locks in aTableLock */ + TableLock *aTableLock; /* Required table locks for shared-cache mode */ +#endif + AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */ + + /* Information used while coding trigger programs. */ + Parse *pToplevel; /* Parse structure for main program (or NULL) */ + Table *pTriggerTab; /* Table triggers are being coded for */ + int addrCrTab; /* Address of OP_CreateTable opcode on CREATE TABLE */ + u32 nQueryLoop; /* Est number of iterations of a query (10*log2(N)) */ + u32 oldmask; /* Mask of old.* columns referenced */ + u32 newmask; /* Mask of new.* columns referenced */ + u8 eTriggerOp; /* TK_UPDATE, TK_INSERT or TK_DELETE */ + u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */ + u8 disableTriggers; /* True to disable triggers */ + + /************************************************************************ + ** Above is constant between recursions. Below is reset before and after + ** each recursion. The boundary between these two regions is determined + ** using offsetof(Parse,nVar) so the nVar field must be the first field + ** in the recursive region. + ************************************************************************/ + + int nVar; /* Number of '?' variables seen in the SQL so far */ + int nzVar; /* Number of available slots in azVar[] */ + u8 iPkSortOrder; /* ASC or DESC for INTEGER PRIMARY KEY */ + u8 bFreeWith; /* True if pWith should be freed with parser */ + u8 explain; /* True if the EXPLAIN flag is found on the query */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + u8 declareVtab; /* True if inside sqlite3_declare_vtab() */ + int nVtabLock; /* Number of virtual tables to lock */ +#endif + int nAlias; /* Number of aliased result set columns */ + int nHeight; /* Expression tree height of current sub-select */ +#ifndef SQLITE_OMIT_EXPLAIN + int iSelectId; /* ID of current select for EXPLAIN output */ + int iNextSelectId; /* Next available select ID for EXPLAIN output */ +#endif + char **azVar; /* Pointers to names of parameters */ + Vdbe *pReprepare; /* VM being reprepared (sqlite3Reprepare()) */ + const char *zTail; /* All SQL text past the last semicolon parsed */ + Table *pNewTable; /* A table being constructed by CREATE TABLE */ + Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */ + const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */ + Token sNameToken; /* Token with unqualified schema object name */ + Token sLastToken; /* The last token parsed */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + Token sArg; /* Complete text of a module argument */ + Table **apVtabLock; /* Pointer to virtual tables needing locking */ +#endif + Table *pZombieTab; /* List of Table objects to delete after code gen */ + TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */ + With *pWith; /* Current WITH clause, or NULL */ +}; + +/* +** Return true if currently inside an sqlite3_declare_vtab() call. +*/ +#ifdef SQLITE_OMIT_VIRTUALTABLE + #define IN_DECLARE_VTAB 0 +#else + #define IN_DECLARE_VTAB (pParse->declareVtab) +#endif + +/* +** An instance of the following structure can be declared on a stack and used +** to save the Parse.zAuthContext value so that it can be restored later. +*/ +struct AuthContext { + const char *zAuthContext; /* Put saved Parse.zAuthContext here */ + Parse *pParse; /* The Parse structure */ +}; + +/* +** Bitfield flags for P5 value in various opcodes. +*/ +#define OPFLAG_NCHANGE 0x01 /* Set to update db->nChange */ +#define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */ +#define OPFLAG_LASTROWID 0x02 /* Set to update db->lastRowid */ +#define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */ +#define OPFLAG_APPEND 0x08 /* This is likely to be an append */ +#define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */ +#define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */ +#define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */ +#define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */ +#define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */ +#define OPFLAG_P2ISREG 0x04 /* P2 to OP_Open** is a register number */ +#define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */ + +/* + * Each trigger present in the database schema is stored as an instance of + * struct Trigger. + * + * Pointers to instances of struct Trigger are stored in two ways. + * 1. In the "trigHash" hash table (part of the sqlite3* that represents the + * database). This allows Trigger structures to be retrieved by name. + * 2. All triggers associated with a single table form a linked list, using the + * pNext member of struct Trigger. A pointer to the first element of the + * linked list is stored as the "pTrigger" member of the associated + * struct Table. + * + * The "step_list" member points to the first element of a linked list + * containing the SQL statements specified as the trigger program. + */ +struct Trigger { + char *zName; /* The name of the trigger */ + char *table; /* The table or view to which the trigger applies */ + u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */ + u8 tr_tm; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */ + Expr *pWhen; /* The WHEN clause of the expression (may be NULL) */ + IdList *pColumns; /* If this is an UPDATE OF trigger, + the is stored here */ + Schema *pSchema; /* Schema containing the trigger */ + Schema *pTabSchema; /* Schema containing the table */ + TriggerStep *step_list; /* Link list of trigger program steps */ + Trigger *pNext; /* Next trigger associated with the table */ +}; + +/* +** A trigger is either a BEFORE or an AFTER trigger. The following constants +** determine which. +** +** If there are multiple triggers, you might of some BEFORE and some AFTER. +** In that cases, the constants below can be ORed together. +*/ +#define TRIGGER_BEFORE 1 +#define TRIGGER_AFTER 2 + +/* + * An instance of struct TriggerStep is used to store a single SQL statement + * that is a part of a trigger-program. + * + * Instances of struct TriggerStep are stored in a singly linked list (linked + * using the "pNext" member) referenced by the "step_list" member of the + * associated struct Trigger instance. The first element of the linked list is + * the first step of the trigger-program. + * + * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or + * "SELECT" statement. The meanings of the other members is determined by the + * value of "op" as follows: + * + * (op == TK_INSERT) + * orconf -> stores the ON CONFLICT algorithm + * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then + * this stores a pointer to the SELECT statement. Otherwise NULL. + * zTarget -> Dequoted name of the table to insert into. + * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then + * this stores values to be inserted. Otherwise NULL. + * pIdList -> If this is an INSERT INTO ... () VALUES ... + * statement, then this stores the column-names to be + * inserted into. + * + * (op == TK_DELETE) + * zTarget -> Dequoted name of the table to delete from. + * pWhere -> The WHERE clause of the DELETE statement if one is specified. + * Otherwise NULL. + * + * (op == TK_UPDATE) + * zTarget -> Dequoted name of the table to update. + * pWhere -> The WHERE clause of the UPDATE statement if one is specified. + * Otherwise NULL. + * pExprList -> A list of the columns to update and the expressions to update + * them to. See sqlite3Update() documentation of "pChanges" + * argument. + * + */ +struct TriggerStep { + u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */ + u8 orconf; /* OE_Rollback etc. */ + Trigger *pTrig; /* The trigger that this step is a part of */ + Select *pSelect; /* SELECT statement or RHS of INSERT INTO SELECT ... */ + char *zTarget; /* Target table for DELETE, UPDATE, INSERT */ + Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */ + ExprList *pExprList; /* SET clause for UPDATE. */ + IdList *pIdList; /* Column names for INSERT */ + TriggerStep *pNext; /* Next in the link-list */ + TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */ +}; + +/* +** The following structure contains information used by the sqliteFix... +** routines as they walk the parse tree to make database references +** explicit. +*/ +typedef struct DbFixer DbFixer; +struct DbFixer { + Parse *pParse; /* The parsing context. Error messages written here */ + Schema *pSchema; /* Fix items to this schema */ + int bVarOnly; /* Check for variable references only */ + const char *zDb; /* Make sure all objects are contained in this database */ + const char *zType; /* Type of the container - used for error messages */ + const Token *pName; /* Name of the container - used for error messages */ +}; + +/* +** An objected used to accumulate the text of a string where we +** do not necessarily know how big the string will be in the end. +*/ +struct StrAccum { + sqlite3 *db; /* Optional database for lookaside. Can be NULL */ + char *zBase; /* A base allocation. Not from malloc. */ + char *zText; /* The string collected so far */ + int nChar; /* Length of the string so far */ + int nAlloc; /* Amount of space allocated in zText */ + int mxAlloc; /* Maximum allowed allocation. 0 for no malloc usage */ + u8 accError; /* STRACCUM_NOMEM or STRACCUM_TOOBIG */ +}; +#define STRACCUM_NOMEM 1 +#define STRACCUM_TOOBIG 2 + +/* +** A pointer to this structure is used to communicate information +** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback. +*/ +typedef struct { + sqlite3 *db; /* The database being initialized */ + char **pzErrMsg; /* Error message stored here */ + int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */ + int rc; /* Result code stored here */ +} InitData; + +/* +** Structure containing global configuration data for the SQLite library. +** +** This structure also contains some state information. +*/ +struct Sqlite3Config { + int bMemstat; /* True to enable memory status */ + int bCoreMutex; /* True to enable core mutexing */ + int bFullMutex; /* True to enable full mutexing */ + int bOpenUri; /* True to interpret filenames as URIs */ + int bUseCis; /* Use covering indices for full-scans */ + int mxStrlen; /* Maximum string length */ + int neverCorrupt; /* Database is always well-formed */ + int szLookaside; /* Default lookaside buffer size */ + int nLookaside; /* Default lookaside buffer count */ + sqlite3_mem_methods m; /* Low-level memory allocation interface */ + sqlite3_mutex_methods mutex; /* Low-level mutex interface */ + sqlite3_pcache_methods2 pcache2; /* Low-level page-cache interface */ + void *pHeap; /* Heap storage space */ + int nHeap; /* Size of pHeap[] */ + int mnReq, mxReq; /* Min and max heap requests sizes */ + sqlite3_int64 szMmap; /* mmap() space per open file */ + sqlite3_int64 mxMmap; /* Maximum value for szMmap */ + void *pScratch; /* Scratch memory */ + int szScratch; /* Size of each scratch buffer */ + int nScratch; /* Number of scratch buffers */ + void *pPage; /* Page cache memory */ + int szPage; /* Size of each page in pPage[] */ + int nPage; /* Number of pages in pPage[] */ + int mxParserStack; /* maximum depth of the parser stack */ + int sharedCacheEnabled; /* true if shared-cache mode enabled */ + u32 szPma; /* Maximum Sorter PMA size */ + /* The above might be initialized to non-zero. The following need to always + ** initially be zero, however. */ + int isInit; /* True after initialization has finished */ + int inProgress; /* True while initialization in progress */ + int isMutexInit; /* True after mutexes are initialized */ + int isMallocInit; /* True after malloc is initialized */ + int isPCacheInit; /* True after malloc is initialized */ + int nRefInitMutex; /* Number of users of pInitMutex */ + sqlite3_mutex *pInitMutex; /* Mutex used by sqlite3_initialize() */ + void (*xLog)(void*,int,const char*); /* Function for logging */ + void *pLogArg; /* First argument to xLog() */ +#ifdef SQLITE_ENABLE_SQLLOG + void(*xSqllog)(void*,sqlite3*,const char*, int); + void *pSqllogArg; +#endif +#ifdef SQLITE_VDBE_COVERAGE + /* The following callback (if not NULL) is invoked on every VDBE branch + ** operation. Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE. + */ + void (*xVdbeBranch)(void*,int iSrcLine,u8 eThis,u8 eMx); /* Callback */ + void *pVdbeBranchArg; /* 1st argument */ +#endif +#ifndef SQLITE_OMIT_BUILTIN_TEST + int (*xTestCallback)(int); /* Invoked by sqlite3FaultSim() */ +#endif + int bLocaltimeFault; /* True to fail localtime() calls */ +}; + +/* +** This macro is used inside of assert() statements to indicate that +** the assert is only valid on a well-formed database. Instead of: +** +** assert( X ); +** +** One writes: +** +** assert( X || CORRUPT_DB ); +** +** CORRUPT_DB is true during normal operation. CORRUPT_DB does not indicate +** that the database is definitely corrupt, only that it might be corrupt. +** For most test cases, CORRUPT_DB is set to false using a special +** sqlite3_test_control(). This enables assert() statements to prove +** things that are always true for well-formed databases. +*/ +#define CORRUPT_DB (sqlite3Config.neverCorrupt==0) + +/* +** Context pointer passed down through the tree-walk. +*/ +struct Walker { + int (*xExprCallback)(Walker*, Expr*); /* Callback for expressions */ + int (*xSelectCallback)(Walker*,Select*); /* Callback for SELECTs */ + void (*xSelectCallback2)(Walker*,Select*);/* Second callback for SELECTs */ + Parse *pParse; /* Parser context. */ + int walkerDepth; /* Number of subqueries */ + u8 eCode; /* A small processing code */ + union { /* Extra data for callback */ + NameContext *pNC; /* Naming context */ + int n; /* A counter */ + int iCur; /* A cursor number */ + SrcList *pSrcList; /* FROM clause */ + struct SrcCount *pSrcCount; /* Counting column references */ + } u; +}; + +/* Forward declarations */ +SQLITE_PRIVATE int sqlite3WalkExpr(Walker*, Expr*); +SQLITE_PRIVATE int sqlite3WalkExprList(Walker*, ExprList*); +SQLITE_PRIVATE int sqlite3WalkSelect(Walker*, Select*); +SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker*, Select*); +SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker*, Select*); + +/* +** Return code from the parse-tree walking primitives and their +** callbacks. +*/ +#define WRC_Continue 0 /* Continue down into children */ +#define WRC_Prune 1 /* Omit children but continue walking siblings */ +#define WRC_Abort 2 /* Abandon the tree walk */ + +/* +** An instance of this structure represents a set of one or more CTEs +** (common table expressions) created by a single WITH clause. +*/ +struct With { + int nCte; /* Number of CTEs in the WITH clause */ + With *pOuter; /* Containing WITH clause, or NULL */ + struct Cte { /* For each CTE in the WITH clause.... */ + char *zName; /* Name of this CTE */ + ExprList *pCols; /* List of explicit column names, or NULL */ + Select *pSelect; /* The definition of this CTE */ + const char *zCteErr; /* Error message for circular references */ + } a[1]; +}; + +#ifdef SQLITE_DEBUG +/* +** An instance of the TreeView object is used for printing the content of +** data structures on sqlite3DebugPrintf() using a tree-like view. +*/ +struct TreeView { + int iLevel; /* Which level of the tree we are on */ + u8 bLine[100]; /* Draw vertical in column i if bLine[i] is true */ +}; +#endif /* SQLITE_DEBUG */ + +/* +** Assuming zIn points to the first byte of a UTF-8 character, +** advance zIn to point to the first byte of the next UTF-8 character. +*/ +#define SQLITE_SKIP_UTF8(zIn) { \ + if( (*(zIn++))>=0xc0 ){ \ + while( (*zIn & 0xc0)==0x80 ){ zIn++; } \ + } \ +} + +/* +** The SQLITE_*_BKPT macros are substitutes for the error codes with +** the same name but without the _BKPT suffix. These macros invoke +** routines that report the line-number on which the error originated +** using sqlite3_log(). The routines also provide a convenient place +** to set a debugger breakpoint. +*/ +SQLITE_PRIVATE int sqlite3CorruptError(int); +SQLITE_PRIVATE int sqlite3MisuseError(int); +SQLITE_PRIVATE int sqlite3CantopenError(int); +#define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__) +#define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__) +#define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__) + + +/* +** FTS4 is really an extension for FTS3. It is enabled using the +** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also call +** the SQLITE_ENABLE_FTS4 macro to serve as an alias for SQLITE_ENABLE_FTS3. +*/ +#if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3) +# define SQLITE_ENABLE_FTS3 1 +#endif + +/* +** The ctype.h header is needed for non-ASCII systems. It is also +** needed by FTS3 when FTS3 is included in the amalgamation. +*/ +#if !defined(SQLITE_ASCII) || \ + (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION)) +# include +#endif + +/* +** The following macros mimic the standard library functions toupper(), +** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The +** sqlite versions only work for ASCII characters, regardless of locale. +*/ +#ifdef SQLITE_ASCII +# define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20)) +# define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01) +# define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06) +# define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02) +# define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04) +# define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08) +# define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)]) +#else +# define sqlite3Toupper(x) toupper((unsigned char)(x)) +# define sqlite3Isspace(x) isspace((unsigned char)(x)) +# define sqlite3Isalnum(x) isalnum((unsigned char)(x)) +# define sqlite3Isalpha(x) isalpha((unsigned char)(x)) +# define sqlite3Isdigit(x) isdigit((unsigned char)(x)) +# define sqlite3Isxdigit(x) isxdigit((unsigned char)(x)) +# define sqlite3Tolower(x) tolower((unsigned char)(x)) +#endif +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +SQLITE_PRIVATE int sqlite3IsIdChar(u8); +#endif + +/* +** Internal function prototypes +*/ +#define sqlite3StrICmp sqlite3_stricmp +SQLITE_PRIVATE int sqlite3Strlen30(const char*); +#define sqlite3StrNICmp sqlite3_strnicmp + +SQLITE_PRIVATE int sqlite3MallocInit(void); +SQLITE_PRIVATE void sqlite3MallocEnd(void); +SQLITE_PRIVATE void *sqlite3Malloc(u64); +SQLITE_PRIVATE void *sqlite3MallocZero(u64); +SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3*, u64); +SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3*, u64); +SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3*,const char*); +SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3*,const char*, u64); +SQLITE_PRIVATE void *sqlite3Realloc(void*, u64); +SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *, void *, u64); +SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *, void *, u64); +SQLITE_PRIVATE void sqlite3DbFree(sqlite3*, void*); +SQLITE_PRIVATE int sqlite3MallocSize(void*); +SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, void*); +SQLITE_PRIVATE void *sqlite3ScratchMalloc(int); +SQLITE_PRIVATE void sqlite3ScratchFree(void*); +SQLITE_PRIVATE void *sqlite3PageMalloc(int); +SQLITE_PRIVATE void sqlite3PageFree(void*); +SQLITE_PRIVATE void sqlite3MemSetDefault(void); +#ifndef SQLITE_OMIT_BUILTIN_TEST +SQLITE_PRIVATE void sqlite3BenignMallocHooks(void (*)(void), void (*)(void)); +#endif +SQLITE_PRIVATE int sqlite3HeapNearlyFull(void); + +/* +** On systems with ample stack space and that support alloca(), make +** use of alloca() to obtain space for large automatic objects. By default, +** obtain space from malloc(). +** +** The alloca() routine never returns NULL. This will cause code paths +** that deal with sqlite3StackAlloc() failures to be unreachable. +*/ +#ifdef SQLITE_USE_ALLOCA +# define sqlite3StackAllocRaw(D,N) alloca(N) +# define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N) +# define sqlite3StackFree(D,P) +#else +# define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N) +# define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N) +# define sqlite3StackFree(D,P) sqlite3DbFree(D,P) +#endif + +#ifdef SQLITE_ENABLE_MEMSYS3 +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void); +#endif +#ifdef SQLITE_ENABLE_MEMSYS5 +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void); +#endif + + +#ifndef SQLITE_MUTEX_OMIT +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void); +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void); +SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int); +SQLITE_PRIVATE int sqlite3MutexInit(void); +SQLITE_PRIVATE int sqlite3MutexEnd(void); +#endif +#if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP) +SQLITE_PRIVATE void sqlite3MemoryBarrier(void); +#else +# define sqlite3MemoryBarrier() +#endif + +SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(int); +SQLITE_PRIVATE void sqlite3StatusUp(int, int); +SQLITE_PRIVATE void sqlite3StatusDown(int, int); +SQLITE_PRIVATE void sqlite3StatusSet(int, int); + +/* Access to mutexes used by sqlite3_status() */ +SQLITE_PRIVATE sqlite3_mutex *sqlite3Pcache1Mutex(void); +SQLITE_PRIVATE sqlite3_mutex *sqlite3MallocMutex(void); + +#ifndef SQLITE_OMIT_FLOATING_POINT +SQLITE_PRIVATE int sqlite3IsNaN(double); +#else +# define sqlite3IsNaN(X) 0 +#endif + +/* +** An instance of the following structure holds information about SQL +** functions arguments that are the parameters to the printf() function. +*/ +struct PrintfArguments { + int nArg; /* Total number of arguments */ + int nUsed; /* Number of arguments used so far */ + sqlite3_value **apArg; /* The argument values */ +}; + +#define SQLITE_PRINTF_INTERNAL 0x01 +#define SQLITE_PRINTF_SQLFUNC 0x02 +SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, u32, const char*, va_list); +SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, u32, const char*, ...); +SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3*,const char*, ...); +SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3*,const char*, va_list); +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) +SQLITE_PRIVATE void sqlite3DebugPrintf(const char*, ...); +#endif +#if defined(SQLITE_TEST) +SQLITE_PRIVATE void *sqlite3TestTextToPtr(const char*); +#endif + +#if defined(SQLITE_DEBUG) +SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView*, const Expr*, u8); +SQLITE_PRIVATE void sqlite3TreeViewExprList(TreeView*, const ExprList*, u8, const char*); +SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView*, const Select*, u8); +#endif + + +SQLITE_PRIVATE void sqlite3SetString(char **, sqlite3*, const char*); +SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...); +SQLITE_PRIVATE int sqlite3Dequote(char*); +SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int); +SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*, char **); +SQLITE_PRIVATE void sqlite3FinishCoding(Parse*); +SQLITE_PRIVATE int sqlite3GetTempReg(Parse*); +SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse*,int); +SQLITE_PRIVATE int sqlite3GetTempRange(Parse*,int); +SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse*,int,int); +SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse*); +SQLITE_PRIVATE Expr *sqlite3ExprAlloc(sqlite3*,int,const Token*,int); +SQLITE_PRIVATE Expr *sqlite3Expr(sqlite3*,int,const char*); +SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*); +SQLITE_PRIVATE Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*, const Token*); +SQLITE_PRIVATE Expr *sqlite3ExprAnd(sqlite3*,Expr*, Expr*); +SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*); +SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*); +SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*); +SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*); +SQLITE_PRIVATE void sqlite3ExprListSetSortOrder(ExprList*,int); +SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int); +SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,ExprSpan*); +SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*); +SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList*); +SQLITE_PRIVATE int sqlite3Init(sqlite3*, char**); +SQLITE_PRIVATE int sqlite3InitCallback(void*, int, char**, char**); +SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int); +SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3*); +SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3*,int); +SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3*); +SQLITE_PRIVATE void sqlite3BeginParse(Parse*,int); +SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*); +SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3*,Table*); +SQLITE_PRIVATE int sqlite3ColumnsFromExprList(Parse*,ExprList*,i16*,Column**); +SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*); +SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *, int); +SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table*); +SQLITE_PRIVATE i16 sqlite3ColumnOfIndex(Index*, i16); +SQLITE_PRIVATE void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int); +SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token*); +SQLITE_PRIVATE void sqlite3AddNotNull(Parse*, int); +SQLITE_PRIVATE void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int); +SQLITE_PRIVATE void sqlite3AddCheckConstraint(Parse*, Expr*); +SQLITE_PRIVATE void sqlite3AddColumnType(Parse*,Token*); +SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,ExprSpan*); +SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*); +SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,u8,Select*); +SQLITE_PRIVATE int sqlite3ParseUri(const char*,const char*,unsigned int*, + sqlite3_vfs**,char**,char **); +SQLITE_PRIVATE Btree *sqlite3DbNameToBtree(sqlite3*,const char*); +SQLITE_PRIVATE int sqlite3CodeOnce(Parse *); + +#ifdef SQLITE_OMIT_BUILTIN_TEST +# define sqlite3FaultSim(X) SQLITE_OK +#else +SQLITE_PRIVATE int sqlite3FaultSim(int); +#endif + +SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32); +SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec*, u32); +SQLITE_PRIVATE int sqlite3BitvecTestNotNull(Bitvec*, u32); +SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec*, u32); +SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec*, u32, void*); +SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec*); +SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec*); +#ifndef SQLITE_OMIT_BUILTIN_TEST +SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int,int*); +#endif + +SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3*, void*, unsigned int); +SQLITE_PRIVATE void sqlite3RowSetClear(RowSet*); +SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet*, i64); +SQLITE_PRIVATE int sqlite3RowSetTest(RowSet*, int iBatch, i64); +SQLITE_PRIVATE int sqlite3RowSetNext(RowSet*, i64*); + +SQLITE_PRIVATE void sqlite3CreateView(Parse*,Token*,Token*,Token*,ExprList*,Select*,int,int); + +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) +SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse*,Table*); +#else +# define sqlite3ViewGetColumnNames(A,B) 0 +#endif + +#if SQLITE_MAX_ATTACHED>30 +SQLITE_PRIVATE int sqlite3DbMaskAllZero(yDbMask); +#endif +SQLITE_PRIVATE void sqlite3DropTable(Parse*, SrcList*, int, int); +SQLITE_PRIVATE void sqlite3CodeDropTable(Parse*, Table*, int, int); +SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3*, Table*); +#ifndef SQLITE_OMIT_AUTOINCREMENT +SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse); +SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse); +#else +# define sqlite3AutoincrementBegin(X) +# define sqlite3AutoincrementEnd(X) +#endif +SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, Select*, IdList*, int); +SQLITE_PRIVATE void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*); +SQLITE_PRIVATE IdList *sqlite3IdListAppend(sqlite3*, IdList*, Token*); +SQLITE_PRIVATE int sqlite3IdListIndex(IdList*,const char*); +SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(sqlite3*, SrcList*, int, int); +SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(sqlite3*, SrcList*, Token*, Token*); +SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*, + Token*, Select*, Expr*, IdList*); +SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *); +SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*); +SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *, struct SrcList_item *); +SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList*); +SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse*, SrcList*); +SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3*, IdList*); +SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3*, SrcList*); +SQLITE_PRIVATE Index *sqlite3AllocateIndexObject(sqlite3*,i16,int,char**); +SQLITE_PRIVATE Index *sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*, + Expr*, int, int); +SQLITE_PRIVATE void sqlite3DropIndex(Parse*, SrcList*, int); +SQLITE_PRIVATE int sqlite3Select(Parse*, Select*, SelectDest*); +SQLITE_PRIVATE Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*, + Expr*,ExprList*,u16,Expr*,Expr*); +SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3*, Select*); +SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse*, SrcList*); +SQLITE_PRIVATE int sqlite3IsReadOnly(Parse*, Table*, int); +SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int); +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) +SQLITE_PRIVATE Expr *sqlite3LimitWhere(Parse*,SrcList*,Expr*,ExprList*,Expr*,Expr*,char*); +#endif +SQLITE_PRIVATE void sqlite3DeleteFrom(Parse*, SrcList*, Expr*); +SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int); +SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,ExprList*,u16,int); +SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo*); +SQLITE_PRIVATE u64 sqlite3WhereOutputRowCount(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereIsSorted(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo*, int*); +#define ONEPASS_OFF 0 /* Use of ONEPASS not allowed */ +#define ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */ +#define ONEPASS_MULTI 2 /* ONEPASS is valid for multiple rows */ +SQLITE_PRIVATE void sqlite3ExprCodeLoadIndexColumn(Parse*, Index*, int, int, int); +SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int, u8); +SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int); +SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int); +SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse*, int, int, int); +SQLITE_PRIVATE void sqlite3ExprCachePush(Parse*); +SQLITE_PRIVATE void sqlite3ExprCachePop(Parse*); +SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse*, int, int); +SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse*); +SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse*, int, int); +SQLITE_PRIVATE void sqlite3ExprCode(Parse*, Expr*, int); +SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse*, Expr*, int); +SQLITE_PRIVATE void sqlite3ExprCodeAtInit(Parse*, Expr*, int, u8); +SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse*, Expr*, int*); +SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse*, Expr*, int); +SQLITE_PRIVATE void sqlite3ExprCodeAndCache(Parse*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprCodeExprList(Parse*, ExprList*, int, int, u8); +#define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */ +#define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */ +#define SQLITE_ECEL_REF 0x04 /* Use ExprList.u.x.iOrderByCol */ +SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse*, Expr*, int, int); +SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse*, Expr*, int, int); +SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse*, Expr*, int, int); +SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3*,const char*, const char*); +SQLITE_PRIVATE Table *sqlite3LocateTable(Parse*,int isView,const char*, const char*); +SQLITE_PRIVATE Table *sqlite3LocateTableItem(Parse*,int isView,struct SrcList_item *); +SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3*,const char*, const char*); +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*); +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*); +SQLITE_PRIVATE void sqlite3Vacuum(Parse*); +SQLITE_PRIVATE int sqlite3RunVacuum(char**, sqlite3*); +SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3*, Token*); +SQLITE_PRIVATE int sqlite3ExprCompare(Expr*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList*, ExprList*, int); +SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Expr*, Expr*, int); +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*); +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*); +SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr*, SrcList*); +SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse*); +#ifndef SQLITE_OMIT_BUILTIN_TEST +SQLITE_PRIVATE void sqlite3PrngSaveState(void); +SQLITE_PRIVATE void sqlite3PrngRestoreState(void); +#endif +SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3*,int); +SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse*, int); +SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb); +SQLITE_PRIVATE void sqlite3BeginTransaction(Parse*, int); +SQLITE_PRIVATE void sqlite3CommitTransaction(Parse*); +SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse*); +SQLITE_PRIVATE void sqlite3Savepoint(Parse*, int, Token*); +SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *); +SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3*); +SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr*); +SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr*); +SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*, u8); +SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr*,int); +SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr*, int*); +SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr*); +SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr*, char); +SQLITE_PRIVATE int sqlite3IsRowid(const char*); +SQLITE_PRIVATE void sqlite3GenerateRowDelete( + Parse*,Table*,Trigger*,int,int,int,i16,u8,u8,u8,int); +SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int, int*, int); +SQLITE_PRIVATE int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int, int*,Index*,int); +SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse*,int); +SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int*,int,int,int,int, + u8,u8,int,int*); +SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*,Table*,int,int,int,int*,int,int,int); +SQLITE_PRIVATE int sqlite3OpenTableAndIndices(Parse*, Table*, int, int, u8*, int*, int*); +SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse*, int, int); +SQLITE_PRIVATE void sqlite3MultiWrite(Parse*); +SQLITE_PRIVATE void sqlite3MayAbort(Parse*); +SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, int, char*, i8, u8); +SQLITE_PRIVATE void sqlite3UniqueConstraint(Parse*, int, Index*); +SQLITE_PRIVATE void sqlite3RowidConstraint(Parse*, int, Table*); +SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3*,Expr*,int); +SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,ExprList*,int); +SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,SrcList*,int); +SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,IdList*); +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,Select*,int); +#if SELECTTRACE_ENABLED +SQLITE_PRIVATE void sqlite3SelectSetName(Select*,const char*); +#else +# define sqlite3SelectSetName(A,B) +#endif +SQLITE_PRIVATE void sqlite3FuncDefInsert(FuncDefHash*, FuncDef*); +SQLITE_PRIVATE FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,int,u8,u8); +SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3*); +SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void); +SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void); +SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3*); +SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3*); +SQLITE_PRIVATE void sqlite3ChangeCookie(Parse*, int); + +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) +SQLITE_PRIVATE void sqlite3MaterializeView(Parse*, Table*, Expr*, int); +#endif + +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*, + Expr*,int, int); +SQLITE_PRIVATE void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*); +SQLITE_PRIVATE void sqlite3DropTrigger(Parse*, SrcList*, int); +SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse*, Trigger*); +SQLITE_PRIVATE Trigger *sqlite3TriggersExist(Parse *, Table*, int, ExprList*, int *pMask); +SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *, Table *); +SQLITE_PRIVATE void sqlite3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *, + int, int, int); +SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int); + void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*); +SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(sqlite3*,Token*, IdList*, + Select*,u8); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(sqlite3*,Token*,ExprList*, Expr*, u8); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(sqlite3*,Token*, Expr*); +SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3*, Trigger*); +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*); +SQLITE_PRIVATE u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int); +# define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p)) +# define sqlite3IsToplevel(p) ((p)->pToplevel==0) +#else +# define sqlite3TriggersExist(B,C,D,E,F) 0 +# define sqlite3DeleteTrigger(A,B) +# define sqlite3DropTriggerPtr(A,B) +# define sqlite3UnlinkAndDeleteTrigger(A,B,C) +# define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I) +# define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F) +# define sqlite3TriggerList(X, Y) 0 +# define sqlite3ParseToplevel(p) p +# define sqlite3IsToplevel(p) 1 +# define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0 +#endif + +SQLITE_PRIVATE int sqlite3JoinType(Parse*, Token*, Token*, Token*); +SQLITE_PRIVATE void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int); +SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse*, int); +#ifndef SQLITE_OMIT_AUTHORIZATION +SQLITE_PRIVATE void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*); +SQLITE_PRIVATE int sqlite3AuthCheck(Parse*,int, const char*, const char*, const char*); +SQLITE_PRIVATE void sqlite3AuthContextPush(Parse*, AuthContext*, const char*); +SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext*); +SQLITE_PRIVATE int sqlite3AuthReadCol(Parse*, const char *, const char *, int); +#else +# define sqlite3AuthRead(a,b,c,d) +# define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK +# define sqlite3AuthContextPush(a,b,c) +# define sqlite3AuthContextPop(a) ((void)(a)) +#endif +SQLITE_PRIVATE void sqlite3Attach(Parse*, Expr*, Expr*, Expr*); +SQLITE_PRIVATE void sqlite3Detach(Parse*, Expr*); +SQLITE_PRIVATE void sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Token*); +SQLITE_PRIVATE int sqlite3FixSrcList(DbFixer*, SrcList*); +SQLITE_PRIVATE int sqlite3FixSelect(DbFixer*, Select*); +SQLITE_PRIVATE int sqlite3FixExpr(DbFixer*, Expr*); +SQLITE_PRIVATE int sqlite3FixExprList(DbFixer*, ExprList*); +SQLITE_PRIVATE int sqlite3FixTriggerStep(DbFixer*, TriggerStep*); +SQLITE_PRIVATE int sqlite3AtoF(const char *z, double*, int, u8); +SQLITE_PRIVATE int sqlite3GetInt32(const char *, int*); +SQLITE_PRIVATE int sqlite3Atoi(const char*); +SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar); +SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte); +SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8**); +SQLITE_PRIVATE LogEst sqlite3LogEst(u64); +SQLITE_PRIVATE LogEst sqlite3LogEstAdd(LogEst,LogEst); +#ifndef SQLITE_OMIT_VIRTUALTABLE +SQLITE_PRIVATE LogEst sqlite3LogEstFromDouble(double); +#endif +SQLITE_PRIVATE u64 sqlite3LogEstToInt(LogEst); + +/* +** Routines to read and write variable-length integers. These used to +** be defined locally, but now we use the varint routines in the util.c +** file. +*/ +SQLITE_PRIVATE int sqlite3PutVarint(unsigned char*, u64); +SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *, u64 *); +SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *, u32 *); +SQLITE_PRIVATE int sqlite3VarintLen(u64 v); + +/* +** The common case is for a varint to be a single byte. They following +** macros handle the common case without a procedure call, but then call +** the procedure for larger varints. +*/ +#define getVarint32(A,B) \ + (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B))) +#define putVarint32(A,B) \ + (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\ + sqlite3PutVarint((A),(B))) +#define getVarint sqlite3GetVarint +#define putVarint sqlite3PutVarint + + +SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3*, Index*); +SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe*, Table*, int); +SQLITE_PRIVATE char sqlite3CompareAffinity(Expr *pExpr, char aff2); +SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity); +SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr); +SQLITE_PRIVATE int sqlite3Atoi64(const char*, i64*, int, u8); +SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char*, i64*); +SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3*, int, const char*,...); +SQLITE_PRIVATE void sqlite3Error(sqlite3*,int); +SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n); +SQLITE_PRIVATE u8 sqlite3HexToInt(int h); +SQLITE_PRIVATE int sqlite3TwoPartName(Parse *, Token *, Token *, Token **); + +#if defined(SQLITE_NEED_ERR_NAME) +SQLITE_PRIVATE const char *sqlite3ErrName(int); +#endif + +SQLITE_PRIVATE const char *sqlite3ErrStr(int); +SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse); +SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int); +SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName); +SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr); +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr*, const Token*, int); +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse*,Expr*,const char*); +SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr*); +SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *, CollSeq *); +SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *, const char *); +SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, int); +SQLITE_PRIVATE int sqlite3AddInt64(i64*,i64); +SQLITE_PRIVATE int sqlite3SubInt64(i64*,i64); +SQLITE_PRIVATE int sqlite3MulInt64(i64*,i64); +SQLITE_PRIVATE int sqlite3AbsInt32(int); +#ifdef SQLITE_ENABLE_8_3_NAMES +SQLITE_PRIVATE void sqlite3FileSuffix3(const char*, char*); +#else +# define sqlite3FileSuffix3(X,Y) +#endif +SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z,u8); + +SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8); +SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value*, u8); +SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8, + void(*)(void*)); +SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value*); +SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value*); +SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *); +SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8); +SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **); +SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8); +#ifndef SQLITE_AMALGAMATION +SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[]; +SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[]; +SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[]; +SQLITE_PRIVATE const Token sqlite3IntTokens[]; +SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config; +SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions; +#ifndef SQLITE_OMIT_WSD +SQLITE_PRIVATE int sqlite3PendingByte; +#endif +#endif +SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3*, int, int, int); +SQLITE_PRIVATE void sqlite3Reindex(Parse*, Token*, Token*); +SQLITE_PRIVATE void sqlite3AlterFunctions(void); +SQLITE_PRIVATE void sqlite3AlterRenameTable(Parse*, SrcList*, Token*); +SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *, int *); +SQLITE_PRIVATE void sqlite3NestedParse(Parse*, const char*, ...); +SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*); +SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *, Expr *, int, int); +SQLITE_PRIVATE void sqlite3SelectPrep(Parse*, Select*, NameContext*); +SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p); +SQLITE_PRIVATE int sqlite3MatchSpanName(const char*, const char*, const char*, const char*); +SQLITE_PRIVATE int sqlite3ResolveExprNames(NameContext*, Expr*); +SQLITE_PRIVATE int sqlite3ResolveExprListNames(NameContext*, ExprList*); +SQLITE_PRIVATE void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*); +SQLITE_PRIVATE void sqlite3ResolveSelfReference(Parse*,Table*,int,Expr*,ExprList*); +SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*); +SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int); +SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *); +SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *); +SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*); +SQLITE_PRIVATE char sqlite3AffinityType(const char*, u8*); +SQLITE_PRIVATE void sqlite3Analyze(Parse*, Token*, Token*); +SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler*); +SQLITE_PRIVATE int sqlite3FindDb(sqlite3*, Token*); +SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *, const char *); +SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3*,int iDB); +SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3*,Index*); +SQLITE_PRIVATE void sqlite3DefaultRowEst(Index*); +SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3*, int); +SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*); +SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse*, int, int); +SQLITE_PRIVATE void sqlite3SchemaClear(void *); +SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *, Btree *); +SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3*,int,int); +SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo*); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo*); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo*); +#endif +SQLITE_PRIVATE int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *, + void (*)(sqlite3_context*,int,sqlite3_value **), + void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*), + FuncDestructor *pDestructor +); +SQLITE_PRIVATE int sqlite3ApiExit(sqlite3 *db, int); +SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *); + +SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, sqlite3*, char*, int, int); +SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum*,const char*,int); +SQLITE_PRIVATE void sqlite3StrAccumAppendAll(StrAccum*,const char*); +SQLITE_PRIVATE void sqlite3AppendChar(StrAccum*,int,char); +SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum*); +SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum*); +SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest*,int,int); +SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int); + +SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *); +SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *); + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +SQLITE_PRIVATE void sqlite3AnalyzeFunctions(void); +SQLITE_PRIVATE int sqlite3Stat4ProbeSetValue(Parse*,Index*,UnpackedRecord**,Expr*,u8,int,int*); +SQLITE_PRIVATE int sqlite3Stat4ValueFromExpr(Parse*, Expr*, u8, sqlite3_value**); +SQLITE_PRIVATE void sqlite3Stat4ProbeFree(UnpackedRecord*); +SQLITE_PRIVATE int sqlite3Stat4Column(sqlite3*, const void*, int, int, sqlite3_value**); +#endif + +/* +** The interface to the LEMON-generated parser +*/ +SQLITE_PRIVATE void *sqlite3ParserAlloc(void*(*)(u64)); +SQLITE_PRIVATE void sqlite3ParserFree(void*, void(*)(void*)); +SQLITE_PRIVATE void sqlite3Parser(void*, int, Token, Parse*); +#ifdef YYTRACKMAXSTACKDEPTH +SQLITE_PRIVATE int sqlite3ParserStackPeak(void*); +#endif + +SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3*); +#ifndef SQLITE_OMIT_LOAD_EXTENSION +SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3*); +#else +# define sqlite3CloseExtensions(X) +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE +SQLITE_PRIVATE void sqlite3TableLock(Parse *, int, int, u8, const char *); +#else + #define sqlite3TableLock(v,w,x,y,z) +#endif + +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3Utf8To8(unsigned char*); +#endif + +#ifdef SQLITE_OMIT_VIRTUALTABLE +# define sqlite3VtabClear(Y) +# define sqlite3VtabSync(X,Y) SQLITE_OK +# define sqlite3VtabRollback(X) +# define sqlite3VtabCommit(X) +# define sqlite3VtabInSync(db) 0 +# define sqlite3VtabLock(X) +# define sqlite3VtabUnlock(X) +# define sqlite3VtabUnlockList(X) +# define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK +# define sqlite3GetVTable(X,Y) ((VTable*)0) +#else +SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table*); +SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p); +SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, Vdbe*); +SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db); +SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db); +SQLITE_PRIVATE void sqlite3VtabLock(VTable *); +SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *); +SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3*); +SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *, int, int); +SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe*, sqlite3_vtab*); +SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3*, Table*); +# define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0) +#endif +SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse*,Module*); +SQLITE_PRIVATE void sqlite3VtabEponymousTableClear(sqlite3*,Module*); +SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse*,Table*); +SQLITE_PRIVATE void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*, int); +SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse*, Token*); +SQLITE_PRIVATE void sqlite3VtabArgInit(Parse*); +SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse*, Token*); +SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **); +SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse*, Table*); +SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3*, int, const char *); +SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *, VTable *); +SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*); +SQLITE_PRIVATE void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**); +SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*); +SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe*, const char*, int); +SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *); +SQLITE_PRIVATE void sqlite3ParserReset(Parse*); +SQLITE_PRIVATE int sqlite3Reprepare(Vdbe*); +SQLITE_PRIVATE void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*); +SQLITE_PRIVATE CollSeq *sqlite3BinaryCompareCollSeq(Parse *, Expr *, Expr *); +SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3*); +SQLITE_PRIVATE const char *sqlite3JournalModename(int); +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3*, int, int, int*, int*); +SQLITE_PRIVATE int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int); +#endif +#ifndef SQLITE_OMIT_CTE +SQLITE_PRIVATE With *sqlite3WithAdd(Parse*,With*,Token*,ExprList*,Select*); +SQLITE_PRIVATE void sqlite3WithDelete(sqlite3*,With*); +SQLITE_PRIVATE void sqlite3WithPush(Parse*, With*, u8); +#else +#define sqlite3WithPush(x,y,z) +#define sqlite3WithDelete(x,y) +#endif + +/* Declarations for functions in fkey.c. All of these are replaced by +** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign +** key functionality is available. If OMIT_TRIGGER is defined but +** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In +** this case foreign keys are parsed, but no other functionality is +** provided (enforcement of FK constraints requires the triggers sub-system). +*/ +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) +SQLITE_PRIVATE void sqlite3FkCheck(Parse*, Table*, int, int, int*, int); +SQLITE_PRIVATE void sqlite3FkDropTable(Parse*, SrcList *, Table*); +SQLITE_PRIVATE void sqlite3FkActions(Parse*, Table*, ExprList*, int, int*, int); +SQLITE_PRIVATE int sqlite3FkRequired(Parse*, Table*, int*, int); +SQLITE_PRIVATE u32 sqlite3FkOldmask(Parse*, Table*); +SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *); +#else + #define sqlite3FkActions(a,b,c,d,e,f) + #define sqlite3FkCheck(a,b,c,d,e,f) + #define sqlite3FkDropTable(a,b,c) + #define sqlite3FkOldmask(a,b) 0 + #define sqlite3FkRequired(a,b,c,d) 0 +#endif +#ifndef SQLITE_OMIT_FOREIGN_KEY +SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *, Table*); +SQLITE_PRIVATE int sqlite3FkLocateIndex(Parse*,Table*,FKey*,Index**,int**); +#else + #define sqlite3FkDelete(a,b) + #define sqlite3FkLocateIndex(a,b,c,d,e) +#endif + + +/* +** Available fault injectors. Should be numbered beginning with 0. +*/ +#define SQLITE_FAULTINJECTOR_MALLOC 0 +#define SQLITE_FAULTINJECTOR_COUNT 1 + +/* +** The interface to the code in fault.c used for identifying "benign" +** malloc failures. This is only present if SQLITE_OMIT_BUILTIN_TEST +** is not defined. +*/ +#ifndef SQLITE_OMIT_BUILTIN_TEST +SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void); +SQLITE_PRIVATE void sqlite3EndBenignMalloc(void); +#else + #define sqlite3BeginBenignMalloc() + #define sqlite3EndBenignMalloc() +#endif + +/* +** Allowed return values from sqlite3FindInIndex() +*/ +#define IN_INDEX_ROWID 1 /* Search the rowid of the table */ +#define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */ +#define IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */ +#define IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */ +#define IN_INDEX_NOOP 5 /* No table available. Use comparisons */ +/* +** Allowed flags for the 3rd parameter to sqlite3FindInIndex(). +*/ +#define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */ +#define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */ +#define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */ +SQLITE_PRIVATE int sqlite3FindInIndex(Parse *, Expr *, u32, int*); + +#ifdef SQLITE_ENABLE_ATOMIC_WRITE +SQLITE_PRIVATE int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int); +SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *); +SQLITE_PRIVATE int sqlite3JournalCreate(sqlite3_file *); +SQLITE_PRIVATE int sqlite3JournalExists(sqlite3_file *p); +#else + #define sqlite3JournalSize(pVfs) ((pVfs)->szOsFile) + #define sqlite3JournalExists(p) 1 +#endif + +SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *); +SQLITE_PRIVATE int sqlite3MemJournalSize(void); +SQLITE_PRIVATE int sqlite3IsMemJournal(sqlite3_file *); + +SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p); +#if SQLITE_MAX_EXPR_DEPTH>0 +SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *); +SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse*, int); +#else + #define sqlite3SelectExprHeight(x) 0 + #define sqlite3ExprCheckHeight(x,y) +#endif + +SQLITE_PRIVATE u32 sqlite3Get4byte(const u8*); +SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32); + +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY +SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *, sqlite3 *); +SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db); +SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db); +#else + #define sqlite3ConnectionBlocked(x,y) + #define sqlite3ConnectionUnlocked(x) + #define sqlite3ConnectionClosed(x) +#endif + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3ParserTrace(FILE*, char *); +#endif + +/* +** If the SQLITE_ENABLE IOTRACE exists then the global variable +** sqlite3IoTrace is a pointer to a printf-like routine used to +** print I/O tracing messages. +*/ +#ifdef SQLITE_ENABLE_IOTRACE +# define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; } +SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe*); +SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(const char*,...); +#else +# define IOTRACE(A) +# define sqlite3VdbeIOTraceSql(X) +#endif + +/* +** These routines are available for the mem2.c debugging memory allocator +** only. They are used to verify that different "types" of memory +** allocations are properly tracked by the system. +** +** sqlite3MemdebugSetType() sets the "type" of an allocation to one of +** the MEMTYPE_* macros defined below. The type must be a bitmask with +** a single bit set. +** +** sqlite3MemdebugHasType() returns true if any of the bits in its second +** argument match the type set by the previous sqlite3MemdebugSetType(). +** sqlite3MemdebugHasType() is intended for use inside assert() statements. +** +** sqlite3MemdebugNoType() returns true if none of the bits in its second +** argument match the type set by the previous sqlite3MemdebugSetType(). +** +** Perhaps the most important point is the difference between MEMTYPE_HEAP +** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means +** it might have been allocated by lookaside, except the allocation was +** too large or lookaside was already full. It is important to verify +** that allocations that might have been satisfied by lookaside are not +** passed back to non-lookaside free() routines. Asserts such as the +** example above are placed on the non-lookaside free() routines to verify +** this constraint. +** +** All of this is no-op for a production build. It only comes into +** play when the SQLITE_MEMDEBUG compile-time option is used. +*/ +#ifdef SQLITE_MEMDEBUG +SQLITE_PRIVATE void sqlite3MemdebugSetType(void*,u8); +SQLITE_PRIVATE int sqlite3MemdebugHasType(void*,u8); +SQLITE_PRIVATE int sqlite3MemdebugNoType(void*,u8); +#else +# define sqlite3MemdebugSetType(X,Y) /* no-op */ +# define sqlite3MemdebugHasType(X,Y) 1 +# define sqlite3MemdebugNoType(X,Y) 1 +#endif +#define MEMTYPE_HEAP 0x01 /* General heap allocations */ +#define MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */ +#define MEMTYPE_SCRATCH 0x04 /* Scratch allocations */ +#define MEMTYPE_PCACHE 0x08 /* Page cache allocations */ + +/* +** Threading interface +*/ +#if SQLITE_MAX_WORKER_THREADS>0 +SQLITE_PRIVATE int sqlite3ThreadCreate(SQLiteThread**,void*(*)(void*),void*); +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread*, void**); +#endif + +#if defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST) +SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3*); +#endif + +#endif /* _SQLITEINT_H_ */ + +/************** End of sqliteInt.h *******************************************/ +/************** Begin file global.c ******************************************/ +/* +** 2008 June 13 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains definitions of global variables and constants. +*/ +/* #include "sqliteInt.h" */ + +/* An array to map all upper-case characters into their corresponding +** lower-case character. +** +** SQLite only considers US-ASCII (or EBCDIC) characters. We do not +** handle case conversions for the UTF character set since the tables +** involved are nearly as big or bigger than SQLite itself. +*/ +SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[] = { +#ifdef SQLITE_ASCII + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103, + 104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121, + 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107, + 108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125, + 126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, + 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161, + 162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179, + 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197, + 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, + 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233, + 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251, + 252,253,254,255 +#endif +#ifdef SQLITE_EBCDIC + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 0x */ + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */ + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */ + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */ + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */ + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */ + 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, /* 6x */ + 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, /* 7x */ + 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */ + 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, /* 9x */ + 160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */ + 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */ + 192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */ + 208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */ + 224,225,162,163,164,165,166,167,168,169,234,235,236,237,238,239, /* Ex */ + 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, /* Fx */ +#endif +}; + +/* +** The following 256 byte lookup table is used to support SQLites built-in +** equivalents to the following standard library functions: +** +** isspace() 0x01 +** isalpha() 0x02 +** isdigit() 0x04 +** isalnum() 0x06 +** isxdigit() 0x08 +** toupper() 0x20 +** SQLite identifier character 0x40 +** +** Bit 0x20 is set if the mapped character requires translation to upper +** case. i.e. if the character is a lower-case ASCII character. +** If x is a lower-case ASCII character, then its upper-case equivalent +** is (x - 0x20). Therefore toupper() can be implemented as: +** +** (x & ~(map[x]&0x20)) +** +** Standard function tolower() is implemented using the sqlite3UpperToLower[] +** array. tolower() is used more often than toupper() by SQLite. +** +** Bit 0x40 is set if the character non-alphanumeric and can be used in an +** SQLite identifier. Identifiers are alphanumerics, "_", "$", and any +** non-ASCII UTF character. Hence the test for whether or not a character is +** part of an identifier is 0x46. +** +** SQLite's versions are identical to the standard versions assuming a +** locale of "C". They are implemented as macros in sqliteInt.h. +*/ +#ifdef SQLITE_ASCII +SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[256] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00..07 ........ */ + 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, /* 08..0f ........ */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 10..17 ........ */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 18..1f ........ */ + 0x01, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, /* 20..27 !"#$%&' */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28..2f ()*+,-./ */ + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, /* 30..37 01234567 */ + 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 38..3f 89:;<=>? */ + + 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02, /* 40..47 @ABCDEFG */ + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 48..4f HIJKLMNO */ + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 50..57 PQRSTUVW */ + 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x40, /* 58..5f XYZ[\]^_ */ + 0x00, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22, /* 60..67 `abcdefg */ + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 68..6f hijklmno */ + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 70..77 pqrstuvw */ + 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, /* 78..7f xyz{|}~. */ + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 80..87 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 88..8f ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 90..97 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 98..9f ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a0..a7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a8..af ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b0..b7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b8..bf ........ */ + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c0..c7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c8..cf ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d0..d7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d8..df ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e0..e7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e8..ef ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* f0..f7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 /* f8..ff ........ */ +}; +#endif + +/* EVIDENCE-OF: R-02982-34736 In order to maintain full backwards +** compatibility for legacy applications, the URI filename capability is +** disabled by default. +** +** EVIDENCE-OF: R-38799-08373 URI filenames can be enabled or disabled +** using the SQLITE_USE_URI=1 or SQLITE_USE_URI=0 compile-time options. +** +** EVIDENCE-OF: R-43642-56306 By default, URI handling is globally +** disabled. The default value may be changed by compiling with the +** SQLITE_USE_URI symbol defined. +*/ +#ifndef SQLITE_USE_URI +# define SQLITE_USE_URI 0 +#endif + +/* EVIDENCE-OF: R-38720-18127 The default setting is determined by the +** SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on" if +** that compile-time option is omitted. +*/ +#ifndef SQLITE_ALLOW_COVERING_INDEX_SCAN +# define SQLITE_ALLOW_COVERING_INDEX_SCAN 1 +#endif + +/* The minimum PMA size is set to this value multiplied by the database +** page size in bytes. +*/ +#ifndef SQLITE_SORTER_PMASZ +# define SQLITE_SORTER_PMASZ 250 +#endif + +/* +** The following singleton contains the global configuration for +** the SQLite library. +*/ +SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = { + SQLITE_DEFAULT_MEMSTATUS, /* bMemstat */ + 1, /* bCoreMutex */ + SQLITE_THREADSAFE==1, /* bFullMutex */ + SQLITE_USE_URI, /* bOpenUri */ + SQLITE_ALLOW_COVERING_INDEX_SCAN, /* bUseCis */ + 0x7ffffffe, /* mxStrlen */ + 0, /* neverCorrupt */ + 128, /* szLookaside */ + 500, /* nLookaside */ + {0,0,0,0,0,0,0,0}, /* m */ + {0,0,0,0,0,0,0,0,0}, /* mutex */ + {0,0,0,0,0,0,0,0,0,0,0,0,0},/* pcache2 */ + (void*)0, /* pHeap */ + 0, /* nHeap */ + 0, 0, /* mnHeap, mxHeap */ + SQLITE_DEFAULT_MMAP_SIZE, /* szMmap */ + SQLITE_MAX_MMAP_SIZE, /* mxMmap */ + (void*)0, /* pScratch */ + 0, /* szScratch */ + 0, /* nScratch */ + (void*)0, /* pPage */ + 0, /* szPage */ + SQLITE_DEFAULT_PCACHE_INITSZ, /* nPage */ + 0, /* mxParserStack */ + 0, /* sharedCacheEnabled */ + SQLITE_SORTER_PMASZ, /* szPma */ + /* All the rest should always be initialized to zero */ + 0, /* isInit */ + 0, /* inProgress */ + 0, /* isMutexInit */ + 0, /* isMallocInit */ + 0, /* isPCacheInit */ + 0, /* nRefInitMutex */ + 0, /* pInitMutex */ + 0, /* xLog */ + 0, /* pLogArg */ +#ifdef SQLITE_ENABLE_SQLLOG + 0, /* xSqllog */ + 0, /* pSqllogArg */ +#endif +#ifdef SQLITE_VDBE_COVERAGE + 0, /* xVdbeBranch */ + 0, /* pVbeBranchArg */ +#endif +#ifndef SQLITE_OMIT_BUILTIN_TEST + 0, /* xTestCallback */ +#endif + 0 /* bLocaltimeFault */ +}; + +/* +** Hash table for global functions - functions common to all +** database connections. After initialization, this table is +** read-only. +*/ +SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions; + +/* +** Constant tokens for values 0 and 1. +*/ +SQLITE_PRIVATE const Token sqlite3IntTokens[] = { + { "0", 1 }, + { "1", 1 } +}; + + +/* +** The value of the "pending" byte must be 0x40000000 (1 byte past the +** 1-gibabyte boundary) in a compatible database. SQLite never uses +** the database page that contains the pending byte. It never attempts +** to read or write that page. The pending byte page is set assign +** for use by the VFS layers as space for managing file locks. +** +** During testing, it is often desirable to move the pending byte to +** a different position in the file. This allows code that has to +** deal with the pending byte to run on files that are much smaller +** than 1 GiB. The sqlite3_test_control() interface can be used to +** move the pending byte. +** +** IMPORTANT: Changing the pending byte to any value other than +** 0x40000000 results in an incompatible database file format! +** Changing the pending byte during operation will result in undefined +** and incorrect behavior. +*/ +#ifndef SQLITE_OMIT_WSD +SQLITE_PRIVATE int sqlite3PendingByte = 0x40000000; +#endif + +/* #include "opcodes.h" */ +/* +** Properties of opcodes. The OPFLG_INITIALIZER macro is +** created by mkopcodeh.awk during compilation. Data is obtained +** from the comments following the "case OP_xxxx:" statements in +** the vdbe.c file. +*/ +SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER; + +/************** End of global.c **********************************************/ +/************** Begin file ctime.c *******************************************/ +/* +** 2010 February 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file implements routines used to report what compile-time options +** SQLite was built with. +*/ + +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS + +/* #include "sqliteInt.h" */ + +/* +** An array of names of all compile-time options. This array should +** be sorted A-Z. +** +** This array looks large, but in a typical installation actually uses +** only a handful of compile-time options, so most times this array is usually +** rather short and uses little memory space. +*/ +static const char * const azCompileOpt[] = { + +/* These macros are provided to "stringify" the value of the define +** for those options in which the value is meaningful. */ +#define CTIMEOPT_VAL_(opt) #opt +#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) + +#if SQLITE_32BIT_ROWID + "32BIT_ROWID", +#endif +#if SQLITE_4_BYTE_ALIGNED_MALLOC + "4_BYTE_ALIGNED_MALLOC", +#endif +#if SQLITE_CASE_SENSITIVE_LIKE + "CASE_SENSITIVE_LIKE", +#endif +#if SQLITE_CHECK_PAGES + "CHECK_PAGES", +#endif +#if SQLITE_COVERAGE_TEST + "COVERAGE_TEST", +#endif +#if SQLITE_DEBUG + "DEBUG", +#endif +#if SQLITE_DEFAULT_LOCKING_MODE + "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE), +#endif +#if defined(SQLITE_DEFAULT_MMAP_SIZE) && !defined(SQLITE_DEFAULT_MMAP_SIZE_xc) + "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE), +#endif +#if SQLITE_DISABLE_DIRSYNC + "DISABLE_DIRSYNC", +#endif +#if SQLITE_DISABLE_LFS + "DISABLE_LFS", +#endif +#if SQLITE_ENABLE_API_ARMOR + "ENABLE_API_ARMOR", +#endif +#if SQLITE_ENABLE_ATOMIC_WRITE + "ENABLE_ATOMIC_WRITE", +#endif +#if SQLITE_ENABLE_CEROD + "ENABLE_CEROD", +#endif +#if SQLITE_ENABLE_COLUMN_METADATA + "ENABLE_COLUMN_METADATA", +#endif +#if SQLITE_ENABLE_DBSTAT_VTAB + "ENABLE_DBSTAT_VTAB", +#endif +#if SQLITE_ENABLE_EXPENSIVE_ASSERT + "ENABLE_EXPENSIVE_ASSERT", +#endif +#if SQLITE_ENABLE_FTS1 + "ENABLE_FTS1", +#endif +#if SQLITE_ENABLE_FTS2 + "ENABLE_FTS2", +#endif +#if SQLITE_ENABLE_FTS3 + "ENABLE_FTS3", +#endif +#if SQLITE_ENABLE_FTS3_PARENTHESIS + "ENABLE_FTS3_PARENTHESIS", +#endif +#if SQLITE_ENABLE_FTS4 + "ENABLE_FTS4", +#endif +#if SQLITE_ENABLE_FTS5 + "ENABLE_FTS5", +#endif +#if SQLITE_ENABLE_ICU + "ENABLE_ICU", +#endif +#if SQLITE_ENABLE_IOTRACE + "ENABLE_IOTRACE", +#endif +#if SQLITE_ENABLE_JSON1 + "ENABLE_JSON1", +#endif +#if SQLITE_ENABLE_LOAD_EXTENSION + "ENABLE_LOAD_EXTENSION", +#endif +#if SQLITE_ENABLE_LOCKING_STYLE + "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE), +#endif +#if SQLITE_ENABLE_MEMORY_MANAGEMENT + "ENABLE_MEMORY_MANAGEMENT", +#endif +#if SQLITE_ENABLE_MEMSYS3 + "ENABLE_MEMSYS3", +#endif +#if SQLITE_ENABLE_MEMSYS5 + "ENABLE_MEMSYS5", +#endif +#if SQLITE_ENABLE_OVERSIZE_CELL_CHECK + "ENABLE_OVERSIZE_CELL_CHECK", +#endif +#if SQLITE_ENABLE_RTREE + "ENABLE_RTREE", +#endif +#if defined(SQLITE_ENABLE_STAT4) + "ENABLE_STAT4", +#elif defined(SQLITE_ENABLE_STAT3) + "ENABLE_STAT3", +#endif +#if SQLITE_ENABLE_UNLOCK_NOTIFY + "ENABLE_UNLOCK_NOTIFY", +#endif +#if SQLITE_ENABLE_UPDATE_DELETE_LIMIT + "ENABLE_UPDATE_DELETE_LIMIT", +#endif +#if SQLITE_HAS_CODEC + "HAS_CODEC", +#endif +#if HAVE_ISNAN || SQLITE_HAVE_ISNAN + "HAVE_ISNAN", +#endif +#if SQLITE_HOMEGROWN_RECURSIVE_MUTEX + "HOMEGROWN_RECURSIVE_MUTEX", +#endif +#if SQLITE_IGNORE_AFP_LOCK_ERRORS + "IGNORE_AFP_LOCK_ERRORS", +#endif +#if SQLITE_IGNORE_FLOCK_LOCK_ERRORS + "IGNORE_FLOCK_LOCK_ERRORS", +#endif +#ifdef SQLITE_INT64_TYPE + "INT64_TYPE", +#endif +#if SQLITE_LOCK_TRACE + "LOCK_TRACE", +#endif +#if defined(SQLITE_MAX_MMAP_SIZE) && !defined(SQLITE_MAX_MMAP_SIZE_xc) + "MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE), +#endif +#ifdef SQLITE_MAX_SCHEMA_RETRY + "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY), +#endif +#if SQLITE_MEMDEBUG + "MEMDEBUG", +#endif +#if SQLITE_MIXED_ENDIAN_64BIT_FLOAT + "MIXED_ENDIAN_64BIT_FLOAT", +#endif +#if SQLITE_NO_SYNC + "NO_SYNC", +#endif +#if SQLITE_OMIT_ALTERTABLE + "OMIT_ALTERTABLE", +#endif +#if SQLITE_OMIT_ANALYZE + "OMIT_ANALYZE", +#endif +#if SQLITE_OMIT_ATTACH + "OMIT_ATTACH", +#endif +#if SQLITE_OMIT_AUTHORIZATION + "OMIT_AUTHORIZATION", +#endif +#if SQLITE_OMIT_AUTOINCREMENT + "OMIT_AUTOINCREMENT", +#endif +#if SQLITE_OMIT_AUTOINIT + "OMIT_AUTOINIT", +#endif +#if SQLITE_OMIT_AUTOMATIC_INDEX + "OMIT_AUTOMATIC_INDEX", +#endif +#if SQLITE_OMIT_AUTORESET + "OMIT_AUTORESET", +#endif +#if SQLITE_OMIT_AUTOVACUUM + "OMIT_AUTOVACUUM", +#endif +#if SQLITE_OMIT_BETWEEN_OPTIMIZATION + "OMIT_BETWEEN_OPTIMIZATION", +#endif +#if SQLITE_OMIT_BLOB_LITERAL + "OMIT_BLOB_LITERAL", +#endif +#if SQLITE_OMIT_BTREECOUNT + "OMIT_BTREECOUNT", +#endif +#if SQLITE_OMIT_BUILTIN_TEST + "OMIT_BUILTIN_TEST", +#endif +#if SQLITE_OMIT_CAST + "OMIT_CAST", +#endif +#if SQLITE_OMIT_CHECK + "OMIT_CHECK", +#endif +#if SQLITE_OMIT_COMPLETE + "OMIT_COMPLETE", +#endif +#if SQLITE_OMIT_COMPOUND_SELECT + "OMIT_COMPOUND_SELECT", +#endif +#if SQLITE_OMIT_CTE + "OMIT_CTE", +#endif +#if SQLITE_OMIT_DATETIME_FUNCS + "OMIT_DATETIME_FUNCS", +#endif +#if SQLITE_OMIT_DECLTYPE + "OMIT_DECLTYPE", +#endif +#if SQLITE_OMIT_DEPRECATED + "OMIT_DEPRECATED", +#endif +#if SQLITE_OMIT_DISKIO + "OMIT_DISKIO", +#endif +#if SQLITE_OMIT_EXPLAIN + "OMIT_EXPLAIN", +#endif +#if SQLITE_OMIT_FLAG_PRAGMAS + "OMIT_FLAG_PRAGMAS", +#endif +#if SQLITE_OMIT_FLOATING_POINT + "OMIT_FLOATING_POINT", +#endif +#if SQLITE_OMIT_FOREIGN_KEY + "OMIT_FOREIGN_KEY", +#endif +#if SQLITE_OMIT_GET_TABLE + "OMIT_GET_TABLE", +#endif +#if SQLITE_OMIT_INCRBLOB + "OMIT_INCRBLOB", +#endif +#if SQLITE_OMIT_INTEGRITY_CHECK + "OMIT_INTEGRITY_CHECK", +#endif +#if SQLITE_OMIT_LIKE_OPTIMIZATION + "OMIT_LIKE_OPTIMIZATION", +#endif +#if SQLITE_OMIT_LOAD_EXTENSION + "OMIT_LOAD_EXTENSION", +#endif +#if SQLITE_OMIT_LOCALTIME + "OMIT_LOCALTIME", +#endif +#if SQLITE_OMIT_LOOKASIDE + "OMIT_LOOKASIDE", +#endif +#if SQLITE_OMIT_MEMORYDB + "OMIT_MEMORYDB", +#endif +#if SQLITE_OMIT_OR_OPTIMIZATION + "OMIT_OR_OPTIMIZATION", +#endif +#if SQLITE_OMIT_PAGER_PRAGMAS + "OMIT_PAGER_PRAGMAS", +#endif +#if SQLITE_OMIT_PRAGMA + "OMIT_PRAGMA", +#endif +#if SQLITE_OMIT_PROGRESS_CALLBACK + "OMIT_PROGRESS_CALLBACK", +#endif +#if SQLITE_OMIT_QUICKBALANCE + "OMIT_QUICKBALANCE", +#endif +#if SQLITE_OMIT_REINDEX + "OMIT_REINDEX", +#endif +#if SQLITE_OMIT_SCHEMA_PRAGMAS + "OMIT_SCHEMA_PRAGMAS", +#endif +#if SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS + "OMIT_SCHEMA_VERSION_PRAGMAS", +#endif +#if SQLITE_OMIT_SHARED_CACHE + "OMIT_SHARED_CACHE", +#endif +#if SQLITE_OMIT_SUBQUERY + "OMIT_SUBQUERY", +#endif +#if SQLITE_OMIT_TCL_VARIABLE + "OMIT_TCL_VARIABLE", +#endif +#if SQLITE_OMIT_TEMPDB + "OMIT_TEMPDB", +#endif +#if SQLITE_OMIT_TRACE + "OMIT_TRACE", +#endif +#if SQLITE_OMIT_TRIGGER + "OMIT_TRIGGER", +#endif +#if SQLITE_OMIT_TRUNCATE_OPTIMIZATION + "OMIT_TRUNCATE_OPTIMIZATION", +#endif +#if SQLITE_OMIT_UTF16 + "OMIT_UTF16", +#endif +#if SQLITE_OMIT_VACUUM + "OMIT_VACUUM", +#endif +#if SQLITE_OMIT_VIEW + "OMIT_VIEW", +#endif +#if SQLITE_OMIT_VIRTUALTABLE + "OMIT_VIRTUALTABLE", +#endif +#if SQLITE_OMIT_WAL + "OMIT_WAL", +#endif +#if SQLITE_OMIT_WSD + "OMIT_WSD", +#endif +#if SQLITE_OMIT_XFER_OPT + "OMIT_XFER_OPT", +#endif +#if SQLITE_PERFORMANCE_TRACE + "PERFORMANCE_TRACE", +#endif +#if SQLITE_PROXY_DEBUG + "PROXY_DEBUG", +#endif +#if SQLITE_RTREE_INT_ONLY + "RTREE_INT_ONLY", +#endif +#if SQLITE_SECURE_DELETE + "SECURE_DELETE", +#endif +#if SQLITE_SMALL_STACK + "SMALL_STACK", +#endif +#if SQLITE_SOUNDEX + "SOUNDEX", +#endif +#if SQLITE_SYSTEM_MALLOC + "SYSTEM_MALLOC", +#endif +#if SQLITE_TCL + "TCL", +#endif +#if defined(SQLITE_TEMP_STORE) && !defined(SQLITE_TEMP_STORE_xc) + "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE), +#endif +#if SQLITE_TEST + "TEST", +#endif +#if defined(SQLITE_THREADSAFE) + "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE), +#endif +#if SQLITE_USE_ALLOCA + "USE_ALLOCA", +#endif +#if SQLITE_USER_AUTHENTICATION + "USER_AUTHENTICATION", +#endif +#if SQLITE_WIN32_MALLOC + "WIN32_MALLOC", +#endif +#if SQLITE_ZERO_MALLOC + "ZERO_MALLOC" +#endif +}; + +/* +** Given the name of a compile-time option, return true if that option +** was used and false if not. +** +** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix +** is not required for a match. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_compileoption_used(const char *zOptName){ + int i, n; + +#if SQLITE_ENABLE_API_ARMOR + if( zOptName==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7; + n = sqlite3Strlen30(zOptName); + + /* Since ArraySize(azCompileOpt) is normally in single digits, a + ** linear search is adequate. No need for a binary search. */ + for(i=0; i=0 && NaDb[] (or -1) */ + u8 nullRow; /* True if pointing to a row with no data */ + u8 deferredMoveto; /* A call to sqlite3BtreeMoveto() is needed */ + Bool isEphemeral:1; /* True for an ephemeral table */ + Bool useRandomRowid:1;/* Generate new record numbers semi-randomly */ + Bool isTable:1; /* True if a table requiring integer keys */ + Bool isOrdered:1; /* True if the underlying table is BTREE_UNORDERED */ + Pgno pgnoRoot; /* Root page of the open btree cursor */ + sqlite3_vtab_cursor *pVtabCursor; /* The cursor for a virtual table */ + i64 seqCount; /* Sequence counter */ + i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */ + VdbeSorter *pSorter; /* Sorter object for OP_SorterOpen cursors */ +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + u64 maskUsed; /* Mask of columns used by this cursor */ +#endif + + /* Cached information about the header for the data record that the + ** cursor is currently pointing to. Only valid if cacheStatus matches + ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of + ** CACHE_STALE and so setting cacheStatus=CACHE_STALE guarantees that + ** the cache is out of date. + ** + ** aRow might point to (ephemeral) data for the current row, or it might + ** be NULL. + */ + u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */ + u32 payloadSize; /* Total number of bytes in the record */ + u32 szRow; /* Byte available in aRow */ + u32 iHdrOffset; /* Offset to next unparsed byte of the header */ + const u8 *aRow; /* Data for the current row, if all on one page */ + u32 *aOffset; /* Pointer to aType[nField] */ + u32 aType[1]; /* Type values for all entries in the record */ + /* 2*nField extra array elements allocated for aType[], beyond the one + ** static element declared in the structure. nField total array slots for + ** aType[] and nField+1 array slots for aOffset[] */ +}; +typedef struct VdbeCursor VdbeCursor; + +/* +** When a sub-program is executed (OP_Program), a structure of this type +** is allocated to store the current value of the program counter, as +** well as the current memory cell array and various other frame specific +** values stored in the Vdbe struct. When the sub-program is finished, +** these values are copied back to the Vdbe from the VdbeFrame structure, +** restoring the state of the VM to as it was before the sub-program +** began executing. +** +** The memory for a VdbeFrame object is allocated and managed by a memory +** cell in the parent (calling) frame. When the memory cell is deleted or +** overwritten, the VdbeFrame object is not freed immediately. Instead, it +** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame +** list is deleted when the VM is reset in VdbeHalt(). The reason for doing +** this instead of deleting the VdbeFrame immediately is to avoid recursive +** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the +** child frame are released. +** +** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is +** set to NULL if the currently executing frame is the main program. +*/ +typedef struct VdbeFrame VdbeFrame; +struct VdbeFrame { + Vdbe *v; /* VM this frame belongs to */ + VdbeFrame *pParent; /* Parent of this frame, or NULL if parent is main */ + Op *aOp; /* Program instructions for parent frame */ + i64 *anExec; /* Event counters from parent frame */ + Mem *aMem; /* Array of memory cells for parent frame */ + u8 *aOnceFlag; /* Array of OP_Once flags for parent frame */ + VdbeCursor **apCsr; /* Array of Vdbe cursors for parent frame */ + void *token; /* Copy of SubProgram.token */ + i64 lastRowid; /* Last insert rowid (sqlite3.lastRowid) */ + int nCursor; /* Number of entries in apCsr */ + int pc; /* Program Counter in parent (calling) frame */ + int nOp; /* Size of aOp array */ + int nMem; /* Number of entries in aMem */ + int nOnceFlag; /* Number of entries in aOnceFlag */ + int nChildMem; /* Number of memory cells for child frame */ + int nChildCsr; /* Number of cursors for child frame */ + int nChange; /* Statement changes (Vdbe.nChange) */ + int nDbChange; /* Value of db->nChange */ +}; + +#define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))]) + +/* +** A value for VdbeCursor.cacheValid that means the cache is always invalid. +*/ +#define CACHE_STALE 0 + +/* +** Internally, the vdbe manipulates nearly all SQL values as Mem +** structures. Each Mem struct may cache multiple representations (string, +** integer etc.) of the same value. +*/ +struct Mem { + union MemValue { + double r; /* Real value used when MEM_Real is set in flags */ + i64 i; /* Integer value used when MEM_Int is set in flags */ + int nZero; /* Used when bit MEM_Zero is set in flags */ + FuncDef *pDef; /* Used only when flags==MEM_Agg */ + RowSet *pRowSet; /* Used only when flags==MEM_RowSet */ + VdbeFrame *pFrame; /* Used when flags==MEM_Frame */ + } u; + u16 flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */ + u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */ + u8 eSubtype; /* Subtype for this value */ + int n; /* Number of characters in string value, excluding '\0' */ + char *z; /* String or BLOB value */ + /* ShallowCopy only needs to copy the information above */ + char *zMalloc; /* Space to hold MEM_Str or MEM_Blob if szMalloc>0 */ + int szMalloc; /* Size of the zMalloc allocation */ + u32 uTemp; /* Transient storage for serial_type in OP_MakeRecord */ + sqlite3 *db; /* The associated database connection */ + void (*xDel)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */ +#ifdef SQLITE_DEBUG + Mem *pScopyFrom; /* This Mem is a shallow copy of pScopyFrom */ + void *pFiller; /* So that sizeof(Mem) is a multiple of 8 */ +#endif +}; + +/* +** Size of struct Mem not including the Mem.zMalloc member or anything that +** follows. +*/ +#define MEMCELLSIZE offsetof(Mem,zMalloc) + +/* One or more of the following flags are set to indicate the validOK +** representations of the value stored in the Mem struct. +** +** If the MEM_Null flag is set, then the value is an SQL NULL value. +** No other flags may be set in this case. +** +** If the MEM_Str flag is set then Mem.z points at a string representation. +** Usually this is encoded in the same unicode encoding as the main +** database (see below for exceptions). If the MEM_Term flag is also +** set, then the string is nul terminated. The MEM_Int and MEM_Real +** flags may coexist with the MEM_Str flag. +*/ +#define MEM_Null 0x0001 /* Value is NULL */ +#define MEM_Str 0x0002 /* Value is a string */ +#define MEM_Int 0x0004 /* Value is an integer */ +#define MEM_Real 0x0008 /* Value is a real number */ +#define MEM_Blob 0x0010 /* Value is a BLOB */ +#define MEM_AffMask 0x001f /* Mask of affinity bits */ +#define MEM_RowSet 0x0020 /* Value is a RowSet object */ +#define MEM_Frame 0x0040 /* Value is a VdbeFrame object */ +#define MEM_Undefined 0x0080 /* Value is undefined */ +#define MEM_Cleared 0x0100 /* NULL set by OP_Null, not from data */ +#define MEM_TypeMask 0x01ff /* Mask of type bits */ + + +/* Whenever Mem contains a valid string or blob representation, one of +** the following flags must be set to determine the memory management +** policy for Mem.z. The MEM_Term flag tells us whether or not the +** string is \000 or \u0000 terminated +*/ +#define MEM_Term 0x0200 /* String rep is nul terminated */ +#define MEM_Dyn 0x0400 /* Need to call Mem.xDel() on Mem.z */ +#define MEM_Static 0x0800 /* Mem.z points to a static string */ +#define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */ +#define MEM_Agg 0x2000 /* Mem.z points to an agg function context */ +#define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */ +#ifdef SQLITE_OMIT_INCRBLOB + #undef MEM_Zero + #define MEM_Zero 0x0000 +#endif + +/* +** Clear any existing type flags from a Mem and replace them with f +*/ +#define MemSetTypeFlag(p, f) \ + ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f) + +/* +** Return true if a memory cell is not marked as invalid. This macro +** is for use inside assert() statements only. +*/ +#ifdef SQLITE_DEBUG +#define memIsValid(M) ((M)->flags & MEM_Undefined)==0 +#endif + +/* +** Each auxiliary data pointer stored by a user defined function +** implementation calling sqlite3_set_auxdata() is stored in an instance +** of this structure. All such structures associated with a single VM +** are stored in a linked list headed at Vdbe.pAuxData. All are destroyed +** when the VM is halted (if not before). +*/ +struct AuxData { + int iOp; /* Instruction number of OP_Function opcode */ + int iArg; /* Index of function argument. */ + void *pAux; /* Aux data pointer */ + void (*xDelete)(void *); /* Destructor for the aux data */ + AuxData *pNext; /* Next element in list */ +}; + +/* +** The "context" argument for an installable function. A pointer to an +** instance of this structure is the first argument to the routines used +** implement the SQL functions. +** +** There is a typedef for this structure in sqlite.h. So all routines, +** even the public interface to SQLite, can use a pointer to this structure. +** But this file is the only place where the internal details of this +** structure are known. +** +** This structure is defined inside of vdbeInt.h because it uses substructures +** (Mem) which are only defined there. +*/ +struct sqlite3_context { + Mem *pOut; /* The return value is stored here */ + FuncDef *pFunc; /* Pointer to function information */ + Mem *pMem; /* Memory cell used to store aggregate context */ + Vdbe *pVdbe; /* The VM that owns this context */ + int iOp; /* Instruction number of OP_Function */ + int isError; /* Error code returned by the function. */ + u8 skipFlag; /* Skip accumulator loading if true */ + u8 fErrorOrAux; /* isError!=0 or pVdbe->pAuxData modified */ + u8 argc; /* Number of arguments */ + sqlite3_value *argv[1]; /* Argument set */ +}; + +/* +** An Explain object accumulates indented output which is helpful +** in describing recursive data structures. +*/ +struct Explain { + Vdbe *pVdbe; /* Attach the explanation to this Vdbe */ + StrAccum str; /* The string being accumulated */ + int nIndent; /* Number of elements in aIndent */ + u16 aIndent[100]; /* Levels of indentation */ + char zBase[100]; /* Initial space */ +}; + +/* A bitfield type for use inside of structures. Always follow with :N where +** N is the number of bits. +*/ +typedef unsigned bft; /* Bit Field Type */ + +typedef struct ScanStatus ScanStatus; +struct ScanStatus { + int addrExplain; /* OP_Explain for loop */ + int addrLoop; /* Address of "loops" counter */ + int addrVisit; /* Address of "rows visited" counter */ + int iSelectID; /* The "Select-ID" for this loop */ + LogEst nEst; /* Estimated output rows per loop */ + char *zName; /* Name of table or index */ +}; + +/* +** An instance of the virtual machine. This structure contains the complete +** state of the virtual machine. +** +** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare() +** is really a pointer to an instance of this structure. +*/ +struct Vdbe { + sqlite3 *db; /* The database connection that owns this statement */ + Op *aOp; /* Space to hold the virtual machine's program */ + Mem *aMem; /* The memory locations */ + Mem **apArg; /* Arguments to currently executing user function */ + Mem *aColName; /* Column names to return */ + Mem *pResultSet; /* Pointer to an array of results */ + Parse *pParse; /* Parsing context used to create this Vdbe */ + int nMem; /* Number of memory locations currently allocated */ + int nOp; /* Number of instructions in the program */ + int nCursor; /* Number of slots in apCsr[] */ + u32 magic; /* Magic number for sanity checking */ + char *zErrMsg; /* Error message written here */ + Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */ + VdbeCursor **apCsr; /* One element of this array for each open cursor */ + Mem *aVar; /* Values for the OP_Variable opcode. */ + char **azVar; /* Name of variables */ + ynVar nVar; /* Number of entries in aVar[] */ + ynVar nzVar; /* Number of entries in azVar[] */ + u32 cacheCtr; /* VdbeCursor row cache generation counter */ + int pc; /* The program counter */ + int rc; /* Value to return */ +#ifdef SQLITE_DEBUG + int rcApp; /* errcode set by sqlite3_result_error_code() */ +#endif + u16 nResColumn; /* Number of columns in one row of the result set */ + u8 errorAction; /* Recovery action to do in case of an error */ + u8 minWriteFileFormat; /* Minimum file format for writable database files */ + bft explain:2; /* True if EXPLAIN present on SQL command */ + bft changeCntOn:1; /* True to update the change-counter */ + bft expired:1; /* True if the VM needs to be recompiled */ + bft runOnlyOnce:1; /* Automatically expire on reset */ + bft usesStmtJournal:1; /* True if uses a statement journal */ + bft readOnly:1; /* True for statements that do not write */ + bft bIsReader:1; /* True for statements that read */ + bft isPrepareV2:1; /* True if prepared with prepare_v2() */ + bft doingRerun:1; /* True if rerunning after an auto-reprepare */ + int nChange; /* Number of db changes made since last reset */ + yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */ + yDbMask lockMask; /* Subset of btreeMask that requires a lock */ + int iStatement; /* Statement number (or 0 if has not opened stmt) */ + u32 aCounter[5]; /* Counters used by sqlite3_stmt_status() */ +#ifndef SQLITE_OMIT_TRACE + i64 startTime; /* Time when query started - used for profiling */ +#endif + i64 iCurrentTime; /* Value of julianday('now') for this statement */ + i64 nFkConstraint; /* Number of imm. FK constraints this VM */ + i64 nStmtDefCons; /* Number of def. constraints when stmt started */ + i64 nStmtDefImmCons; /* Number of def. imm constraints when stmt started */ + char *zSql; /* Text of the SQL statement that generated this */ + void *pFree; /* Free this when deleting the vdbe */ + VdbeFrame *pFrame; /* Parent frame */ + VdbeFrame *pDelFrame; /* List of frame objects to free on VM reset */ + int nFrame; /* Number of frames in pFrame list */ + u32 expmask; /* Binding to these vars invalidates VM */ + SubProgram *pProgram; /* Linked list of all sub-programs used by VM */ + int nOnceFlag; /* Size of array aOnceFlag[] */ + u8 *aOnceFlag; /* Flags for OP_Once */ + AuxData *pAuxData; /* Linked list of auxdata allocations */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + i64 *anExec; /* Number of times each op has been executed */ + int nScan; /* Entries in aScan[] */ + ScanStatus *aScan; /* Scan definitions for sqlite3_stmt_scanstatus() */ +#endif +}; + +/* +** The following are allowed values for Vdbe.magic +*/ +#define VDBE_MAGIC_INIT 0x26bceaa5 /* Building a VDBE program */ +#define VDBE_MAGIC_RUN 0xbdf20da3 /* VDBE is ready to execute */ +#define VDBE_MAGIC_HALT 0x519c2973 /* VDBE has completed execution */ +#define VDBE_MAGIC_DEAD 0xb606c3c8 /* The VDBE has been deallocated */ + +/* +** Function prototypes +*/ +SQLITE_PRIVATE void sqlite3VdbeError(Vdbe*, const char *, ...); +SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*); +void sqliteVdbePopStack(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor*); +SQLITE_PRIVATE int sqlite3VdbeCursorRestore(VdbeCursor*); +#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) +SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, Op*); +#endif +SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32); +SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*, int); +SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, Mem*, u32); +SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*); +SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(Vdbe*, int, int); + +int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *); +SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(sqlite3*,VdbeCursor*,UnpackedRecord*,int*); +SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3*, BtCursor*, i64*); +SQLITE_PRIVATE int sqlite3VdbeExec(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeList(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int); +SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*); +SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int); +SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*)); +SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64); +#ifdef SQLITE_OMIT_FLOATING_POINT +# define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64 +#else +SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double); +#endif +SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem*,sqlite3*,u16); +SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*); +SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int); +SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, u8, u8); +SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*); +SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*); +SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*); +SQLITE_PRIVATE void sqlite3VdbeMemCast(Mem*,u8,u8); +SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,int,Mem*); +SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p); +#define VdbeMemDynamic(X) \ + (((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))!=0) +SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*); +SQLITE_PRIVATE const char *sqlite3OpcodeName(int); +SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve); +SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int n); +SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *, int); +SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*); +SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *); +SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p); + +SQLITE_PRIVATE int sqlite3VdbeSorterInit(sqlite3 *, int, VdbeCursor *); +SQLITE_PRIVATE void sqlite3VdbeSorterReset(sqlite3 *, VdbeSorter *); +SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *, VdbeCursor *); +SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *, Mem *); +SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *, const VdbeCursor *, int *); +SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *, int *); +SQLITE_PRIVATE int sqlite3VdbeSorterWrite(const VdbeCursor *, Mem *); +SQLITE_PRIVATE int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *); + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0 +SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe*); +#else +# define sqlite3VdbeEnter(X) +# define sqlite3VdbeLeave(X) +#endif + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*); +SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem*); +#endif + +#ifndef SQLITE_OMIT_FOREIGN_KEY +SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *, int); +#else +# define sqlite3VdbeCheckFk(p,i) 0 +#endif + +SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem*, u8); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf); +#endif +SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem); + +#ifndef SQLITE_OMIT_INCRBLOB +SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *); + #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0) +#else + #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK + #define ExpandBlob(P) SQLITE_OK +#endif + +#endif /* !defined(_VDBEINT_H_) */ + +/************** End of vdbeInt.h *********************************************/ +/************** Continuing where we left off in status.c *********************/ + +/* +** Variables in which to record status information. +*/ +typedef struct sqlite3StatType sqlite3StatType; +static SQLITE_WSD struct sqlite3StatType { +#if SQLITE_PTRSIZE>4 + sqlite3_int64 nowValue[10]; /* Current value */ + sqlite3_int64 mxValue[10]; /* Maximum value */ +#else + u32 nowValue[10]; /* Current value */ + u32 mxValue[10]; /* Maximum value */ +#endif +} sqlite3Stat = { {0,}, {0,} }; + +/* +** Elements of sqlite3Stat[] are protected by either the memory allocator +** mutex, or by the pcache1 mutex. The following array determines which. +*/ +static const char statMutex[] = { + 0, /* SQLITE_STATUS_MEMORY_USED */ + 1, /* SQLITE_STATUS_PAGECACHE_USED */ + 1, /* SQLITE_STATUS_PAGECACHE_OVERFLOW */ + 0, /* SQLITE_STATUS_SCRATCH_USED */ + 0, /* SQLITE_STATUS_SCRATCH_OVERFLOW */ + 0, /* SQLITE_STATUS_MALLOC_SIZE */ + 0, /* SQLITE_STATUS_PARSER_STACK */ + 1, /* SQLITE_STATUS_PAGECACHE_SIZE */ + 0, /* SQLITE_STATUS_SCRATCH_SIZE */ + 0, /* SQLITE_STATUS_MALLOC_COUNT */ +}; + + +/* The "wsdStat" macro will resolve to the status information +** state vector. If writable static data is unsupported on the target, +** we have to locate the state vector at run-time. In the more common +** case where writable static data is supported, wsdStat can refer directly +** to the "sqlite3Stat" state vector declared above. +*/ +#ifdef SQLITE_OMIT_WSD +# define wsdStatInit sqlite3StatType *x = &GLOBAL(sqlite3StatType,sqlite3Stat) +# define wsdStat x[0] +#else +# define wsdStatInit +# define wsdStat sqlite3Stat +#endif + +/* +** Return the current value of a status parameter. The caller must +** be holding the appropriate mutex. +*/ +SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(int op){ + wsdStatInit; + assert( op>=0 && op=0 && op=0 && op=0 && opwsdStat.mxValue[op] ){ + wsdStat.mxValue[op] = wsdStat.nowValue[op]; + } +} +SQLITE_PRIVATE void sqlite3StatusDown(int op, int N){ + wsdStatInit; + assert( N>=0 ); + assert( op>=0 && op=0 && op=0 && op=0 && opwsdStat.mxValue[op] ){ + wsdStat.mxValue[op] = wsdStat.nowValue[op]; + } +} + +/* +** Query status information. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_status64( + int op, + sqlite3_int64 *pCurrent, + sqlite3_int64 *pHighwater, + int resetFlag +){ + sqlite3_mutex *pMutex; + wsdStatInit; + if( op<0 || op>=ArraySize(wsdStat.nowValue) ){ + return SQLITE_MISUSE_BKPT; + } +#ifdef SQLITE_ENABLE_API_ARMOR + if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT; +#endif + pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex(); + sqlite3_mutex_enter(pMutex); + *pCurrent = wsdStat.nowValue[op]; + *pHighwater = wsdStat.mxValue[op]; + if( resetFlag ){ + wsdStat.mxValue[op] = wsdStat.nowValue[op]; + } + sqlite3_mutex_leave(pMutex); + (void)pMutex; /* Prevent warning when SQLITE_THREADSAFE=0 */ + return SQLITE_OK; +} +SQLITE_API int SQLITE_STDCALL sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){ + sqlite3_int64 iCur, iHwtr; + int rc; +#ifdef SQLITE_ENABLE_API_ARMOR + if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT; +#endif + rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag); + if( rc==0 ){ + *pCurrent = (int)iCur; + *pHighwater = (int)iHwtr; + } + return rc; +} + +/* +** Query status information for a single database connection +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_db_status( + sqlite3 *db, /* The database connection whose status is desired */ + int op, /* Status verb */ + int *pCurrent, /* Write current value here */ + int *pHighwater, /* Write high-water mark here */ + int resetFlag /* Reset high-water mark if true */ +){ + int rc = SQLITE_OK; /* Return code */ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || pCurrent==0|| pHighwater==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + switch( op ){ + case SQLITE_DBSTATUS_LOOKASIDE_USED: { + *pCurrent = db->lookaside.nOut; + *pHighwater = db->lookaside.mxOut; + if( resetFlag ){ + db->lookaside.mxOut = db->lookaside.nOut; + } + break; + } + + case SQLITE_DBSTATUS_LOOKASIDE_HIT: + case SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: + case SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: { + testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT ); + testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE ); + testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL ); + assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 ); + assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 ); + *pCurrent = 0; + *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT]; + if( resetFlag ){ + db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0; + } + break; + } + + /* + ** Return an approximation for the amount of memory currently used + ** by all pagers associated with the given database connection. The + ** highwater mark is meaningless and is returned as zero. + */ + case SQLITE_DBSTATUS_CACHE_USED: { + int totalUsed = 0; + int i; + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + Pager *pPager = sqlite3BtreePager(pBt); + totalUsed += sqlite3PagerMemUsed(pPager); + } + } + sqlite3BtreeLeaveAll(db); + *pCurrent = totalUsed; + *pHighwater = 0; + break; + } + + /* + ** *pCurrent gets an accurate estimate of the amount of memory used + ** to store the schema for all databases (main, temp, and any ATTACHed + ** databases. *pHighwater is set to zero. + */ + case SQLITE_DBSTATUS_SCHEMA_USED: { + int i; /* Used to iterate through schemas */ + int nByte = 0; /* Used to accumulate return value */ + + sqlite3BtreeEnterAll(db); + db->pnBytesFreed = &nByte; + for(i=0; inDb; i++){ + Schema *pSchema = db->aDb[i].pSchema; + if( ALWAYS(pSchema!=0) ){ + HashElem *p; + + nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * ( + pSchema->tblHash.count + + pSchema->trigHash.count + + pSchema->idxHash.count + + pSchema->fkeyHash.count + ); + nByte += sqlite3MallocSize(pSchema->tblHash.ht); + nByte += sqlite3MallocSize(pSchema->trigHash.ht); + nByte += sqlite3MallocSize(pSchema->idxHash.ht); + nByte += sqlite3MallocSize(pSchema->fkeyHash.ht); + + for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){ + sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p)); + } + for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){ + sqlite3DeleteTable(db, (Table *)sqliteHashData(p)); + } + } + } + db->pnBytesFreed = 0; + sqlite3BtreeLeaveAll(db); + + *pHighwater = 0; + *pCurrent = nByte; + break; + } + + /* + ** *pCurrent gets an accurate estimate of the amount of memory used + ** to store all prepared statements. + ** *pHighwater is set to zero. + */ + case SQLITE_DBSTATUS_STMT_USED: { + struct Vdbe *pVdbe; /* Used to iterate through VMs */ + int nByte = 0; /* Used to accumulate return value */ + + db->pnBytesFreed = &nByte; + for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){ + sqlite3VdbeClearObject(db, pVdbe); + sqlite3DbFree(db, pVdbe); + } + db->pnBytesFreed = 0; + + *pHighwater = 0; /* IMP: R-64479-57858 */ + *pCurrent = nByte; + + break; + } + + /* + ** Set *pCurrent to the total cache hits or misses encountered by all + ** pagers the database handle is connected to. *pHighwater is always set + ** to zero. + */ + case SQLITE_DBSTATUS_CACHE_HIT: + case SQLITE_DBSTATUS_CACHE_MISS: + case SQLITE_DBSTATUS_CACHE_WRITE:{ + int i; + int nRet = 0; + assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 ); + assert( SQLITE_DBSTATUS_CACHE_WRITE==SQLITE_DBSTATUS_CACHE_HIT+2 ); + + for(i=0; inDb; i++){ + if( db->aDb[i].pBt ){ + Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt); + sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet); + } + } + *pHighwater = 0; /* IMP: R-42420-56072 */ + /* IMP: R-54100-20147 */ + /* IMP: R-29431-39229 */ + *pCurrent = nRet; + break; + } + + /* Set *pCurrent to non-zero if there are unresolved deferred foreign + ** key constraints. Set *pCurrent to zero if all foreign key constraints + ** have been satisfied. The *pHighwater is always set to zero. + */ + case SQLITE_DBSTATUS_DEFERRED_FKS: { + *pHighwater = 0; /* IMP: R-11967-56545 */ + *pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0; + break; + } + + default: { + rc = SQLITE_ERROR; + } + } + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/************** End of status.c **********************************************/ +/************** Begin file date.c ********************************************/ +/* +** 2003 October 31 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement date and time +** functions for SQLite. +** +** There is only one exported symbol in this file - the function +** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. +** All other code has file scope. +** +** SQLite processes all times and dates as julian day numbers. The +** dates and times are stored as the number of days since noon +** in Greenwich on November 24, 4714 B.C. according to the Gregorian +** calendar system. +** +** 1970-01-01 00:00:00 is JD 2440587.5 +** 2000-01-01 00:00:00 is JD 2451544.5 +** +** This implementation requires years to be expressed as a 4-digit number +** which means that only dates between 0000-01-01 and 9999-12-31 can +** be represented, even though julian day numbers allow a much wider +** range of dates. +** +** The Gregorian calendar system is used for all dates and times, +** even those that predate the Gregorian calendar. Historians usually +** use the julian calendar for dates prior to 1582-10-15 and for some +** dates afterwards, depending on locale. Beware of this difference. +** +** The conversion algorithms are implemented based on descriptions +** in the following text: +** +** Jean Meeus +** Astronomical Algorithms, 2nd Edition, 1998 +** ISBM 0-943396-61-1 +** Willmann-Bell, Inc +** Richmond, Virginia (USA) +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ +#include + +#ifndef SQLITE_OMIT_DATETIME_FUNCS + + +/* +** A structure for holding a single date and time. +*/ +typedef struct DateTime DateTime; +struct DateTime { + sqlite3_int64 iJD; /* The julian day number times 86400000 */ + int Y, M, D; /* Year, month, and day */ + int h, m; /* Hour and minutes */ + int tz; /* Timezone offset in minutes */ + double s; /* Seconds */ + char validYMD; /* True (1) if Y,M,D are valid */ + char validHMS; /* True (1) if h,m,s are valid */ + char validJD; /* True (1) if iJD is valid */ + char validTZ; /* True (1) if tz is valid */ +}; + + +/* +** Convert zDate into one or more integers. Additional arguments +** come in groups of 5 as follows: +** +** N number of digits in the integer +** min minimum allowed value of the integer +** max maximum allowed value of the integer +** nextC first character after the integer +** pVal where to write the integers value. +** +** Conversions continue until one with nextC==0 is encountered. +** The function returns the number of successful conversions. +*/ +static int getDigits(const char *zDate, ...){ + va_list ap; + int val; + int N; + int min; + int max; + int nextC; + int *pVal; + int cnt = 0; + va_start(ap, zDate); + do{ + N = va_arg(ap, int); + min = va_arg(ap, int); + max = va_arg(ap, int); + nextC = va_arg(ap, int); + pVal = va_arg(ap, int*); + val = 0; + while( N-- ){ + if( !sqlite3Isdigit(*zDate) ){ + goto end_getDigits; + } + val = val*10 + *zDate - '0'; + zDate++; + } + if( valmax || (nextC!=0 && nextC!=*zDate) ){ + goto end_getDigits; + } + *pVal = val; + zDate++; + cnt++; + }while( nextC ); +end_getDigits: + va_end(ap); + return cnt; +} + +/* +** Parse a timezone extension on the end of a date-time. +** The extension is of the form: +** +** (+/-)HH:MM +** +** Or the "zulu" notation: +** +** Z +** +** If the parse is successful, write the number of minutes +** of change in p->tz and return 0. If a parser error occurs, +** return non-zero. +** +** A missing specifier is not considered an error. +*/ +static int parseTimezone(const char *zDate, DateTime *p){ + int sgn = 0; + int nHr, nMn; + int c; + while( sqlite3Isspace(*zDate) ){ zDate++; } + p->tz = 0; + c = *zDate; + if( c=='-' ){ + sgn = -1; + }else if( c=='+' ){ + sgn = +1; + }else if( c=='Z' || c=='z' ){ + zDate++; + goto zulu_time; + }else{ + return c!=0; + } + zDate++; + if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){ + return 1; + } + zDate += 5; + p->tz = sgn*(nMn + nHr*60); +zulu_time: + while( sqlite3Isspace(*zDate) ){ zDate++; } + return *zDate!=0; +} + +/* +** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF. +** The HH, MM, and SS must each be exactly 2 digits. The +** fractional seconds FFFF can be one or more digits. +** +** Return 1 if there is a parsing error and 0 on success. +*/ +static int parseHhMmSs(const char *zDate, DateTime *p){ + int h, m, s; + double ms = 0.0; + if( getDigits(zDate, 2, 0, 24, ':', &h, 2, 0, 59, 0, &m)!=2 ){ + return 1; + } + zDate += 5; + if( *zDate==':' ){ + zDate++; + if( getDigits(zDate, 2, 0, 59, 0, &s)!=1 ){ + return 1; + } + zDate += 2; + if( *zDate=='.' && sqlite3Isdigit(zDate[1]) ){ + double rScale = 1.0; + zDate++; + while( sqlite3Isdigit(*zDate) ){ + ms = ms*10.0 + *zDate - '0'; + rScale *= 10.0; + zDate++; + } + ms /= rScale; + } + }else{ + s = 0; + } + p->validJD = 0; + p->validHMS = 1; + p->h = h; + p->m = m; + p->s = s + ms; + if( parseTimezone(zDate, p) ) return 1; + p->validTZ = (p->tz!=0)?1:0; + return 0; +} + +/* +** Convert from YYYY-MM-DD HH:MM:SS to julian day. We always assume +** that the YYYY-MM-DD is according to the Gregorian calendar. +** +** Reference: Meeus page 61 +*/ +static void computeJD(DateTime *p){ + int Y, M, D, A, B, X1, X2; + + if( p->validJD ) return; + if( p->validYMD ){ + Y = p->Y; + M = p->M; + D = p->D; + }else{ + Y = 2000; /* If no YMD specified, assume 2000-Jan-01 */ + M = 1; + D = 1; + } + if( M<=2 ){ + Y--; + M += 12; + } + A = Y/100; + B = 2 - A + (A/4); + X1 = 36525*(Y+4716)/100; + X2 = 306001*(M+1)/10000; + p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000); + p->validJD = 1; + if( p->validHMS ){ + p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000); + if( p->validTZ ){ + p->iJD -= p->tz*60000; + p->validYMD = 0; + p->validHMS = 0; + p->validTZ = 0; + } + } +} + +/* +** Parse dates of the form +** +** YYYY-MM-DD HH:MM:SS.FFF +** YYYY-MM-DD HH:MM:SS +** YYYY-MM-DD HH:MM +** YYYY-MM-DD +** +** Write the result into the DateTime structure and return 0 +** on success and 1 if the input string is not a well-formed +** date. +*/ +static int parseYyyyMmDd(const char *zDate, DateTime *p){ + int Y, M, D, neg; + + if( zDate[0]=='-' ){ + zDate++; + neg = 1; + }else{ + neg = 0; + } + if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){ + return 1; + } + zDate += 10; + while( sqlite3Isspace(*zDate) || 'T'==*(u8*)zDate ){ zDate++; } + if( parseHhMmSs(zDate, p)==0 ){ + /* We got the time */ + }else if( *zDate==0 ){ + p->validHMS = 0; + }else{ + return 1; + } + p->validJD = 0; + p->validYMD = 1; + p->Y = neg ? -Y : Y; + p->M = M; + p->D = D; + if( p->validTZ ){ + computeJD(p); + } + return 0; +} + +/* +** Set the time to the current time reported by the VFS. +** +** Return the number of errors. +*/ +static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){ + p->iJD = sqlite3StmtCurrentTime(context); + if( p->iJD>0 ){ + p->validJD = 1; + return 0; + }else{ + return 1; + } +} + +/* +** Attempt to parse the given string into a julian day number. Return +** the number of errors. +** +** The following are acceptable forms for the input string: +** +** YYYY-MM-DD HH:MM:SS.FFF +/-HH:MM +** DDDD.DD +** now +** +** In the first form, the +/-HH:MM is always optional. The fractional +** seconds extension (the ".FFF") is optional. The seconds portion +** (":SS.FFF") is option. The year and date can be omitted as long +** as there is a time string. The time string can be omitted as long +** as there is a year and date. +*/ +static int parseDateOrTime( + sqlite3_context *context, + const char *zDate, + DateTime *p +){ + double r; + if( parseYyyyMmDd(zDate,p)==0 ){ + return 0; + }else if( parseHhMmSs(zDate, p)==0 ){ + return 0; + }else if( sqlite3StrICmp(zDate,"now")==0){ + return setDateTimeToCurrent(context, p); + }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8) ){ + p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5); + p->validJD = 1; + return 0; + } + return 1; +} + +/* +** Compute the Year, Month, and Day from the julian day number. +*/ +static void computeYMD(DateTime *p){ + int Z, A, B, C, D, E, X1; + if( p->validYMD ) return; + if( !p->validJD ){ + p->Y = 2000; + p->M = 1; + p->D = 1; + }else{ + Z = (int)((p->iJD + 43200000)/86400000); + A = (int)((Z - 1867216.25)/36524.25); + A = Z + 1 + A - (A/4); + B = A + 1524; + C = (int)((B - 122.1)/365.25); + D = (36525*(C&32767))/100; + E = (int)((B-D)/30.6001); + X1 = (int)(30.6001*E); + p->D = B - D - X1; + p->M = E<14 ? E-1 : E-13; + p->Y = p->M>2 ? C - 4716 : C - 4715; + } + p->validYMD = 1; +} + +/* +** Compute the Hour, Minute, and Seconds from the julian day number. +*/ +static void computeHMS(DateTime *p){ + int s; + if( p->validHMS ) return; + computeJD(p); + s = (int)((p->iJD + 43200000) % 86400000); + p->s = s/1000.0; + s = (int)p->s; + p->s -= s; + p->h = s/3600; + s -= p->h*3600; + p->m = s/60; + p->s += s - p->m*60; + p->validHMS = 1; +} + +/* +** Compute both YMD and HMS +*/ +static void computeYMD_HMS(DateTime *p){ + computeYMD(p); + computeHMS(p); +} + +/* +** Clear the YMD and HMS and the TZ +*/ +static void clearYMD_HMS_TZ(DateTime *p){ + p->validYMD = 0; + p->validHMS = 0; + p->validTZ = 0; +} + +/* +** On recent Windows platforms, the localtime_s() function is available +** as part of the "Secure CRT". It is essentially equivalent to +** localtime_r() available under most POSIX platforms, except that the +** order of the parameters is reversed. +** +** See http://msdn.microsoft.com/en-us/library/a442x3ye(VS.80).aspx. +** +** If the user has not indicated to use localtime_r() or localtime_s() +** already, check for an MSVC build environment that provides +** localtime_s(). +*/ +#if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S \ + && defined(_MSC_VER) && defined(_CRT_INSECURE_DEPRECATE) +#undef HAVE_LOCALTIME_S +#define HAVE_LOCALTIME_S 1 +#endif + +#ifndef SQLITE_OMIT_LOCALTIME +/* +** The following routine implements the rough equivalent of localtime_r() +** using whatever operating-system specific localtime facility that +** is available. This routine returns 0 on success and +** non-zero on any kind of error. +** +** If the sqlite3GlobalConfig.bLocaltimeFault variable is true then this +** routine will always fail. +** +** EVIDENCE-OF: R-62172-00036 In this implementation, the standard C +** library function localtime_r() is used to assist in the calculation of +** local time. +*/ +static int osLocaltime(time_t *t, struct tm *pTm){ + int rc; +#if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S + struct tm *pX; +#if SQLITE_THREADSAFE>0 + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); +#endif + sqlite3_mutex_enter(mutex); + pX = localtime(t); +#ifndef SQLITE_OMIT_BUILTIN_TEST + if( sqlite3GlobalConfig.bLocaltimeFault ) pX = 0; +#endif + if( pX ) *pTm = *pX; + sqlite3_mutex_leave(mutex); + rc = pX==0; +#else +#ifndef SQLITE_OMIT_BUILTIN_TEST + if( sqlite3GlobalConfig.bLocaltimeFault ) return 1; +#endif +#if HAVE_LOCALTIME_R + rc = localtime_r(t, pTm)==0; +#else + rc = localtime_s(pTm, t); +#endif /* HAVE_LOCALTIME_R */ +#endif /* HAVE_LOCALTIME_R || HAVE_LOCALTIME_S */ + return rc; +} +#endif /* SQLITE_OMIT_LOCALTIME */ + + +#ifndef SQLITE_OMIT_LOCALTIME +/* +** Compute the difference (in milliseconds) between localtime and UTC +** (a.k.a. GMT) for the time value p where p is in UTC. If no error occurs, +** return this value and set *pRc to SQLITE_OK. +** +** Or, if an error does occur, set *pRc to SQLITE_ERROR. The returned value +** is undefined in this case. +*/ +static sqlite3_int64 localtimeOffset( + DateTime *p, /* Date at which to calculate offset */ + sqlite3_context *pCtx, /* Write error here if one occurs */ + int *pRc /* OUT: Error code. SQLITE_OK or ERROR */ +){ + DateTime x, y; + time_t t; + struct tm sLocal; + + /* Initialize the contents of sLocal to avoid a compiler warning. */ + memset(&sLocal, 0, sizeof(sLocal)); + + x = *p; + computeYMD_HMS(&x); + if( x.Y<1971 || x.Y>=2038 ){ + /* EVIDENCE-OF: R-55269-29598 The localtime_r() C function normally only + ** works for years between 1970 and 2037. For dates outside this range, + ** SQLite attempts to map the year into an equivalent year within this + ** range, do the calculation, then map the year back. + */ + x.Y = 2000; + x.M = 1; + x.D = 1; + x.h = 0; + x.m = 0; + x.s = 0.0; + } else { + int s = (int)(x.s + 0.5); + x.s = s; + } + x.tz = 0; + x.validJD = 0; + computeJD(&x); + t = (time_t)(x.iJD/1000 - 21086676*(i64)10000); + if( osLocaltime(&t, &sLocal) ){ + sqlite3_result_error(pCtx, "local time unavailable", -1); + *pRc = SQLITE_ERROR; + return 0; + } + y.Y = sLocal.tm_year + 1900; + y.M = sLocal.tm_mon + 1; + y.D = sLocal.tm_mday; + y.h = sLocal.tm_hour; + y.m = sLocal.tm_min; + y.s = sLocal.tm_sec; + y.validYMD = 1; + y.validHMS = 1; + y.validJD = 0; + y.validTZ = 0; + computeJD(&y); + *pRc = SQLITE_OK; + return y.iJD - x.iJD; +} +#endif /* SQLITE_OMIT_LOCALTIME */ + +/* +** Process a modifier to a date-time stamp. The modifiers are +** as follows: +** +** NNN days +** NNN hours +** NNN minutes +** NNN.NNNN seconds +** NNN months +** NNN years +** start of month +** start of year +** start of week +** start of day +** weekday N +** unixepoch +** localtime +** utc +** +** Return 0 on success and 1 if there is any kind of error. If the error +** is in a system call (i.e. localtime()), then an error message is written +** to context pCtx. If the error is an unrecognized modifier, no error is +** written to pCtx. +*/ +static int parseModifier(sqlite3_context *pCtx, const char *zMod, DateTime *p){ + int rc = 1; + int n; + double r; + char *z, zBuf[30]; + z = zBuf; + for(n=0; niJD += localtimeOffset(p, pCtx, &rc); + clearYMD_HMS_TZ(p); + } + break; + } +#endif + case 'u': { + /* + ** unixepoch + ** + ** Treat the current value of p->iJD as the number of + ** seconds since 1970. Convert to a real julian day number. + */ + if( strcmp(z, "unixepoch")==0 && p->validJD ){ + p->iJD = (p->iJD + 43200)/86400 + 21086676*(i64)10000000; + clearYMD_HMS_TZ(p); + rc = 0; + } +#ifndef SQLITE_OMIT_LOCALTIME + else if( strcmp(z, "utc")==0 ){ + sqlite3_int64 c1; + computeJD(p); + c1 = localtimeOffset(p, pCtx, &rc); + if( rc==SQLITE_OK ){ + p->iJD -= c1; + clearYMD_HMS_TZ(p); + p->iJD += c1 - localtimeOffset(p, pCtx, &rc); + } + } +#endif + break; + } + case 'w': { + /* + ** weekday N + ** + ** Move the date to the same time on the next occurrence of + ** weekday N where 0==Sunday, 1==Monday, and so forth. If the + ** date is already on the appropriate weekday, this is a no-op. + */ + if( strncmp(z, "weekday ", 8)==0 + && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8) + && (n=(int)r)==r && n>=0 && r<7 ){ + sqlite3_int64 Z; + computeYMD_HMS(p); + p->validTZ = 0; + p->validJD = 0; + computeJD(p); + Z = ((p->iJD + 129600000)/86400000) % 7; + if( Z>n ) Z -= 7; + p->iJD += (n - Z)*86400000; + clearYMD_HMS_TZ(p); + rc = 0; + } + break; + } + case 's': { + /* + ** start of TTTTT + ** + ** Move the date backwards to the beginning of the current day, + ** or month or year. + */ + if( strncmp(z, "start of ", 9)!=0 ) break; + z += 9; + computeYMD(p); + p->validHMS = 1; + p->h = p->m = 0; + p->s = 0.0; + p->validTZ = 0; + p->validJD = 0; + if( strcmp(z,"month")==0 ){ + p->D = 1; + rc = 0; + }else if( strcmp(z,"year")==0 ){ + computeYMD(p); + p->M = 1; + p->D = 1; + rc = 0; + }else if( strcmp(z,"day")==0 ){ + rc = 0; + } + break; + } + case '+': + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': { + double rRounder; + for(n=1; z[n] && z[n]!=':' && !sqlite3Isspace(z[n]); n++){} + if( !sqlite3AtoF(z, &r, n, SQLITE_UTF8) ){ + rc = 1; + break; + } + if( z[n]==':' ){ + /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the + ** specified number of hours, minutes, seconds, and fractional seconds + ** to the time. The ".FFF" may be omitted. The ":SS.FFF" may be + ** omitted. + */ + const char *z2 = z; + DateTime tx; + sqlite3_int64 day; + if( !sqlite3Isdigit(*z2) ) z2++; + memset(&tx, 0, sizeof(tx)); + if( parseHhMmSs(z2, &tx) ) break; + computeJD(&tx); + tx.iJD -= 43200000; + day = tx.iJD/86400000; + tx.iJD -= day*86400000; + if( z[0]=='-' ) tx.iJD = -tx.iJD; + computeJD(p); + clearYMD_HMS_TZ(p); + p->iJD += tx.iJD; + rc = 0; + break; + } + z += n; + while( sqlite3Isspace(*z) ) z++; + n = sqlite3Strlen30(z); + if( n>10 || n<3 ) break; + if( z[n-1]=='s' ){ z[n-1] = 0; n--; } + computeJD(p); + rc = 0; + rRounder = r<0 ? -0.5 : +0.5; + if( n==3 && strcmp(z,"day")==0 ){ + p->iJD += (sqlite3_int64)(r*86400000.0 + rRounder); + }else if( n==4 && strcmp(z,"hour")==0 ){ + p->iJD += (sqlite3_int64)(r*(86400000.0/24.0) + rRounder); + }else if( n==6 && strcmp(z,"minute")==0 ){ + p->iJD += (sqlite3_int64)(r*(86400000.0/(24.0*60.0)) + rRounder); + }else if( n==6 && strcmp(z,"second")==0 ){ + p->iJD += (sqlite3_int64)(r*(86400000.0/(24.0*60.0*60.0)) + rRounder); + }else if( n==5 && strcmp(z,"month")==0 ){ + int x, y; + computeYMD_HMS(p); + p->M += (int)r; + x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12; + p->Y += x; + p->M -= x*12; + p->validJD = 0; + computeJD(p); + y = (int)r; + if( y!=r ){ + p->iJD += (sqlite3_int64)((r - y)*30.0*86400000.0 + rRounder); + } + }else if( n==4 && strcmp(z,"year")==0 ){ + int y = (int)r; + computeYMD_HMS(p); + p->Y += y; + p->validJD = 0; + computeJD(p); + if( y!=r ){ + p->iJD += (sqlite3_int64)((r - y)*365.0*86400000.0 + rRounder); + } + }else{ + rc = 1; + } + clearYMD_HMS_TZ(p); + break; + } + default: { + break; + } + } + return rc; +} + +/* +** Process time function arguments. argv[0] is a date-time stamp. +** argv[1] and following are modifiers. Parse them all and write +** the resulting time into the DateTime structure p. Return 0 +** on success and 1 if there are any errors. +** +** If there are zero parameters (if even argv[0] is undefined) +** then assume a default value of "now" for argv[0]. +*/ +static int isDate( + sqlite3_context *context, + int argc, + sqlite3_value **argv, + DateTime *p +){ + int i; + const unsigned char *z; + int eType; + memset(p, 0, sizeof(*p)); + if( argc==0 ){ + return setDateTimeToCurrent(context, p); + } + if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT + || eType==SQLITE_INTEGER ){ + p->iJD = (sqlite3_int64)(sqlite3_value_double(argv[0])*86400000.0 + 0.5); + p->validJD = 1; + }else{ + z = sqlite3_value_text(argv[0]); + if( !z || parseDateOrTime(context, (char*)z, p) ){ + return 1; + } + } + for(i=1; iaLimit[SQLITE_LIMIT_LENGTH]+1 ); + testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ); + if( n(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ){ + sqlite3_result_error_toobig(context); + return; + }else{ + z = sqlite3DbMallocRaw(db, (int)n); + if( z==0 ){ + sqlite3_result_error_nomem(context); + return; + } + } + computeJD(&x); + computeYMD_HMS(&x); + for(i=j=0; zFmt[i]; i++){ + if( zFmt[i]!='%' ){ + z[j++] = zFmt[i]; + }else{ + i++; + switch( zFmt[i] ){ + case 'd': sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break; + case 'f': { + double s = x.s; + if( s>59.999 ) s = 59.999; + sqlite3_snprintf(7, &z[j],"%06.3f", s); + j += sqlite3Strlen30(&z[j]); + break; + } + case 'H': sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break; + case 'W': /* Fall thru */ + case 'j': { + int nDay; /* Number of days since 1st day of year */ + DateTime y = x; + y.validJD = 0; + y.M = 1; + y.D = 1; + computeJD(&y); + nDay = (int)((x.iJD-y.iJD+43200000)/86400000); + if( zFmt[i]=='W' ){ + int wd; /* 0=Monday, 1=Tuesday, ... 6=Sunday */ + wd = (int)(((x.iJD+43200000)/86400000)%7); + sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7); + j += 2; + }else{ + sqlite3_snprintf(4, &z[j],"%03d",nDay+1); + j += 3; + } + break; + } + case 'J': { + sqlite3_snprintf(20, &z[j],"%.16g",x.iJD/86400000.0); + j+=sqlite3Strlen30(&z[j]); + break; + } + case 'm': sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break; + case 'M': sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break; + case 's': { + sqlite3_snprintf(30,&z[j],"%lld", + (i64)(x.iJD/1000 - 21086676*(i64)10000)); + j += sqlite3Strlen30(&z[j]); + break; + } + case 'S': sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break; + case 'w': { + z[j++] = (char)(((x.iJD+129600000)/86400000) % 7) + '0'; + break; + } + case 'Y': { + sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlite3Strlen30(&z[j]); + break; + } + default: z[j++] = '%'; break; + } + } + } + z[j] = 0; + sqlite3_result_text(context, z, -1, + z==zBuf ? SQLITE_TRANSIENT : SQLITE_DYNAMIC); +} + +/* +** current_time() +** +** This function returns the same value as time('now'). +*/ +static void ctimeFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + timeFunc(context, 0, 0); +} + +/* +** current_date() +** +** This function returns the same value as date('now'). +*/ +static void cdateFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + dateFunc(context, 0, 0); +} + +/* +** current_timestamp() +** +** This function returns the same value as datetime('now'). +*/ +static void ctimestampFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + datetimeFunc(context, 0, 0); +} +#endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) */ + +#ifdef SQLITE_OMIT_DATETIME_FUNCS +/* +** If the library is compiled to omit the full-scale date and time +** handling (to get a smaller binary), the following minimal version +** of the functions current_time(), current_date() and current_timestamp() +** are included instead. This is to support column declarations that +** include "DEFAULT CURRENT_TIME" etc. +** +** This function uses the C-library functions time(), gmtime() +** and strftime(). The format string to pass to strftime() is supplied +** as the user-data for the function. +*/ +static void currentTimeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + time_t t; + char *zFormat = (char *)sqlite3_user_data(context); + sqlite3 *db; + sqlite3_int64 iT; + struct tm *pTm; + struct tm sNow; + char zBuf[20]; + + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + + iT = sqlite3StmtCurrentTime(context); + if( iT<=0 ) return; + t = iT/1000 - 10000*(sqlite3_int64)21086676; +#if HAVE_GMTIME_R + pTm = gmtime_r(&t, &sNow); +#else + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)); + pTm = gmtime(&t); + if( pTm ) memcpy(&sNow, pTm, sizeof(sNow)); + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)); +#endif + if( pTm ){ + strftime(zBuf, 20, zFormat, &sNow); + sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); + } +} +#endif + +/* +** This function registered all of the above C functions as SQL +** functions. This should be the only routine in this file with +** external linkage. +*/ +SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){ + static SQLITE_WSD FuncDef aDateTimeFuncs[] = { +#ifndef SQLITE_OMIT_DATETIME_FUNCS + DFUNCTION(julianday, -1, 0, 0, juliandayFunc ), + DFUNCTION(date, -1, 0, 0, dateFunc ), + DFUNCTION(time, -1, 0, 0, timeFunc ), + DFUNCTION(datetime, -1, 0, 0, datetimeFunc ), + DFUNCTION(strftime, -1, 0, 0, strftimeFunc ), + DFUNCTION(current_time, 0, 0, 0, ctimeFunc ), + DFUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc), + DFUNCTION(current_date, 0, 0, 0, cdateFunc ), +#else + STR_FUNCTION(current_time, 0, "%H:%M:%S", 0, currentTimeFunc), + STR_FUNCTION(current_date, 0, "%Y-%m-%d", 0, currentTimeFunc), + STR_FUNCTION(current_timestamp, 0, "%Y-%m-%d %H:%M:%S", 0, currentTimeFunc), +#endif + }; + int i; + FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions); + FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aDateTimeFuncs); + + for(i=0; ipMethods ){ + rc = pId->pMethods->xClose(pId); + pId->pMethods = 0; + } + return rc; +} +SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xRead(id, pBuf, amt, offset); +} +SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xWrite(id, pBuf, amt, offset); +} +SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file *id, i64 size){ + return id->pMethods->xTruncate(id, size); +} +SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file *id, int flags){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xSync(id, flags); +} +SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xFileSize(id, pSize); +} +SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file *id, int lockType){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xLock(id, lockType); +} +SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file *id, int lockType){ + return id->pMethods->xUnlock(id, lockType); +} +SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xCheckReservedLock(id, pResOut); +} + +/* +** Use sqlite3OsFileControl() when we are doing something that might fail +** and we need to know about the failures. Use sqlite3OsFileControlHint() +** when simply tossing information over the wall to the VFS and we do not +** really care if the VFS receives and understands the information since it +** is only a hint and can be safely ignored. The sqlite3OsFileControlHint() +** routine has no return value since the return value would be meaningless. +*/ +SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){ +#ifdef SQLITE_TEST + if( op!=SQLITE_FCNTL_COMMIT_PHASETWO ){ + /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite + ** is using a regular VFS, it is called after the corresponding + ** transaction has been committed. Injecting a fault at this point + ** confuses the test scripts - the COMMIT comand returns SQLITE_NOMEM + ** but the transaction is committed anyway. + ** + ** The core must call OsFileControl() though, not OsFileControlHint(), + ** as if a custom VFS (e.g. zipvfs) returns an error here, it probably + ** means the commit really has failed and an error should be returned + ** to the user. */ + DO_OS_MALLOC_TEST(id); + } +#endif + return id->pMethods->xFileControl(id, op, pArg); +} +SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){ + (void)id->pMethods->xFileControl(id, op, pArg); +} + +SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id){ + int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize; + return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE); +} +SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id){ + return id->pMethods->xDeviceCharacteristics(id); +} +SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){ + return id->pMethods->xShmLock(id, offset, n, flags); +} +SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id){ + id->pMethods->xShmBarrier(id); +} +SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int deleteFlag){ + return id->pMethods->xShmUnmap(id, deleteFlag); +} +SQLITE_PRIVATE int sqlite3OsShmMap( + sqlite3_file *id, /* Database file handle */ + int iPage, + int pgsz, + int bExtend, /* True to extend file if necessary */ + void volatile **pp /* OUT: Pointer to mapping */ +){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp); +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* The real implementation of xFetch and xUnfetch */ +SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64 iOff, int iAmt, void **pp){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xFetch(id, iOff, iAmt, pp); +} +SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){ + return id->pMethods->xUnfetch(id, iOff, p); +} +#else +/* No-op stubs to use when memory-mapped I/O is disabled */ +SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64 iOff, int iAmt, void **pp){ + *pp = 0; + return SQLITE_OK; +} +SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){ + return SQLITE_OK; +} +#endif + +/* +** The next group of routines are convenience wrappers around the +** VFS methods. +*/ +SQLITE_PRIVATE int sqlite3OsOpen( + sqlite3_vfs *pVfs, + const char *zPath, + sqlite3_file *pFile, + int flags, + int *pFlagsOut +){ + int rc; + DO_OS_MALLOC_TEST(0); + /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed + ** down into the VFS layer. Some SQLITE_OPEN_ flags (for example, + ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before + ** reaching the VFS. */ + rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut); + assert( rc==SQLITE_OK || pFile->pMethods==0 ); + return rc; +} +SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ + DO_OS_MALLOC_TEST(0); + assert( dirSync==0 || dirSync==1 ); + return pVfs->xDelete(pVfs, zPath, dirSync); +} +SQLITE_PRIVATE int sqlite3OsAccess( + sqlite3_vfs *pVfs, + const char *zPath, + int flags, + int *pResOut +){ + DO_OS_MALLOC_TEST(0); + return pVfs->xAccess(pVfs, zPath, flags, pResOut); +} +SQLITE_PRIVATE int sqlite3OsFullPathname( + sqlite3_vfs *pVfs, + const char *zPath, + int nPathOut, + char *zPathOut +){ + DO_OS_MALLOC_TEST(0); + zPathOut[0] = 0; + return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut); +} +#ifndef SQLITE_OMIT_LOAD_EXTENSION +SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){ + return pVfs->xDlOpen(pVfs, zPath); +} +SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ + pVfs->xDlError(pVfs, nByte, zBufOut); +} +SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHdle, const char *zSym))(void){ + return pVfs->xDlSym(pVfs, pHdle, zSym); +} +SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){ + pVfs->xDlClose(pVfs, pHandle); +} +#endif /* SQLITE_OMIT_LOAD_EXTENSION */ +SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ + return pVfs->xRandomness(pVfs, nByte, zBufOut); +} +SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){ + return pVfs->xSleep(pVfs, nMicro); +} +SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){ + int rc; + /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64() + ** method to get the current date and time if that method is available + ** (if iVersion is 2 or greater and the function pointer is not NULL) and + ** will fall back to xCurrentTime() if xCurrentTimeInt64() is + ** unavailable. + */ + if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){ + rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut); + }else{ + double r; + rc = pVfs->xCurrentTime(pVfs, &r); + *pTimeOut = (sqlite3_int64)(r*86400000.0); + } + return rc; +} + +SQLITE_PRIVATE int sqlite3OsOpenMalloc( + sqlite3_vfs *pVfs, + const char *zFile, + sqlite3_file **ppFile, + int flags, + int *pOutFlags +){ + int rc = SQLITE_NOMEM; + sqlite3_file *pFile; + pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile); + if( pFile ){ + rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags); + if( rc!=SQLITE_OK ){ + sqlite3_free(pFile); + }else{ + *ppFile = pFile; + } + } + return rc; +} +SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *pFile){ + int rc = SQLITE_OK; + assert( pFile ); + rc = sqlite3OsClose(pFile); + sqlite3_free(pFile); + return rc; +} + +/* +** This function is a wrapper around the OS specific implementation of +** sqlite3_os_init(). The purpose of the wrapper is to provide the +** ability to simulate a malloc failure, so that the handling of an +** error in sqlite3_os_init() by the upper layers can be tested. +*/ +SQLITE_PRIVATE int sqlite3OsInit(void){ + void *p = sqlite3_malloc(10); + if( p==0 ) return SQLITE_NOMEM; + sqlite3_free(p); + return sqlite3_os_init(); +} + +/* +** The list of all registered VFS implementations. +*/ +static sqlite3_vfs * SQLITE_WSD vfsList = 0; +#define vfsList GLOBAL(sqlite3_vfs *, vfsList) + +/* +** Locate a VFS by name. If no name is given, simply return the +** first VFS on the list. +*/ +SQLITE_API sqlite3_vfs *SQLITE_STDCALL sqlite3_vfs_find(const char *zVfs){ + sqlite3_vfs *pVfs = 0; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex; +#endif +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return 0; +#endif +#if SQLITE_THREADSAFE + mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); +#endif + sqlite3_mutex_enter(mutex); + for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){ + if( zVfs==0 ) break; + if( strcmp(zVfs, pVfs->zName)==0 ) break; + } + sqlite3_mutex_leave(mutex); + return pVfs; +} + +/* +** Unlink a VFS from the linked list +*/ +static void vfsUnlink(sqlite3_vfs *pVfs){ + assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) ); + if( pVfs==0 ){ + /* No-op */ + }else if( vfsList==pVfs ){ + vfsList = pVfs->pNext; + }else if( vfsList ){ + sqlite3_vfs *p = vfsList; + while( p->pNext && p->pNext!=pVfs ){ + p = p->pNext; + } + if( p->pNext==pVfs ){ + p->pNext = pVfs->pNext; + } + } +} + +/* +** Register a VFS with the system. It is harmless to register the same +** VFS multiple times. The new VFS becomes the default if makeDflt is +** true. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){ + MUTEX_LOGIC(sqlite3_mutex *mutex;) +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return rc; +#endif +#ifdef SQLITE_ENABLE_API_ARMOR + if( pVfs==0 ) return SQLITE_MISUSE_BKPT; +#endif + + MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); ) + sqlite3_mutex_enter(mutex); + vfsUnlink(pVfs); + if( makeDflt || vfsList==0 ){ + pVfs->pNext = vfsList; + vfsList = pVfs; + }else{ + pVfs->pNext = vfsList->pNext; + vfsList->pNext = pVfs; + } + assert(vfsList); + sqlite3_mutex_leave(mutex); + return SQLITE_OK; +} + +/* +** Unregister a VFS so that it is no longer accessible. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_vfs_unregister(sqlite3_vfs *pVfs){ +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); +#endif + sqlite3_mutex_enter(mutex); + vfsUnlink(pVfs); + sqlite3_mutex_leave(mutex); + return SQLITE_OK; +} + +/************** End of os.c **************************************************/ +/************** Begin file fault.c *******************************************/ +/* +** 2008 Jan 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code to support the concept of "benign" +** malloc failures (when the xMalloc() or xRealloc() method of the +** sqlite3_mem_methods structure fails to allocate a block of memory +** and returns 0). +** +** Most malloc failures are non-benign. After they occur, SQLite +** abandons the current operation and returns an error code (usually +** SQLITE_NOMEM) to the user. However, sometimes a fault is not necessarily +** fatal. For example, if a malloc fails while resizing a hash table, this +** is completely recoverable simply by not carrying out the resize. The +** hash table will continue to function normally. So a malloc failure +** during a hash table resize is a benign fault. +*/ + +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_BUILTIN_TEST + +/* +** Global variables. +*/ +typedef struct BenignMallocHooks BenignMallocHooks; +static SQLITE_WSD struct BenignMallocHooks { + void (*xBenignBegin)(void); + void (*xBenignEnd)(void); +} sqlite3Hooks = { 0, 0 }; + +/* The "wsdHooks" macro will resolve to the appropriate BenignMallocHooks +** structure. If writable static data is unsupported on the target, +** we have to locate the state vector at run-time. In the more common +** case where writable static data is supported, wsdHooks can refer directly +** to the "sqlite3Hooks" state vector declared above. +*/ +#ifdef SQLITE_OMIT_WSD +# define wsdHooksInit \ + BenignMallocHooks *x = &GLOBAL(BenignMallocHooks,sqlite3Hooks) +# define wsdHooks x[0] +#else +# define wsdHooksInit +# define wsdHooks sqlite3Hooks +#endif + + +/* +** Register hooks to call when sqlite3BeginBenignMalloc() and +** sqlite3EndBenignMalloc() are called, respectively. +*/ +SQLITE_PRIVATE void sqlite3BenignMallocHooks( + void (*xBenignBegin)(void), + void (*xBenignEnd)(void) +){ + wsdHooksInit; + wsdHooks.xBenignBegin = xBenignBegin; + wsdHooks.xBenignEnd = xBenignEnd; +} + +/* +** This (sqlite3EndBenignMalloc()) is called by SQLite code to indicate that +** subsequent malloc failures are benign. A call to sqlite3EndBenignMalloc() +** indicates that subsequent malloc failures are non-benign. +*/ +SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void){ + wsdHooksInit; + if( wsdHooks.xBenignBegin ){ + wsdHooks.xBenignBegin(); + } +} +SQLITE_PRIVATE void sqlite3EndBenignMalloc(void){ + wsdHooksInit; + if( wsdHooks.xBenignEnd ){ + wsdHooks.xBenignEnd(); + } +} + +#endif /* #ifndef SQLITE_OMIT_BUILTIN_TEST */ + +/************** End of fault.c ***********************************************/ +/************** Begin file mem0.c ********************************************/ +/* +** 2008 October 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains a no-op memory allocation drivers for use when +** SQLITE_ZERO_MALLOC is defined. The allocation drivers implemented +** here always fail. SQLite will not operate with these drivers. These +** are merely placeholders. Real drivers must be substituted using +** sqlite3_config() before SQLite will operate. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is the default. It is +** used when no other memory allocator is specified using compile-time +** macros. +*/ +#ifdef SQLITE_ZERO_MALLOC + +/* +** No-op versions of all memory allocation routines +*/ +static void *sqlite3MemMalloc(int nByte){ return 0; } +static void sqlite3MemFree(void *pPrior){ return; } +static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; } +static int sqlite3MemSize(void *pPrior){ return 0; } +static int sqlite3MemRoundup(int n){ return n; } +static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; } +static void sqlite3MemShutdown(void *NotUsed){ return; } + +/* +** This routine is the only routine in this file with external linkage. +** +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. +*/ +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + static const sqlite3_mem_methods defaultMethods = { + sqlite3MemMalloc, + sqlite3MemFree, + sqlite3MemRealloc, + sqlite3MemSize, + sqlite3MemRoundup, + sqlite3MemInit, + sqlite3MemShutdown, + 0 + }; + sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); +} + +#endif /* SQLITE_ZERO_MALLOC */ + +/************** End of mem0.c ************************************************/ +/************** Begin file mem1.c ********************************************/ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains low-level memory allocation drivers for when +** SQLite will use the standard C-library malloc/realloc/free interface +** to obtain the memory it needs. +** +** This file contains implementations of the low-level memory allocation +** routines specified in the sqlite3_mem_methods object. The content of +** this file is only used if SQLITE_SYSTEM_MALLOC is defined. The +** SQLITE_SYSTEM_MALLOC macro is defined automatically if neither the +** SQLITE_MEMDEBUG nor the SQLITE_WIN32_MALLOC macros are defined. The +** default configuration is to use memory allocation routines in this +** file. +** +** C-preprocessor macro summary: +** +** HAVE_MALLOC_USABLE_SIZE The configure script sets this symbol if +** the malloc_usable_size() interface exists +** on the target platform. Or, this symbol +** can be set manually, if desired. +** If an equivalent interface exists by +** a different name, using a separate -D +** option to rename it. +** +** SQLITE_WITHOUT_ZONEMALLOC Some older macs lack support for the zone +** memory allocator. Set this symbol to enable +** building on older macs. +** +** SQLITE_WITHOUT_MSIZE Set this symbol to disable the use of +** _msize() on windows systems. This might +** be necessary when compiling for Delphi, +** for example. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is the default. It is +** used when no other memory allocator is specified using compile-time +** macros. +*/ +#ifdef SQLITE_SYSTEM_MALLOC +#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) + +/* +** Use the zone allocator available on apple products unless the +** SQLITE_WITHOUT_ZONEMALLOC symbol is defined. +*/ +#include +#include +#include +static malloc_zone_t* _sqliteZone_; +#define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x)) +#define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x)); +#define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y)) +#define SQLITE_MALLOCSIZE(x) \ + (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x)) + +#else /* if not __APPLE__ */ + +/* +** Use standard C library malloc and free on non-Apple systems. +** Also used by Apple systems if SQLITE_WITHOUT_ZONEMALLOC is defined. +*/ +#define SQLITE_MALLOC(x) malloc(x) +#define SQLITE_FREE(x) free(x) +#define SQLITE_REALLOC(x,y) realloc((x),(y)) + +/* +** The malloc.h header file is needed for malloc_usable_size() function +** on some systems (e.g. Linux). +*/ +#if HAVE_MALLOC_H && HAVE_MALLOC_USABLE_SIZE +# define SQLITE_USE_MALLOC_H 1 +# define SQLITE_USE_MALLOC_USABLE_SIZE 1 +/* +** The MSVCRT has malloc_usable_size(), but it is called _msize(). The +** use of _msize() is automatic, but can be disabled by compiling with +** -DSQLITE_WITHOUT_MSIZE. Using the _msize() function also requires +** the malloc.h header file. +*/ +#elif defined(_MSC_VER) && !defined(SQLITE_WITHOUT_MSIZE) +# define SQLITE_USE_MALLOC_H +# define SQLITE_USE_MSIZE +#endif + +/* +** Include the malloc.h header file, if necessary. Also set define macro +** SQLITE_MALLOCSIZE to the appropriate function name, which is _msize() +** for MSVC and malloc_usable_size() for most other systems (e.g. Linux). +** The memory size function can always be overridden manually by defining +** the macro SQLITE_MALLOCSIZE to the desired function name. +*/ +#if defined(SQLITE_USE_MALLOC_H) +# include +# if defined(SQLITE_USE_MALLOC_USABLE_SIZE) +# if !defined(SQLITE_MALLOCSIZE) +# define SQLITE_MALLOCSIZE(x) malloc_usable_size(x) +# endif +# elif defined(SQLITE_USE_MSIZE) +# if !defined(SQLITE_MALLOCSIZE) +# define SQLITE_MALLOCSIZE _msize +# endif +# endif +#endif /* defined(SQLITE_USE_MALLOC_H) */ + +#endif /* __APPLE__ or not __APPLE__ */ + +/* +** Like malloc(), but remember the size of the allocation +** so that we can find it later using sqlite3MemSize(). +** +** For this low-level routine, we are guaranteed that nByte>0 because +** cases of nByte<=0 will be intercepted and dealt with by higher level +** routines. +*/ +static void *sqlite3MemMalloc(int nByte){ +#ifdef SQLITE_MALLOCSIZE + void *p = SQLITE_MALLOC( nByte ); + if( p==0 ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); + } + return p; +#else + sqlite3_int64 *p; + assert( nByte>0 ); + nByte = ROUND8(nByte); + p = SQLITE_MALLOC( nByte+8 ); + if( p ){ + p[0] = nByte; + p++; + }else{ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); + } + return (void *)p; +#endif +} + +/* +** Like free() but works for allocations obtained from sqlite3MemMalloc() +** or sqlite3MemRealloc(). +** +** For this low-level routine, we already know that pPrior!=0 since +** cases where pPrior==0 will have been intecepted and dealt with +** by higher-level routines. +*/ +static void sqlite3MemFree(void *pPrior){ +#ifdef SQLITE_MALLOCSIZE + SQLITE_FREE(pPrior); +#else + sqlite3_int64 *p = (sqlite3_int64*)pPrior; + assert( pPrior!=0 ); + p--; + SQLITE_FREE(p); +#endif +} + +/* +** Report the allocated size of a prior return from xMalloc() +** or xRealloc(). +*/ +static int sqlite3MemSize(void *pPrior){ +#ifdef SQLITE_MALLOCSIZE + return pPrior ? (int)SQLITE_MALLOCSIZE(pPrior) : 0; +#else + sqlite3_int64 *p; + if( pPrior==0 ) return 0; + p = (sqlite3_int64*)pPrior; + p--; + return (int)p[0]; +#endif +} + +/* +** Like realloc(). Resize an allocation previously obtained from +** sqlite3MemMalloc(). +** +** For this low-level interface, we know that pPrior!=0. Cases where +** pPrior==0 while have been intercepted by higher-level routine and +** redirected to xMalloc. Similarly, we know that nByte>0 because +** cases where nByte<=0 will have been intercepted by higher-level +** routines and redirected to xFree. +*/ +static void *sqlite3MemRealloc(void *pPrior, int nByte){ +#ifdef SQLITE_MALLOCSIZE + void *p = SQLITE_REALLOC(pPrior, nByte); + if( p==0 ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, + "failed memory resize %u to %u bytes", + SQLITE_MALLOCSIZE(pPrior), nByte); + } + return p; +#else + sqlite3_int64 *p = (sqlite3_int64*)pPrior; + assert( pPrior!=0 && nByte>0 ); + assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */ + p--; + p = SQLITE_REALLOC(p, nByte+8 ); + if( p ){ + p[0] = nByte; + p++; + }else{ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, + "failed memory resize %u to %u bytes", + sqlite3MemSize(pPrior), nByte); + } + return (void*)p; +#endif +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int sqlite3MemRoundup(int n){ + return ROUND8(n); +} + +/* +** Initialize this module. +*/ +static int sqlite3MemInit(void *NotUsed){ +#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) + int cpuCount; + size_t len; + if( _sqliteZone_ ){ + return SQLITE_OK; + } + len = sizeof(cpuCount); + /* One usually wants to use hw.acctivecpu for MT decisions, but not here */ + sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0); + if( cpuCount>1 ){ + /* defer MT decisions to system malloc */ + _sqliteZone_ = malloc_default_zone(); + }else{ + /* only 1 core, use our own zone to contention over global locks, + ** e.g. we have our own dedicated locks */ + bool success; + malloc_zone_t* newzone = malloc_create_zone(4096, 0); + malloc_set_zone_name(newzone, "Sqlite_Heap"); + do{ + success = OSAtomicCompareAndSwapPtrBarrier(NULL, newzone, + (void * volatile *)&_sqliteZone_); + }while(!_sqliteZone_); + if( !success ){ + /* somebody registered a zone first */ + malloc_destroy_zone(newzone); + } + } +#endif + UNUSED_PARAMETER(NotUsed); + return SQLITE_OK; +} + +/* +** Deinitialize this module. +*/ +static void sqlite3MemShutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + return; +} + +/* +** This routine is the only routine in this file with external linkage. +** +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. +*/ +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + static const sqlite3_mem_methods defaultMethods = { + sqlite3MemMalloc, + sqlite3MemFree, + sqlite3MemRealloc, + sqlite3MemSize, + sqlite3MemRoundup, + sqlite3MemInit, + sqlite3MemShutdown, + 0 + }; + sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); +} + +#endif /* SQLITE_SYSTEM_MALLOC */ + +/************** End of mem1.c ************************************************/ +/************** Begin file mem2.c ********************************************/ +/* +** 2007 August 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains low-level memory allocation drivers for when +** SQLite will use the standard C-library malloc/realloc/free interface +** to obtain the memory it needs while adding lots of additional debugging +** information to each allocation in order to help detect and fix memory +** leaks and memory usage errors. +** +** This file contains implementations of the low-level memory allocation +** routines specified in the sqlite3_mem_methods object. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is used only if the +** SQLITE_MEMDEBUG macro is defined +*/ +#ifdef SQLITE_MEMDEBUG + +/* +** The backtrace functionality is only available with GLIBC +*/ +#ifdef __GLIBC__ + extern int backtrace(void**,int); + extern void backtrace_symbols_fd(void*const*,int,int); +#else +# define backtrace(A,B) 1 +# define backtrace_symbols_fd(A,B,C) +#endif +/* #include */ + +/* +** Each memory allocation looks like this: +** +** ------------------------------------------------------------------------ +** | Title | backtrace pointers | MemBlockHdr | allocation | EndGuard | +** ------------------------------------------------------------------------ +** +** The application code sees only a pointer to the allocation. We have +** to back up from the allocation pointer to find the MemBlockHdr. The +** MemBlockHdr tells us the size of the allocation and the number of +** backtrace pointers. There is also a guard word at the end of the +** MemBlockHdr. +*/ +struct MemBlockHdr { + i64 iSize; /* Size of this allocation */ + struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */ + char nBacktrace; /* Number of backtraces on this alloc */ + char nBacktraceSlots; /* Available backtrace slots */ + u8 nTitle; /* Bytes of title; includes '\0' */ + u8 eType; /* Allocation type code */ + int iForeGuard; /* Guard word for sanity */ +}; + +/* +** Guard words +*/ +#define FOREGUARD 0x80F5E153 +#define REARGUARD 0xE4676B53 + +/* +** Number of malloc size increments to track. +*/ +#define NCSIZE 1000 + +/* +** All of the static variables used by this module are collected +** into a single structure named "mem". This is to keep the +** static variables organized and to reduce namespace pollution +** when this module is combined with other in the amalgamation. +*/ +static struct { + + /* + ** Mutex to control access to the memory allocation subsystem. + */ + sqlite3_mutex *mutex; + + /* + ** Head and tail of a linked list of all outstanding allocations + */ + struct MemBlockHdr *pFirst; + struct MemBlockHdr *pLast; + + /* + ** The number of levels of backtrace to save in new allocations. + */ + int nBacktrace; + void (*xBacktrace)(int, int, void **); + + /* + ** Title text to insert in front of each block + */ + int nTitle; /* Bytes of zTitle to save. Includes '\0' and padding */ + char zTitle[100]; /* The title text */ + + /* + ** sqlite3MallocDisallow() increments the following counter. + ** sqlite3MallocAllow() decrements it. + */ + int disallow; /* Do not allow memory allocation */ + + /* + ** Gather statistics on the sizes of memory allocations. + ** nAlloc[i] is the number of allocation attempts of i*8 + ** bytes. i==NCSIZE is the number of allocation attempts for + ** sizes more than NCSIZE*8 bytes. + */ + int nAlloc[NCSIZE]; /* Total number of allocations */ + int nCurrent[NCSIZE]; /* Current number of allocations */ + int mxCurrent[NCSIZE]; /* Highwater mark for nCurrent */ + +} mem; + + +/* +** Adjust memory usage statistics +*/ +static void adjustStats(int iSize, int increment){ + int i = ROUND8(iSize)/8; + if( i>NCSIZE-1 ){ + i = NCSIZE - 1; + } + if( increment>0 ){ + mem.nAlloc[i]++; + mem.nCurrent[i]++; + if( mem.nCurrent[i]>mem.mxCurrent[i] ){ + mem.mxCurrent[i] = mem.nCurrent[i]; + } + }else{ + mem.nCurrent[i]--; + assert( mem.nCurrent[i]>=0 ); + } +} + +/* +** Given an allocation, find the MemBlockHdr for that allocation. +** +** This routine checks the guards at either end of the allocation and +** if they are incorrect it asserts. +*/ +static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){ + struct MemBlockHdr *p; + int *pInt; + u8 *pU8; + int nReserve; + + p = (struct MemBlockHdr*)pAllocation; + p--; + assert( p->iForeGuard==(int)FOREGUARD ); + nReserve = ROUND8(p->iSize); + pInt = (int*)pAllocation; + pU8 = (u8*)pAllocation; + assert( pInt[nReserve/sizeof(int)]==(int)REARGUARD ); + /* This checks any of the "extra" bytes allocated due + ** to rounding up to an 8 byte boundary to ensure + ** they haven't been overwritten. + */ + while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 ); + return p; +} + +/* +** Return the number of bytes currently allocated at address p. +*/ +static int sqlite3MemSize(void *p){ + struct MemBlockHdr *pHdr; + if( !p ){ + return 0; + } + pHdr = sqlite3MemsysGetHeader(p); + return (int)pHdr->iSize; +} + +/* +** Initialize the memory allocation subsystem. +*/ +static int sqlite3MemInit(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + assert( (sizeof(struct MemBlockHdr)&7) == 0 ); + if( !sqlite3GlobalConfig.bMemstat ){ + /* If memory status is enabled, then the malloc.c wrapper will already + ** hold the STATIC_MEM mutex when the routines here are invoked. */ + mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); + } + return SQLITE_OK; +} + +/* +** Deinitialize the memory allocation subsystem. +*/ +static void sqlite3MemShutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + mem.mutex = 0; +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int sqlite3MemRoundup(int n){ + return ROUND8(n); +} + +/* +** Fill a buffer with pseudo-random bytes. This is used to preset +** the content of a new memory allocation to unpredictable values and +** to clear the content of a freed allocation to unpredictable values. +*/ +static void randomFill(char *pBuf, int nByte){ + unsigned int x, y, r; + x = SQLITE_PTR_TO_INT(pBuf); + y = nByte | 1; + while( nByte >= 4 ){ + x = (x>>1) ^ (-(int)(x&1) & 0xd0000001); + y = y*1103515245 + 12345; + r = x ^ y; + *(int*)pBuf = r; + pBuf += 4; + nByte -= 4; + } + while( nByte-- > 0 ){ + x = (x>>1) ^ (-(int)(x&1) & 0xd0000001); + y = y*1103515245 + 12345; + r = x ^ y; + *(pBuf++) = r & 0xff; + } +} + +/* +** Allocate nByte bytes of memory. +*/ +static void *sqlite3MemMalloc(int nByte){ + struct MemBlockHdr *pHdr; + void **pBt; + char *z; + int *pInt; + void *p = 0; + int totalSize; + int nReserve; + sqlite3_mutex_enter(mem.mutex); + assert( mem.disallow==0 ); + nReserve = ROUND8(nByte); + totalSize = nReserve + sizeof(*pHdr) + sizeof(int) + + mem.nBacktrace*sizeof(void*) + mem.nTitle; + p = malloc(totalSize); + if( p ){ + z = p; + pBt = (void**)&z[mem.nTitle]; + pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace]; + pHdr->pNext = 0; + pHdr->pPrev = mem.pLast; + if( mem.pLast ){ + mem.pLast->pNext = pHdr; + }else{ + mem.pFirst = pHdr; + } + mem.pLast = pHdr; + pHdr->iForeGuard = FOREGUARD; + pHdr->eType = MEMTYPE_HEAP; + pHdr->nBacktraceSlots = mem.nBacktrace; + pHdr->nTitle = mem.nTitle; + if( mem.nBacktrace ){ + void *aAddr[40]; + pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1; + memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*)); + assert(pBt[0]); + if( mem.xBacktrace ){ + mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]); + } + }else{ + pHdr->nBacktrace = 0; + } + if( mem.nTitle ){ + memcpy(z, mem.zTitle, mem.nTitle); + } + pHdr->iSize = nByte; + adjustStats(nByte, +1); + pInt = (int*)&pHdr[1]; + pInt[nReserve/sizeof(int)] = REARGUARD; + randomFill((char*)pInt, nByte); + memset(((char*)pInt)+nByte, 0x65, nReserve-nByte); + p = (void*)pInt; + } + sqlite3_mutex_leave(mem.mutex); + return p; +} + +/* +** Free memory. +*/ +static void sqlite3MemFree(void *pPrior){ + struct MemBlockHdr *pHdr; + void **pBt; + char *z; + assert( sqlite3GlobalConfig.bMemstat || sqlite3GlobalConfig.bCoreMutex==0 + || mem.mutex!=0 ); + pHdr = sqlite3MemsysGetHeader(pPrior); + pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + sqlite3_mutex_enter(mem.mutex); + if( pHdr->pPrev ){ + assert( pHdr->pPrev->pNext==pHdr ); + pHdr->pPrev->pNext = pHdr->pNext; + }else{ + assert( mem.pFirst==pHdr ); + mem.pFirst = pHdr->pNext; + } + if( pHdr->pNext ){ + assert( pHdr->pNext->pPrev==pHdr ); + pHdr->pNext->pPrev = pHdr->pPrev; + }else{ + assert( mem.pLast==pHdr ); + mem.pLast = pHdr->pPrev; + } + z = (char*)pBt; + z -= pHdr->nTitle; + adjustStats((int)pHdr->iSize, -1); + randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) + + (int)pHdr->iSize + sizeof(int) + pHdr->nTitle); + free(z); + sqlite3_mutex_leave(mem.mutex); +} + +/* +** Change the size of an existing memory allocation. +** +** For this debugging implementation, we *always* make a copy of the +** allocation into a new place in memory. In this way, if the +** higher level code is using pointer to the old allocation, it is +** much more likely to break and we are much more liking to find +** the error. +*/ +static void *sqlite3MemRealloc(void *pPrior, int nByte){ + struct MemBlockHdr *pOldHdr; + void *pNew; + assert( mem.disallow==0 ); + assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */ + pOldHdr = sqlite3MemsysGetHeader(pPrior); + pNew = sqlite3MemMalloc(nByte); + if( pNew ){ + memcpy(pNew, pPrior, (int)(nByteiSize ? nByte : pOldHdr->iSize)); + if( nByte>pOldHdr->iSize ){ + randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - (int)pOldHdr->iSize); + } + sqlite3MemFree(pPrior); + } + return pNew; +} + +/* +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. +*/ +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + static const sqlite3_mem_methods defaultMethods = { + sqlite3MemMalloc, + sqlite3MemFree, + sqlite3MemRealloc, + sqlite3MemSize, + sqlite3MemRoundup, + sqlite3MemInit, + sqlite3MemShutdown, + 0 + }; + sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); +} + +/* +** Set the "type" of an allocation. +*/ +SQLITE_PRIVATE void sqlite3MemdebugSetType(void *p, u8 eType){ + if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){ + struct MemBlockHdr *pHdr; + pHdr = sqlite3MemsysGetHeader(p); + assert( pHdr->iForeGuard==FOREGUARD ); + pHdr->eType = eType; + } +} + +/* +** Return TRUE if the mask of type in eType matches the type of the +** allocation p. Also return true if p==NULL. +** +** This routine is designed for use within an assert() statement, to +** verify the type of an allocation. For example: +** +** assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); +*/ +SQLITE_PRIVATE int sqlite3MemdebugHasType(void *p, u8 eType){ + int rc = 1; + if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){ + struct MemBlockHdr *pHdr; + pHdr = sqlite3MemsysGetHeader(p); + assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ + if( (pHdr->eType&eType)==0 ){ + rc = 0; + } + } + return rc; +} + +/* +** Return TRUE if the mask of type in eType matches no bits of the type of the +** allocation p. Also return true if p==NULL. +** +** This routine is designed for use within an assert() statement, to +** verify the type of an allocation. For example: +** +** assert( sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); +*/ +SQLITE_PRIVATE int sqlite3MemdebugNoType(void *p, u8 eType){ + int rc = 1; + if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){ + struct MemBlockHdr *pHdr; + pHdr = sqlite3MemsysGetHeader(p); + assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ + if( (pHdr->eType&eType)!=0 ){ + rc = 0; + } + } + return rc; +} + +/* +** Set the number of backtrace levels kept for each allocation. +** A value of zero turns off backtracing. The number is always rounded +** up to a multiple of 2. +*/ +SQLITE_PRIVATE void sqlite3MemdebugBacktrace(int depth){ + if( depth<0 ){ depth = 0; } + if( depth>20 ){ depth = 20; } + depth = (depth+1)&0xfe; + mem.nBacktrace = depth; +} + +SQLITE_PRIVATE void sqlite3MemdebugBacktraceCallback(void (*xBacktrace)(int, int, void **)){ + mem.xBacktrace = xBacktrace; +} + +/* +** Set the title string for subsequent allocations. +*/ +SQLITE_PRIVATE void sqlite3MemdebugSettitle(const char *zTitle){ + unsigned int n = sqlite3Strlen30(zTitle) + 1; + sqlite3_mutex_enter(mem.mutex); + if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1; + memcpy(mem.zTitle, zTitle, n); + mem.zTitle[n] = 0; + mem.nTitle = ROUND8(n); + sqlite3_mutex_leave(mem.mutex); +} + +SQLITE_PRIVATE void sqlite3MemdebugSync(){ + struct MemBlockHdr *pHdr; + for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){ + void **pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + mem.xBacktrace((int)pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]); + } +} + +/* +** Open the file indicated and write a log of all unfreed memory +** allocations into that log. +*/ +SQLITE_PRIVATE void sqlite3MemdebugDump(const char *zFilename){ + FILE *out; + struct MemBlockHdr *pHdr; + void **pBt; + int i; + out = fopen(zFilename, "w"); + if( out==0 ){ + fprintf(stderr, "** Unable to output memory debug output log: %s **\n", + zFilename); + return; + } + for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){ + char *z = (char*)pHdr; + z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle; + fprintf(out, "**** %lld bytes at %p from %s ****\n", + pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???"); + if( pHdr->nBacktrace ){ + fflush(out); + pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out)); + fprintf(out, "\n"); + } + } + fprintf(out, "COUNTS:\n"); + for(i=0; i=1 ); + size = mem3.aPool[i-1].u.hdr.size4x/4; + assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); + assert( size>=2 ); + if( size <= MX_SMALL ){ + memsys3UnlinkFromList(i, &mem3.aiSmall[size-2]); + }else{ + hash = size % N_HASH; + memsys3UnlinkFromList(i, &mem3.aiHash[hash]); + } +} + +/* +** Link the chunk at mem3.aPool[i] so that is on the list rooted +** at *pRoot. +*/ +static void memsys3LinkIntoList(u32 i, u32 *pRoot){ + assert( sqlite3_mutex_held(mem3.mutex) ); + mem3.aPool[i].u.list.next = *pRoot; + mem3.aPool[i].u.list.prev = 0; + if( *pRoot ){ + mem3.aPool[*pRoot].u.list.prev = i; + } + *pRoot = i; +} + +/* +** Link the chunk at index i into either the appropriate +** small chunk list, or into the large chunk hash table. +*/ +static void memsys3Link(u32 i){ + u32 size, hash; + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( i>=1 ); + assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); + size = mem3.aPool[i-1].u.hdr.size4x/4; + assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); + assert( size>=2 ); + if( size <= MX_SMALL ){ + memsys3LinkIntoList(i, &mem3.aiSmall[size-2]); + }else{ + hash = size % N_HASH; + memsys3LinkIntoList(i, &mem3.aiHash[hash]); + } +} + +/* +** If the STATIC_MEM mutex is not already held, obtain it now. The mutex +** will already be held (obtained by code in malloc.c) if +** sqlite3GlobalConfig.bMemStat is true. +*/ +static void memsys3Enter(void){ + if( sqlite3GlobalConfig.bMemstat==0 && mem3.mutex==0 ){ + mem3.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); + } + sqlite3_mutex_enter(mem3.mutex); +} +static void memsys3Leave(void){ + sqlite3_mutex_leave(mem3.mutex); +} + +/* +** Called when we are unable to satisfy an allocation of nBytes. +*/ +static void memsys3OutOfMemory(int nByte){ + if( !mem3.alarmBusy ){ + mem3.alarmBusy = 1; + assert( sqlite3_mutex_held(mem3.mutex) ); + sqlite3_mutex_leave(mem3.mutex); + sqlite3_release_memory(nByte); + sqlite3_mutex_enter(mem3.mutex); + mem3.alarmBusy = 0; + } +} + + +/* +** Chunk i is a free chunk that has been unlinked. Adjust its +** size parameters for check-out and return a pointer to the +** user portion of the chunk. +*/ +static void *memsys3Checkout(u32 i, u32 nBlock){ + u32 x; + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( i>=1 ); + assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ); + assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock ); + x = mem3.aPool[i-1].u.hdr.size4x; + mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2); + mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock; + mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2; + return &mem3.aPool[i]; +} + +/* +** Carve a piece off of the end of the mem3.iMaster free chunk. +** Return a pointer to the new allocation. Or, if the master chunk +** is not large enough, return 0. +*/ +static void *memsys3FromMaster(u32 nBlock){ + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( mem3.szMaster>=nBlock ); + if( nBlock>=mem3.szMaster-1 ){ + /* Use the entire master */ + void *p = memsys3Checkout(mem3.iMaster, mem3.szMaster); + mem3.iMaster = 0; + mem3.szMaster = 0; + mem3.mnMaster = 0; + return p; + }else{ + /* Split the master block. Return the tail. */ + u32 newi, x; + newi = mem3.iMaster + mem3.szMaster - nBlock; + assert( newi > mem3.iMaster+1 ); + mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = nBlock; + mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x |= 2; + mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1; + mem3.szMaster -= nBlock; + mem3.aPool[newi-1].u.hdr.prevSize = mem3.szMaster; + x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2; + mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x; + if( mem3.szMaster < mem3.mnMaster ){ + mem3.mnMaster = mem3.szMaster; + } + return (void*)&mem3.aPool[newi]; + } +} + +/* +** *pRoot is the head of a list of free chunks of the same size +** or same size hash. In other words, *pRoot is an entry in either +** mem3.aiSmall[] or mem3.aiHash[]. +** +** This routine examines all entries on the given list and tries +** to coalesce each entries with adjacent free chunks. +** +** If it sees a chunk that is larger than mem3.iMaster, it replaces +** the current mem3.iMaster with the new larger chunk. In order for +** this mem3.iMaster replacement to work, the master chunk must be +** linked into the hash tables. That is not the normal state of +** affairs, of course. The calling routine must link the master +** chunk before invoking this routine, then must unlink the (possibly +** changed) master chunk once this routine has finished. +*/ +static void memsys3Merge(u32 *pRoot){ + u32 iNext, prev, size, i, x; + + assert( sqlite3_mutex_held(mem3.mutex) ); + for(i=*pRoot; i>0; i=iNext){ + iNext = mem3.aPool[i].u.list.next; + size = mem3.aPool[i-1].u.hdr.size4x; + assert( (size&1)==0 ); + if( (size&2)==0 ){ + memsys3UnlinkFromList(i, pRoot); + assert( i > mem3.aPool[i-1].u.hdr.prevSize ); + prev = i - mem3.aPool[i-1].u.hdr.prevSize; + if( prev==iNext ){ + iNext = mem3.aPool[prev].u.list.next; + } + memsys3Unlink(prev); + size = i + size/4 - prev; + x = mem3.aPool[prev-1].u.hdr.size4x & 2; + mem3.aPool[prev-1].u.hdr.size4x = size*4 | x; + mem3.aPool[prev+size-1].u.hdr.prevSize = size; + memsys3Link(prev); + i = prev; + }else{ + size /= 4; + } + if( size>mem3.szMaster ){ + mem3.iMaster = i; + mem3.szMaster = size; + } + } +} + +/* +** Return a block of memory of at least nBytes in size. +** Return NULL if unable. +** +** This function assumes that the necessary mutexes, if any, are +** already held by the caller. Hence "Unsafe". +*/ +static void *memsys3MallocUnsafe(int nByte){ + u32 i; + u32 nBlock; + u32 toFree; + + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( sizeof(Mem3Block)==8 ); + if( nByte<=12 ){ + nBlock = 2; + }else{ + nBlock = (nByte + 11)/8; + } + assert( nBlock>=2 ); + + /* STEP 1: + ** Look for an entry of the correct size in either the small + ** chunk table or in the large chunk hash table. This is + ** successful most of the time (about 9 times out of 10). + */ + if( nBlock <= MX_SMALL ){ + i = mem3.aiSmall[nBlock-2]; + if( i>0 ){ + memsys3UnlinkFromList(i, &mem3.aiSmall[nBlock-2]); + return memsys3Checkout(i, nBlock); + } + }else{ + int hash = nBlock % N_HASH; + for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){ + if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){ + memsys3UnlinkFromList(i, &mem3.aiHash[hash]); + return memsys3Checkout(i, nBlock); + } + } + } + + /* STEP 2: + ** Try to satisfy the allocation by carving a piece off of the end + ** of the master chunk. This step usually works if step 1 fails. + */ + if( mem3.szMaster>=nBlock ){ + return memsys3FromMaster(nBlock); + } + + + /* STEP 3: + ** Loop through the entire memory pool. Coalesce adjacent free + ** chunks. Recompute the master chunk as the largest free chunk. + ** Then try again to satisfy the allocation by carving a piece off + ** of the end of the master chunk. This step happens very + ** rarely (we hope!) + */ + for(toFree=nBlock*16; toFree<(mem3.nPool*16); toFree *= 2){ + memsys3OutOfMemory(toFree); + if( mem3.iMaster ){ + memsys3Link(mem3.iMaster); + mem3.iMaster = 0; + mem3.szMaster = 0; + } + for(i=0; i=nBlock ){ + return memsys3FromMaster(nBlock); + } + } + } + + /* If none of the above worked, then we fail. */ + return 0; +} + +/* +** Free an outstanding memory allocation. +** +** This function assumes that the necessary mutexes, if any, are +** already held by the caller. Hence "Unsafe". +*/ +static void memsys3FreeUnsafe(void *pOld){ + Mem3Block *p = (Mem3Block*)pOld; + int i; + u32 size, x; + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] ); + i = p - mem3.aPool; + assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 ); + size = mem3.aPool[i-1].u.hdr.size4x/4; + assert( i+size<=mem3.nPool+1 ); + mem3.aPool[i-1].u.hdr.size4x &= ~1; + mem3.aPool[i+size-1].u.hdr.prevSize = size; + mem3.aPool[i+size-1].u.hdr.size4x &= ~2; + memsys3Link(i); + + /* Try to expand the master using the newly freed chunk */ + if( mem3.iMaster ){ + while( (mem3.aPool[mem3.iMaster-1].u.hdr.size4x&2)==0 ){ + size = mem3.aPool[mem3.iMaster-1].u.hdr.prevSize; + mem3.iMaster -= size; + mem3.szMaster += size; + memsys3Unlink(mem3.iMaster); + x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2; + mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x; + mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster; + } + x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2; + while( (mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x&1)==0 ){ + memsys3Unlink(mem3.iMaster+mem3.szMaster); + mem3.szMaster += mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x/4; + mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x; + mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster; + } + } +} + +/* +** Return the size of an outstanding allocation, in bytes. The +** size returned omits the 8-byte header overhead. This only +** works for chunks that are currently checked out. +*/ +static int memsys3Size(void *p){ + Mem3Block *pBlock; + if( p==0 ) return 0; + pBlock = (Mem3Block*)p; + assert( (pBlock[-1].u.hdr.size4x&1)!=0 ); + return (pBlock[-1].u.hdr.size4x&~3)*2 - 4; +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int memsys3Roundup(int n){ + if( n<=12 ){ + return 12; + }else{ + return ((n+11)&~7) - 4; + } +} + +/* +** Allocate nBytes of memory. +*/ +static void *memsys3Malloc(int nBytes){ + sqlite3_int64 *p; + assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */ + memsys3Enter(); + p = memsys3MallocUnsafe(nBytes); + memsys3Leave(); + return (void*)p; +} + +/* +** Free memory. +*/ +static void memsys3Free(void *pPrior){ + assert( pPrior ); + memsys3Enter(); + memsys3FreeUnsafe(pPrior); + memsys3Leave(); +} + +/* +** Change the size of an existing memory allocation +*/ +static void *memsys3Realloc(void *pPrior, int nBytes){ + int nOld; + void *p; + if( pPrior==0 ){ + return sqlite3_malloc(nBytes); + } + if( nBytes<=0 ){ + sqlite3_free(pPrior); + return 0; + } + nOld = memsys3Size(pPrior); + if( nBytes<=nOld && nBytes>=nOld-128 ){ + return pPrior; + } + memsys3Enter(); + p = memsys3MallocUnsafe(nBytes); + if( p ){ + if( nOld>1)!=(size&1) ){ + fprintf(out, "%p tail checkout bit is incorrect\n", &mem3.aPool[i]); + assert( 0 ); + break; + } + if( size&1 ){ + fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8); + }else{ + fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8, + i==mem3.iMaster ? " **master**" : ""); + } + } + for(i=0; i0; j=mem3.aPool[j].u.list.next){ + fprintf(out, " %p(%d)", &mem3.aPool[j], + (mem3.aPool[j-1].u.hdr.size4x/4)*8-8); + } + fprintf(out, "\n"); + } + for(i=0; i0; j=mem3.aPool[j].u.list.next){ + fprintf(out, " %p(%d)", &mem3.aPool[j], + (mem3.aPool[j-1].u.hdr.size4x/4)*8-8); + } + fprintf(out, "\n"); + } + fprintf(out, "master=%d\n", mem3.iMaster); + fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szMaster*8); + fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnMaster*8); + sqlite3_mutex_leave(mem3.mutex); + if( out==stdout ){ + fflush(stdout); + }else{ + fclose(out); + } +#else + UNUSED_PARAMETER(zFilename); +#endif +} + +/* +** This routine is the only routine in this file with external +** linkage. +** +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. The +** arguments specify the block of memory to manage. +** +** This routine is only called by sqlite3_config(), and therefore +** is not required to be threadsafe (it is not). +*/ +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void){ + static const sqlite3_mem_methods mempoolMethods = { + memsys3Malloc, + memsys3Free, + memsys3Realloc, + memsys3Size, + memsys3Roundup, + memsys3Init, + memsys3Shutdown, + 0 + }; + return &mempoolMethods; +} + +#endif /* SQLITE_ENABLE_MEMSYS3 */ + +/************** End of mem3.c ************************************************/ +/************** Begin file mem5.c ********************************************/ +/* +** 2007 October 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement a memory +** allocation subsystem for use by SQLite. +** +** This version of the memory allocation subsystem omits all +** use of malloc(). The application gives SQLite a block of memory +** before calling sqlite3_initialize() from which allocations +** are made and returned by the xMalloc() and xRealloc() +** implementations. Once sqlite3_initialize() has been called, +** the amount of memory available to SQLite is fixed and cannot +** be changed. +** +** This version of the memory allocation subsystem is included +** in the build only if SQLITE_ENABLE_MEMSYS5 is defined. +** +** This memory allocator uses the following algorithm: +** +** 1. All memory allocations sizes are rounded up to a power of 2. +** +** 2. If two adjacent free blocks are the halves of a larger block, +** then the two blocks are coalesced into the single larger block. +** +** 3. New memory is allocated from the first available free block. +** +** This algorithm is described in: J. M. Robson. "Bounds for Some Functions +** Concerning Dynamic Storage Allocation". Journal of the Association for +** Computing Machinery, Volume 21, Number 8, July 1974, pages 491-499. +** +** Let n be the size of the largest allocation divided by the minimum +** allocation size (after rounding all sizes up to a power of 2.) Let M +** be the maximum amount of memory ever outstanding at one time. Let +** N be the total amount of memory available for allocation. Robson +** proved that this memory allocator will never breakdown due to +** fragmentation as long as the following constraint holds: +** +** N >= M*(1 + log2(n)/2) - n + 1 +** +** The sqlite3_status() logic tracks the maximum values of n and M so +** that an application can, at any time, verify this constraint. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is used only when +** SQLITE_ENABLE_MEMSYS5 is defined. +*/ +#ifdef SQLITE_ENABLE_MEMSYS5 + +/* +** A minimum allocation is an instance of the following structure. +** Larger allocations are an array of these structures where the +** size of the array is a power of 2. +** +** The size of this object must be a power of two. That fact is +** verified in memsys5Init(). +*/ +typedef struct Mem5Link Mem5Link; +struct Mem5Link { + int next; /* Index of next free chunk */ + int prev; /* Index of previous free chunk */ +}; + +/* +** Maximum size of any allocation is ((1<=0 && i=0 && iLogsize<=LOGMAX ); + assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); + + next = MEM5LINK(i)->next; + prev = MEM5LINK(i)->prev; + if( prev<0 ){ + mem5.aiFreelist[iLogsize] = next; + }else{ + MEM5LINK(prev)->next = next; + } + if( next>=0 ){ + MEM5LINK(next)->prev = prev; + } +} + +/* +** Link the chunk at mem5.aPool[i] so that is on the iLogsize +** free list. +*/ +static void memsys5Link(int i, int iLogsize){ + int x; + assert( sqlite3_mutex_held(mem5.mutex) ); + assert( i>=0 && i=0 && iLogsize<=LOGMAX ); + assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); + + x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize]; + MEM5LINK(i)->prev = -1; + if( x>=0 ){ + assert( xprev = i; + } + mem5.aiFreelist[iLogsize] = i; +} + +/* +** If the STATIC_MEM mutex is not already held, obtain it now. The mutex +** will already be held (obtained by code in malloc.c) if +** sqlite3GlobalConfig.bMemStat is true. +*/ +static void memsys5Enter(void){ + sqlite3_mutex_enter(mem5.mutex); +} +static void memsys5Leave(void){ + sqlite3_mutex_leave(mem5.mutex); +} + +/* +** Return the size of an outstanding allocation, in bytes. The +** size returned omits the 8-byte header overhead. This only +** works for chunks that are currently checked out. +*/ +static int memsys5Size(void *p){ + int iSize = 0; + if( p ){ + int i = (int)(((u8 *)p-mem5.zPool)/mem5.szAtom); + assert( i>=0 && i0 ); + + /* Keep track of the maximum allocation request. Even unfulfilled + ** requests are counted */ + if( (u32)nByte>mem5.maxRequest ){ + mem5.maxRequest = nByte; + } + + /* Abort if the requested allocation size is larger than the largest + ** power of two that we can represent using 32-bit signed integers. + */ + if( nByte > 0x40000000 ){ + return 0; + } + + /* Round nByte up to the next valid power of two */ + for(iFullSz=mem5.szAtom, iLogsize=0; iFullSzLOGMAX ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte); + return 0; + } + i = mem5.aiFreelist[iBin]; + memsys5Unlink(i, iBin); + while( iBin>iLogsize ){ + int newSize; + + iBin--; + newSize = 1 << iBin; + mem5.aCtrl[i+newSize] = CTRL_FREE | iBin; + memsys5Link(i+newSize, iBin); + } + mem5.aCtrl[i] = iLogsize; + + /* Update allocator performance statistics. */ + mem5.nAlloc++; + mem5.totalAlloc += iFullSz; + mem5.totalExcess += iFullSz - nByte; + mem5.currentCount++; + mem5.currentOut += iFullSz; + if( mem5.maxCount=0 && iBlock0 ); + assert( mem5.currentOut>=(size*mem5.szAtom) ); + mem5.currentCount--; + mem5.currentOut -= size*mem5.szAtom; + assert( mem5.currentOut>0 || mem5.currentCount==0 ); + assert( mem5.currentCount>0 || mem5.currentOut==0 ); + + mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize; + while( ALWAYS(iLogsize>iLogsize) & 1 ){ + iBuddy = iBlock - size; + }else{ + iBuddy = iBlock + size; + } + assert( iBuddy>=0 ); + if( (iBuddy+(1<mem5.nBlock ) break; + if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break; + memsys5Unlink(iBuddy, iLogsize); + iLogsize++; + if( iBuddy0 ){ + memsys5Enter(); + p = memsys5MallocUnsafe(nBytes); + memsys5Leave(); + } + return (void*)p; +} + +/* +** Free memory. +** +** The outer layer memory allocator prevents this routine from +** being called with pPrior==0. +*/ +static void memsys5Free(void *pPrior){ + assert( pPrior!=0 ); + memsys5Enter(); + memsys5FreeUnsafe(pPrior); + memsys5Leave(); +} + +/* +** Change the size of an existing memory allocation. +** +** The outer layer memory allocator prevents this routine from +** being called with pPrior==0. +** +** nBytes is always a value obtained from a prior call to +** memsys5Round(). Hence nBytes is always a non-negative power +** of two. If nBytes==0 that means that an oversize allocation +** (an allocation larger than 0x40000000) was requested and this +** routine should return 0 without freeing pPrior. +*/ +static void *memsys5Realloc(void *pPrior, int nBytes){ + int nOld; + void *p; + assert( pPrior!=0 ); + assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */ + assert( nBytes>=0 ); + if( nBytes==0 ){ + return 0; + } + nOld = memsys5Size(pPrior); + if( nBytes<=nOld ){ + return pPrior; + } + memsys5Enter(); + p = memsys5MallocUnsafe(nBytes); + if( p ){ + memcpy(p, pPrior, nOld); + memsys5FreeUnsafe(pPrior); + } + memsys5Leave(); + return p; +} + +/* +** Round up a request size to the next valid allocation size. If +** the allocation is too large to be handled by this allocation system, +** return 0. +** +** All allocations must be a power of two and must be expressed by a +** 32-bit signed integer. Hence the largest allocation is 0x40000000 +** or 1073741824 bytes. +*/ +static int memsys5Roundup(int n){ + int iFullSz; + if( n > 0x40000000 ) return 0; + for(iFullSz=mem5.szAtom; iFullSz 0 +** memsys5Log(2) -> 1 +** memsys5Log(4) -> 2 +** memsys5Log(5) -> 3 +** memsys5Log(8) -> 3 +** memsys5Log(9) -> 4 +*/ +static int memsys5Log(int iValue){ + int iLog; + for(iLog=0; (iLog<(int)((sizeof(int)*8)-1)) && (1<mem5.szAtom ){ + mem5.szAtom = mem5.szAtom << 1; + } + + mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8))); + mem5.zPool = zByte; + mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom]; + + for(ii=0; ii<=LOGMAX; ii++){ + mem5.aiFreelist[ii] = -1; + } + + iOffset = 0; + for(ii=LOGMAX; ii>=0; ii--){ + int nAlloc = (1<mem5.nBlock); + } + + /* If a mutex is required for normal operation, allocate one */ + if( sqlite3GlobalConfig.bMemstat==0 ){ + mem5.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); + } + + return SQLITE_OK; +} + +/* +** Deinitialize this module. +*/ +static void memsys5Shutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + mem5.mutex = 0; + return; +} + +#ifdef SQLITE_TEST +/* +** Open the file indicated and write a log of all unfreed memory +** allocations into that log. +*/ +SQLITE_PRIVATE void sqlite3Memsys5Dump(const char *zFilename){ + FILE *out; + int i, j, n; + int nMinLog; + + if( zFilename==0 || zFilename[0]==0 ){ + out = stdout; + }else{ + out = fopen(zFilename, "w"); + if( out==0 ){ + fprintf(stderr, "** Unable to output memory debug output log: %s **\n", + zFilename); + return; + } + } + memsys5Enter(); + nMinLog = memsys5Log(mem5.szAtom); + for(i=0; i<=LOGMAX && i+nMinLog<32; i++){ + for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){} + fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n); + } + fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc); + fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc); + fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess); + fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut); + fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount); + fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut); + fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount); + fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest); + memsys5Leave(); + if( out==stdout ){ + fflush(stdout); + }else{ + fclose(out); + } +} +#endif + +/* +** This routine is the only routine in this file with external +** linkage. It returns a pointer to a static sqlite3_mem_methods +** struct populated with the memsys5 methods. +*/ +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void){ + static const sqlite3_mem_methods memsys5Methods = { + memsys5Malloc, + memsys5Free, + memsys5Realloc, + memsys5Size, + memsys5Roundup, + memsys5Init, + memsys5Shutdown, + 0 + }; + return &memsys5Methods; +} + +#endif /* SQLITE_ENABLE_MEMSYS5 */ + +/************** End of mem5.c ************************************************/ +/************** Begin file mutex.c *******************************************/ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes. +** +** This file contains code that is common across all mutex implementations. +*/ +/* #include "sqliteInt.h" */ + +#if defined(SQLITE_DEBUG) && !defined(SQLITE_MUTEX_OMIT) +/* +** For debugging purposes, record when the mutex subsystem is initialized +** and uninitialized so that we can assert() if there is an attempt to +** allocate a mutex while the system is uninitialized. +*/ +static SQLITE_WSD int mutexIsInit = 0; +#endif /* SQLITE_DEBUG && !defined(SQLITE_MUTEX_OMIT) */ + + +#ifndef SQLITE_MUTEX_OMIT +/* +** Initialize the mutex system. +*/ +SQLITE_PRIVATE int sqlite3MutexInit(void){ + int rc = SQLITE_OK; + if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){ + /* If the xMutexAlloc method has not been set, then the user did not + ** install a mutex implementation via sqlite3_config() prior to + ** sqlite3_initialize() being called. This block copies pointers to + ** the default implementation into the sqlite3GlobalConfig structure. + */ + sqlite3_mutex_methods const *pFrom; + sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex; + + if( sqlite3GlobalConfig.bCoreMutex ){ + pFrom = sqlite3DefaultMutex(); + }else{ + pFrom = sqlite3NoopMutex(); + } + pTo->xMutexInit = pFrom->xMutexInit; + pTo->xMutexEnd = pFrom->xMutexEnd; + pTo->xMutexFree = pFrom->xMutexFree; + pTo->xMutexEnter = pFrom->xMutexEnter; + pTo->xMutexTry = pFrom->xMutexTry; + pTo->xMutexLeave = pFrom->xMutexLeave; + pTo->xMutexHeld = pFrom->xMutexHeld; + pTo->xMutexNotheld = pFrom->xMutexNotheld; + sqlite3MemoryBarrier(); + pTo->xMutexAlloc = pFrom->xMutexAlloc; + } + assert( sqlite3GlobalConfig.mutex.xMutexInit ); + rc = sqlite3GlobalConfig.mutex.xMutexInit(); + +#ifdef SQLITE_DEBUG + GLOBAL(int, mutexIsInit) = 1; +#endif + + return rc; +} + +/* +** Shutdown the mutex system. This call frees resources allocated by +** sqlite3MutexInit(). +*/ +SQLITE_PRIVATE int sqlite3MutexEnd(void){ + int rc = SQLITE_OK; + if( sqlite3GlobalConfig.mutex.xMutexEnd ){ + rc = sqlite3GlobalConfig.mutex.xMutexEnd(); + } + +#ifdef SQLITE_DEBUG + GLOBAL(int, mutexIsInit) = 0; +#endif + + return rc; +} + +/* +** Retrieve a pointer to a static mutex or allocate a new dynamic one. +*/ +SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_mutex_alloc(int id){ +#ifndef SQLITE_OMIT_AUTOINIT + if( id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() ) return 0; + if( id>SQLITE_MUTEX_RECURSIVE && sqlite3MutexInit() ) return 0; +#endif + assert( sqlite3GlobalConfig.mutex.xMutexAlloc ); + return sqlite3GlobalConfig.mutex.xMutexAlloc(id); +} + +SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int id){ + if( !sqlite3GlobalConfig.bCoreMutex ){ + return 0; + } + assert( GLOBAL(int, mutexIsInit) ); + assert( sqlite3GlobalConfig.mutex.xMutexAlloc ); + return sqlite3GlobalConfig.mutex.xMutexAlloc(id); +} + +/* +** Free a dynamic mutex. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_mutex_free(sqlite3_mutex *p){ + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexFree ); + sqlite3GlobalConfig.mutex.xMutexFree(p); + } +} + +/* +** Obtain the mutex p. If some other thread already has the mutex, block +** until it can be obtained. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_mutex_enter(sqlite3_mutex *p){ + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexEnter ); + sqlite3GlobalConfig.mutex.xMutexEnter(p); + } +} + +/* +** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another +** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_mutex_try(sqlite3_mutex *p){ + int rc = SQLITE_OK; + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexTry ); + return sqlite3GlobalConfig.mutex.xMutexTry(p); + } + return rc; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was previously +** entered by the same thread. The behavior is undefined if the mutex +** is not currently entered. If a NULL pointer is passed as an argument +** this function is a no-op. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_mutex_leave(sqlite3_mutex *p){ + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexLeave ); + sqlite3GlobalConfig.mutex.xMutexLeave(p); + } +} + +#ifndef NDEBUG +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use inside assert() statements. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_mutex_held(sqlite3_mutex *p){ + assert( p==0 || sqlite3GlobalConfig.mutex.xMutexHeld ); + return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p); +} +SQLITE_API int SQLITE_STDCALL sqlite3_mutex_notheld(sqlite3_mutex *p){ + assert( p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld ); + return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p); +} +#endif + +#endif /* !defined(SQLITE_MUTEX_OMIT) */ + +/************** End of mutex.c ***********************************************/ +/************** Begin file mutex_noop.c **************************************/ +/* +** 2008 October 07 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes. +** +** This implementation in this file does not provide any mutual +** exclusion and is thus suitable for use only in applications +** that use SQLite in a single thread. The routines defined +** here are place-holders. Applications can substitute working +** mutex routines at start-time using the +** +** sqlite3_config(SQLITE_CONFIG_MUTEX,...) +** +** interface. +** +** If compiled with SQLITE_DEBUG, then additional logic is inserted +** that does error checking on mutexes to make sure they are being +** called correctly. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_MUTEX_OMIT + +#ifndef SQLITE_DEBUG +/* +** Stub routines for all mutex methods. +** +** This routines provide no mutual exclusion or error checking. +*/ +static int noopMutexInit(void){ return SQLITE_OK; } +static int noopMutexEnd(void){ return SQLITE_OK; } +static sqlite3_mutex *noopMutexAlloc(int id){ + UNUSED_PARAMETER(id); + return (sqlite3_mutex*)8; +} +static void noopMutexFree(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } +static void noopMutexEnter(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } +static int noopMutexTry(sqlite3_mutex *p){ + UNUSED_PARAMETER(p); + return SQLITE_OK; +} +static void noopMutexLeave(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){ + static const sqlite3_mutex_methods sMutex = { + noopMutexInit, + noopMutexEnd, + noopMutexAlloc, + noopMutexFree, + noopMutexEnter, + noopMutexTry, + noopMutexLeave, + + 0, + 0, + }; + + return &sMutex; +} +#endif /* !SQLITE_DEBUG */ + +#ifdef SQLITE_DEBUG +/* +** In this implementation, error checking is provided for testing +** and debugging purposes. The mutexes still do not provide any +** mutual exclusion. +*/ + +/* +** The mutex object +*/ +typedef struct sqlite3_debug_mutex { + int id; /* The mutex type */ + int cnt; /* Number of entries without a matching leave */ +} sqlite3_debug_mutex; + +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use inside assert() statements. +*/ +static int debugMutexHeld(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + return p==0 || p->cnt>0; +} +static int debugMutexNotheld(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + return p==0 || p->cnt==0; +} + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static int debugMutexInit(void){ return SQLITE_OK; } +static int debugMutexEnd(void){ return SQLITE_OK; } + +/* +** The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. If it returns NULL +** that means that a mutex could not be allocated. +*/ +static sqlite3_mutex *debugMutexAlloc(int id){ + static sqlite3_debug_mutex aStatic[SQLITE_MUTEX_STATIC_VFS3 - 1]; + sqlite3_debug_mutex *pNew = 0; + switch( id ){ + case SQLITE_MUTEX_FAST: + case SQLITE_MUTEX_RECURSIVE: { + pNew = sqlite3Malloc(sizeof(*pNew)); + if( pNew ){ + pNew->id = id; + pNew->cnt = 0; + } + break; + } + default: { +#ifdef SQLITE_ENABLE_API_ARMOR + if( id-2<0 || id-2>=ArraySize(aStatic) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + pNew = &aStatic[id-2]; + pNew->id = id; + break; + } + } + return (sqlite3_mutex*)pNew; +} + +/* +** This routine deallocates a previously allocated mutex. +*/ +static void debugMutexFree(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( p->cnt==0 ); + if( p->id==SQLITE_MUTEX_RECURSIVE || p->id==SQLITE_MUTEX_FAST ){ + sqlite3_free(p); + }else{ +#ifdef SQLITE_ENABLE_API_ARMOR + (void)SQLITE_MISUSE_BKPT; +#endif + } +} + +/* +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can +** be entered multiple times by the same thread. In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. If the same thread tries to enter any other kind of mutex +** more than once, the behavior is undefined. +*/ +static void debugMutexEnter(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); + p->cnt++; +} +static int debugMutexTry(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); + p->cnt++; + return SQLITE_OK; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered or +** is not currently allocated. SQLite will never do either. +*/ +static void debugMutexLeave(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( debugMutexHeld(pX) ); + p->cnt--; + assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); +} + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){ + static const sqlite3_mutex_methods sMutex = { + debugMutexInit, + debugMutexEnd, + debugMutexAlloc, + debugMutexFree, + debugMutexEnter, + debugMutexTry, + debugMutexLeave, + + debugMutexHeld, + debugMutexNotheld + }; + + return &sMutex; +} +#endif /* SQLITE_DEBUG */ + +/* +** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation +** is used regardless of the run-time threadsafety setting. +*/ +#ifdef SQLITE_MUTEX_NOOP +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){ + return sqlite3NoopMutex(); +} +#endif /* defined(SQLITE_MUTEX_NOOP) */ +#endif /* !defined(SQLITE_MUTEX_OMIT) */ + +/************** End of mutex_noop.c ******************************************/ +/************** Begin file mutex_unix.c **************************************/ +/* +** 2007 August 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes for pthreads +*/ +/* #include "sqliteInt.h" */ + +/* +** The code in this file is only used if we are compiling threadsafe +** under unix with pthreads. +** +** Note that this implementation requires a version of pthreads that +** supports recursive mutexes. +*/ +#ifdef SQLITE_MUTEX_PTHREADS + +#include + +/* +** The sqlite3_mutex.id, sqlite3_mutex.nRef, and sqlite3_mutex.owner fields +** are necessary under two condidtions: (1) Debug builds and (2) using +** home-grown mutexes. Encapsulate these conditions into a single #define. +*/ +#if defined(SQLITE_DEBUG) || defined(SQLITE_HOMEGROWN_RECURSIVE_MUTEX) +# define SQLITE_MUTEX_NREF 1 +#else +# define SQLITE_MUTEX_NREF 0 +#endif + +/* +** Each recursive mutex is an instance of the following structure. +*/ +struct sqlite3_mutex { + pthread_mutex_t mutex; /* Mutex controlling the lock */ +#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) + int id; /* Mutex type */ +#endif +#if SQLITE_MUTEX_NREF + volatile int nRef; /* Number of entrances */ + volatile pthread_t owner; /* Thread that is within this mutex */ + int trace; /* True to trace changes */ +#endif +}; +#if SQLITE_MUTEX_NREF +#define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER, 0, 0, (pthread_t)0, 0 } +#else +#define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER } +#endif + +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use only inside assert() statements. On some platforms, +** there might be race conditions that can cause these routines to +** deliver incorrect results. In particular, if pthread_equal() is +** not an atomic operation, then these routines might delivery +** incorrect results. On most platforms, pthread_equal() is a +** comparison of two integers and is therefore atomic. But we are +** told that HPUX is not such a platform. If so, then these routines +** will not always work correctly on HPUX. +** +** On those platforms where pthread_equal() is not atomic, SQLite +** should be compiled without -DSQLITE_DEBUG and with -DNDEBUG to +** make sure no assert() statements are evaluated and hence these +** routines are never called. +*/ +#if !defined(NDEBUG) || defined(SQLITE_DEBUG) +static int pthreadMutexHeld(sqlite3_mutex *p){ + return (p->nRef!=0 && pthread_equal(p->owner, pthread_self())); +} +static int pthreadMutexNotheld(sqlite3_mutex *p){ + return p->nRef==0 || pthread_equal(p->owner, pthread_self())==0; +} +#endif + +/* +** Try to provide a memory barrier operation, needed for initialization +** and also for the implementation of xShmBarrier in the VFS in cases +** where SQLite is compiled without mutexes. +*/ +SQLITE_PRIVATE void sqlite3MemoryBarrier(void){ +#if defined(SQLITE_MEMORY_BARRIER) + SQLITE_MEMORY_BARRIER; +#elif defined(__GNUC__) && GCC_VERSION>=4001000 + __sync_synchronize(); +#endif +} + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static int pthreadMutexInit(void){ return SQLITE_OK; } +static int pthreadMutexEnd(void){ return SQLITE_OK; } + +/* +** The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. If it returns NULL +** that means that a mutex could not be allocated. SQLite +** will unwind its stack and return an error. The argument +** to sqlite3_mutex_alloc() is one of these integer constants: +** +**
    +**
  • SQLITE_MUTEX_FAST +**
  • SQLITE_MUTEX_RECURSIVE +**
  • SQLITE_MUTEX_STATIC_MASTER +**
  • SQLITE_MUTEX_STATIC_MEM +**
  • SQLITE_MUTEX_STATIC_OPEN +**
  • SQLITE_MUTEX_STATIC_PRNG +**
  • SQLITE_MUTEX_STATIC_LRU +**
  • SQLITE_MUTEX_STATIC_PMEM +**
  • SQLITE_MUTEX_STATIC_APP1 +**
  • SQLITE_MUTEX_STATIC_APP2 +**
  • SQLITE_MUTEX_STATIC_APP3 +**
  • SQLITE_MUTEX_STATIC_VFS1 +**
  • SQLITE_MUTEX_STATIC_VFS2 +**
  • SQLITE_MUTEX_STATIC_VFS3 +**
+** +** The first two constants cause sqlite3_mutex_alloc() to create +** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. But SQLite will only request a recursive mutex in +** cases where it really needs one. If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** The other allowed parameters to sqlite3_mutex_alloc() each return +** a pointer to a static preexisting mutex. Six static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. But for the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +*/ +static sqlite3_mutex *pthreadMutexAlloc(int iType){ + static sqlite3_mutex staticMutexes[] = { + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER + }; + sqlite3_mutex *p; + switch( iType ){ + case SQLITE_MUTEX_RECURSIVE: { + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + /* If recursive mutexes are not available, we will have to + ** build our own. See below. */ + pthread_mutex_init(&p->mutex, 0); +#else + /* Use a recursive mutex if it is available */ + pthread_mutexattr_t recursiveAttr; + pthread_mutexattr_init(&recursiveAttr); + pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&p->mutex, &recursiveAttr); + pthread_mutexattr_destroy(&recursiveAttr); +#endif + } + break; + } + case SQLITE_MUTEX_FAST: { + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ + pthread_mutex_init(&p->mutex, 0); + } + break; + } + default: { +#ifdef SQLITE_ENABLE_API_ARMOR + if( iType-2<0 || iType-2>=ArraySize(staticMutexes) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + p = &staticMutexes[iType-2]; + break; + } + } +#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) + if( p ) p->id = iType; +#endif + return p; +} + + +/* +** This routine deallocates a previously +** allocated mutex. SQLite is careful to deallocate every +** mutex that it allocates. +*/ +static void pthreadMutexFree(sqlite3_mutex *p){ + assert( p->nRef==0 ); +#if SQLITE_ENABLE_API_ARMOR + if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ) +#endif + { + pthread_mutex_destroy(&p->mutex); + sqlite3_free(p); + } +#ifdef SQLITE_ENABLE_API_ARMOR + else{ + (void)SQLITE_MISUSE_BKPT; + } +#endif +} + +/* +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can +** be entered multiple times by the same thread. In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. If the same thread tries to enter any other kind of mutex +** more than once, the behavior is undefined. +*/ +static void pthreadMutexEnter(sqlite3_mutex *p){ + assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); + +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + /* If recursive mutexes are not available, then we have to grow + ** our own. This implementation assumes that pthread_equal() + ** is atomic - that it cannot be deceived into thinking self + ** and p->owner are equal if p->owner changes between two values + ** that are not equal to self while the comparison is taking place. + ** This implementation also assumes a coherent cache - that + ** separate processes cannot read different values from the same + ** address at the same time. If either of these two conditions + ** are not met, then the mutexes will fail and problems will result. + */ + { + pthread_t self = pthread_self(); + if( p->nRef>0 && pthread_equal(p->owner, self) ){ + p->nRef++; + }else{ + pthread_mutex_lock(&p->mutex); + assert( p->nRef==0 ); + p->owner = self; + p->nRef = 1; + } + } +#else + /* Use the built-in recursive mutexes if they are available. + */ + pthread_mutex_lock(&p->mutex); +#if SQLITE_MUTEX_NREF + assert( p->nRef>0 || p->owner==0 ); + p->owner = pthread_self(); + p->nRef++; +#endif +#endif + +#ifdef SQLITE_DEBUG + if( p->trace ){ + printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); + } +#endif +} +static int pthreadMutexTry(sqlite3_mutex *p){ + int rc; + assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); + +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + /* If recursive mutexes are not available, then we have to grow + ** our own. This implementation assumes that pthread_equal() + ** is atomic - that it cannot be deceived into thinking self + ** and p->owner are equal if p->owner changes between two values + ** that are not equal to self while the comparison is taking place. + ** This implementation also assumes a coherent cache - that + ** separate processes cannot read different values from the same + ** address at the same time. If either of these two conditions + ** are not met, then the mutexes will fail and problems will result. + */ + { + pthread_t self = pthread_self(); + if( p->nRef>0 && pthread_equal(p->owner, self) ){ + p->nRef++; + rc = SQLITE_OK; + }else if( pthread_mutex_trylock(&p->mutex)==0 ){ + assert( p->nRef==0 ); + p->owner = self; + p->nRef = 1; + rc = SQLITE_OK; + }else{ + rc = SQLITE_BUSY; + } + } +#else + /* Use the built-in recursive mutexes if they are available. + */ + if( pthread_mutex_trylock(&p->mutex)==0 ){ +#if SQLITE_MUTEX_NREF + p->owner = pthread_self(); + p->nRef++; +#endif + rc = SQLITE_OK; + }else{ + rc = SQLITE_BUSY; + } +#endif + +#ifdef SQLITE_DEBUG + if( rc==SQLITE_OK && p->trace ){ + printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); + } +#endif + return rc; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered or +** is not currently allocated. SQLite will never do either. +*/ +static void pthreadMutexLeave(sqlite3_mutex *p){ + assert( pthreadMutexHeld(p) ); +#if SQLITE_MUTEX_NREF + p->nRef--; + if( p->nRef==0 ) p->owner = 0; +#endif + assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); + +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + if( p->nRef==0 ){ + pthread_mutex_unlock(&p->mutex); + } +#else + pthread_mutex_unlock(&p->mutex); +#endif + +#ifdef SQLITE_DEBUG + if( p->trace ){ + printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); + } +#endif +} + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){ + static const sqlite3_mutex_methods sMutex = { + pthreadMutexInit, + pthreadMutexEnd, + pthreadMutexAlloc, + pthreadMutexFree, + pthreadMutexEnter, + pthreadMutexTry, + pthreadMutexLeave, +#ifdef SQLITE_DEBUG + pthreadMutexHeld, + pthreadMutexNotheld +#else + 0, + 0 +#endif + }; + + return &sMutex; +} + +#endif /* SQLITE_MUTEX_PTHREADS */ + +/************** End of mutex_unix.c ******************************************/ +/************** Begin file mutex_w32.c ***************************************/ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes for Win32. +*/ +/* #include "sqliteInt.h" */ + +#if SQLITE_OS_WIN +/* +** Include code that is common to all os_*.c files +*/ +/************** Include os_common.h in the middle of mutex_w32.c *************/ +/************** Begin file os_common.h ***************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains macros and a little bit of code that is common to +** all of the platform-specific files (os_*.c) and is #included into those +** files. +** +** This file should be #included by the os_*.c files only. It is not a +** general purpose header file. +*/ +#ifndef _OS_COMMON_H_ +#define _OS_COMMON_H_ + +/* +** At least two bugs have slipped in because we changed the MEMORY_DEBUG +** macro to SQLITE_DEBUG and some older makefiles have not yet made the +** switch. The following code should catch this problem at compile-time. +*/ +#ifdef MEMORY_DEBUG +# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." +#endif + +/* +** Macros for performance tracing. Normally turned off. Only works +** on i486 hardware. +*/ +#ifdef SQLITE_PERFORMANCE_TRACE + +/* +** hwtime.h contains inline assembler code for implementing +** high-performance timing routines. +*/ +/************** Include hwtime.h in the middle of os_common.h ****************/ +/************** Begin file hwtime.h ******************************************/ +/* +** 2008 May 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains inline asm code for retrieving "high-performance" +** counters for x86 class CPUs. +*/ +#ifndef _HWTIME_H_ +#define _HWTIME_H_ + +/* +** The following routine only works on pentium-class (or newer) processors. +** It uses the RDTSC opcode to read the cycle count value out of the +** processor and returns that value. This can be used for high-res +** profiling. +*/ +#if (defined(__GNUC__) || defined(_MSC_VER)) && \ + (defined(i386) || defined(__i386__) || defined(_M_IX86)) + + #if defined(__GNUC__) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned int lo, hi; + __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); + return (sqlite_uint64)hi << 32 | lo; + } + + #elif defined(_MSC_VER) + + __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ + __asm { + rdtsc + ret ; return value at EDX:EAX + } + } + + #endif + +#elif (defined(__GNUC__) && defined(__x86_64__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long val; + __asm__ __volatile__ ("rdtsc" : "=A" (val)); + return val; + } + +#elif (defined(__GNUC__) && defined(__ppc__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long long retval; + unsigned long junk; + __asm__ __volatile__ ("\n\ + 1: mftbu %1\n\ + mftb %L0\n\ + mftbu %0\n\ + cmpw %0,%1\n\ + bne 1b" + : "=r" (retval), "=r" (junk)); + return retval; + } + +#else + + #error Need implementation of sqlite3Hwtime() for your platform. + + /* + ** To compile without implementing sqlite3Hwtime() for your platform, + ** you can remove the above #error and use the following + ** stub function. You will lose timing support for many + ** of the debugging and testing utilities, but it should at + ** least compile and run. + */ +SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } + +#endif + +#endif /* !defined(_HWTIME_H_) */ + +/************** End of hwtime.h **********************************************/ +/************** Continuing where we left off in os_common.h ******************/ + +static sqlite_uint64 g_start; +static sqlite_uint64 g_elapsed; +#define TIMER_START g_start=sqlite3Hwtime() +#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start +#define TIMER_ELAPSED g_elapsed +#else +#define TIMER_START +#define TIMER_END +#define TIMER_ELAPSED ((sqlite_uint64)0) +#endif + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_io_error_hit = 0; /* Total number of I/O Errors */ +SQLITE_API int sqlite3_io_error_hardhit = 0; /* Number of non-benign errors */ +SQLITE_API int sqlite3_io_error_pending = 0; /* Count down to first I/O error */ +SQLITE_API int sqlite3_io_error_persist = 0; /* True if I/O errors persist */ +SQLITE_API int sqlite3_io_error_benign = 0; /* True if errors are benign */ +SQLITE_API int sqlite3_diskfull_pending = 0; +SQLITE_API int sqlite3_diskfull = 0; +#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) +#define SimulateIOError(CODE) \ + if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ + || sqlite3_io_error_pending-- == 1 ) \ + { local_ioerr(); CODE; } +static void local_ioerr(){ + IOTRACE(("IOERR\n")); + sqlite3_io_error_hit++; + if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; +} +#define SimulateDiskfullError(CODE) \ + if( sqlite3_diskfull_pending ){ \ + if( sqlite3_diskfull_pending == 1 ){ \ + local_ioerr(); \ + sqlite3_diskfull = 1; \ + sqlite3_io_error_hit = 1; \ + CODE; \ + }else{ \ + sqlite3_diskfull_pending--; \ + } \ + } +#else +#define SimulateIOErrorBenign(X) +#define SimulateIOError(A) +#define SimulateDiskfullError(A) +#endif + +/* +** When testing, keep a count of the number of open files. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_open_file_count = 0; +#define OpenCounter(X) sqlite3_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif + +#endif /* !defined(_OS_COMMON_H_) */ + +/************** End of os_common.h *******************************************/ +/************** Continuing where we left off in mutex_w32.c ******************/ + +/* +** Include the header file for the Windows VFS. +*/ +/************** Include os_win.h in the middle of mutex_w32.c ****************/ +/************** Begin file os_win.h ******************************************/ +/* +** 2013 November 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to Windows. +*/ +#ifndef _OS_WIN_H_ +#define _OS_WIN_H_ + +/* +** Include the primary Windows SDK header file. +*/ +#include "windows.h" + +#ifdef __CYGWIN__ +# include +# include /* amalgamator: dontcache */ +#endif + +/* +** Determine if we are dealing with Windows NT. +** +** We ought to be able to determine if we are compiling for Windows 9x or +** Windows NT using the _WIN32_WINNT macro as follows: +** +** #if defined(_WIN32_WINNT) +** # define SQLITE_OS_WINNT 1 +** #else +** # define SQLITE_OS_WINNT 0 +** #endif +** +** However, Visual Studio 2005 does not set _WIN32_WINNT by default, as +** it ought to, so the above test does not work. We'll just assume that +** everything is Windows NT unless the programmer explicitly says otherwise +** by setting SQLITE_OS_WINNT to 0. +*/ +#if SQLITE_OS_WIN && !defined(SQLITE_OS_WINNT) +# define SQLITE_OS_WINNT 1 +#endif + +/* +** Determine if we are dealing with Windows CE - which has a much reduced +** API. +*/ +#if defined(_WIN32_WCE) +# define SQLITE_OS_WINCE 1 +#else +# define SQLITE_OS_WINCE 0 +#endif + +/* +** Determine if we are dealing with WinRT, which provides only a subset of +** the full Win32 API. +*/ +#if !defined(SQLITE_OS_WINRT) +# define SQLITE_OS_WINRT 0 +#endif + +/* +** For WinCE, some API function parameters do not appear to be declared as +** volatile. +*/ +#if SQLITE_OS_WINCE +# define SQLITE_WIN32_VOLATILE +#else +# define SQLITE_WIN32_VOLATILE volatile +#endif + +/* +** For some Windows sub-platforms, the _beginthreadex() / _endthreadex() +** functions are not available (e.g. those not using MSVC, Cygwin, etc). +*/ +#if SQLITE_OS_WIN && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && \ + SQLITE_THREADSAFE>0 && !defined(__CYGWIN__) +# define SQLITE_OS_WIN_THREADS 1 +#else +# define SQLITE_OS_WIN_THREADS 0 +#endif + +#endif /* _OS_WIN_H_ */ + +/************** End of os_win.h **********************************************/ +/************** Continuing where we left off in mutex_w32.c ******************/ +#endif + +/* +** The code in this file is only used if we are compiling multithreaded +** on a Win32 system. +*/ +#ifdef SQLITE_MUTEX_W32 + +/* +** Each recursive mutex is an instance of the following structure. +*/ +struct sqlite3_mutex { + CRITICAL_SECTION mutex; /* Mutex controlling the lock */ + int id; /* Mutex type */ +#ifdef SQLITE_DEBUG + volatile int nRef; /* Number of enterances */ + volatile DWORD owner; /* Thread holding this mutex */ + volatile int trace; /* True to trace changes */ +#endif +}; + +/* +** These are the initializer values used when declaring a "static" mutex +** on Win32. It should be noted that all mutexes require initialization +** on the Win32 platform. +*/ +#define SQLITE_W32_MUTEX_INITIALIZER { 0 } + +#ifdef SQLITE_DEBUG +#define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0, \ + 0L, (DWORD)0, 0 } +#else +#define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0 } +#endif + +#ifdef SQLITE_DEBUG +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use only inside assert() statements. +*/ +static int winMutexHeld(sqlite3_mutex *p){ + return p->nRef!=0 && p->owner==GetCurrentThreadId(); +} + +static int winMutexNotheld2(sqlite3_mutex *p, DWORD tid){ + return p->nRef==0 || p->owner!=tid; +} + +static int winMutexNotheld(sqlite3_mutex *p){ + DWORD tid = GetCurrentThreadId(); + return winMutexNotheld2(p, tid); +} +#endif + +/* +** Try to provide a memory barrier operation, needed for initialization +** and also for the xShmBarrier method of the VFS in cases when SQLite is +** compiled without mutexes (SQLITE_THREADSAFE=0). +*/ +SQLITE_PRIVATE void sqlite3MemoryBarrier(void){ +#if defined(SQLITE_MEMORY_BARRIER) + SQLITE_MEMORY_BARRIER; +#elif defined(__GNUC__) + __sync_synchronize(); +#elif !defined(SQLITE_DISABLE_INTRINSIC) && \ + defined(_MSC_VER) && _MSC_VER>=1300 + _ReadWriteBarrier(); +#elif defined(MemoryBarrier) + MemoryBarrier(); +#endif +} + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static sqlite3_mutex winMutex_staticMutexes[] = { + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER, + SQLITE3_MUTEX_INITIALIZER +}; + +static int winMutex_isInit = 0; +static int winMutex_isNt = -1; /* <0 means "need to query" */ + +/* As the winMutexInit() and winMutexEnd() functions are called as part +** of the sqlite3_initialize() and sqlite3_shutdown() processing, the +** "interlocked" magic used here is probably not strictly necessary. +*/ +static LONG SQLITE_WIN32_VOLATILE winMutex_lock = 0; + +SQLITE_API int SQLITE_STDCALL sqlite3_win32_is_nt(void); /* os_win.c */ +SQLITE_API void SQLITE_STDCALL sqlite3_win32_sleep(DWORD milliseconds); /* os_win.c */ + +static int winMutexInit(void){ + /* The first to increment to 1 does actual initialization */ + if( InterlockedCompareExchange(&winMutex_lock, 1, 0)==0 ){ + int i; + for(i=0; i +**
  • SQLITE_MUTEX_FAST +**
  • SQLITE_MUTEX_RECURSIVE +**
  • SQLITE_MUTEX_STATIC_MASTER +**
  • SQLITE_MUTEX_STATIC_MEM +**
  • SQLITE_MUTEX_STATIC_OPEN +**
  • SQLITE_MUTEX_STATIC_PRNG +**
  • SQLITE_MUTEX_STATIC_LRU +**
  • SQLITE_MUTEX_STATIC_PMEM +**
  • SQLITE_MUTEX_STATIC_APP1 +**
  • SQLITE_MUTEX_STATIC_APP2 +**
  • SQLITE_MUTEX_STATIC_APP3 +**
  • SQLITE_MUTEX_STATIC_VFS1 +**
  • SQLITE_MUTEX_STATIC_VFS2 +**
  • SQLITE_MUTEX_STATIC_VFS3 +** +** +** The first two constants cause sqlite3_mutex_alloc() to create +** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. But SQLite will only request a recursive mutex in +** cases where it really needs one. If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** The other allowed parameters to sqlite3_mutex_alloc() each return +** a pointer to a static preexisting mutex. Six static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. But for the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +*/ +static sqlite3_mutex *winMutexAlloc(int iType){ + sqlite3_mutex *p; + + switch( iType ){ + case SQLITE_MUTEX_FAST: + case SQLITE_MUTEX_RECURSIVE: { + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ + p->id = iType; +#ifdef SQLITE_DEBUG +#ifdef SQLITE_WIN32_MUTEX_TRACE_DYNAMIC + p->trace = 1; +#endif +#endif +#if SQLITE_OS_WINRT + InitializeCriticalSectionEx(&p->mutex, 0, 0); +#else + InitializeCriticalSection(&p->mutex); +#endif + } + break; + } + default: { +#ifdef SQLITE_ENABLE_API_ARMOR + if( iType-2<0 || iType-2>=ArraySize(winMutex_staticMutexes) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + p = &winMutex_staticMutexes[iType-2]; + p->id = iType; +#ifdef SQLITE_DEBUG +#ifdef SQLITE_WIN32_MUTEX_TRACE_STATIC + p->trace = 1; +#endif +#endif + break; + } + } + return p; +} + + +/* +** This routine deallocates a previously +** allocated mutex. SQLite is careful to deallocate every +** mutex that it allocates. +*/ +static void winMutexFree(sqlite3_mutex *p){ + assert( p ); + assert( p->nRef==0 && p->owner==0 ); + if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ){ + DeleteCriticalSection(&p->mutex); + sqlite3_free(p); + }else{ +#ifdef SQLITE_ENABLE_API_ARMOR + (void)SQLITE_MISUSE_BKPT; +#endif + } +} + +/* +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can +** be entered multiple times by the same thread. In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. If the same thread tries to enter any other kind of mutex +** more than once, the behavior is undefined. +*/ +static void winMutexEnter(sqlite3_mutex *p){ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + DWORD tid = GetCurrentThreadId(); +#endif +#ifdef SQLITE_DEBUG + assert( p ); + assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); +#else + assert( p ); +#endif + assert( winMutex_isInit==1 ); + EnterCriticalSection(&p->mutex); +#ifdef SQLITE_DEBUG + assert( p->nRef>0 || p->owner==0 ); + p->owner = tid; + p->nRef++; + if( p->trace ){ + OSTRACE(("ENTER-MUTEX tid=%lu, mutex=%p (%d), nRef=%d\n", + tid, p, p->trace, p->nRef)); + } +#endif +} + +static int winMutexTry(sqlite3_mutex *p){ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + DWORD tid = GetCurrentThreadId(); +#endif + int rc = SQLITE_BUSY; + assert( p ); + assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); + /* + ** The sqlite3_mutex_try() routine is very rarely used, and when it + ** is used it is merely an optimization. So it is OK for it to always + ** fail. + ** + ** The TryEnterCriticalSection() interface is only available on WinNT. + ** And some windows compilers complain if you try to use it without + ** first doing some #defines that prevent SQLite from building on Win98. + ** For that reason, we will omit this optimization for now. See + ** ticket #2685. + */ +#if defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0400 + assert( winMutex_isInit==1 ); + assert( winMutex_isNt>=-1 && winMutex_isNt<=1 ); + if( winMutex_isNt<0 ){ + winMutex_isNt = sqlite3_win32_is_nt(); + } + assert( winMutex_isNt==0 || winMutex_isNt==1 ); + if( winMutex_isNt && TryEnterCriticalSection(&p->mutex) ){ +#ifdef SQLITE_DEBUG + p->owner = tid; + p->nRef++; +#endif + rc = SQLITE_OK; + } +#else + UNUSED_PARAMETER(p); +#endif +#ifdef SQLITE_DEBUG + if( p->trace ){ + OSTRACE(("TRY-MUTEX tid=%lu, mutex=%p (%d), owner=%lu, nRef=%d, rc=%s\n", + tid, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc))); + } +#endif + return rc; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered or +** is not currently allocated. SQLite will never do either. +*/ +static void winMutexLeave(sqlite3_mutex *p){ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + DWORD tid = GetCurrentThreadId(); +#endif + assert( p ); +#ifdef SQLITE_DEBUG + assert( p->nRef>0 ); + assert( p->owner==tid ); + p->nRef--; + if( p->nRef==0 ) p->owner = 0; + assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); +#endif + assert( winMutex_isInit==1 ); + LeaveCriticalSection(&p->mutex); +#ifdef SQLITE_DEBUG + if( p->trace ){ + OSTRACE(("LEAVE-MUTEX tid=%lu, mutex=%p (%d), nRef=%d\n", + tid, p, p->trace, p->nRef)); + } +#endif +} + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){ + static const sqlite3_mutex_methods sMutex = { + winMutexInit, + winMutexEnd, + winMutexAlloc, + winMutexFree, + winMutexEnter, + winMutexTry, + winMutexLeave, +#ifdef SQLITE_DEBUG + winMutexHeld, + winMutexNotheld +#else + 0, + 0 +#endif + }; + return &sMutex; +} + +#endif /* SQLITE_MUTEX_W32 */ + +/************** End of mutex_w32.c *******************************************/ +/************** Begin file malloc.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** Memory allocation functions used throughout sqlite. +*/ +/* #include "sqliteInt.h" */ +/* #include */ + +/* +** Attempt to release up to n bytes of non-essential memory currently +** held by SQLite. An example of non-essential memory is memory used to +** cache database pages that are not currently in use. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_release_memory(int n){ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + return sqlite3PcacheReleaseMemory(n); +#else + /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine + ** is a no-op returning zero if SQLite is not compiled with + ** SQLITE_ENABLE_MEMORY_MANAGEMENT. */ + UNUSED_PARAMETER(n); + return 0; +#endif +} + +/* +** An instance of the following object records the location of +** each unused scratch buffer. +*/ +typedef struct ScratchFreeslot { + struct ScratchFreeslot *pNext; /* Next unused scratch buffer */ +} ScratchFreeslot; + +/* +** State information local to the memory allocation subsystem. +*/ +static SQLITE_WSD struct Mem0Global { + sqlite3_mutex *mutex; /* Mutex to serialize access */ + sqlite3_int64 alarmThreshold; /* The soft heap limit */ + + /* + ** Pointers to the end of sqlite3GlobalConfig.pScratch memory + ** (so that a range test can be used to determine if an allocation + ** being freed came from pScratch) and a pointer to the list of + ** unused scratch allocations. + */ + void *pScratchEnd; + ScratchFreeslot *pScratchFree; + u32 nScratchFree; + + /* + ** True if heap is nearly "full" where "full" is defined by the + ** sqlite3_soft_heap_limit() setting. + */ + int nearlyFull; +} mem0 = { 0, 0, 0, 0, 0, 0 }; + +#define mem0 GLOBAL(struct Mem0Global, mem0) + +/* +** Return the memory allocator mutex. sqlite3_status() needs it. +*/ +SQLITE_PRIVATE sqlite3_mutex *sqlite3MallocMutex(void){ + return mem0.mutex; +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Deprecated external interface. It used to set an alarm callback +** that was invoked when memory usage grew too large. Now it is a +** no-op. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_memory_alarm( + void(*xCallback)(void *pArg, sqlite3_int64 used,int N), + void *pArg, + sqlite3_int64 iThreshold +){ + (void)xCallback; + (void)pArg; + (void)iThreshold; + return SQLITE_OK; +} +#endif + +/* +** Set the soft heap-size limit for the library. Passing a zero or +** negative value indicates no limit. +*/ +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_soft_heap_limit64(sqlite3_int64 n){ + sqlite3_int64 priorLimit; + sqlite3_int64 excess; + sqlite3_int64 nUsed; +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return -1; +#endif + sqlite3_mutex_enter(mem0.mutex); + priorLimit = mem0.alarmThreshold; + if( n<0 ){ + sqlite3_mutex_leave(mem0.mutex); + return priorLimit; + } + mem0.alarmThreshold = n; + nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); + mem0.nearlyFull = (n>0 && n<=nUsed); + sqlite3_mutex_leave(mem0.mutex); + excess = sqlite3_memory_used() - n; + if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff)); + return priorLimit; +} +SQLITE_API void SQLITE_STDCALL sqlite3_soft_heap_limit(int n){ + if( n<0 ) n = 0; + sqlite3_soft_heap_limit64(n); +} + +/* +** Initialize the memory allocation subsystem. +*/ +SQLITE_PRIVATE int sqlite3MallocInit(void){ + int rc; + if( sqlite3GlobalConfig.m.xMalloc==0 ){ + sqlite3MemSetDefault(); + } + memset(&mem0, 0, sizeof(mem0)); + if( sqlite3GlobalConfig.bCoreMutex ){ + mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); + } + if( sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch>=100 + && sqlite3GlobalConfig.nScratch>0 ){ + int i, n, sz; + ScratchFreeslot *pSlot; + sz = ROUNDDOWN8(sqlite3GlobalConfig.szScratch); + sqlite3GlobalConfig.szScratch = sz; + pSlot = (ScratchFreeslot*)sqlite3GlobalConfig.pScratch; + n = sqlite3GlobalConfig.nScratch; + mem0.pScratchFree = pSlot; + mem0.nScratchFree = n; + for(i=0; ipNext = (ScratchFreeslot*)(sz+(char*)pSlot); + pSlot = pSlot->pNext; + } + pSlot->pNext = 0; + mem0.pScratchEnd = (void*)&pSlot[1]; + }else{ + mem0.pScratchEnd = 0; + sqlite3GlobalConfig.pScratch = 0; + sqlite3GlobalConfig.szScratch = 0; + sqlite3GlobalConfig.nScratch = 0; + } + if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512 + || sqlite3GlobalConfig.nPage<=0 ){ + sqlite3GlobalConfig.pPage = 0; + sqlite3GlobalConfig.szPage = 0; + } + rc = sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData); + if( rc!=SQLITE_OK ) memset(&mem0, 0, sizeof(mem0)); + return rc; +} + +/* +** Return true if the heap is currently under memory pressure - in other +** words if the amount of heap used is close to the limit set by +** sqlite3_soft_heap_limit(). +*/ +SQLITE_PRIVATE int sqlite3HeapNearlyFull(void){ + return mem0.nearlyFull; +} + +/* +** Deinitialize the memory allocation subsystem. +*/ +SQLITE_PRIVATE void sqlite3MallocEnd(void){ + if( sqlite3GlobalConfig.m.xShutdown ){ + sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData); + } + memset(&mem0, 0, sizeof(mem0)); +} + +/* +** Return the amount of memory currently checked out. +*/ +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_used(void){ + sqlite3_int64 res, mx; + sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, 0); + return res; +} + +/* +** Return the maximum amount of memory that has ever been +** checked out since either the beginning of this process +** or since the most recent reset. +*/ +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_highwater(int resetFlag){ + sqlite3_int64 res, mx; + sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, resetFlag); + return mx; +} + +/* +** Trigger the alarm +*/ +static void sqlite3MallocAlarm(int nByte){ + if( mem0.alarmThreshold<=0 ) return; + sqlite3_mutex_leave(mem0.mutex); + sqlite3_release_memory(nByte); + sqlite3_mutex_enter(mem0.mutex); +} + +/* +** Do a memory allocation with statistics and alarms. Assume the +** lock is already held. +*/ +static int mallocWithAlarm(int n, void **pp){ + int nFull; + void *p; + assert( sqlite3_mutex_held(mem0.mutex) ); + nFull = sqlite3GlobalConfig.m.xRoundup(n); + sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, n); + if( mem0.alarmThreshold>0 ){ + sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); + if( nUsed >= mem0.alarmThreshold - nFull ){ + mem0.nearlyFull = 1; + sqlite3MallocAlarm(nFull); + }else{ + mem0.nearlyFull = 0; + } + } + p = sqlite3GlobalConfig.m.xMalloc(nFull); +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + if( p==0 && mem0.alarmThreshold>0 ){ + sqlite3MallocAlarm(nFull); + p = sqlite3GlobalConfig.m.xMalloc(nFull); + } +#endif + if( p ){ + nFull = sqlite3MallocSize(p); + sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nFull); + sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1); + } + *pp = p; + return nFull; +} + +/* +** Allocate memory. This routine is like sqlite3_malloc() except that it +** assumes the memory subsystem has already been initialized. +*/ +SQLITE_PRIVATE void *sqlite3Malloc(u64 n){ + void *p; + if( n==0 || n>=0x7fffff00 ){ + /* A memory allocation of a number of bytes which is near the maximum + ** signed integer value might cause an integer overflow inside of the + ** xMalloc(). Hence we limit the maximum size to 0x7fffff00, giving + ** 255 bytes of overhead. SQLite itself will never use anything near + ** this amount. The only way to reach the limit is with sqlite3_malloc() */ + p = 0; + }else if( sqlite3GlobalConfig.bMemstat ){ + sqlite3_mutex_enter(mem0.mutex); + mallocWithAlarm((int)n, &p); + sqlite3_mutex_leave(mem0.mutex); + }else{ + p = sqlite3GlobalConfig.m.xMalloc((int)n); + } + assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-11148-40995 */ + return p; +} + +/* +** This version of the memory allocation is for use by the application. +** First make sure the memory subsystem is initialized, then do the +** allocation. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_malloc(int n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return n<=0 ? 0 : sqlite3Malloc(n); +} +SQLITE_API void *SQLITE_STDCALL sqlite3_malloc64(sqlite3_uint64 n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return sqlite3Malloc(n); +} + +/* +** Each thread may only have a single outstanding allocation from +** xScratchMalloc(). We verify this constraint in the single-threaded +** case by setting scratchAllocOut to 1 when an allocation +** is outstanding clearing it when the allocation is freed. +*/ +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG) +static int scratchAllocOut = 0; +#endif + + +/* +** Allocate memory that is to be used and released right away. +** This routine is similar to alloca() in that it is not intended +** for situations where the memory might be held long-term. This +** routine is intended to get memory to old large transient data +** structures that would not normally fit on the stack of an +** embedded processor. +*/ +SQLITE_PRIVATE void *sqlite3ScratchMalloc(int n){ + void *p; + assert( n>0 ); + + sqlite3_mutex_enter(mem0.mutex); + sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n); + if( mem0.nScratchFree && sqlite3GlobalConfig.szScratch>=n ){ + p = mem0.pScratchFree; + mem0.pScratchFree = mem0.pScratchFree->pNext; + mem0.nScratchFree--; + sqlite3StatusUp(SQLITE_STATUS_SCRATCH_USED, 1); + sqlite3_mutex_leave(mem0.mutex); + }else{ + sqlite3_mutex_leave(mem0.mutex); + p = sqlite3Malloc(n); + if( sqlite3GlobalConfig.bMemstat && p ){ + sqlite3_mutex_enter(mem0.mutex); + sqlite3StatusUp(SQLITE_STATUS_SCRATCH_OVERFLOW, sqlite3MallocSize(p)); + sqlite3_mutex_leave(mem0.mutex); + } + sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH); + } + assert( sqlite3_mutex_notheld(mem0.mutex) ); + + +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG) + /* EVIDENCE-OF: R-12970-05880 SQLite will not use more than one scratch + ** buffers per thread. + ** + ** This can only be checked in single-threaded mode. + */ + assert( scratchAllocOut==0 ); + if( p ) scratchAllocOut++; +#endif + + return p; +} +SQLITE_PRIVATE void sqlite3ScratchFree(void *p){ + if( p ){ + +#if SQLITE_THREADSAFE==0 && !defined(NDEBUG) + /* Verify that no more than two scratch allocation per thread + ** is outstanding at one time. (This is only checked in the + ** single-threaded case since checking in the multi-threaded case + ** would be much more complicated.) */ + assert( scratchAllocOut>=1 && scratchAllocOut<=2 ); + scratchAllocOut--; +#endif + + if( p>=sqlite3GlobalConfig.pScratch && ppNext = mem0.pScratchFree; + mem0.pScratchFree = pSlot; + mem0.nScratchFree++; + assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch ); + sqlite3StatusDown(SQLITE_STATUS_SCRATCH_USED, 1); + sqlite3_mutex_leave(mem0.mutex); + }else{ + /* Release memory back to the heap */ + assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) ); + assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_SCRATCH) ); + sqlite3MemdebugSetType(p, MEMTYPE_HEAP); + if( sqlite3GlobalConfig.bMemstat ){ + int iSize = sqlite3MallocSize(p); + sqlite3_mutex_enter(mem0.mutex); + sqlite3StatusDown(SQLITE_STATUS_SCRATCH_OVERFLOW, iSize); + sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, iSize); + sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1); + sqlite3GlobalConfig.m.xFree(p); + sqlite3_mutex_leave(mem0.mutex); + }else{ + sqlite3GlobalConfig.m.xFree(p); + } + } + } +} + +/* +** TRUE if p is a lookaside memory allocation from db +*/ +#ifndef SQLITE_OMIT_LOOKASIDE +static int isLookaside(sqlite3 *db, void *p){ + return p>=db->lookaside.pStart && plookaside.pEnd; +} +#else +#define isLookaside(A,B) 0 +#endif + +/* +** Return the size of a memory allocation previously obtained from +** sqlite3Malloc() or sqlite3_malloc(). +*/ +SQLITE_PRIVATE int sqlite3MallocSize(void *p){ + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + return sqlite3GlobalConfig.m.xSize(p); +} +SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){ + if( db==0 || !isLookaside(db,p) ){ +#if SQLITE_DEBUG + if( db==0 ){ + assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + }else{ + assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + } +#endif + return sqlite3GlobalConfig.m.xSize(p); + }else{ + assert( sqlite3_mutex_held(db->mutex) ); + return db->lookaside.sz; + } +} +SQLITE_API sqlite3_uint64 SQLITE_STDCALL sqlite3_msize(void *p){ + assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + return (sqlite3_uint64)sqlite3GlobalConfig.m.xSize(p); +} + +/* +** Free memory previously obtained from sqlite3Malloc(). +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_free(void *p){ + if( p==0 ) return; /* IMP: R-49053-54554 */ + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); + if( sqlite3GlobalConfig.bMemstat ){ + sqlite3_mutex_enter(mem0.mutex); + sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p)); + sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1); + sqlite3GlobalConfig.m.xFree(p); + sqlite3_mutex_leave(mem0.mutex); + }else{ + sqlite3GlobalConfig.m.xFree(p); + } +} + +/* +** Add the size of memory allocation "p" to the count in +** *db->pnBytesFreed. +*/ +static SQLITE_NOINLINE void measureAllocationSize(sqlite3 *db, void *p){ + *db->pnBytesFreed += sqlite3DbMallocSize(db,p); +} + +/* +** Free memory that might be associated with a particular database +** connection. +*/ +SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){ + assert( db==0 || sqlite3_mutex_held(db->mutex) ); + if( p==0 ) return; + if( db ){ + if( db->pnBytesFreed ){ + measureAllocationSize(db, p); + return; + } + if( isLookaside(db, p) ){ + LookasideSlot *pBuf = (LookasideSlot*)p; +#if SQLITE_DEBUG + /* Trash all content in the buffer being freed */ + memset(p, 0xaa, db->lookaside.sz); +#endif + pBuf->pNext = db->lookaside.pFree; + db->lookaside.pFree = pBuf; + db->lookaside.nOut--; + return; + } + } + assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); + sqlite3MemdebugSetType(p, MEMTYPE_HEAP); + sqlite3_free(p); +} + +/* +** Change the size of an existing memory allocation +*/ +SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, u64 nBytes){ + int nOld, nNew, nDiff; + void *pNew; + assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) ); + assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) ); + if( pOld==0 ){ + return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */ + } + if( nBytes==0 ){ + sqlite3_free(pOld); /* IMP: R-26507-47431 */ + return 0; + } + if( nBytes>=0x7fffff00 ){ + /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */ + return 0; + } + nOld = sqlite3MallocSize(pOld); + /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second + ** argument to xRealloc is always a value returned by a prior call to + ** xRoundup. */ + nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes); + if( nOld==nNew ){ + pNew = pOld; + }else if( sqlite3GlobalConfig.bMemstat ){ + sqlite3_mutex_enter(mem0.mutex); + sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes); + nDiff = nNew - nOld; + if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >= + mem0.alarmThreshold-nDiff ){ + sqlite3MallocAlarm(nDiff); + } + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); + if( pNew==0 && mem0.alarmThreshold>0 ){ + sqlite3MallocAlarm((int)nBytes); + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); + } + if( pNew ){ + nNew = sqlite3MallocSize(pNew); + sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld); + } + sqlite3_mutex_leave(mem0.mutex); + }else{ + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); + } + assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */ + return pNew; +} + +/* +** The public interface to sqlite3Realloc. Make sure that the memory +** subsystem is initialized prior to invoking sqliteRealloc. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_realloc(void *pOld, int n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + if( n<0 ) n = 0; /* IMP: R-26507-47431 */ + return sqlite3Realloc(pOld, n); +} +SQLITE_API void *SQLITE_STDCALL sqlite3_realloc64(void *pOld, sqlite3_uint64 n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return sqlite3Realloc(pOld, n); +} + + +/* +** Allocate and zero memory. +*/ +SQLITE_PRIVATE void *sqlite3MallocZero(u64 n){ + void *p = sqlite3Malloc(n); + if( p ){ + memset(p, 0, (size_t)n); + } + return p; +} + +/* +** Allocate and zero memory. If the allocation fails, make +** the mallocFailed flag in the connection pointer. +*/ +SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, u64 n){ + void *p = sqlite3DbMallocRaw(db, n); + if( p ){ + memset(p, 0, (size_t)n); + } + return p; +} + +/* +** Allocate and zero memory. If the allocation fails, make +** the mallocFailed flag in the connection pointer. +** +** If db!=0 and db->mallocFailed is true (indicating a prior malloc +** failure on the same database connection) then always return 0. +** Hence for a particular database connection, once malloc starts +** failing, it fails consistently until mallocFailed is reset. +** This is an important assumption. There are many places in the +** code that do things like this: +** +** int *a = (int*)sqlite3DbMallocRaw(db, 100); +** int *b = (int*)sqlite3DbMallocRaw(db, 200); +** if( b ) a[10] = 9; +** +** In other words, if a subsequent malloc (ex: "b") worked, it is assumed +** that all prior mallocs (ex: "a") worked too. +*/ +SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){ + void *p; + assert( db==0 || sqlite3_mutex_held(db->mutex) ); + assert( db==0 || db->pnBytesFreed==0 ); +#ifndef SQLITE_OMIT_LOOKASIDE + if( db ){ + LookasideSlot *pBuf; + if( db->mallocFailed ){ + return 0; + } + if( db->lookaside.bEnabled ){ + if( n>db->lookaside.sz ){ + db->lookaside.anStat[1]++; + }else if( (pBuf = db->lookaside.pFree)==0 ){ + db->lookaside.anStat[2]++; + }else{ + db->lookaside.pFree = pBuf->pNext; + db->lookaside.nOut++; + db->lookaside.anStat[0]++; + if( db->lookaside.nOut>db->lookaside.mxOut ){ + db->lookaside.mxOut = db->lookaside.nOut; + } + return (void*)pBuf; + } + } + } +#else + if( db && db->mallocFailed ){ + return 0; + } +#endif + p = sqlite3Malloc(n); + if( !p && db ){ + db->mallocFailed = 1; + } + sqlite3MemdebugSetType(p, + (db && db->lookaside.bEnabled) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP); + return p; +} + +/* +** Resize the block of memory pointed to by p to n bytes. If the +** resize fails, set the mallocFailed flag in the connection object. +*/ +SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){ + void *pNew = 0; + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + if( db->mallocFailed==0 ){ + if( p==0 ){ + return sqlite3DbMallocRaw(db, n); + } + if( isLookaside(db, p) ){ + if( n<=db->lookaside.sz ){ + return p; + } + pNew = sqlite3DbMallocRaw(db, n); + if( pNew ){ + memcpy(pNew, p, db->lookaside.sz); + sqlite3DbFree(db, p); + } + }else{ + assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + sqlite3MemdebugSetType(p, MEMTYPE_HEAP); + pNew = sqlite3_realloc64(p, n); + if( !pNew ){ + db->mallocFailed = 1; + } + sqlite3MemdebugSetType(pNew, + (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP)); + } + } + return pNew; +} + +/* +** Attempt to reallocate p. If the reallocation fails, then free p +** and set the mallocFailed flag in the database connection. +*/ +SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){ + void *pNew; + pNew = sqlite3DbRealloc(db, p, n); + if( !pNew ){ + sqlite3DbFree(db, p); + } + return pNew; +} + +/* +** Make a copy of a string in memory obtained from sqliteMalloc(). These +** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This +** is because when memory debugging is turned on, these two functions are +** called via macros that record the current file and line number in the +** ThreadData structure. +*/ +SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3 *db, const char *z){ + char *zNew; + size_t n; + if( z==0 ){ + return 0; + } + n = sqlite3Strlen30(z) + 1; + assert( (n&0x7fffffff)==n ); + zNew = sqlite3DbMallocRaw(db, (int)n); + if( zNew ){ + memcpy(zNew, z, n); + } + return zNew; +} +SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){ + char *zNew; + if( z==0 ){ + return 0; + } + assert( (n&0x7fffffff)==n ); + zNew = sqlite3DbMallocRaw(db, n+1); + if( zNew ){ + memcpy(zNew, z, (size_t)n); + zNew[n] = 0; + } + return zNew; +} + +/* +** Free any prior content in *pz and replace it with a copy of zNew. +*/ +SQLITE_PRIVATE void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){ + sqlite3DbFree(db, *pz); + *pz = sqlite3DbStrDup(db, zNew); +} + +/* +** Take actions at the end of an API call to indicate an OOM error +*/ +static SQLITE_NOINLINE int apiOomError(sqlite3 *db){ + db->mallocFailed = 0; + sqlite3Error(db, SQLITE_NOMEM); + return SQLITE_NOMEM; +} + +/* +** This function must be called before exiting any API function (i.e. +** returning control to the user) that has called sqlite3_malloc or +** sqlite3_realloc. +** +** The returned value is normally a copy of the second argument to this +** function. However, if a malloc() failure has occurred since the previous +** invocation SQLITE_NOMEM is returned instead. +** +** If an OOM as occurred, then the connection error-code (the value +** returned by sqlite3_errcode()) is set to SQLITE_NOMEM. +*/ +SQLITE_PRIVATE int sqlite3ApiExit(sqlite3* db, int rc){ + /* If the db handle must hold the connection handle mutex here. + ** Otherwise the read (and possible write) of db->mallocFailed + ** is unsafe, as is the call to sqlite3Error(). + */ + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){ + return apiOomError(db); + } + return rc & db->errMask; +} + +/************** End of malloc.c **********************************************/ +/************** Begin file printf.c ******************************************/ +/* +** The "printf" code that follows dates from the 1980's. It is in +** the public domain. +** +************************************************************************** +** +** This file contains code for a set of "printf"-like routines. These +** routines format strings much like the printf() from the standard C +** library, though the implementation here has enhancements to support +** SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* +** Conversion types fall into various categories as defined by the +** following enumeration. +*/ +#define etRADIX 1 /* Integer types. %d, %x, %o, and so forth */ +#define etFLOAT 2 /* Floating point. %f */ +#define etEXP 3 /* Exponentional notation. %e and %E */ +#define etGENERIC 4 /* Floating or exponential, depending on exponent. %g */ +#define etSIZE 5 /* Return number of characters processed so far. %n */ +#define etSTRING 6 /* Strings. %s */ +#define etDYNSTRING 7 /* Dynamically allocated strings. %z */ +#define etPERCENT 8 /* Percent symbol. %% */ +#define etCHARX 9 /* Characters. %c */ +/* The rest are extensions, not normally found in printf() */ +#define etSQLESCAPE 10 /* Strings with '\'' doubled. %q */ +#define etSQLESCAPE2 11 /* Strings with '\'' doubled and enclosed in '', + NULL pointers replaced by SQL NULL. %Q */ +#define etTOKEN 12 /* a pointer to a Token structure */ +#define etSRCLIST 13 /* a pointer to a SrcList */ +#define etPOINTER 14 /* The %p conversion */ +#define etSQLESCAPE3 15 /* %w -> Strings with '\"' doubled */ +#define etORDINAL 16 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */ + +#define etINVALID 0 /* Any unrecognized conversion type */ + + +/* +** An "etByte" is an 8-bit unsigned value. +*/ +typedef unsigned char etByte; + +/* +** Each builtin conversion character (ex: the 'd' in "%d") is described +** by an instance of the following structure +*/ +typedef struct et_info { /* Information about each format field */ + char fmttype; /* The format field code letter */ + etByte base; /* The base for radix conversion */ + etByte flags; /* One or more of FLAG_ constants below */ + etByte type; /* Conversion paradigm */ + etByte charset; /* Offset into aDigits[] of the digits string */ + etByte prefix; /* Offset into aPrefix[] of the prefix string */ +} et_info; + +/* +** Allowed values for et_info.flags +*/ +#define FLAG_SIGNED 1 /* True if the value to convert is signed */ +#define FLAG_INTERN 2 /* True if for internal use only */ +#define FLAG_STRING 4 /* Allow infinity precision */ + + +/* +** The following table is searched linearly, so it is good to put the +** most frequently used conversion types first. +*/ +static const char aDigits[] = "0123456789ABCDEF0123456789abcdef"; +static const char aPrefix[] = "-x0\000X0"; +static const et_info fmtinfo[] = { + { 'd', 10, 1, etRADIX, 0, 0 }, + { 's', 0, 4, etSTRING, 0, 0 }, + { 'g', 0, 1, etGENERIC, 30, 0 }, + { 'z', 0, 4, etDYNSTRING, 0, 0 }, + { 'q', 0, 4, etSQLESCAPE, 0, 0 }, + { 'Q', 0, 4, etSQLESCAPE2, 0, 0 }, + { 'w', 0, 4, etSQLESCAPE3, 0, 0 }, + { 'c', 0, 0, etCHARX, 0, 0 }, + { 'o', 8, 0, etRADIX, 0, 2 }, + { 'u', 10, 0, etRADIX, 0, 0 }, + { 'x', 16, 0, etRADIX, 16, 1 }, + { 'X', 16, 0, etRADIX, 0, 4 }, +#ifndef SQLITE_OMIT_FLOATING_POINT + { 'f', 0, 1, etFLOAT, 0, 0 }, + { 'e', 0, 1, etEXP, 30, 0 }, + { 'E', 0, 1, etEXP, 14, 0 }, + { 'G', 0, 1, etGENERIC, 14, 0 }, +#endif + { 'i', 10, 1, etRADIX, 0, 0 }, + { 'n', 0, 0, etSIZE, 0, 0 }, + { '%', 0, 0, etPERCENT, 0, 0 }, + { 'p', 16, 0, etPOINTER, 0, 1 }, + +/* All the rest have the FLAG_INTERN bit set and are thus for internal +** use only */ + { 'T', 0, 2, etTOKEN, 0, 0 }, + { 'S', 0, 2, etSRCLIST, 0, 0 }, + { 'r', 10, 3, etORDINAL, 0, 0 }, +}; + +/* +** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point +** conversions will work. +*/ +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** "*val" is a double such that 0.1 <= *val < 10.0 +** Return the ascii code for the leading digit of *val, then +** multiply "*val" by 10.0 to renormalize. +** +** Example: +** input: *val = 3.14159 +** output: *val = 1.4159 function return = '3' +** +** The counter *cnt is incremented each time. After counter exceeds +** 16 (the number of significant digits in a 64-bit float) '0' is +** always returned. +*/ +static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){ + int digit; + LONGDOUBLE_TYPE d; + if( (*cnt)<=0 ) return '0'; + (*cnt)--; + digit = (int)*val; + d = digit; + digit += '0'; + *val = (*val - d)*10.0; + return (char)digit; +} +#endif /* SQLITE_OMIT_FLOATING_POINT */ + +/* +** Set the StrAccum object to an error mode. +*/ +static void setStrAccumError(StrAccum *p, u8 eError){ + assert( eError==STRACCUM_NOMEM || eError==STRACCUM_TOOBIG ); + p->accError = eError; + p->nAlloc = 0; +} + +/* +** Extra argument values from a PrintfArguments object +*/ +static sqlite3_int64 getIntArg(PrintfArguments *p){ + if( p->nArg<=p->nUsed ) return 0; + return sqlite3_value_int64(p->apArg[p->nUsed++]); +} +static double getDoubleArg(PrintfArguments *p){ + if( p->nArg<=p->nUsed ) return 0.0; + return sqlite3_value_double(p->apArg[p->nUsed++]); +} +static char *getTextArg(PrintfArguments *p){ + if( p->nArg<=p->nUsed ) return 0; + return (char*)sqlite3_value_text(p->apArg[p->nUsed++]); +} + + +/* +** On machines with a small stack size, you can redefine the +** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired. +*/ +#ifndef SQLITE_PRINT_BUF_SIZE +# define SQLITE_PRINT_BUF_SIZE 70 +#endif +#define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */ + +/* +** Render a string given by "fmt" into the StrAccum object. +*/ +SQLITE_PRIVATE void sqlite3VXPrintf( + StrAccum *pAccum, /* Accumulate results here */ + u32 bFlags, /* SQLITE_PRINTF_* flags */ + const char *fmt, /* Format string */ + va_list ap /* arguments */ +){ + int c; /* Next character in the format string */ + char *bufpt; /* Pointer to the conversion buffer */ + int precision; /* Precision of the current field */ + int length; /* Length of the field */ + int idx; /* A general purpose loop counter */ + int width; /* Width of the current field */ + etByte flag_leftjustify; /* True if "-" flag is present */ + etByte flag_plussign; /* True if "+" flag is present */ + etByte flag_blanksign; /* True if " " flag is present */ + etByte flag_alternateform; /* True if "#" flag is present */ + etByte flag_altform2; /* True if "!" flag is present */ + etByte flag_zeropad; /* True if field width constant starts with zero */ + etByte flag_long; /* True if "l" flag is present */ + etByte flag_longlong; /* True if the "ll" flag is present */ + etByte done; /* Loop termination flag */ + etByte xtype = 0; /* Conversion paradigm */ + u8 bArgList; /* True for SQLITE_PRINTF_SQLFUNC */ + u8 useIntern; /* Ok to use internal conversions (ex: %T) */ + char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */ + sqlite_uint64 longvalue; /* Value for integer types */ + LONGDOUBLE_TYPE realvalue; /* Value for real types */ + const et_info *infop; /* Pointer to the appropriate info structure */ + char *zOut; /* Rendering buffer */ + int nOut; /* Size of the rendering buffer */ + char *zExtra = 0; /* Malloced memory used by some conversion */ +#ifndef SQLITE_OMIT_FLOATING_POINT + int exp, e2; /* exponent of real numbers */ + int nsd; /* Number of significant digits returned */ + double rounder; /* Used for rounding floating point values */ + etByte flag_dp; /* True if decimal point should be shown */ + etByte flag_rtz; /* True if trailing zeros should be removed */ +#endif + PrintfArguments *pArgList = 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */ + char buf[etBUFSIZE]; /* Conversion buffer */ + + bufpt = 0; + if( bFlags ){ + if( (bArgList = (bFlags & SQLITE_PRINTF_SQLFUNC))!=0 ){ + pArgList = va_arg(ap, PrintfArguments*); + } + useIntern = bFlags & SQLITE_PRINTF_INTERNAL; + }else{ + bArgList = useIntern = 0; + } + for(; (c=(*fmt))!=0; ++fmt){ + if( c!='%' ){ + bufpt = (char *)fmt; +#if HAVE_STRCHRNUL + fmt = strchrnul(fmt, '%'); +#else + do{ fmt++; }while( *fmt && *fmt != '%' ); +#endif + sqlite3StrAccumAppend(pAccum, bufpt, (int)(fmt - bufpt)); + if( *fmt==0 ) break; + } + if( (c=(*++fmt))==0 ){ + sqlite3StrAccumAppend(pAccum, "%", 1); + break; + } + /* Find out what flags are present */ + flag_leftjustify = flag_plussign = flag_blanksign = + flag_alternateform = flag_altform2 = flag_zeropad = 0; + done = 0; + do{ + switch( c ){ + case '-': flag_leftjustify = 1; break; + case '+': flag_plussign = 1; break; + case ' ': flag_blanksign = 1; break; + case '#': flag_alternateform = 1; break; + case '!': flag_altform2 = 1; break; + case '0': flag_zeropad = 1; break; + default: done = 1; break; + } + }while( !done && (c=(*++fmt))!=0 ); + /* Get the field width */ + if( c=='*' ){ + if( bArgList ){ + width = (int)getIntArg(pArgList); + }else{ + width = va_arg(ap,int); + } + if( width<0 ){ + flag_leftjustify = 1; + width = width >= -2147483647 ? -width : 0; + } + c = *++fmt; + }else{ + unsigned wx = 0; + while( c>='0' && c<='9' ){ + wx = wx*10 + c - '0'; + c = *++fmt; + } + testcase( wx>0x7fffffff ); + width = wx & 0x7fffffff; + } + + /* Get the precision */ + if( c=='.' ){ + c = *++fmt; + if( c=='*' ){ + if( bArgList ){ + precision = (int)getIntArg(pArgList); + }else{ + precision = va_arg(ap,int); + } + c = *++fmt; + if( precision<0 ){ + precision = precision >= -2147483647 ? -precision : -1; + } + }else{ + unsigned px = 0; + while( c>='0' && c<='9' ){ + px = px*10 + c - '0'; + c = *++fmt; + } + testcase( px>0x7fffffff ); + precision = px & 0x7fffffff; + } + }else{ + precision = -1; + } + /* Get the conversion type modifier */ + if( c=='l' ){ + flag_long = 1; + c = *++fmt; + if( c=='l' ){ + flag_longlong = 1; + c = *++fmt; + }else{ + flag_longlong = 0; + } + }else{ + flag_long = flag_longlong = 0; + } + /* Fetch the info entry for the field */ + infop = &fmtinfo[0]; + xtype = etINVALID; + for(idx=0; idxflags & FLAG_INTERN)==0 ){ + xtype = infop->type; + }else{ + return; + } + break; + } + } + + /* + ** At this point, variables are initialized as follows: + ** + ** flag_alternateform TRUE if a '#' is present. + ** flag_altform2 TRUE if a '!' is present. + ** flag_plussign TRUE if a '+' is present. + ** flag_leftjustify TRUE if a '-' is present or if the + ** field width was negative. + ** flag_zeropad TRUE if the width began with 0. + ** flag_long TRUE if the letter 'l' (ell) prefixed + ** the conversion character. + ** flag_longlong TRUE if the letter 'll' (ell ell) prefixed + ** the conversion character. + ** flag_blanksign TRUE if a ' ' is present. + ** width The specified field width. This is + ** always non-negative. Zero is the default. + ** precision The specified precision. The default + ** is -1. + ** xtype The class of the conversion. + ** infop Pointer to the appropriate info struct. + */ + switch( xtype ){ + case etPOINTER: + flag_longlong = sizeof(char*)==sizeof(i64); + flag_long = sizeof(char*)==sizeof(long int); + /* Fall through into the next case */ + case etORDINAL: + case etRADIX: + if( infop->flags & FLAG_SIGNED ){ + i64 v; + if( bArgList ){ + v = getIntArg(pArgList); + }else if( flag_longlong ){ + v = va_arg(ap,i64); + }else if( flag_long ){ + v = va_arg(ap,long int); + }else{ + v = va_arg(ap,int); + } + if( v<0 ){ + if( v==SMALLEST_INT64 ){ + longvalue = ((u64)1)<<63; + }else{ + longvalue = -v; + } + prefix = '-'; + }else{ + longvalue = v; + if( flag_plussign ) prefix = '+'; + else if( flag_blanksign ) prefix = ' '; + else prefix = 0; + } + }else{ + if( bArgList ){ + longvalue = (u64)getIntArg(pArgList); + }else if( flag_longlong ){ + longvalue = va_arg(ap,u64); + }else if( flag_long ){ + longvalue = va_arg(ap,unsigned long int); + }else{ + longvalue = va_arg(ap,unsigned int); + } + prefix = 0; + } + if( longvalue==0 ) flag_alternateform = 0; + if( flag_zeropad && precision=4 || (longvalue/10)%10==1 ){ + x = 0; + } + *(--bufpt) = zOrd[x*2+1]; + *(--bufpt) = zOrd[x*2]; + } + { + const char *cset = &aDigits[infop->charset]; + u8 base = infop->base; + do{ /* Convert to ascii */ + *(--bufpt) = cset[longvalue%base]; + longvalue = longvalue/base; + }while( longvalue>0 ); + } + length = (int)(&zOut[nOut-1]-bufpt); + for(idx=precision-length; idx>0; idx--){ + *(--bufpt) = '0'; /* Zero pad */ + } + if( prefix ) *(--bufpt) = prefix; /* Add sign */ + if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */ + const char *pre; + char x; + pre = &aPrefix[infop->prefix]; + for(; (x=(*pre))!=0; pre++) *(--bufpt) = x; + } + length = (int)(&zOut[nOut-1]-bufpt); + break; + case etFLOAT: + case etEXP: + case etGENERIC: + if( bArgList ){ + realvalue = getDoubleArg(pArgList); + }else{ + realvalue = va_arg(ap,double); + } +#ifdef SQLITE_OMIT_FLOATING_POINT + length = 0; +#else + if( precision<0 ) precision = 6; /* Set default precision */ + if( realvalue<0.0 ){ + realvalue = -realvalue; + prefix = '-'; + }else{ + if( flag_plussign ) prefix = '+'; + else if( flag_blanksign ) prefix = ' '; + else prefix = 0; + } + if( xtype==etGENERIC && precision>0 ) precision--; + testcase( precision>0xfff ); + for(idx=precision&0xfff, rounder=0.5; idx>0; idx--, rounder*=0.1){} + if( xtype==etFLOAT ) realvalue += rounder; + /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */ + exp = 0; + if( sqlite3IsNaN((double)realvalue) ){ + bufpt = "NaN"; + length = 3; + break; + } + if( realvalue>0.0 ){ + LONGDOUBLE_TYPE scale = 1.0; + while( realvalue>=1e100*scale && exp<=350 ){ scale *= 1e100;exp+=100;} + while( realvalue>=1e10*scale && exp<=350 ){ scale *= 1e10; exp+=10; } + while( realvalue>=10.0*scale && exp<=350 ){ scale *= 10.0; exp++; } + realvalue /= scale; + while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; } + while( realvalue<1.0 ){ realvalue *= 10.0; exp--; } + if( exp>350 ){ + bufpt = buf; + buf[0] = prefix; + memcpy(buf+(prefix!=0),"Inf",4); + length = 3+(prefix!=0); + break; + } + } + bufpt = buf; + /* + ** If the field type is etGENERIC, then convert to either etEXP + ** or etFLOAT, as appropriate. + */ + if( xtype!=etFLOAT ){ + realvalue += rounder; + if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; } + } + if( xtype==etGENERIC ){ + flag_rtz = !flag_alternateform; + if( exp<-4 || exp>precision ){ + xtype = etEXP; + }else{ + precision = precision - exp; + xtype = etFLOAT; + } + }else{ + flag_rtz = flag_altform2; + } + if( xtype==etEXP ){ + e2 = 0; + }else{ + e2 = exp; + } + if( MAX(e2,0)+(i64)precision+(i64)width > etBUFSIZE - 15 ){ + bufpt = zExtra + = sqlite3Malloc( MAX(e2,0)+(i64)precision+(i64)width+15 ); + if( bufpt==0 ){ + setStrAccumError(pAccum, STRACCUM_NOMEM); + return; + } + } + zOut = bufpt; + nsd = 16 + flag_altform2*10; + flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2; + /* The sign in front of the number */ + if( prefix ){ + *(bufpt++) = prefix; + } + /* Digits prior to the decimal point */ + if( e2<0 ){ + *(bufpt++) = '0'; + }else{ + for(; e2>=0; e2--){ + *(bufpt++) = et_getdigit(&realvalue,&nsd); + } + } + /* The decimal point */ + if( flag_dp ){ + *(bufpt++) = '.'; + } + /* "0" digits after the decimal point but before the first + ** significant digit of the number */ + for(e2++; e2<0; precision--, e2++){ + assert( precision>0 ); + *(bufpt++) = '0'; + } + /* Significant digits after the decimal point */ + while( (precision--)>0 ){ + *(bufpt++) = et_getdigit(&realvalue,&nsd); + } + /* Remove trailing zeros and the "." if no digits follow the "." */ + if( flag_rtz && flag_dp ){ + while( bufpt[-1]=='0' ) *(--bufpt) = 0; + assert( bufpt>zOut ); + if( bufpt[-1]=='.' ){ + if( flag_altform2 ){ + *(bufpt++) = '0'; + }else{ + *(--bufpt) = 0; + } + } + } + /* Add the "eNNN" suffix */ + if( xtype==etEXP ){ + *(bufpt++) = aDigits[infop->charset]; + if( exp<0 ){ + *(bufpt++) = '-'; exp = -exp; + }else{ + *(bufpt++) = '+'; + } + if( exp>=100 ){ + *(bufpt++) = (char)((exp/100)+'0'); /* 100's digit */ + exp %= 100; + } + *(bufpt++) = (char)(exp/10+'0'); /* 10's digit */ + *(bufpt++) = (char)(exp%10+'0'); /* 1's digit */ + } + *bufpt = 0; + + /* The converted number is in buf[] and zero terminated. Output it. + ** Note that the number is in the usual order, not reversed as with + ** integer conversions. */ + length = (int)(bufpt-zOut); + bufpt = zOut; + + /* Special case: Add leading zeros if the flag_zeropad flag is + ** set and we are not left justified */ + if( flag_zeropad && !flag_leftjustify && length < width){ + int i; + int nPad = width - length; + for(i=width; i>=nPad; i--){ + bufpt[i] = bufpt[i-nPad]; + } + i = prefix!=0; + while( nPad-- ) bufpt[i++] = '0'; + length = width; + } +#endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */ + break; + case etSIZE: + if( !bArgList ){ + *(va_arg(ap,int*)) = pAccum->nChar; + } + length = width = 0; + break; + case etPERCENT: + buf[0] = '%'; + bufpt = buf; + length = 1; + break; + case etCHARX: + if( bArgList ){ + bufpt = getTextArg(pArgList); + c = bufpt ? bufpt[0] : 0; + }else{ + c = va_arg(ap,int); + } + if( precision>1 ){ + width -= precision-1; + if( width>1 && !flag_leftjustify ){ + sqlite3AppendChar(pAccum, width-1, ' '); + width = 0; + } + sqlite3AppendChar(pAccum, precision-1, c); + } + length = 1; + buf[0] = c; + bufpt = buf; + break; + case etSTRING: + case etDYNSTRING: + if( bArgList ){ + bufpt = getTextArg(pArgList); + xtype = etSTRING; + }else{ + bufpt = va_arg(ap,char*); + } + if( bufpt==0 ){ + bufpt = ""; + }else if( xtype==etDYNSTRING ){ + zExtra = bufpt; + } + if( precision>=0 ){ + for(length=0; lengthetBUFSIZE ){ + bufpt = zExtra = sqlite3Malloc( n ); + if( bufpt==0 ){ + setStrAccumError(pAccum, STRACCUM_NOMEM); + return; + } + }else{ + bufpt = buf; + } + j = 0; + if( needQuote ) bufpt[j++] = q; + k = i; + for(i=0; i=0 && precisionn ){ + sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n); + } + length = width = 0; + break; + } + case etSRCLIST: { + SrcList *pSrc = va_arg(ap, SrcList*); + int k = va_arg(ap, int); + struct SrcList_item *pItem = &pSrc->a[k]; + assert( bArgList==0 ); + assert( k>=0 && knSrc ); + if( pItem->zDatabase ){ + sqlite3StrAccumAppendAll(pAccum, pItem->zDatabase); + sqlite3StrAccumAppend(pAccum, ".", 1); + } + sqlite3StrAccumAppendAll(pAccum, pItem->zName); + length = width = 0; + break; + } + default: { + assert( xtype==etINVALID ); + return; + } + }/* End switch over the format type */ + /* + ** The text of the conversion is pointed to by "bufpt" and is + ** "length" characters long. The field width is "width". Do + ** the output. + */ + width -= length; + if( width>0 && !flag_leftjustify ) sqlite3AppendChar(pAccum, width, ' '); + sqlite3StrAccumAppend(pAccum, bufpt, length); + if( width>0 && flag_leftjustify ) sqlite3AppendChar(pAccum, width, ' '); + + if( zExtra ){ + sqlite3_free(zExtra); + zExtra = 0; + } + }/* End for loop over the format string */ +} /* End of function */ + +/* +** Enlarge the memory allocation on a StrAccum object so that it is +** able to accept at least N more bytes of text. +** +** Return the number of bytes of text that StrAccum is able to accept +** after the attempted enlargement. The value returned might be zero. +*/ +static int sqlite3StrAccumEnlarge(StrAccum *p, int N){ + char *zNew; + assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */ + if( p->accError ){ + testcase(p->accError==STRACCUM_TOOBIG); + testcase(p->accError==STRACCUM_NOMEM); + return 0; + } + if( p->mxAlloc==0 ){ + N = p->nAlloc - p->nChar - 1; + setStrAccumError(p, STRACCUM_TOOBIG); + return N; + }else{ + char *zOld = (p->zText==p->zBase ? 0 : p->zText); + i64 szNew = p->nChar; + szNew += N + 1; + if( szNew+p->nChar<=p->mxAlloc ){ + /* Force exponential buffer size growth as long as it does not overflow, + ** to avoid having to call this routine too often */ + szNew += p->nChar; + } + if( szNew > p->mxAlloc ){ + sqlite3StrAccumReset(p); + setStrAccumError(p, STRACCUM_TOOBIG); + return 0; + }else{ + p->nAlloc = (int)szNew; + } + if( p->db ){ + zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc); + }else{ + zNew = sqlite3_realloc64(zOld, p->nAlloc); + } + if( zNew ){ + assert( p->zText!=0 || p->nChar==0 ); + if( zOld==0 && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar); + p->zText = zNew; + p->nAlloc = sqlite3DbMallocSize(p->db, zNew); + }else{ + sqlite3StrAccumReset(p); + setStrAccumError(p, STRACCUM_NOMEM); + return 0; + } + } + return N; +} + +/* +** Append N copies of character c to the given string buffer. +*/ +SQLITE_PRIVATE void sqlite3AppendChar(StrAccum *p, int N, char c){ + testcase( p->nChar + (i64)N > 0x7fffffff ); + if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){ + return; + } + while( (N--)>0 ) p->zText[p->nChar++] = c; +} + +/* +** The StrAccum "p" is not large enough to accept N new bytes of z[]. +** So enlarge if first, then do the append. +** +** This is a helper routine to sqlite3StrAccumAppend() that does special-case +** work (enlarging the buffer) using tail recursion, so that the +** sqlite3StrAccumAppend() routine can use fast calling semantics. +*/ +static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){ + N = sqlite3StrAccumEnlarge(p, N); + if( N>0 ){ + memcpy(&p->zText[p->nChar], z, N); + p->nChar += N; + } +} + +/* +** Append N bytes of text from z to the StrAccum object. Increase the +** size of the memory allocation for StrAccum if necessary. +*/ +SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){ + assert( z!=0 || N==0 ); + assert( p->zText!=0 || p->nChar==0 || p->accError ); + assert( N>=0 ); + assert( p->accError==0 || p->nAlloc==0 ); + if( p->nChar+N >= p->nAlloc ){ + enlargeAndAppend(p,z,N); + }else{ + assert( p->zText ); + p->nChar += N; + memcpy(&p->zText[p->nChar-N], z, N); + } +} + +/* +** Append the complete text of zero-terminated string z[] to the p string. +*/ +SQLITE_PRIVATE void sqlite3StrAccumAppendAll(StrAccum *p, const char *z){ + sqlite3StrAccumAppend(p, z, sqlite3Strlen30(z)); +} + + +/* +** Finish off a string by making sure it is zero-terminated. +** Return a pointer to the resulting string. Return a NULL +** pointer if any kind of error was encountered. +*/ +SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){ + if( p->zText ){ + p->zText[p->nChar] = 0; + if( p->mxAlloc>0 && p->zText==p->zBase ){ + p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 ); + if( p->zText ){ + memcpy(p->zText, p->zBase, p->nChar+1); + }else{ + setStrAccumError(p, STRACCUM_NOMEM); + } + } + } + return p->zText; +} + +/* +** Reset an StrAccum string. Reclaim all malloced memory. +*/ +SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum *p){ + if( p->zText!=p->zBase ){ + sqlite3DbFree(p->db, p->zText); + } + p->zText = 0; +} + +/* +** Initialize a string accumulator. +** +** p: The accumulator to be initialized. +** db: Pointer to a database connection. May be NULL. Lookaside +** memory is used if not NULL. db->mallocFailed is set appropriately +** when not NULL. +** zBase: An initial buffer. May be NULL in which case the initial buffer +** is malloced. +** n: Size of zBase in bytes. If total space requirements never exceed +** n then no memory allocations ever occur. +** mx: Maximum number of bytes to accumulate. If mx==0 then no memory +** allocations will ever occur. +*/ +SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, int n, int mx){ + p->zText = p->zBase = zBase; + p->db = db; + p->nChar = 0; + p->nAlloc = n; + p->mxAlloc = mx; + p->accError = 0; +} + +/* +** Print into memory obtained from sqliteMalloc(). Use the internal +** %-conversion extensions. +*/ +SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){ + char *z; + char zBase[SQLITE_PRINT_BUF_SIZE]; + StrAccum acc; + assert( db!=0 ); + sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase), + db->aLimit[SQLITE_LIMIT_LENGTH]); + sqlite3VXPrintf(&acc, SQLITE_PRINTF_INTERNAL, zFormat, ap); + z = sqlite3StrAccumFinish(&acc); + if( acc.accError==STRACCUM_NOMEM ){ + db->mallocFailed = 1; + } + return z; +} + +/* +** Print into memory obtained from sqliteMalloc(). Use the internal +** %-conversion extensions. +*/ +SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){ + va_list ap; + char *z; + va_start(ap, zFormat); + z = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + return z; +} + +/* +** Print into memory obtained from sqlite3_malloc(). Omit the internal +** %-conversion extensions. +*/ +SQLITE_API char *SQLITE_STDCALL sqlite3_vmprintf(const char *zFormat, va_list ap){ + char *z; + char zBase[SQLITE_PRINT_BUF_SIZE]; + StrAccum acc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( zFormat==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + sqlite3StrAccumInit(&acc, 0, zBase, sizeof(zBase), SQLITE_MAX_LENGTH); + sqlite3VXPrintf(&acc, 0, zFormat, ap); + z = sqlite3StrAccumFinish(&acc); + return z; +} + +/* +** Print into memory obtained from sqlite3_malloc()(). Omit the internal +** %-conversion extensions. +*/ +SQLITE_API char *SQLITE_CDECL sqlite3_mprintf(const char *zFormat, ...){ + va_list ap; + char *z; +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + va_start(ap, zFormat); + z = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + return z; +} + +/* +** sqlite3_snprintf() works like snprintf() except that it ignores the +** current locale settings. This is important for SQLite because we +** are not able to use a "," as the decimal point in place of "." as +** specified by some locales. +** +** Oops: The first two arguments of sqlite3_snprintf() are backwards +** from the snprintf() standard. Unfortunately, it is too late to change +** this without breaking compatibility, so we just have to live with the +** mistake. +** +** sqlite3_vsnprintf() is the varargs version. +*/ +SQLITE_API char *SQLITE_STDCALL sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){ + StrAccum acc; + if( n<=0 ) return zBuf; +#ifdef SQLITE_ENABLE_API_ARMOR + if( zBuf==0 || zFormat==0 ) { + (void)SQLITE_MISUSE_BKPT; + if( zBuf ) zBuf[0] = 0; + return zBuf; + } +#endif + sqlite3StrAccumInit(&acc, 0, zBuf, n, 0); + sqlite3VXPrintf(&acc, 0, zFormat, ap); + return sqlite3StrAccumFinish(&acc); +} +SQLITE_API char *SQLITE_CDECL sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){ + char *z; + va_list ap; + va_start(ap,zFormat); + z = sqlite3_vsnprintf(n, zBuf, zFormat, ap); + va_end(ap); + return z; +} + +/* +** This is the routine that actually formats the sqlite3_log() message. +** We house it in a separate routine from sqlite3_log() to avoid using +** stack space on small-stack systems when logging is disabled. +** +** sqlite3_log() must render into a static buffer. It cannot dynamically +** allocate memory because it might be called while the memory allocator +** mutex is held. +** +** sqlite3VXPrintf() might ask for *temporary* memory allocations for +** certain format characters (%q) or for very large precisions or widths. +** Care must be taken that any sqlite3_log() calls that occur while the +** memory mutex is held do not use these mechanisms. +*/ +static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){ + StrAccum acc; /* String accumulator */ + char zMsg[SQLITE_PRINT_BUF_SIZE*3]; /* Complete log message */ + + sqlite3StrAccumInit(&acc, 0, zMsg, sizeof(zMsg), 0); + sqlite3VXPrintf(&acc, 0, zFormat, ap); + sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode, + sqlite3StrAccumFinish(&acc)); +} + +/* +** Format and write a message to the log if logging is enabled. +*/ +SQLITE_API void SQLITE_CDECL sqlite3_log(int iErrCode, const char *zFormat, ...){ + va_list ap; /* Vararg list */ + if( sqlite3GlobalConfig.xLog ){ + va_start(ap, zFormat); + renderLogMsg(iErrCode, zFormat, ap); + va_end(ap); + } +} + +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) +/* +** A version of printf() that understands %lld. Used for debugging. +** The printf() built into some versions of windows does not understand %lld +** and segfaults if you give it a long long int. +*/ +SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){ + va_list ap; + StrAccum acc; + char zBuf[500]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + va_start(ap,zFormat); + sqlite3VXPrintf(&acc, 0, zFormat, ap); + va_end(ap); + sqlite3StrAccumFinish(&acc); + fprintf(stdout,"%s", zBuf); + fflush(stdout); +} +#endif + + +/* +** variable-argument wrapper around sqlite3VXPrintf(). The bFlags argument +** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats. +*/ +SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, u32 bFlags, const char *zFormat, ...){ + va_list ap; + va_start(ap,zFormat); + sqlite3VXPrintf(p, bFlags, zFormat, ap); + va_end(ap); +} + +/************** End of printf.c **********************************************/ +/************** Begin file treeview.c ****************************************/ +/* +** 2015-06-08 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains C code to implement the TreeView debugging routines. +** These routines print a parse tree to standard output for debugging and +** analysis. +** +** The interfaces in this file is only available when compiling +** with SQLITE_DEBUG. +*/ +/* #include "sqliteInt.h" */ +#ifdef SQLITE_DEBUG + +/* +** Add a new subitem to the tree. The moreToFollow flag indicates that this +** is not the last item in the tree. +*/ +static TreeView *sqlite3TreeViewPush(TreeView *p, u8 moreToFollow){ + if( p==0 ){ + p = sqlite3_malloc64( sizeof(*p) ); + if( p==0 ) return 0; + memset(p, 0, sizeof(*p)); + }else{ + p->iLevel++; + } + assert( moreToFollow==0 || moreToFollow==1 ); + if( p->iLevelbLine) ) p->bLine[p->iLevel] = moreToFollow; + return p; +} + +/* +** Finished with one layer of the tree +*/ +static void sqlite3TreeViewPop(TreeView *p){ + if( p==0 ) return; + p->iLevel--; + if( p->iLevel<0 ) sqlite3_free(p); +} + +/* +** Generate a single line of output for the tree, with a prefix that contains +** all the appropriate tree lines +*/ +static void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){ + va_list ap; + int i; + StrAccum acc; + char zBuf[500]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + if( p ){ + for(i=0; iiLevel && ibLine)-1; i++){ + sqlite3StrAccumAppend(&acc, p->bLine[i] ? "| " : " ", 4); + } + sqlite3StrAccumAppend(&acc, p->bLine[i] ? "|-- " : "'-- ", 4); + } + va_start(ap, zFormat); + sqlite3VXPrintf(&acc, 0, zFormat, ap); + va_end(ap); + if( zBuf[acc.nChar-1]!='\n' ) sqlite3StrAccumAppend(&acc, "\n", 1); + sqlite3StrAccumFinish(&acc); + fprintf(stdout,"%s", zBuf); + fflush(stdout); +} + +/* +** Shorthand for starting a new tree item that consists of a single label +*/ +static void sqlite3TreeViewItem(TreeView *p, const char *zLabel,u8 moreFollows){ + p = sqlite3TreeViewPush(p, moreFollows); + sqlite3TreeViewLine(p, "%s", zLabel); +} + + +/* +** Generate a human-readable description of a the Select object. +*/ +SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){ + int n = 0; + int cnt = 0; + pView = sqlite3TreeViewPush(pView, moreToFollow); + do{ + sqlite3TreeViewLine(pView, "SELECT%s%s (0x%p) selFlags=0x%x", + ((p->selFlags & SF_Distinct) ? " DISTINCT" : ""), + ((p->selFlags & SF_Aggregate) ? " agg_flag" : ""), p, p->selFlags + ); + if( cnt++ ) sqlite3TreeViewPop(pView); + if( p->pPrior ){ + n = 1000; + }else{ + n = 0; + if( p->pSrc && p->pSrc->nSrc ) n++; + if( p->pWhere ) n++; + if( p->pGroupBy ) n++; + if( p->pHaving ) n++; + if( p->pOrderBy ) n++; + if( p->pLimit ) n++; + if( p->pOffset ) n++; + } + sqlite3TreeViewExprList(pView, p->pEList, (n--)>0, "result-set"); + if( p->pSrc && p->pSrc->nSrc ){ + int i; + pView = sqlite3TreeViewPush(pView, (n--)>0); + sqlite3TreeViewLine(pView, "FROM"); + for(i=0; ipSrc->nSrc; i++){ + struct SrcList_item *pItem = &p->pSrc->a[i]; + StrAccum x; + char zLine[100]; + sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0); + sqlite3XPrintf(&x, 0, "{%d,*}", pItem->iCursor); + if( pItem->zDatabase ){ + sqlite3XPrintf(&x, 0, " %s.%s", pItem->zDatabase, pItem->zName); + }else if( pItem->zName ){ + sqlite3XPrintf(&x, 0, " %s", pItem->zName); + } + if( pItem->pTab ){ + sqlite3XPrintf(&x, 0, " tabname=%Q", pItem->pTab->zName); + } + if( pItem->zAlias ){ + sqlite3XPrintf(&x, 0, " (AS %s)", pItem->zAlias); + } + if( pItem->fg.jointype & JT_LEFT ){ + sqlite3XPrintf(&x, 0, " LEFT-JOIN"); + } + sqlite3StrAccumFinish(&x); + sqlite3TreeViewItem(pView, zLine, ipSrc->nSrc-1); + if( pItem->pSelect ){ + sqlite3TreeViewSelect(pView, pItem->pSelect, 0); + } + if( pItem->fg.isTabFunc ){ + sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:"); + } + sqlite3TreeViewPop(pView); + } + sqlite3TreeViewPop(pView); + } + if( p->pWhere ){ + sqlite3TreeViewItem(pView, "WHERE", (n--)>0); + sqlite3TreeViewExpr(pView, p->pWhere, 0); + sqlite3TreeViewPop(pView); + } + if( p->pGroupBy ){ + sqlite3TreeViewExprList(pView, p->pGroupBy, (n--)>0, "GROUPBY"); + } + if( p->pHaving ){ + sqlite3TreeViewItem(pView, "HAVING", (n--)>0); + sqlite3TreeViewExpr(pView, p->pHaving, 0); + sqlite3TreeViewPop(pView); + } + if( p->pOrderBy ){ + sqlite3TreeViewExprList(pView, p->pOrderBy, (n--)>0, "ORDERBY"); + } + if( p->pLimit ){ + sqlite3TreeViewItem(pView, "LIMIT", (n--)>0); + sqlite3TreeViewExpr(pView, p->pLimit, 0); + sqlite3TreeViewPop(pView); + } + if( p->pOffset ){ + sqlite3TreeViewItem(pView, "OFFSET", (n--)>0); + sqlite3TreeViewExpr(pView, p->pOffset, 0); + sqlite3TreeViewPop(pView); + } + if( p->pPrior ){ + const char *zOp = "UNION"; + switch( p->op ){ + case TK_ALL: zOp = "UNION ALL"; break; + case TK_INTERSECT: zOp = "INTERSECT"; break; + case TK_EXCEPT: zOp = "EXCEPT"; break; + } + sqlite3TreeViewItem(pView, zOp, 1); + } + p = p->pPrior; + }while( p!=0 ); + sqlite3TreeViewPop(pView); +} + +/* +** Generate a human-readable explanation of an expression tree. +*/ +SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){ + const char *zBinOp = 0; /* Binary operator */ + const char *zUniOp = 0; /* Unary operator */ + char zFlgs[30]; + pView = sqlite3TreeViewPush(pView, moreToFollow); + if( pExpr==0 ){ + sqlite3TreeViewLine(pView, "nil"); + sqlite3TreeViewPop(pView); + return; + } + if( pExpr->flags ){ + sqlite3_snprintf(sizeof(zFlgs),zFlgs," flags=0x%x",pExpr->flags); + }else{ + zFlgs[0] = 0; + } + switch( pExpr->op ){ + case TK_AGG_COLUMN: { + sqlite3TreeViewLine(pView, "AGG{%d:%d}%s", + pExpr->iTable, pExpr->iColumn, zFlgs); + break; + } + case TK_COLUMN: { + if( pExpr->iTable<0 ){ + /* This only happens when coding check constraints */ + sqlite3TreeViewLine(pView, "COLUMN(%d)%s", pExpr->iColumn, zFlgs); + }else{ + sqlite3TreeViewLine(pView, "{%d:%d}%s", + pExpr->iTable, pExpr->iColumn, zFlgs); + } + break; + } + case TK_INTEGER: { + if( pExpr->flags & EP_IntValue ){ + sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue); + }else{ + sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken); + } + break; + } +#ifndef SQLITE_OMIT_FLOATING_POINT + case TK_FLOAT: { + sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); + break; + } +#endif + case TK_STRING: { + sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken); + break; + } + case TK_NULL: { + sqlite3TreeViewLine(pView,"NULL"); + break; + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + case TK_BLOB: { + sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); + break; + } +#endif + case TK_VARIABLE: { + sqlite3TreeViewLine(pView,"VARIABLE(%s,%d)", + pExpr->u.zToken, pExpr->iColumn); + break; + } + case TK_REGISTER: { + sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable); + break; + } + case TK_ID: { + sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken); + break; + } +#ifndef SQLITE_OMIT_CAST + case TK_CAST: { + /* Expressions of the form: CAST(pLeft AS token) */ + sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + break; + } +#endif /* SQLITE_OMIT_CAST */ + case TK_LT: zBinOp = "LT"; break; + case TK_LE: zBinOp = "LE"; break; + case TK_GT: zBinOp = "GT"; break; + case TK_GE: zBinOp = "GE"; break; + case TK_NE: zBinOp = "NE"; break; + case TK_EQ: zBinOp = "EQ"; break; + case TK_IS: zBinOp = "IS"; break; + case TK_ISNOT: zBinOp = "ISNOT"; break; + case TK_AND: zBinOp = "AND"; break; + case TK_OR: zBinOp = "OR"; break; + case TK_PLUS: zBinOp = "ADD"; break; + case TK_STAR: zBinOp = "MUL"; break; + case TK_MINUS: zBinOp = "SUB"; break; + case TK_REM: zBinOp = "REM"; break; + case TK_BITAND: zBinOp = "BITAND"; break; + case TK_BITOR: zBinOp = "BITOR"; break; + case TK_SLASH: zBinOp = "DIV"; break; + case TK_LSHIFT: zBinOp = "LSHIFT"; break; + case TK_RSHIFT: zBinOp = "RSHIFT"; break; + case TK_CONCAT: zBinOp = "CONCAT"; break; + case TK_DOT: zBinOp = "DOT"; break; + + case TK_UMINUS: zUniOp = "UMINUS"; break; + case TK_UPLUS: zUniOp = "UPLUS"; break; + case TK_BITNOT: zUniOp = "BITNOT"; break; + case TK_NOT: zUniOp = "NOT"; break; + case TK_ISNULL: zUniOp = "ISNULL"; break; + case TK_NOTNULL: zUniOp = "NOTNULL"; break; + + case TK_COLLATE: { + sqlite3TreeViewLine(pView, "COLLATE %Q", pExpr->u.zToken); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + break; + } + + case TK_AGG_FUNCTION: + case TK_FUNCTION: { + ExprList *pFarg; /* List of function arguments */ + if( ExprHasProperty(pExpr, EP_TokenOnly) ){ + pFarg = 0; + }else{ + pFarg = pExpr->x.pList; + } + if( pExpr->op==TK_AGG_FUNCTION ){ + sqlite3TreeViewLine(pView, "AGG_FUNCTION%d %Q", + pExpr->op2, pExpr->u.zToken); + }else{ + sqlite3TreeViewLine(pView, "FUNCTION %Q", pExpr->u.zToken); + } + if( pFarg ){ + sqlite3TreeViewExprList(pView, pFarg, 0, 0); + } + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_EXISTS: { + sqlite3TreeViewLine(pView, "EXISTS-expr"); + sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); + break; + } + case TK_SELECT: { + sqlite3TreeViewLine(pView, "SELECT-expr"); + sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); + break; + } + case TK_IN: { + sqlite3TreeViewLine(pView, "IN"); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); + }else{ + sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); + } + break; + } +#endif /* SQLITE_OMIT_SUBQUERY */ + + /* + ** x BETWEEN y AND z + ** + ** This is equivalent to + ** + ** x>=y AND x<=z + ** + ** X is stored in pExpr->pLeft. + ** Y is stored in pExpr->pList->a[0].pExpr. + ** Z is stored in pExpr->pList->a[1].pExpr. + */ + case TK_BETWEEN: { + Expr *pX = pExpr->pLeft; + Expr *pY = pExpr->x.pList->a[0].pExpr; + Expr *pZ = pExpr->x.pList->a[1].pExpr; + sqlite3TreeViewLine(pView, "BETWEEN"); + sqlite3TreeViewExpr(pView, pX, 1); + sqlite3TreeViewExpr(pView, pY, 1); + sqlite3TreeViewExpr(pView, pZ, 0); + break; + } + case TK_TRIGGER: { + /* If the opcode is TK_TRIGGER, then the expression is a reference + ** to a column in the new.* or old.* pseudo-tables available to + ** trigger programs. In this case Expr.iTable is set to 1 for the + ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn + ** is set to the column of the pseudo-table to read, or to -1 to + ** read the rowid field. + */ + sqlite3TreeViewLine(pView, "%s(%d)", + pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn); + break; + } + case TK_CASE: { + sqlite3TreeViewLine(pView, "CASE"); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); + sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); + break; + } +#ifndef SQLITE_OMIT_TRIGGER + case TK_RAISE: { + const char *zType = "unk"; + switch( pExpr->affinity ){ + case OE_Rollback: zType = "rollback"; break; + case OE_Abort: zType = "abort"; break; + case OE_Fail: zType = "fail"; break; + case OE_Ignore: zType = "ignore"; break; + } + sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken); + break; + } +#endif + default: { + sqlite3TreeViewLine(pView, "op=%d", pExpr->op); + break; + } + } + if( zBinOp ){ + sqlite3TreeViewLine(pView, "%s%s", zBinOp, zFlgs); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); + sqlite3TreeViewExpr(pView, pExpr->pRight, 0); + }else if( zUniOp ){ + sqlite3TreeViewLine(pView, "%s%s", zUniOp, zFlgs); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + } + sqlite3TreeViewPop(pView); +} + +/* +** Generate a human-readable explanation of an expression list. +*/ +SQLITE_PRIVATE void sqlite3TreeViewExprList( + TreeView *pView, + const ExprList *pList, + u8 moreToFollow, + const char *zLabel +){ + int i; + pView = sqlite3TreeViewPush(pView, moreToFollow); + if( zLabel==0 || zLabel[0]==0 ) zLabel = "LIST"; + if( pList==0 ){ + sqlite3TreeViewLine(pView, "%s (empty)", zLabel); + }else{ + sqlite3TreeViewLine(pView, "%s", zLabel); + for(i=0; inExpr; i++){ + int j = pList->a[i].u.x.iOrderByCol; + if( j ){ + sqlite3TreeViewPush(pView, 0); + sqlite3TreeViewLine(pView, "iOrderByCol=%d", j); + } + sqlite3TreeViewExpr(pView, pList->a[i].pExpr, inExpr-1); + if( j ) sqlite3TreeViewPop(pView); + } + } + sqlite3TreeViewPop(pView); +} + +#endif /* SQLITE_DEBUG */ + +/************** End of treeview.c ********************************************/ +/************** Begin file random.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code to implement a pseudo-random number +** generator (PRNG) for SQLite. +** +** Random numbers are used by some of the database backends in order +** to generate random integer keys for tables or random filenames. +*/ +/* #include "sqliteInt.h" */ + + +/* All threads share a single random number generator. +** This structure is the current state of the generator. +*/ +static SQLITE_WSD struct sqlite3PrngType { + unsigned char isInit; /* True if initialized */ + unsigned char i, j; /* State variables */ + unsigned char s[256]; /* State variables */ +} sqlite3Prng; + +/* +** Return N random bytes. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_randomness(int N, void *pBuf){ + unsigned char t; + unsigned char *zBuf = pBuf; + + /* The "wsdPrng" macro will resolve to the pseudo-random number generator + ** state vector. If writable static data is unsupported on the target, + ** we have to locate the state vector at run-time. In the more common + ** case where writable static data is supported, wsdPrng can refer directly + ** to the "sqlite3Prng" state vector declared above. + */ +#ifdef SQLITE_OMIT_WSD + struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng); +# define wsdPrng p[0] +#else +# define wsdPrng sqlite3Prng +#endif + +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex; +#endif + +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return; +#endif + +#if SQLITE_THREADSAFE + mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG); +#endif + + sqlite3_mutex_enter(mutex); + if( N<=0 || pBuf==0 ){ + wsdPrng.isInit = 0; + sqlite3_mutex_leave(mutex); + return; + } + + /* Initialize the state of the random number generator once, + ** the first time this routine is called. The seed value does + ** not need to contain a lot of randomness since we are not + ** trying to do secure encryption or anything like that... + ** + ** Nothing in this file or anywhere else in SQLite does any kind of + ** encryption. The RC4 algorithm is being used as a PRNG (pseudo-random + ** number generator) not as an encryption device. + */ + if( !wsdPrng.isInit ){ + int i; + char k[256]; + wsdPrng.j = 0; + wsdPrng.i = 0; + sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k); + for(i=0; i<256; i++){ + wsdPrng.s[i] = (u8)i; + } + for(i=0; i<256; i++){ + wsdPrng.j += wsdPrng.s[i] + k[i]; + t = wsdPrng.s[wsdPrng.j]; + wsdPrng.s[wsdPrng.j] = wsdPrng.s[i]; + wsdPrng.s[i] = t; + } + wsdPrng.isInit = 1; + } + + assert( N>0 ); + do{ + wsdPrng.i++; + t = wsdPrng.s[wsdPrng.i]; + wsdPrng.j += t; + wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j]; + wsdPrng.s[wsdPrng.j] = t; + t += wsdPrng.s[wsdPrng.i]; + *(zBuf++) = wsdPrng.s[t]; + }while( --N ); + sqlite3_mutex_leave(mutex); +} + +#ifndef SQLITE_OMIT_BUILTIN_TEST +/* +** For testing purposes, we sometimes want to preserve the state of +** PRNG and restore the PRNG to its saved state at a later time, or +** to reset the PRNG to its initial state. These routines accomplish +** those tasks. +** +** The sqlite3_test_control() interface calls these routines to +** control the PRNG. +*/ +static SQLITE_WSD struct sqlite3PrngType sqlite3SavedPrng; +SQLITE_PRIVATE void sqlite3PrngSaveState(void){ + memcpy( + &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng), + &GLOBAL(struct sqlite3PrngType, sqlite3Prng), + sizeof(sqlite3Prng) + ); +} +SQLITE_PRIVATE void sqlite3PrngRestoreState(void){ + memcpy( + &GLOBAL(struct sqlite3PrngType, sqlite3Prng), + &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng), + sizeof(sqlite3Prng) + ); +} +#endif /* SQLITE_OMIT_BUILTIN_TEST */ + +/************** End of random.c **********************************************/ +/************** Begin file threads.c *****************************************/ +/* +** 2012 July 21 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file presents a simple cross-platform threading interface for +** use internally by SQLite. +** +** A "thread" can be created using sqlite3ThreadCreate(). This thread +** runs independently of its creator until it is joined using +** sqlite3ThreadJoin(), at which point it terminates. +** +** Threads do not have to be real. It could be that the work of the +** "thread" is done by the main thread at either the sqlite3ThreadCreate() +** or sqlite3ThreadJoin() call. This is, in fact, what happens in +** single threaded systems. Nothing in SQLite requires multiple threads. +** This interface exists so that applications that want to take advantage +** of multiple cores can do so, while also allowing applications to stay +** single-threaded if desired. +*/ +/* #include "sqliteInt.h" */ +#if SQLITE_OS_WIN +/* # include "os_win.h" */ +#endif + +#if SQLITE_MAX_WORKER_THREADS>0 + +/********************************* Unix Pthreads ****************************/ +#if SQLITE_OS_UNIX && defined(SQLITE_MUTEX_PTHREADS) && SQLITE_THREADSAFE>0 + +#define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */ +/* #include */ + +/* A running thread */ +struct SQLiteThread { + pthread_t tid; /* Thread ID */ + int done; /* Set to true when thread finishes */ + void *pOut; /* Result returned by the thread */ + void *(*xTask)(void*); /* The thread routine */ + void *pIn; /* Argument to the thread */ +}; + +/* Create a new thread */ +SQLITE_PRIVATE int sqlite3ThreadCreate( + SQLiteThread **ppThread, /* OUT: Write the thread object here */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + SQLiteThread *p; + int rc; + + assert( ppThread!=0 ); + assert( xTask!=0 ); + /* This routine is never used in single-threaded mode */ + assert( sqlite3GlobalConfig.bCoreMutex!=0 ); + + *ppThread = 0; + p = sqlite3Malloc(sizeof(*p)); + if( p==0 ) return SQLITE_NOMEM; + memset(p, 0, sizeof(*p)); + p->xTask = xTask; + p->pIn = pIn; + /* If the SQLITE_TESTCTRL_FAULT_INSTALL callback is registered to a + ** function that returns SQLITE_ERROR when passed the argument 200, that + ** forces worker threads to run sequentially and deterministically + ** for testing purposes. */ + if( sqlite3FaultSim(200) ){ + rc = 1; + }else{ + rc = pthread_create(&p->tid, 0, xTask, pIn); + } + if( rc ){ + p->done = 1; + p->pOut = xTask(pIn); + } + *ppThread = p; + return SQLITE_OK; +} + +/* Get the results of the thread */ +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ + int rc; + + assert( ppOut!=0 ); + if( NEVER(p==0) ) return SQLITE_NOMEM; + if( p->done ){ + *ppOut = p->pOut; + rc = SQLITE_OK; + }else{ + rc = pthread_join(p->tid, ppOut) ? SQLITE_ERROR : SQLITE_OK; + } + sqlite3_free(p); + return rc; +} + +#endif /* SQLITE_OS_UNIX && defined(SQLITE_MUTEX_PTHREADS) */ +/******************************** End Unix Pthreads *************************/ + + +/********************************* Win32 Threads ****************************/ +#if SQLITE_OS_WIN_THREADS + +#define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */ +#include + +/* A running thread */ +struct SQLiteThread { + void *tid; /* The thread handle */ + unsigned id; /* The thread identifier */ + void *(*xTask)(void*); /* The routine to run as a thread */ + void *pIn; /* Argument to xTask */ + void *pResult; /* Result of xTask */ +}; + +/* Thread procedure Win32 compatibility shim */ +static unsigned __stdcall sqlite3ThreadProc( + void *pArg /* IN: Pointer to the SQLiteThread structure */ +){ + SQLiteThread *p = (SQLiteThread *)pArg; + + assert( p!=0 ); +#if 0 + /* + ** This assert appears to trigger spuriously on certain + ** versions of Windows, possibly due to _beginthreadex() + ** and/or CreateThread() not fully setting their thread + ** ID parameter before starting the thread. + */ + assert( p->id==GetCurrentThreadId() ); +#endif + assert( p->xTask!=0 ); + p->pResult = p->xTask(p->pIn); + + _endthreadex(0); + return 0; /* NOT REACHED */ +} + +/* Create a new thread */ +SQLITE_PRIVATE int sqlite3ThreadCreate( + SQLiteThread **ppThread, /* OUT: Write the thread object here */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + SQLiteThread *p; + + assert( ppThread!=0 ); + assert( xTask!=0 ); + *ppThread = 0; + p = sqlite3Malloc(sizeof(*p)); + if( p==0 ) return SQLITE_NOMEM; + /* If the SQLITE_TESTCTRL_FAULT_INSTALL callback is registered to a + ** function that returns SQLITE_ERROR when passed the argument 200, that + ** forces worker threads to run sequentially and deterministically + ** (via the sqlite3FaultSim() term of the conditional) for testing + ** purposes. */ + if( sqlite3GlobalConfig.bCoreMutex==0 || sqlite3FaultSim(200) ){ + memset(p, 0, sizeof(*p)); + }else{ + p->xTask = xTask; + p->pIn = pIn; + p->tid = (void*)_beginthreadex(0, 0, sqlite3ThreadProc, p, 0, &p->id); + if( p->tid==0 ){ + memset(p, 0, sizeof(*p)); + } + } + if( p->xTask==0 ){ + p->id = GetCurrentThreadId(); + p->pResult = xTask(pIn); + } + *ppThread = p; + return SQLITE_OK; +} + +SQLITE_PRIVATE DWORD sqlite3Win32Wait(HANDLE hObject); /* os_win.c */ + +/* Get the results of the thread */ +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ + DWORD rc; + BOOL bRc; + + assert( ppOut!=0 ); + if( NEVER(p==0) ) return SQLITE_NOMEM; + if( p->xTask==0 ){ + /* assert( p->id==GetCurrentThreadId() ); */ + rc = WAIT_OBJECT_0; + assert( p->tid==0 ); + }else{ + assert( p->id!=0 && p->id!=GetCurrentThreadId() ); + rc = sqlite3Win32Wait((HANDLE)p->tid); + assert( rc!=WAIT_IO_COMPLETION ); + bRc = CloseHandle((HANDLE)p->tid); + assert( bRc ); + } + if( rc==WAIT_OBJECT_0 ) *ppOut = p->pResult; + sqlite3_free(p); + return (rc==WAIT_OBJECT_0) ? SQLITE_OK : SQLITE_ERROR; +} + +#endif /* SQLITE_OS_WIN_THREADS */ +/******************************** End Win32 Threads *************************/ + + +/********************************* Single-Threaded **************************/ +#ifndef SQLITE_THREADS_IMPLEMENTED +/* +** This implementation does not actually create a new thread. It does the +** work of the thread in the main thread, when either the thread is created +** or when it is joined +*/ + +/* A running thread */ +struct SQLiteThread { + void *(*xTask)(void*); /* The routine to run as a thread */ + void *pIn; /* Argument to xTask */ + void *pResult; /* Result of xTask */ +}; + +/* Create a new thread */ +SQLITE_PRIVATE int sqlite3ThreadCreate( + SQLiteThread **ppThread, /* OUT: Write the thread object here */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + SQLiteThread *p; + + assert( ppThread!=0 ); + assert( xTask!=0 ); + *ppThread = 0; + p = sqlite3Malloc(sizeof(*p)); + if( p==0 ) return SQLITE_NOMEM; + if( (SQLITE_PTR_TO_INT(p)/17)&1 ){ + p->xTask = xTask; + p->pIn = pIn; + }else{ + p->xTask = 0; + p->pResult = xTask(pIn); + } + *ppThread = p; + return SQLITE_OK; +} + +/* Get the results of the thread */ +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ + + assert( ppOut!=0 ); + if( NEVER(p==0) ) return SQLITE_NOMEM; + if( p->xTask ){ + *ppOut = p->xTask(p->pIn); + }else{ + *ppOut = p->pResult; + } + sqlite3_free(p); + +#if defined(SQLITE_TEST) + { + void *pTstAlloc = sqlite3Malloc(10); + if (!pTstAlloc) return SQLITE_NOMEM; + sqlite3_free(pTstAlloc); + } +#endif + + return SQLITE_OK; +} + +#endif /* !defined(SQLITE_THREADS_IMPLEMENTED) */ +/****************************** End Single-Threaded *************************/ +#endif /* SQLITE_MAX_WORKER_THREADS>0 */ + +/************** End of threads.c *********************************************/ +/************** Begin file utf.c *********************************************/ +/* +** 2004 April 13 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used to translate between UTF-8, +** UTF-16, UTF-16BE, and UTF-16LE. +** +** Notes on UTF-8: +** +** Byte-0 Byte-1 Byte-2 Byte-3 Value +** 0xxxxxxx 00000000 00000000 0xxxxxxx +** 110yyyyy 10xxxxxx 00000000 00000yyy yyxxxxxx +** 1110zzzz 10yyyyyy 10xxxxxx 00000000 zzzzyyyy yyxxxxxx +** 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx 000uuuuu zzzzyyyy yyxxxxxx +** +** +** Notes on UTF-16: (with wwww+1==uuuuu) +** +** Word-0 Word-1 Value +** 110110ww wwzzzzyy 110111yy yyxxxxxx 000uuuuu zzzzyyyy yyxxxxxx +** zzzzyyyy yyxxxxxx 00000000 zzzzyyyy yyxxxxxx +** +** +** BOM or Byte Order Mark: +** 0xff 0xfe little-endian utf-16 follows +** 0xfe 0xff big-endian utf-16 follows +** +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include "vdbeInt.h" */ + +#ifndef SQLITE_AMALGAMATION +/* +** The following constant value is used by the SQLITE_BIGENDIAN and +** SQLITE_LITTLEENDIAN macros. +*/ +SQLITE_PRIVATE const int sqlite3one = 1; +#endif /* SQLITE_AMALGAMATION */ + +/* +** This lookup table is used to help decode the first byte of +** a multi-byte UTF8 character. +*/ +static const unsigned char sqlite3Utf8Trans1[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00, +}; + + +#define WRITE_UTF8(zOut, c) { \ + if( c<0x00080 ){ \ + *zOut++ = (u8)(c&0xFF); \ + } \ + else if( c<0x00800 ){ \ + *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ + else if( c<0x10000 ){ \ + *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + }else{ \ + *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \ + *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ +} + +#define WRITE_UTF16LE(zOut, c) { \ + if( c<=0xFFFF ){ \ + *zOut++ = (u8)(c&0x00FF); \ + *zOut++ = (u8)((c>>8)&0x00FF); \ + }else{ \ + *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \ + *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \ + *zOut++ = (u8)(c&0x00FF); \ + *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \ + } \ +} + +#define WRITE_UTF16BE(zOut, c) { \ + if( c<=0xFFFF ){ \ + *zOut++ = (u8)((c>>8)&0x00FF); \ + *zOut++ = (u8)(c&0x00FF); \ + }else{ \ + *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \ + *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \ + *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \ + *zOut++ = (u8)(c&0x00FF); \ + } \ +} + +#define READ_UTF16LE(zIn, TERM, c){ \ + c = (*zIn++); \ + c += ((*zIn++)<<8); \ + if( c>=0xD800 && c<0xE000 && TERM ){ \ + int c2 = (*zIn++); \ + c2 += ((*zIn++)<<8); \ + c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); \ + } \ +} + +#define READ_UTF16BE(zIn, TERM, c){ \ + c = ((*zIn++)<<8); \ + c += (*zIn++); \ + if( c>=0xD800 && c<0xE000 && TERM ){ \ + int c2 = ((*zIn++)<<8); \ + c2 += (*zIn++); \ + c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); \ + } \ +} + +/* +** Translate a single UTF-8 character. Return the unicode value. +** +** During translation, assume that the byte that zTerm points +** is a 0x00. +** +** Write a pointer to the next unread byte back into *pzNext. +** +** Notes On Invalid UTF-8: +** +** * This routine never allows a 7-bit character (0x00 through 0x7f) to +** be encoded as a multi-byte character. Any multi-byte character that +** attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd. +** +** * This routine never allows a UTF16 surrogate value to be encoded. +** If a multi-byte character attempts to encode a value between +** 0xd800 and 0xe000 then it is rendered as 0xfffd. +** +** * Bytes in the range of 0x80 through 0xbf which occur as the first +** byte of a character are interpreted as single-byte characters +** and rendered as themselves even though they are technically +** invalid characters. +** +** * This routine accepts over-length UTF8 encodings +** for unicode values 0x80 and greater. It does not change over-length +** encodings to 0xfffd as some systems recommend. +*/ +#define READ_UTF8(zIn, zTerm, c) \ + c = *(zIn++); \ + if( c>=0xc0 ){ \ + c = sqlite3Utf8Trans1[c-0xc0]; \ + while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \ + c = (c<<6) + (0x3f & *(zIn++)); \ + } \ + if( c<0x80 \ + || (c&0xFFFFF800)==0xD800 \ + || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ + } +SQLITE_PRIVATE u32 sqlite3Utf8Read( + const unsigned char **pz /* Pointer to string from which to read char */ +){ + unsigned int c; + + /* Same as READ_UTF8() above but without the zTerm parameter. + ** For this routine, we assume the UTF8 string is always zero-terminated. + */ + c = *((*pz)++); + if( c>=0xc0 ){ + c = sqlite3Utf8Trans1[c-0xc0]; + while( (*(*pz) & 0xc0)==0x80 ){ + c = (c<<6) + (0x3f & *((*pz)++)); + } + if( c<0x80 + || (c&0xFFFFF800)==0xD800 + || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } + } + return c; +} + + + + +/* +** If the TRANSLATE_TRACE macro is defined, the value of each Mem is +** printed on stderr on the way into and out of sqlite3VdbeMemTranslate(). +*/ +/* #define TRANSLATE_TRACE 1 */ + +#ifndef SQLITE_OMIT_UTF16 +/* +** This routine transforms the internal text encoding used by pMem to +** desiredEnc. It is an error if the string is already of the desired +** encoding, or if *pMem does not contain a string value. +*/ +SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){ + int len; /* Maximum length of output string in bytes */ + unsigned char *zOut; /* Output buffer */ + unsigned char *zIn; /* Input iterator */ + unsigned char *zTerm; /* End of input */ + unsigned char *z; /* Output iterator */ + unsigned int c; + + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( pMem->flags&MEM_Str ); + assert( pMem->enc!=desiredEnc ); + assert( pMem->enc!=0 ); + assert( pMem->n>=0 ); + +#if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG) + { + char zBuf[100]; + sqlite3VdbeMemPrettyPrint(pMem, zBuf); + fprintf(stderr, "INPUT: %s\n", zBuf); + } +#endif + + /* If the translation is between UTF-16 little and big endian, then + ** all that is required is to swap the byte order. This case is handled + ** differently from the others. + */ + if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){ + u8 temp; + int rc; + rc = sqlite3VdbeMemMakeWriteable(pMem); + if( rc!=SQLITE_OK ){ + assert( rc==SQLITE_NOMEM ); + return SQLITE_NOMEM; + } + zIn = (u8*)pMem->z; + zTerm = &zIn[pMem->n&~1]; + while( zInenc = desiredEnc; + goto translate_out; + } + + /* Set len to the maximum number of bytes required in the output buffer. */ + if( desiredEnc==SQLITE_UTF8 ){ + /* When converting from UTF-16, the maximum growth results from + ** translating a 2-byte character to a 4-byte UTF-8 character. + ** A single byte is required for the output string + ** nul-terminator. + */ + pMem->n &= ~1; + len = pMem->n * 2 + 1; + }else{ + /* When converting from UTF-8 to UTF-16 the maximum growth is caused + ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16 + ** character. Two bytes are required in the output buffer for the + ** nul-terminator. + */ + len = pMem->n * 2 + 2; + } + + /* Set zIn to point at the start of the input buffer and zTerm to point 1 + ** byte past the end. + ** + ** Variable zOut is set to point at the output buffer, space obtained + ** from sqlite3_malloc(). + */ + zIn = (u8*)pMem->z; + zTerm = &zIn[pMem->n]; + zOut = sqlite3DbMallocRaw(pMem->db, len); + if( !zOut ){ + return SQLITE_NOMEM; + } + z = zOut; + + if( pMem->enc==SQLITE_UTF8 ){ + if( desiredEnc==SQLITE_UTF16LE ){ + /* UTF-8 -> UTF-16 Little-endian */ + while( zIn UTF-16 Big-endian */ + while( zInn = (int)(z - zOut); + *z++ = 0; + }else{ + assert( desiredEnc==SQLITE_UTF8 ); + if( pMem->enc==SQLITE_UTF16LE ){ + /* UTF-16 Little-endian -> UTF-8 */ + while( zIn UTF-8 */ + while( zInn = (int)(z - zOut); + } + *z = 0; + assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len ); + + c = pMem->flags; + sqlite3VdbeMemRelease(pMem); + pMem->flags = MEM_Str|MEM_Term|(c&MEM_AffMask); + pMem->enc = desiredEnc; + pMem->z = (char*)zOut; + pMem->zMalloc = pMem->z; + pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->z); + +translate_out: +#if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG) + { + char zBuf[100]; + sqlite3VdbeMemPrettyPrint(pMem, zBuf); + fprintf(stderr, "OUTPUT: %s\n", zBuf); + } +#endif + return SQLITE_OK; +} + +/* +** This routine checks for a byte-order mark at the beginning of the +** UTF-16 string stored in *pMem. If one is present, it is removed and +** the encoding of the Mem adjusted. This routine does not do any +** byte-swapping, it just sets Mem.enc appropriately. +** +** The allocation (static, dynamic etc.) and encoding of the Mem may be +** changed by this function. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem){ + int rc = SQLITE_OK; + u8 bom = 0; + + assert( pMem->n>=0 ); + if( pMem->n>1 ){ + u8 b1 = *(u8 *)pMem->z; + u8 b2 = *(((u8 *)pMem->z) + 1); + if( b1==0xFE && b2==0xFF ){ + bom = SQLITE_UTF16BE; + } + if( b1==0xFF && b2==0xFE ){ + bom = SQLITE_UTF16LE; + } + } + + if( bom ){ + rc = sqlite3VdbeMemMakeWriteable(pMem); + if( rc==SQLITE_OK ){ + pMem->n -= 2; + memmove(pMem->z, &pMem->z[2], pMem->n); + pMem->z[pMem->n] = '\0'; + pMem->z[pMem->n+1] = '\0'; + pMem->flags |= MEM_Term; + pMem->enc = bom; + } + } + return rc; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** pZ is a UTF-8 encoded unicode string. If nByte is less than zero, +** return the number of unicode characters in pZ up to (but not including) +** the first 0x00 byte. If nByte is not less than zero, return the +** number of unicode characters in the first nByte of pZ (or up to +** the first 0x00, whichever comes first). +*/ +SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *zIn, int nByte){ + int r = 0; + const u8 *z = (const u8*)zIn; + const u8 *zTerm; + if( nByte>=0 ){ + zTerm = &z[nByte]; + }else{ + zTerm = (const u8*)(-1); + } + assert( z<=zTerm ); + while( *z!=0 && zmallocFailed ){ + sqlite3VdbeMemRelease(&m); + m.z = 0; + } + assert( (m.flags & MEM_Term)!=0 || db->mallocFailed ); + assert( (m.flags & MEM_Str)!=0 || db->mallocFailed ); + assert( m.z || db->mallocFailed ); + return m.z; +} + +/* +** zIn is a UTF-16 encoded unicode string at least nChar characters long. +** Return the number of bytes in the first nChar unicode characters +** in pZ. nChar must be non-negative. +*/ +SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nChar){ + int c; + unsigned char const *z = zIn; + int n = 0; + + if( SQLITE_UTF16NATIVE==SQLITE_UTF16BE ){ + while( n0 && n<=4 ); + z[0] = 0; + z = zBuf; + c = sqlite3Utf8Read((const u8**)&z); + t = i; + if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD; + if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD; + assert( c==t ); + assert( (z-zBuf)==n ); + } + for(i=0; i<0x00110000; i++){ + if( i>=0xD800 && i<0xE000 ) continue; + z = zBuf; + WRITE_UTF16LE(z, i); + n = (int)(z-zBuf); + assert( n>0 && n<=4 ); + z[0] = 0; + z = zBuf; + READ_UTF16LE(z, 1, c); + assert( c==i ); + assert( (z-zBuf)==n ); + } + for(i=0; i<0x00110000; i++){ + if( i>=0xD800 && i<0xE000 ) continue; + z = zBuf; + WRITE_UTF16BE(z, i); + n = (int)(z-zBuf); + assert( n>0 && n<=4 ); + z[0] = 0; + z = zBuf; + READ_UTF16BE(z, 1, c); + assert( c==i ); + assert( (z-zBuf)==n ); + } +} +#endif /* SQLITE_TEST */ +#endif /* SQLITE_OMIT_UTF16 */ + +/************** End of utf.c *************************************************/ +/************** Begin file util.c ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Utility functions used throughout sqlite. +** +** This file contains functions for allocating memory, comparing +** strings, and stuff like that. +** +*/ +/* #include "sqliteInt.h" */ +/* #include */ +#if HAVE_ISNAN || SQLITE_HAVE_ISNAN +# include +#endif + +/* +** Routine needed to support the testcase() macro. +*/ +#ifdef SQLITE_COVERAGE_TEST +SQLITE_PRIVATE void sqlite3Coverage(int x){ + static unsigned dummy = 0; + dummy += (unsigned)x; +} +#endif + +/* +** Give a callback to the test harness that can be used to simulate faults +** in places where it is difficult or expensive to do so purely by means +** of inputs. +** +** The intent of the integer argument is to let the fault simulator know +** which of multiple sqlite3FaultSim() calls has been hit. +** +** Return whatever integer value the test callback returns, or return +** SQLITE_OK if no test callback is installed. +*/ +#ifndef SQLITE_OMIT_BUILTIN_TEST +SQLITE_PRIVATE int sqlite3FaultSim(int iTest){ + int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback; + return xCallback ? xCallback(iTest) : SQLITE_OK; +} +#endif + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** Return true if the floating point value is Not a Number (NaN). +** +** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN. +** Otherwise, we have our own implementation that works on most systems. +*/ +SQLITE_PRIVATE int sqlite3IsNaN(double x){ + int rc; /* The value return */ +#if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN + /* + ** Systems that support the isnan() library function should probably + ** make use of it by compiling with -DSQLITE_HAVE_ISNAN. But we have + ** found that many systems do not have a working isnan() function so + ** this implementation is provided as an alternative. + ** + ** This NaN test sometimes fails if compiled on GCC with -ffast-math. + ** On the other hand, the use of -ffast-math comes with the following + ** warning: + ** + ** This option [-ffast-math] should never be turned on by any + ** -O option since it can result in incorrect output for programs + ** which depend on an exact implementation of IEEE or ISO + ** rules/specifications for math functions. + ** + ** Under MSVC, this NaN test may fail if compiled with a floating- + ** point precision mode other than /fp:precise. From the MSDN + ** documentation: + ** + ** The compiler [with /fp:precise] will properly handle comparisons + ** involving NaN. For example, x != x evaluates to true if x is NaN + ** ... + */ +#ifdef __FAST_MATH__ +# error SQLite will not work correctly with the -ffast-math option of GCC. +#endif + volatile double y = x; + volatile double z = y; + rc = (y!=z); +#else /* if HAVE_ISNAN */ + rc = isnan(x); +#endif /* HAVE_ISNAN */ + testcase( rc ); + return rc; +} +#endif /* SQLITE_OMIT_FLOATING_POINT */ + +/* +** Compute a string length that is limited to what can be stored in +** lower 30 bits of a 32-bit signed integer. +** +** The value returned will never be negative. Nor will it ever be greater +** than the actual length of the string. For very long strings (greater +** than 1GiB) the value returned might be less than the true string length. +*/ +SQLITE_PRIVATE int sqlite3Strlen30(const char *z){ + if( z==0 ) return 0; + return 0x3fffffff & (int)strlen(z); +} + +/* +** Set the current error code to err_code and clear any prior error message. +*/ +SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code){ + assert( db!=0 ); + db->errCode = err_code; + if( db->pErr ) sqlite3ValueSetNull(db->pErr); +} + +/* +** Set the most recent error code and error string for the sqlite +** handle "db". The error code is set to "err_code". +** +** If it is not NULL, string zFormat specifies the format of the +** error string in the style of the printf functions: The following +** format characters are allowed: +** +** %s Insert a string +** %z A string that should be freed after use +** %d Insert an integer +** %T Insert a token +** %S Insert the first element of a SrcList +** +** zFormat and any string tokens that follow it are assumed to be +** encoded in UTF-8. +** +** To clear the most recent error for sqlite handle "db", sqlite3Error +** should be called with err_code set to SQLITE_OK and zFormat set +** to NULL. +*/ +SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){ + assert( db!=0 ); + db->errCode = err_code; + if( zFormat==0 ){ + sqlite3Error(db, err_code); + }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){ + char *z; + va_list ap; + va_start(ap, zFormat); + z = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC); + } +} + +/* +** Add an error message to pParse->zErrMsg and increment pParse->nErr. +** The following formatting characters are allowed: +** +** %s Insert a string +** %z A string that should be freed after use +** %d Insert an integer +** %T Insert a token +** %S Insert the first element of a SrcList +** +** This function should be used to report any error that occurs while +** compiling an SQL statement (i.e. within sqlite3_prepare()). The +** last thing the sqlite3_prepare() function does is copy the error +** stored by this function into the database handle using sqlite3Error(). +** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used +** during statement execution (sqlite3_step() etc.). +*/ +SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){ + char *zMsg; + va_list ap; + sqlite3 *db = pParse->db; + va_start(ap, zFormat); + zMsg = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + if( db->suppressErr ){ + sqlite3DbFree(db, zMsg); + }else{ + pParse->nErr++; + sqlite3DbFree(db, pParse->zErrMsg); + pParse->zErrMsg = zMsg; + pParse->rc = SQLITE_ERROR; + } +} + +/* +** Convert an SQL-style quoted string into a normal string by removing +** the quote characters. The conversion is done in-place. If the +** input does not begin with a quote character, then this routine +** is a no-op. +** +** The input string must be zero-terminated. A new zero-terminator +** is added to the dequoted string. +** +** The return value is -1 if no dequoting occurs or the length of the +** dequoted string, exclusive of the zero terminator, if dequoting does +** occur. +** +** 2002-Feb-14: This routine is extended to remove MS-Access style +** brackets from around identifiers. For example: "[a-b-c]" becomes +** "a-b-c". +*/ +SQLITE_PRIVATE int sqlite3Dequote(char *z){ + char quote; + int i, j; + if( z==0 ) return -1; + quote = z[0]; + switch( quote ){ + case '\'': break; + case '"': break; + case '`': break; /* For MySQL compatibility */ + case '[': quote = ']'; break; /* For MS SqlServer compatibility */ + default: return -1; + } + for(i=1, j=0;; i++){ + assert( z[i] ); + if( z[i]==quote ){ + if( z[i+1]==quote ){ + z[j++] = quote; + i++; + }else{ + break; + } + }else{ + z[j++] = z[i]; + } + } + z[j] = 0; + return j; +} + +/* Convenient short-hand */ +#define UpperToLower sqlite3UpperToLower + +/* +** Some systems have stricmp(). Others have strcasecmp(). Because +** there is no consistency, we will define our own. +** +** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and +** sqlite3_strnicmp() APIs allow applications and extensions to compare +** the contents of two buffers containing UTF-8 strings in a +** case-independent fashion, using the same definition of "case +** independence" that SQLite uses internally when comparing identifiers. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_stricmp(const char *zLeft, const char *zRight){ + register unsigned char *a, *b; + if( zLeft==0 ){ + return zRight ? -1 : 0; + }else if( zRight==0 ){ + return 1; + } + a = (unsigned char *)zLeft; + b = (unsigned char *)zRight; + while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } + return UpperToLower[*a] - UpperToLower[*b]; +} +SQLITE_API int SQLITE_STDCALL sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){ + register unsigned char *a, *b; + if( zLeft==0 ){ + return zRight ? -1 : 0; + }else if( zRight==0 ){ + return 1; + } + a = (unsigned char *)zLeft; + b = (unsigned char *)zRight; + while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } + return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; +} + +/* +** The string z[] is an text representation of a real number. +** Convert this string to a double and write it into *pResult. +** +** The string z[] is length bytes in length (bytes, not characters) and +** uses the encoding enc. The string is not necessarily zero-terminated. +** +** Return TRUE if the result is a valid real number (or integer) and FALSE +** if the string is empty or contains extraneous text. Valid numbers +** are in one of these formats: +** +** [+-]digits[E[+-]digits] +** [+-]digits.[digits][E[+-]digits] +** [+-].digits[E[+-]digits] +** +** Leading and trailing whitespace is ignored for the purpose of determining +** validity. +** +** If some prefix of the input string is a valid number, this routine +** returns FALSE but it still converts the prefix and writes the result +** into *pResult. +*/ +SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){ +#ifndef SQLITE_OMIT_FLOATING_POINT + int incr; + const char *zEnd = z + length; + /* sign * significand * (10 ^ (esign * exponent)) */ + int sign = 1; /* sign of significand */ + i64 s = 0; /* significand */ + int d = 0; /* adjust exponent for shifting decimal point */ + int esign = 1; /* sign of exponent */ + int e = 0; /* exponent */ + int eValid = 1; /* True exponent is either not used or is well-formed */ + double result; + int nDigits = 0; + int nonNum = 0; + + assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); + *pResult = 0.0; /* Default return value, in case of an error */ + + if( enc==SQLITE_UTF8 ){ + incr = 1; + }else{ + int i; + incr = 2; + assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + for(i=3-enc; i=zEnd ) return 0; + + /* get sign of significand */ + if( *z=='-' ){ + sign = -1; + z+=incr; + }else if( *z=='+' ){ + z+=incr; + } + + /* skip leading zeroes */ + while( z=zEnd ) goto do_atof_calc; + + /* if decimal point is present */ + if( *z=='.' ){ + z+=incr; + /* copy digits from after decimal to significand + ** (decrease exponent by d to shift decimal right) */ + while( z=zEnd ) goto do_atof_calc; + + /* if exponent is present */ + if( *z=='e' || *z=='E' ){ + z+=incr; + eValid = 0; + if( z>=zEnd ) goto do_atof_calc; + /* get sign of exponent */ + if( *z=='-' ){ + esign = -1; + z+=incr; + }else if( *z=='+' ){ + z+=incr; + } + /* copy digits to exponent */ + while( z0 ){ + while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10; + }else{ + while( !(s%10) && e>0 ) e--,s/=10; + } + + /* adjust the sign of significand */ + s = sign<0 ? -s : s; + + /* if exponent, scale significand as appropriate + ** and store in result. */ + if( e ){ + LONGDOUBLE_TYPE scale = 1.0; + /* attempt to handle extremely small/large numbers better */ + if( e>307 && e<342 ){ + while( e%308 ) { scale *= 1.0e+1; e -= 1; } + if( esign<0 ){ + result = s / scale; + result /= 1.0e+308; + }else{ + result = s * scale; + result *= 1.0e+308; + } + }else if( e>=342 ){ + if( esign<0 ){ + result = 0.0*s; + }else{ + result = 1e308*1e308*s; /* Infinity */ + } + }else{ + /* 1.0e+22 is the largest power of 10 than can be + ** represented exactly. */ + while( e%22 ) { scale *= 1.0e+1; e -= 1; } + while( e>0 ) { scale *= 1.0e+22; e -= 22; } + if( esign<0 ){ + result = s / scale; + }else{ + result = s * scale; + } + } + } else { + result = (double)s; + } + } + + /* store the result */ + *pResult = result; + + /* return true if number and no extra non-whitespace chracters after */ + return z>=zEnd && nDigits>0 && eValid && nonNum==0; +#else + return !sqlite3Atoi64(z, pResult, length, enc); +#endif /* SQLITE_OMIT_FLOATING_POINT */ +} + +/* +** Compare the 19-character string zNum against the text representation +** value 2^63: 9223372036854775808. Return negative, zero, or positive +** if zNum is less than, equal to, or greater than the string. +** Note that zNum must contain exactly 19 characters. +** +** Unlike memcmp() this routine is guaranteed to return the difference +** in the values of the last digit if the only difference is in the +** last digit. So, for example, +** +** compare2pow63("9223372036854775800", 1) +** +** will return -8. +*/ +static int compare2pow63(const char *zNum, int incr){ + int c = 0; + int i; + /* 012345678901234567 */ + const char *pow63 = "922337203685477580"; + for(i=0; c==0 && i<18; i++){ + c = (zNum[i*incr]-pow63[i])*10; + } + if( c==0 ){ + c = zNum[18*incr] - '8'; + testcase( c==(-1) ); + testcase( c==0 ); + testcase( c==(+1) ); + } + return c; +} + +/* +** Convert zNum to a 64-bit signed integer. zNum must be decimal. This +** routine does *not* accept hexadecimal notation. +** +** If the zNum value is representable as a 64-bit twos-complement +** integer, then write that value into *pNum and return 0. +** +** If zNum is exactly 9223372036854775808, return 2. This special +** case is broken out because while 9223372036854775808 cannot be a +** signed 64-bit integer, its negative -9223372036854775808 can be. +** +** If zNum is too big for a 64-bit integer and is not +** 9223372036854775808 or if zNum contains any non-numeric text, +** then return 1. +** +** length is the number of bytes in the string (bytes, not characters). +** The string is not necessarily zero-terminated. The encoding is +** given by enc. +*/ +SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){ + int incr; + u64 u = 0; + int neg = 0; /* assume positive */ + int i; + int c = 0; + int nonNum = 0; + const char *zStart; + const char *zEnd = zNum + length; + assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); + if( enc==SQLITE_UTF8 ){ + incr = 1; + }else{ + incr = 2; + assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + for(i=3-enc; i='0' && c<='9'; i+=incr){ + u = u*10 + c - '0'; + } + if( u>LARGEST_INT64 ){ + *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; + }else if( neg ){ + *pNum = -(i64)u; + }else{ + *pNum = (i64)u; + } + testcase( i==18 ); + testcase( i==19 ); + testcase( i==20 ); + if( (c!=0 && &zNum[i]19*incr || nonNum ){ + /* zNum is empty or contains non-numeric text or is longer + ** than 19 digits (thus guaranteeing that it is too large) */ + return 1; + }else if( i<19*incr ){ + /* Less than 19 digits, so we know that it fits in 64 bits */ + assert( u<=LARGEST_INT64 ); + return 0; + }else{ + /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */ + c = compare2pow63(zNum, incr); + if( c<0 ){ + /* zNum is less than 9223372036854775808 so it fits */ + assert( u<=LARGEST_INT64 ); + return 0; + }else if( c>0 ){ + /* zNum is greater than 9223372036854775808 so it overflows */ + return 1; + }else{ + /* zNum is exactly 9223372036854775808. Fits if negative. The + ** special case 2 overflow if positive */ + assert( u-1==LARGEST_INT64 ); + return neg ? 0 : 2; + } + } +} + +/* +** Transform a UTF-8 integer literal, in either decimal or hexadecimal, +** into a 64-bit signed integer. This routine accepts hexadecimal literals, +** whereas sqlite3Atoi64() does not. +** +** Returns: +** +** 0 Successful transformation. Fits in a 64-bit signed integer. +** 1 Integer too large for a 64-bit signed integer or is malformed +** 2 Special case of 9223372036854775808 +*/ +SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char *z, i64 *pOut){ +#ifndef SQLITE_OMIT_HEX_INTEGER + if( z[0]=='0' + && (z[1]=='x' || z[1]=='X') + && sqlite3Isxdigit(z[2]) + ){ + u64 u = 0; + int i, k; + for(i=2; z[i]=='0'; i++){} + for(k=i; sqlite3Isxdigit(z[k]); k++){ + u = u*16 + sqlite3HexToInt(z[k]); + } + memcpy(pOut, &u, 8); + return (z[k]==0 && k-i<=16) ? 0 : 1; + }else +#endif /* SQLITE_OMIT_HEX_INTEGER */ + { + return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8); + } +} + +/* +** If zNum represents an integer that will fit in 32-bits, then set +** *pValue to that integer and return true. Otherwise return false. +** +** This routine accepts both decimal and hexadecimal notation for integers. +** +** Any non-numeric characters that following zNum are ignored. +** This is different from sqlite3Atoi64() which requires the +** input number to be zero-terminated. +*/ +SQLITE_PRIVATE int sqlite3GetInt32(const char *zNum, int *pValue){ + sqlite_int64 v = 0; + int i, c; + int neg = 0; + if( zNum[0]=='-' ){ + neg = 1; + zNum++; + }else if( zNum[0]=='+' ){ + zNum++; + } +#ifndef SQLITE_OMIT_HEX_INTEGER + else if( zNum[0]=='0' + && (zNum[1]=='x' || zNum[1]=='X') + && sqlite3Isxdigit(zNum[2]) + ){ + u32 u = 0; + zNum += 2; + while( zNum[0]=='0' ) zNum++; + for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){ + u = u*16 + sqlite3HexToInt(zNum[i]); + } + if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){ + memcpy(pValue, &u, 4); + return 1; + }else{ + return 0; + } + } +#endif + while( zNum[0]=='0' ) zNum++; + for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){ + v = v*10 + c; + } + + /* The longest decimal representation of a 32 bit integer is 10 digits: + ** + ** 1234567890 + ** 2^31 -> 2147483648 + */ + testcase( i==10 ); + if( i>10 ){ + return 0; + } + testcase( v-neg==2147483647 ); + if( v-neg>2147483647 ){ + return 0; + } + if( neg ){ + v = -v; + } + *pValue = (int)v; + return 1; +} + +/* +** Return a 32-bit integer value extracted from a string. If the +** string is not an integer, just return 0. +*/ +SQLITE_PRIVATE int sqlite3Atoi(const char *z){ + int x = 0; + if( z ) sqlite3GetInt32(z, &x); + return x; +} + +/* +** The variable-length integer encoding is as follows: +** +** KEY: +** A = 0xxxxxxx 7 bits of data and one flag bit +** B = 1xxxxxxx 7 bits of data and one flag bit +** C = xxxxxxxx 8 bits of data +** +** 7 bits - A +** 14 bits - BA +** 21 bits - BBA +** 28 bits - BBBA +** 35 bits - BBBBA +** 42 bits - BBBBBA +** 49 bits - BBBBBBA +** 56 bits - BBBBBBBA +** 64 bits - BBBBBBBBC +*/ + +/* +** Write a 64-bit variable-length integer to memory starting at p[0]. +** The length of data write will be between 1 and 9 bytes. The number +** of bytes written is returned. +** +** A variable-length integer consists of the lower 7 bits of each byte +** for all bytes that have the 8th bit set and one byte with the 8th +** bit clear. Except, if we get to the 9th byte, it stores the full +** 8 bits and is the last byte. +*/ +static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){ + int i, j, n; + u8 buf[10]; + if( v & (((u64)0xff000000)<<32) ){ + p[8] = (u8)v; + v >>= 8; + for(i=7; i>=0; i--){ + p[i] = (u8)((v & 0x7f) | 0x80); + v >>= 7; + } + return 9; + } + n = 0; + do{ + buf[n++] = (u8)((v & 0x7f) | 0x80); + v >>= 7; + }while( v!=0 ); + buf[0] &= 0x7f; + assert( n<=9 ); + for(i=0, j=n-1; j>=0; j--, i++){ + p[i] = buf[j]; + } + return n; +} +SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){ + if( v<=0x7f ){ + p[0] = v&0x7f; + return 1; + } + if( v<=0x3fff ){ + p[0] = ((v>>7)&0x7f)|0x80; + p[1] = v&0x7f; + return 2; + } + return putVarint64(p,v); +} + +/* +** Bitmasks used by sqlite3GetVarint(). These precomputed constants +** are defined here rather than simply putting the constant expressions +** inline in order to work around bugs in the RVT compiler. +** +** SLOT_2_0 A mask for (0x7f<<14) | 0x7f +** +** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0 +*/ +#define SLOT_2_0 0x001fc07f +#define SLOT_4_2_0 0xf01fc07f + + +/* +** Read a 64-bit variable-length integer from memory starting at p[0]. +** Return the number of bytes read. The value is stored in *v. +*/ +SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){ + u32 a,b,s; + + a = *p; + /* a: p0 (unmasked) */ + if (!(a&0x80)) + { + *v = a; + return 1; + } + + p++; + b = *p; + /* b: p1 (unmasked) */ + if (!(b&0x80)) + { + a &= 0x7f; + a = a<<7; + a |= b; + *v = a; + return 2; + } + + /* Verify that constants are precomputed correctly */ + assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) ); + assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) ); + + p++; + a = a<<14; + a |= *p; + /* a: p0<<14 | p2 (unmasked) */ + if (!(a&0x80)) + { + a &= SLOT_2_0; + b &= 0x7f; + b = b<<7; + a |= b; + *v = a; + return 3; + } + + /* CSE1 from below */ + a &= SLOT_2_0; + p++; + b = b<<14; + b |= *p; + /* b: p1<<14 | p3 (unmasked) */ + if (!(b&0x80)) + { + b &= SLOT_2_0; + /* moved CSE1 up */ + /* a &= (0x7f<<14)|(0x7f); */ + a = a<<7; + a |= b; + *v = a; + return 4; + } + + /* a: p0<<14 | p2 (masked) */ + /* b: p1<<14 | p3 (unmasked) */ + /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ + /* moved CSE1 up */ + /* a &= (0x7f<<14)|(0x7f); */ + b &= SLOT_2_0; + s = a; + /* s: p0<<14 | p2 (masked) */ + + p++; + a = a<<14; + a |= *p; + /* a: p0<<28 | p2<<14 | p4 (unmasked) */ + if (!(a&0x80)) + { + /* we can skip these cause they were (effectively) done above in calc'ing s */ + /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ + /* b &= (0x7f<<14)|(0x7f); */ + b = b<<7; + a |= b; + s = s>>18; + *v = ((u64)s)<<32 | a; + return 5; + } + + /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ + s = s<<7; + s |= b; + /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ + + p++; + b = b<<14; + b |= *p; + /* b: p1<<28 | p3<<14 | p5 (unmasked) */ + if (!(b&0x80)) + { + /* we can skip this cause it was (effectively) done above in calc'ing s */ + /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ + a &= SLOT_2_0; + a = a<<7; + a |= b; + s = s>>18; + *v = ((u64)s)<<32 | a; + return 6; + } + + p++; + a = a<<14; + a |= *p; + /* a: p2<<28 | p4<<14 | p6 (unmasked) */ + if (!(a&0x80)) + { + a &= SLOT_4_2_0; + b &= SLOT_2_0; + b = b<<7; + a |= b; + s = s>>11; + *v = ((u64)s)<<32 | a; + return 7; + } + + /* CSE2 from below */ + a &= SLOT_2_0; + p++; + b = b<<14; + b |= *p; + /* b: p3<<28 | p5<<14 | p7 (unmasked) */ + if (!(b&0x80)) + { + b &= SLOT_4_2_0; + /* moved CSE2 up */ + /* a &= (0x7f<<14)|(0x7f); */ + a = a<<7; + a |= b; + s = s>>4; + *v = ((u64)s)<<32 | a; + return 8; + } + + p++; + a = a<<15; + a |= *p; + /* a: p4<<29 | p6<<15 | p8 (unmasked) */ + + /* moved CSE2 up */ + /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */ + b &= SLOT_2_0; + b = b<<8; + a |= b; + + s = s<<4; + b = p[-4]; + b &= 0x7f; + b = b>>3; + s |= b; + + *v = ((u64)s)<<32 | a; + + return 9; +} + +/* +** Read a 32-bit variable-length integer from memory starting at p[0]. +** Return the number of bytes read. The value is stored in *v. +** +** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned +** integer, then set *v to 0xffffffff. +** +** A MACRO version, getVarint32, is provided which inlines the +** single-byte case. All code should use the MACRO version as +** this function assumes the single-byte case has already been handled. +*/ +SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){ + u32 a,b; + + /* The 1-byte case. Overwhelmingly the most common. Handled inline + ** by the getVarin32() macro */ + a = *p; + /* a: p0 (unmasked) */ +#ifndef getVarint32 + if (!(a&0x80)) + { + /* Values between 0 and 127 */ + *v = a; + return 1; + } +#endif + + /* The 2-byte case */ + p++; + b = *p; + /* b: p1 (unmasked) */ + if (!(b&0x80)) + { + /* Values between 128 and 16383 */ + a &= 0x7f; + a = a<<7; + *v = a | b; + return 2; + } + + /* The 3-byte case */ + p++; + a = a<<14; + a |= *p; + /* a: p0<<14 | p2 (unmasked) */ + if (!(a&0x80)) + { + /* Values between 16384 and 2097151 */ + a &= (0x7f<<14)|(0x7f); + b &= 0x7f; + b = b<<7; + *v = a | b; + return 3; + } + + /* A 32-bit varint is used to store size information in btrees. + ** Objects are rarely larger than 2MiB limit of a 3-byte varint. + ** A 3-byte varint is sufficient, for example, to record the size + ** of a 1048569-byte BLOB or string. + ** + ** We only unroll the first 1-, 2-, and 3- byte cases. The very + ** rare larger cases can be handled by the slower 64-bit varint + ** routine. + */ +#if 1 + { + u64 v64; + u8 n; + + p -= 2; + n = sqlite3GetVarint(p, &v64); + assert( n>3 && n<=9 ); + if( (v64 & SQLITE_MAX_U32)!=v64 ){ + *v = 0xffffffff; + }else{ + *v = (u32)v64; + } + return n; + } + +#else + /* For following code (kept for historical record only) shows an + ** unrolling for the 3- and 4-byte varint cases. This code is + ** slightly faster, but it is also larger and much harder to test. + */ + p++; + b = b<<14; + b |= *p; + /* b: p1<<14 | p3 (unmasked) */ + if (!(b&0x80)) + { + /* Values between 2097152 and 268435455 */ + b &= (0x7f<<14)|(0x7f); + a &= (0x7f<<14)|(0x7f); + a = a<<7; + *v = a | b; + return 4; + } + + p++; + a = a<<14; + a |= *p; + /* a: p0<<28 | p2<<14 | p4 (unmasked) */ + if (!(a&0x80)) + { + /* Values between 268435456 and 34359738367 */ + a &= SLOT_4_2_0; + b &= SLOT_4_2_0; + b = b<<7; + *v = a | b; + return 5; + } + + /* We can only reach this point when reading a corrupt database + ** file. In that case we are not in any hurry. Use the (relatively + ** slow) general-purpose sqlite3GetVarint() routine to extract the + ** value. */ + { + u64 v64; + u8 n; + + p -= 4; + n = sqlite3GetVarint(p, &v64); + assert( n>5 && n<=9 ); + *v = (u32)v64; + return n; + } +#endif +} + +/* +** Return the number of bytes that will be needed to store the given +** 64-bit integer. +*/ +SQLITE_PRIVATE int sqlite3VarintLen(u64 v){ + int i; + for(i=1; (v >>= 7)!=0; i++){ assert( i<9 ); } + return i; +} + + +/* +** Read or write a four-byte big-endian integer value. +*/ +SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){ +#if SQLITE_BYTEORDER==4321 + u32 x; + memcpy(&x,p,4); + return x; +#elif SQLITE_BYTEORDER==1234 && !defined(SQLITE_DISABLE_INTRINSIC) \ + && defined(__GNUC__) && GCC_VERSION>=4003000 + u32 x; + memcpy(&x,p,4); + return __builtin_bswap32(x); +#elif SQLITE_BYTEORDER==1234 && !defined(SQLITE_DISABLE_INTRINSIC) \ + && defined(_MSC_VER) && _MSC_VER>=1300 + u32 x; + memcpy(&x,p,4); + return _byteswap_ulong(x); +#else + testcase( p[0]&0x80 ); + return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3]; +#endif +} +SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){ +#if SQLITE_BYTEORDER==4321 + memcpy(p,&v,4); +#elif SQLITE_BYTEORDER==1234 && defined(__GNUC__) && GCC_VERSION>=4003000 + u32 x = __builtin_bswap32(v); + memcpy(p,&x,4); +#elif SQLITE_BYTEORDER==1234 && defined(_MSC_VER) && _MSC_VER>=1300 + u32 x = _byteswap_ulong(v); + memcpy(p,&x,4); +#else + p[0] = (u8)(v>>24); + p[1] = (u8)(v>>16); + p[2] = (u8)(v>>8); + p[3] = (u8)v; +#endif +} + + + +/* +** Translate a single byte of Hex into an integer. +** This routine only works if h really is a valid hexadecimal +** character: 0..9a..fA..F +*/ +SQLITE_PRIVATE u8 sqlite3HexToInt(int h){ + assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); +#ifdef SQLITE_ASCII + h += 9*(1&(h>>6)); +#endif +#ifdef SQLITE_EBCDIC + h += 9*(1&~(h>>4)); +#endif + return (u8)(h & 0xf); +} + +#if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) +/* +** Convert a BLOB literal of the form "x'hhhhhh'" into its binary +** value. Return a pointer to its binary value. Space to hold the +** binary value has been obtained from malloc and must be freed by +** the calling routine. +*/ +SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){ + char *zBlob; + int i; + + zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1); + n--; + if( zBlob ){ + for(i=0; imagic; + if( magic!=SQLITE_MAGIC_OPEN ){ + if( sqlite3SafetyCheckSickOrOk(db) ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + logBadConnection("unopened"); + } + return 0; + }else{ + return 1; + } +} +SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3 *db){ + u32 magic; + magic = db->magic; + if( magic!=SQLITE_MAGIC_SICK && + magic!=SQLITE_MAGIC_OPEN && + magic!=SQLITE_MAGIC_BUSY ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + logBadConnection("invalid"); + return 0; + }else{ + return 1; + } +} + +/* +** Attempt to add, substract, or multiply the 64-bit signed value iB against +** the other 64-bit signed integer at *pA and store the result in *pA. +** Return 0 on success. Or if the operation would have resulted in an +** overflow, leave *pA unchanged and return 1. +*/ +SQLITE_PRIVATE int sqlite3AddInt64(i64 *pA, i64 iB){ + i64 iA = *pA; + testcase( iA==0 ); testcase( iA==1 ); + testcase( iB==-1 ); testcase( iB==0 ); + if( iB>=0 ){ + testcase( iA>0 && LARGEST_INT64 - iA == iB ); + testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 ); + if( iA>0 && LARGEST_INT64 - iA < iB ) return 1; + }else{ + testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 ); + testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 ); + if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1; + } + *pA += iB; + return 0; +} +SQLITE_PRIVATE int sqlite3SubInt64(i64 *pA, i64 iB){ + testcase( iB==SMALLEST_INT64+1 ); + if( iB==SMALLEST_INT64 ){ + testcase( (*pA)==(-1) ); testcase( (*pA)==0 ); + if( (*pA)>=0 ) return 1; + *pA -= iB; + return 0; + }else{ + return sqlite3AddInt64(pA, -iB); + } +} +#define TWOPOWER32 (((i64)1)<<32) +#define TWOPOWER31 (((i64)1)<<31) +SQLITE_PRIVATE int sqlite3MulInt64(i64 *pA, i64 iB){ + i64 iA = *pA; + i64 iA1, iA0, iB1, iB0, r; + + iA1 = iA/TWOPOWER32; + iA0 = iA % TWOPOWER32; + iB1 = iB/TWOPOWER32; + iB0 = iB % TWOPOWER32; + if( iA1==0 ){ + if( iB1==0 ){ + *pA *= iB; + return 0; + } + r = iA0*iB1; + }else if( iB1==0 ){ + r = iA1*iB0; + }else{ + /* If both iA1 and iB1 are non-zero, overflow will result */ + return 1; + } + testcase( r==(-TWOPOWER31)-1 ); + testcase( r==(-TWOPOWER31) ); + testcase( r==TWOPOWER31 ); + testcase( r==TWOPOWER31-1 ); + if( r<(-TWOPOWER31) || r>=TWOPOWER31 ) return 1; + r *= TWOPOWER32; + if( sqlite3AddInt64(&r, iA0*iB0) ) return 1; + *pA = r; + return 0; +} + +/* +** Compute the absolute value of a 32-bit signed integer, of possible. Or +** if the integer has a value of -2147483648, return +2147483647 +*/ +SQLITE_PRIVATE int sqlite3AbsInt32(int x){ + if( x>=0 ) return x; + if( x==(int)0x80000000 ) return 0x7fffffff; + return -x; +} + +#ifdef SQLITE_ENABLE_8_3_NAMES +/* +** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database +** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and +** if filename in z[] has a suffix (a.k.a. "extension") that is longer than +** three characters, then shorten the suffix on z[] to be the last three +** characters of the original suffix. +** +** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always +** do the suffix shortening regardless of URI parameter. +** +** Examples: +** +** test.db-journal => test.nal +** test.db-wal => test.wal +** test.db-shm => test.shm +** test.db-mj7f3319fa => test.9fa +*/ +SQLITE_PRIVATE void sqlite3FileSuffix3(const char *zBaseFilename, char *z){ +#if SQLITE_ENABLE_8_3_NAMES<2 + if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) ) +#endif + { + int i, sz; + sz = sqlite3Strlen30(z); + for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} + if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4); + } +} +#endif + +/* +** Find (an approximate) sum of two LogEst values. This computation is +** not a simple "+" operator because LogEst is stored as a logarithmic +** value. +** +*/ +SQLITE_PRIVATE LogEst sqlite3LogEstAdd(LogEst a, LogEst b){ + static const unsigned char x[] = { + 10, 10, /* 0,1 */ + 9, 9, /* 2,3 */ + 8, 8, /* 4,5 */ + 7, 7, 7, /* 6,7,8 */ + 6, 6, 6, /* 9,10,11 */ + 5, 5, 5, /* 12-14 */ + 4, 4, 4, 4, /* 15-18 */ + 3, 3, 3, 3, 3, 3, /* 19-24 */ + 2, 2, 2, 2, 2, 2, 2, /* 25-31 */ + }; + if( a>=b ){ + if( a>b+49 ) return a; + if( a>b+31 ) return a+1; + return a+x[a-b]; + }else{ + if( b>a+49 ) return b; + if( b>a+31 ) return b+1; + return b+x[b-a]; + } +} + +/* +** Convert an integer into a LogEst. In other words, compute an +** approximation for 10*log2(x). +*/ +SQLITE_PRIVATE LogEst sqlite3LogEst(u64 x){ + static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 }; + LogEst y = 40; + if( x<8 ){ + if( x<2 ) return 0; + while( x<8 ){ y -= 10; x <<= 1; } + }else{ + while( x>255 ){ y += 40; x >>= 4; } + while( x>15 ){ y += 10; x >>= 1; } + } + return a[x&7] + y - 10; +} + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Convert a double into a LogEst +** In other words, compute an approximation for 10*log2(x). +*/ +SQLITE_PRIVATE LogEst sqlite3LogEstFromDouble(double x){ + u64 a; + LogEst e; + assert( sizeof(x)==8 && sizeof(a)==8 ); + if( x<=1 ) return 0; + if( x<=2000000000 ) return sqlite3LogEst((u64)x); + memcpy(&a, &x, 8); + e = (a>>52) - 1022; + return e*10; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/* +** Convert a LogEst into an integer. +*/ +SQLITE_PRIVATE u64 sqlite3LogEstToInt(LogEst x){ + u64 n; + if( x<10 ) return 1; + n = x%10; + x /= 10; + if( n>=5 ) n -= 2; + else if( n>=1 ) n -= 1; + if( x>=3 ){ + return x>60 ? (u64)LARGEST_INT64 : (n+8)<<(x-3); + } + return (n+8)>>(3-x); +} + +/************** End of util.c ************************************************/ +/************** Begin file hash.c ********************************************/ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the implementation of generic hash-tables +** used in SQLite. +*/ +/* #include "sqliteInt.h" */ +/* #include */ + +/* Turn bulk memory into a hash table object by initializing the +** fields of the Hash structure. +** +** "pNew" is a pointer to the hash table that is to be initialized. +*/ +SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){ + assert( pNew!=0 ); + pNew->first = 0; + pNew->count = 0; + pNew->htsize = 0; + pNew->ht = 0; +} + +/* Remove all entries from a hash table. Reclaim all memory. +** Call this routine to delete a hash table or to reset a hash table +** to the empty state. +*/ +SQLITE_PRIVATE void sqlite3HashClear(Hash *pH){ + HashElem *elem; /* For looping over all elements of the table */ + + assert( pH!=0 ); + elem = pH->first; + pH->first = 0; + sqlite3_free(pH->ht); + pH->ht = 0; + pH->htsize = 0; + while( elem ){ + HashElem *next_elem = elem->next; + sqlite3_free(elem); + elem = next_elem; + } + pH->count = 0; +} + +/* +** The hashing function. +*/ +static unsigned int strHash(const char *z){ + unsigned int h = 0; + unsigned char c; + while( (c = (unsigned char)*z++)!=0 ){ + h = (h<<3) ^ h ^ sqlite3UpperToLower[c]; + } + return h; +} + + +/* Link pNew element into the hash table pH. If pEntry!=0 then also +** insert pNew into the pEntry hash bucket. +*/ +static void insertElement( + Hash *pH, /* The complete hash table */ + struct _ht *pEntry, /* The entry into which pNew is inserted */ + HashElem *pNew /* The element to be inserted */ +){ + HashElem *pHead; /* First element already in pEntry */ + if( pEntry ){ + pHead = pEntry->count ? pEntry->chain : 0; + pEntry->count++; + pEntry->chain = pNew; + }else{ + pHead = 0; + } + if( pHead ){ + pNew->next = pHead; + pNew->prev = pHead->prev; + if( pHead->prev ){ pHead->prev->next = pNew; } + else { pH->first = pNew; } + pHead->prev = pNew; + }else{ + pNew->next = pH->first; + if( pH->first ){ pH->first->prev = pNew; } + pNew->prev = 0; + pH->first = pNew; + } +} + + +/* Resize the hash table so that it cantains "new_size" buckets. +** +** The hash table might fail to resize if sqlite3_malloc() fails or +** if the new size is the same as the prior size. +** Return TRUE if the resize occurs and false if not. +*/ +static int rehash(Hash *pH, unsigned int new_size){ + struct _ht *new_ht; /* The new hash table */ + HashElem *elem, *next_elem; /* For looping over existing elements */ + +#if SQLITE_MALLOC_SOFT_LIMIT>0 + if( new_size*sizeof(struct _ht)>SQLITE_MALLOC_SOFT_LIMIT ){ + new_size = SQLITE_MALLOC_SOFT_LIMIT/sizeof(struct _ht); + } + if( new_size==pH->htsize ) return 0; +#endif + + /* The inability to allocates space for a larger hash table is + ** a performance hit but it is not a fatal error. So mark the + ** allocation as a benign. Use sqlite3Malloc()/memset(0) instead of + ** sqlite3MallocZero() to make the allocation, as sqlite3MallocZero() + ** only zeroes the requested number of bytes whereas this module will + ** use the actual amount of space allocated for the hash table (which + ** may be larger than the requested amount). + */ + sqlite3BeginBenignMalloc(); + new_ht = (struct _ht *)sqlite3Malloc( new_size*sizeof(struct _ht) ); + sqlite3EndBenignMalloc(); + + if( new_ht==0 ) return 0; + sqlite3_free(pH->ht); + pH->ht = new_ht; + pH->htsize = new_size = sqlite3MallocSize(new_ht)/sizeof(struct _ht); + memset(new_ht, 0, new_size*sizeof(struct _ht)); + for(elem=pH->first, pH->first=0; elem; elem = next_elem){ + unsigned int h = strHash(elem->pKey) % new_size; + next_elem = elem->next; + insertElement(pH, &new_ht[h], elem); + } + return 1; +} + +/* This function (for internal use only) locates an element in an +** hash table that matches the given key. The hash for this key is +** also computed and returned in the *pH parameter. +*/ +static HashElem *findElementWithHash( + const Hash *pH, /* The pH to be searched */ + const char *pKey, /* The key we are searching for */ + unsigned int *pHash /* Write the hash value here */ +){ + HashElem *elem; /* Used to loop thru the element list */ + int count; /* Number of elements left to test */ + unsigned int h; /* The computed hash */ + + if( pH->ht ){ + struct _ht *pEntry; + h = strHash(pKey) % pH->htsize; + pEntry = &pH->ht[h]; + elem = pEntry->chain; + count = pEntry->count; + }else{ + h = 0; + elem = pH->first; + count = pH->count; + } + *pHash = h; + while( count-- ){ + assert( elem!=0 ); + if( sqlite3StrICmp(elem->pKey,pKey)==0 ){ + return elem; + } + elem = elem->next; + } + return 0; +} + +/* Remove a single entry from the hash table given a pointer to that +** element and a hash on the element's key. +*/ +static void removeElementGivenHash( + Hash *pH, /* The pH containing "elem" */ + HashElem* elem, /* The element to be removed from the pH */ + unsigned int h /* Hash value for the element */ +){ + struct _ht *pEntry; + if( elem->prev ){ + elem->prev->next = elem->next; + }else{ + pH->first = elem->next; + } + if( elem->next ){ + elem->next->prev = elem->prev; + } + if( pH->ht ){ + pEntry = &pH->ht[h]; + if( pEntry->chain==elem ){ + pEntry->chain = elem->next; + } + pEntry->count--; + assert( pEntry->count>=0 ); + } + sqlite3_free( elem ); + pH->count--; + if( pH->count==0 ){ + assert( pH->first==0 ); + assert( pH->count==0 ); + sqlite3HashClear(pH); + } +} + +/* Attempt to locate an element of the hash table pH with a key +** that matches pKey. Return the data for this element if it is +** found, or NULL if there is no match. +*/ +SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey){ + HashElem *elem; /* The element that matches key */ + unsigned int h; /* A hash on key */ + + assert( pH!=0 ); + assert( pKey!=0 ); + elem = findElementWithHash(pH, pKey, &h); + return elem ? elem->data : 0; +} + +/* Insert an element into the hash table pH. The key is pKey +** and the data is "data". +** +** If no element exists with a matching key, then a new +** element is created and NULL is returned. +** +** If another element already exists with the same key, then the +** new data replaces the old data and the old data is returned. +** The key is not copied in this instance. If a malloc fails, then +** the new data is returned and the hash table is unchanged. +** +** If the "data" parameter to this function is NULL, then the +** element corresponding to "key" is removed from the hash table. +*/ +SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, void *data){ + unsigned int h; /* the hash of the key modulo hash table size */ + HashElem *elem; /* Used to loop thru the element list */ + HashElem *new_elem; /* New element added to the pH */ + + assert( pH!=0 ); + assert( pKey!=0 ); + elem = findElementWithHash(pH,pKey,&h); + if( elem ){ + void *old_data = elem->data; + if( data==0 ){ + removeElementGivenHash(pH,elem,h); + }else{ + elem->data = data; + elem->pKey = pKey; + } + return old_data; + } + if( data==0 ) return 0; + new_elem = (HashElem*)sqlite3Malloc( sizeof(HashElem) ); + if( new_elem==0 ) return data; + new_elem->pKey = pKey; + new_elem->data = data; + pH->count++; + if( pH->count>=10 && pH->count > 2*pH->htsize ){ + if( rehash(pH, pH->count*2) ){ + assert( pH->htsize>0 ); + h = strHash(pKey) % pH->htsize; + } + } + insertElement(pH, pH->ht ? &pH->ht[h] : 0, new_elem); + return 0; +} + +/************** End of hash.c ************************************************/ +/************** Begin file opcodes.c *****************************************/ +/* Automatically generated. Do not edit */ +/* See the mkopcodec.awk script for details. */ +#if !defined(SQLITE_OMIT_EXPLAIN) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) +#if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) || defined(SQLITE_DEBUG) +# define OpHelp(X) "\0" X +#else +# define OpHelp(X) +#endif +SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){ + static const char *const azName[] = { "?", + /* 1 */ "Savepoint" OpHelp(""), + /* 2 */ "AutoCommit" OpHelp(""), + /* 3 */ "Transaction" OpHelp(""), + /* 4 */ "SorterNext" OpHelp(""), + /* 5 */ "PrevIfOpen" OpHelp(""), + /* 6 */ "NextIfOpen" OpHelp(""), + /* 7 */ "Prev" OpHelp(""), + /* 8 */ "Next" OpHelp(""), + /* 9 */ "Checkpoint" OpHelp(""), + /* 10 */ "JournalMode" OpHelp(""), + /* 11 */ "Vacuum" OpHelp(""), + /* 12 */ "VFilter" OpHelp("iplan=r[P3] zplan='P4'"), + /* 13 */ "VUpdate" OpHelp("data=r[P3@P2]"), + /* 14 */ "Goto" OpHelp(""), + /* 15 */ "Gosub" OpHelp(""), + /* 16 */ "Return" OpHelp(""), + /* 17 */ "InitCoroutine" OpHelp(""), + /* 18 */ "EndCoroutine" OpHelp(""), + /* 19 */ "Not" OpHelp("r[P2]= !r[P1]"), + /* 20 */ "Yield" OpHelp(""), + /* 21 */ "HaltIfNull" OpHelp("if r[P3]=null halt"), + /* 22 */ "Halt" OpHelp(""), + /* 23 */ "Integer" OpHelp("r[P2]=P1"), + /* 24 */ "Int64" OpHelp("r[P2]=P4"), + /* 25 */ "String" OpHelp("r[P2]='P4' (len=P1)"), + /* 26 */ "Null" OpHelp("r[P2..P3]=NULL"), + /* 27 */ "SoftNull" OpHelp("r[P1]=NULL"), + /* 28 */ "Blob" OpHelp("r[P2]=P4 (len=P1)"), + /* 29 */ "Variable" OpHelp("r[P2]=parameter(P1,P4)"), + /* 30 */ "Move" OpHelp("r[P2@P3]=r[P1@P3]"), + /* 31 */ "Copy" OpHelp("r[P2@P3+1]=r[P1@P3+1]"), + /* 32 */ "SCopy" OpHelp("r[P2]=r[P1]"), + /* 33 */ "ResultRow" OpHelp("output=r[P1@P2]"), + /* 34 */ "CollSeq" OpHelp(""), + /* 35 */ "Function0" OpHelp("r[P3]=func(r[P2@P5])"), + /* 36 */ "Function" OpHelp("r[P3]=func(r[P2@P5])"), + /* 37 */ "AddImm" OpHelp("r[P1]=r[P1]+P2"), + /* 38 */ "MustBeInt" OpHelp(""), + /* 39 */ "RealAffinity" OpHelp(""), + /* 40 */ "Cast" OpHelp("affinity(r[P1])"), + /* 41 */ "Permutation" OpHelp(""), + /* 42 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"), + /* 43 */ "Jump" OpHelp(""), + /* 44 */ "Once" OpHelp(""), + /* 45 */ "If" OpHelp(""), + /* 46 */ "IfNot" OpHelp(""), + /* 47 */ "Column" OpHelp("r[P3]=PX"), + /* 48 */ "Affinity" OpHelp("affinity(r[P1@P2])"), + /* 49 */ "MakeRecord" OpHelp("r[P3]=mkrec(r[P1@P2])"), + /* 50 */ "Count" OpHelp("r[P2]=count()"), + /* 51 */ "ReadCookie" OpHelp(""), + /* 52 */ "SetCookie" OpHelp(""), + /* 53 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"), + /* 54 */ "OpenRead" OpHelp("root=P2 iDb=P3"), + /* 55 */ "OpenWrite" OpHelp("root=P2 iDb=P3"), + /* 56 */ "OpenAutoindex" OpHelp("nColumn=P2"), + /* 57 */ "OpenEphemeral" OpHelp("nColumn=P2"), + /* 58 */ "SorterOpen" OpHelp(""), + /* 59 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"), + /* 60 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"), + /* 61 */ "Close" OpHelp(""), + /* 62 */ "ColumnsUsed" OpHelp(""), + /* 63 */ "SeekLT" OpHelp("key=r[P3@P4]"), + /* 64 */ "SeekLE" OpHelp("key=r[P3@P4]"), + /* 65 */ "SeekGE" OpHelp("key=r[P3@P4]"), + /* 66 */ "SeekGT" OpHelp("key=r[P3@P4]"), + /* 67 */ "Seek" OpHelp("intkey=r[P2]"), + /* 68 */ "NoConflict" OpHelp("key=r[P3@P4]"), + /* 69 */ "NotFound" OpHelp("key=r[P3@P4]"), + /* 70 */ "Found" OpHelp("key=r[P3@P4]"), + /* 71 */ "Or" OpHelp("r[P3]=(r[P1] || r[P2])"), + /* 72 */ "And" OpHelp("r[P3]=(r[P1] && r[P2])"), + /* 73 */ "NotExists" OpHelp("intkey=r[P3]"), + /* 74 */ "Sequence" OpHelp("r[P2]=cursor[P1].ctr++"), + /* 75 */ "NewRowid" OpHelp("r[P2]=rowid"), + /* 76 */ "IsNull" OpHelp("if r[P1]==NULL goto P2"), + /* 77 */ "NotNull" OpHelp("if r[P1]!=NULL goto P2"), + /* 78 */ "Ne" OpHelp("if r[P1]!=r[P3] goto P2"), + /* 79 */ "Eq" OpHelp("if r[P1]==r[P3] goto P2"), + /* 80 */ "Gt" OpHelp("if r[P1]>r[P3] goto P2"), + /* 81 */ "Le" OpHelp("if r[P1]<=r[P3] goto P2"), + /* 82 */ "Lt" OpHelp("if r[P1]=r[P3] goto P2"), + /* 84 */ "Insert" OpHelp("intkey=r[P3] data=r[P2]"), + /* 85 */ "BitAnd" OpHelp("r[P3]=r[P1]&r[P2]"), + /* 86 */ "BitOr" OpHelp("r[P3]=r[P1]|r[P2]"), + /* 87 */ "ShiftLeft" OpHelp("r[P3]=r[P2]<>r[P1]"), + /* 89 */ "Add" OpHelp("r[P3]=r[P1]+r[P2]"), + /* 90 */ "Subtract" OpHelp("r[P3]=r[P2]-r[P1]"), + /* 91 */ "Multiply" OpHelp("r[P3]=r[P1]*r[P2]"), + /* 92 */ "Divide" OpHelp("r[P3]=r[P2]/r[P1]"), + /* 93 */ "Remainder" OpHelp("r[P3]=r[P2]%r[P1]"), + /* 94 */ "Concat" OpHelp("r[P3]=r[P2]+r[P1]"), + /* 95 */ "InsertInt" OpHelp("intkey=P3 data=r[P2]"), + /* 96 */ "BitNot" OpHelp("r[P1]= ~r[P1]"), + /* 97 */ "String8" OpHelp("r[P2]='P4'"), + /* 98 */ "Delete" OpHelp(""), + /* 99 */ "ResetCount" OpHelp(""), + /* 100 */ "SorterCompare" OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"), + /* 101 */ "SorterData" OpHelp("r[P2]=data"), + /* 102 */ "RowKey" OpHelp("r[P2]=key"), + /* 103 */ "RowData" OpHelp("r[P2]=data"), + /* 104 */ "Rowid" OpHelp("r[P2]=rowid"), + /* 105 */ "NullRow" OpHelp(""), + /* 106 */ "Last" OpHelp(""), + /* 107 */ "SorterSort" OpHelp(""), + /* 108 */ "Sort" OpHelp(""), + /* 109 */ "Rewind" OpHelp(""), + /* 110 */ "SorterInsert" OpHelp(""), + /* 111 */ "IdxInsert" OpHelp("key=r[P2]"), + /* 112 */ "IdxDelete" OpHelp("key=r[P2@P3]"), + /* 113 */ "IdxRowid" OpHelp("r[P2]=rowid"), + /* 114 */ "IdxLE" OpHelp("key=r[P3@P4]"), + /* 115 */ "IdxGT" OpHelp("key=r[P3@P4]"), + /* 116 */ "IdxLT" OpHelp("key=r[P3@P4]"), + /* 117 */ "IdxGE" OpHelp("key=r[P3@P4]"), + /* 118 */ "Destroy" OpHelp(""), + /* 119 */ "Clear" OpHelp(""), + /* 120 */ "ResetSorter" OpHelp(""), + /* 121 */ "CreateIndex" OpHelp("r[P2]=root iDb=P1"), + /* 122 */ "CreateTable" OpHelp("r[P2]=root iDb=P1"), + /* 123 */ "ParseSchema" OpHelp(""), + /* 124 */ "LoadAnalysis" OpHelp(""), + /* 125 */ "DropTable" OpHelp(""), + /* 126 */ "DropIndex" OpHelp(""), + /* 127 */ "DropTrigger" OpHelp(""), + /* 128 */ "IntegrityCk" OpHelp(""), + /* 129 */ "RowSetAdd" OpHelp("rowset(P1)=r[P2]"), + /* 130 */ "RowSetRead" OpHelp("r[P3]=rowset(P1)"), + /* 131 */ "RowSetTest" OpHelp("if r[P3] in rowset(P1) goto P2"), + /* 132 */ "Program" OpHelp(""), + /* 133 */ "Real" OpHelp("r[P2]=P4"), + /* 134 */ "Param" OpHelp(""), + /* 135 */ "FkCounter" OpHelp("fkctr[P1]+=P2"), + /* 136 */ "FkIfZero" OpHelp("if fkctr[P1]==0 goto P2"), + /* 137 */ "MemMax" OpHelp("r[P1]=max(r[P1],r[P2])"), + /* 138 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"), + /* 139 */ "SetIfNotPos" OpHelp("if r[P1]<=0 then r[P2]=P3"), + /* 140 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]-=P3, goto P2"), + /* 141 */ "DecrJumpZero" OpHelp("if (--r[P1])==0 goto P2"), + /* 142 */ "JumpZeroIncr" OpHelp("if (r[P1]++)==0 ) goto P2"), + /* 143 */ "AggStep0" OpHelp("accum=r[P3] step(r[P2@P5])"), + /* 144 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"), + /* 145 */ "AggFinal" OpHelp("accum=r[P1] N=P2"), + /* 146 */ "IncrVacuum" OpHelp(""), + /* 147 */ "Expire" OpHelp(""), + /* 148 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"), + /* 149 */ "VBegin" OpHelp(""), + /* 150 */ "VCreate" OpHelp(""), + /* 151 */ "VDestroy" OpHelp(""), + /* 152 */ "VOpen" OpHelp(""), + /* 153 */ "VColumn" OpHelp("r[P3]=vcolumn(P2)"), + /* 154 */ "VNext" OpHelp(""), + /* 155 */ "VRename" OpHelp(""), + /* 156 */ "Pagecount" OpHelp(""), + /* 157 */ "MaxPgcnt" OpHelp(""), + /* 158 */ "Init" OpHelp("Start at P2"), + /* 159 */ "Noop" OpHelp(""), + /* 160 */ "Explain" OpHelp(""), + }; + return azName[i]; +} +#endif + +/************** End of opcodes.c *********************************************/ +/************** Begin file os_unix.c *****************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains the VFS implementation for unix-like operating systems +** include Linux, MacOSX, *BSD, QNX, VxWorks, AIX, HPUX, and others. +** +** There are actually several different VFS implementations in this file. +** The differences are in the way that file locking is done. The default +** implementation uses Posix Advisory Locks. Alternative implementations +** use flock(), dot-files, various proprietary locking schemas, or simply +** skip locking all together. +** +** This source file is organized into divisions where the logic for various +** subfunctions is contained within the appropriate division. PLEASE +** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed +** in the correct division and should be clearly labeled. +** +** The layout of divisions is as follows: +** +** * General-purpose declarations and utility functions. +** * Unique file ID logic used by VxWorks. +** * Various locking primitive implementations (all except proxy locking): +** + for Posix Advisory Locks +** + for no-op locks +** + for dot-file locks +** + for flock() locking +** + for named semaphore locks (VxWorks only) +** + for AFP filesystem locks (MacOSX only) +** * sqlite3_file methods not associated with locking. +** * Definitions of sqlite3_io_methods objects for all locking +** methods plus "finder" functions for each locking method. +** * sqlite3_vfs method implementations. +** * Locking primitives for the proxy uber-locking-method. (MacOSX only) +** * Definitions of sqlite3_vfs objects for all locking methods +** plus implementations of sqlite3_os_init() and sqlite3_os_end(). +*/ +/* #include "sqliteInt.h" */ +#if SQLITE_OS_UNIX /* This file is used on unix only */ + +/* +** There are various methods for file locking used for concurrency +** control: +** +** 1. POSIX locking (the default), +** 2. No locking, +** 3. Dot-file locking, +** 4. flock() locking, +** 5. AFP locking (OSX only), +** 6. Named POSIX semaphores (VXWorks only), +** 7. proxy locking. (OSX only) +** +** Styles 4, 5, and 7 are only available of SQLITE_ENABLE_LOCKING_STYLE +** is defined to 1. The SQLITE_ENABLE_LOCKING_STYLE also enables automatic +** selection of the appropriate locking style based on the filesystem +** where the database is located. +*/ +#if !defined(SQLITE_ENABLE_LOCKING_STYLE) +# if defined(__APPLE__) +# define SQLITE_ENABLE_LOCKING_STYLE 1 +# else +# define SQLITE_ENABLE_LOCKING_STYLE 0 +# endif +#endif + +/* +** standard include files. +*/ +#include +#include +#include +#include +/* #include */ +#include +#include +#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 +# include +#endif + +#if SQLITE_ENABLE_LOCKING_STYLE +# include +# include +# include +#endif /* SQLITE_ENABLE_LOCKING_STYLE */ + +#if defined(__APPLE__) && ((__MAC_OS_X_VERSION_MIN_REQUIRED > 1050) || \ + (__IPHONE_OS_VERSION_MIN_REQUIRED > 2000)) +# if (!defined(TARGET_OS_EMBEDDED) || (TARGET_OS_EMBEDDED==0)) \ + && (!defined(TARGET_IPHONE_SIMULATOR) || (TARGET_IPHONE_SIMULATOR==0)) +# define HAVE_GETHOSTUUID 1 +# else +# warning "gethostuuid() is disabled." +# endif +#endif + + +#if OS_VXWORKS +/* # include */ +# include +# include +#endif /* OS_VXWORKS */ + +#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE +# include +#endif + +#ifdef HAVE_UTIME +# include +#endif + +/* +** Allowed values of unixFile.fsFlags +*/ +#define SQLITE_FSFLAGS_IS_MSDOS 0x1 + +/* +** If we are to be thread-safe, include the pthreads header and define +** the SQLITE_UNIX_THREADS macro. +*/ +#if SQLITE_THREADSAFE +/* # include */ +# define SQLITE_UNIX_THREADS 1 +#endif + +/* +** Default permissions when creating a new file +*/ +#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS +# define SQLITE_DEFAULT_FILE_PERMISSIONS 0644 +#endif + +/* +** Default permissions when creating auto proxy dir +*/ +#ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS +# define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755 +#endif + +/* +** Maximum supported path-length. +*/ +#define MAX_PATHNAME 512 + +/* Always cast the getpid() return type for compatibility with +** kernel modules in VxWorks. */ +#define osGetpid(X) (pid_t)getpid() + +/* +** Only set the lastErrno if the error code is a real error and not +** a normal expected return code of SQLITE_BUSY or SQLITE_OK +*/ +#define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY)) + +/* Forward references */ +typedef struct unixShm unixShm; /* Connection shared memory */ +typedef struct unixShmNode unixShmNode; /* Shared memory instance */ +typedef struct unixInodeInfo unixInodeInfo; /* An i-node */ +typedef struct UnixUnusedFd UnixUnusedFd; /* An unused file descriptor */ + +/* +** Sometimes, after a file handle is closed by SQLite, the file descriptor +** cannot be closed immediately. In these cases, instances of the following +** structure are used to store the file descriptor while waiting for an +** opportunity to either close or reuse it. +*/ +struct UnixUnusedFd { + int fd; /* File descriptor to close */ + int flags; /* Flags this file descriptor was opened with */ + UnixUnusedFd *pNext; /* Next unused file descriptor on same file */ +}; + +/* +** The unixFile structure is subclass of sqlite3_file specific to the unix +** VFS implementations. +*/ +typedef struct unixFile unixFile; +struct unixFile { + sqlite3_io_methods const *pMethod; /* Always the first entry */ + sqlite3_vfs *pVfs; /* The VFS that created this unixFile */ + unixInodeInfo *pInode; /* Info about locks on this inode */ + int h; /* The file descriptor */ + unsigned char eFileLock; /* The type of lock held on this fd */ + unsigned short int ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */ + int lastErrno; /* The unix errno from last I/O error */ + void *lockingContext; /* Locking style specific state */ + UnixUnusedFd *pUnused; /* Pre-allocated UnixUnusedFd */ + const char *zPath; /* Name of the file */ + unixShm *pShm; /* Shared memory segment information */ + int szChunk; /* Configured by FCNTL_CHUNK_SIZE */ +#if SQLITE_MAX_MMAP_SIZE>0 + int nFetchOut; /* Number of outstanding xFetch refs */ + sqlite3_int64 mmapSize; /* Usable size of mapping at pMapRegion */ + sqlite3_int64 mmapSizeActual; /* Actual size of mapping at pMapRegion */ + sqlite3_int64 mmapSizeMax; /* Configured FCNTL_MMAP_SIZE value */ + void *pMapRegion; /* Memory mapped region */ +#endif +#ifdef __QNXNTO__ + int sectorSize; /* Device sector size */ + int deviceCharacteristics; /* Precomputed device characteristics */ +#endif +#if SQLITE_ENABLE_LOCKING_STYLE + int openFlags; /* The flags specified at open() */ +#endif +#if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__) + unsigned fsFlags; /* cached details from statfs() */ +#endif +#if OS_VXWORKS + struct vxworksFileId *pId; /* Unique file ID */ +#endif +#ifdef SQLITE_DEBUG + /* The next group of variables are used to track whether or not the + ** transaction counter in bytes 24-27 of database files are updated + ** whenever any part of the database changes. An assertion fault will + ** occur if a file is updated without also updating the transaction + ** counter. This test is made to avoid new problems similar to the + ** one described by ticket #3584. + */ + unsigned char transCntrChng; /* True if the transaction counter changed */ + unsigned char dbUpdate; /* True if any part of database file changed */ + unsigned char inNormalWrite; /* True if in a normal write operation */ + +#endif + +#ifdef SQLITE_TEST + /* In test mode, increase the size of this structure a bit so that + ** it is larger than the struct CrashFile defined in test6.c. + */ + char aPadding[32]; +#endif +}; + +/* This variable holds the process id (pid) from when the xRandomness() +** method was called. If xOpen() is called from a different process id, +** indicating that a fork() has occurred, the PRNG will be reset. +*/ +static pid_t randomnessPid = 0; + +/* +** Allowed values for the unixFile.ctrlFlags bitmask: +*/ +#define UNIXFILE_EXCL 0x01 /* Connections from one process only */ +#define UNIXFILE_RDONLY 0x02 /* Connection is read only */ +#define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */ +#ifndef SQLITE_DISABLE_DIRSYNC +# define UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */ +#else +# define UNIXFILE_DIRSYNC 0x00 +#endif +#define UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */ +#define UNIXFILE_DELETE 0x20 /* Delete on close */ +#define UNIXFILE_URI 0x40 /* Filename might have query parameters */ +#define UNIXFILE_NOLOCK 0x80 /* Do no file locking */ +#define UNIXFILE_WARNED 0x0100 /* verifyDbFile() warnings issued */ +#define UNIXFILE_BLOCK 0x0200 /* Next SHM lock might block */ + +/* +** Include code that is common to all os_*.c files +*/ +/************** Include os_common.h in the middle of os_unix.c ***************/ +/************** Begin file os_common.h ***************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains macros and a little bit of code that is common to +** all of the platform-specific files (os_*.c) and is #included into those +** files. +** +** This file should be #included by the os_*.c files only. It is not a +** general purpose header file. +*/ +#ifndef _OS_COMMON_H_ +#define _OS_COMMON_H_ + +/* +** At least two bugs have slipped in because we changed the MEMORY_DEBUG +** macro to SQLITE_DEBUG and some older makefiles have not yet made the +** switch. The following code should catch this problem at compile-time. +*/ +#ifdef MEMORY_DEBUG +# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." +#endif + +/* +** Macros for performance tracing. Normally turned off. Only works +** on i486 hardware. +*/ +#ifdef SQLITE_PERFORMANCE_TRACE + +/* +** hwtime.h contains inline assembler code for implementing +** high-performance timing routines. +*/ +/************** Include hwtime.h in the middle of os_common.h ****************/ +/************** Begin file hwtime.h ******************************************/ +/* +** 2008 May 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains inline asm code for retrieving "high-performance" +** counters for x86 class CPUs. +*/ +#ifndef _HWTIME_H_ +#define _HWTIME_H_ + +/* +** The following routine only works on pentium-class (or newer) processors. +** It uses the RDTSC opcode to read the cycle count value out of the +** processor and returns that value. This can be used for high-res +** profiling. +*/ +#if (defined(__GNUC__) || defined(_MSC_VER)) && \ + (defined(i386) || defined(__i386__) || defined(_M_IX86)) + + #if defined(__GNUC__) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned int lo, hi; + __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); + return (sqlite_uint64)hi << 32 | lo; + } + + #elif defined(_MSC_VER) + + __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ + __asm { + rdtsc + ret ; return value at EDX:EAX + } + } + + #endif + +#elif (defined(__GNUC__) && defined(__x86_64__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long val; + __asm__ __volatile__ ("rdtsc" : "=A" (val)); + return val; + } + +#elif (defined(__GNUC__) && defined(__ppc__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long long retval; + unsigned long junk; + __asm__ __volatile__ ("\n\ + 1: mftbu %1\n\ + mftb %L0\n\ + mftbu %0\n\ + cmpw %0,%1\n\ + bne 1b" + : "=r" (retval), "=r" (junk)); + return retval; + } + +#else + + #error Need implementation of sqlite3Hwtime() for your platform. + + /* + ** To compile without implementing sqlite3Hwtime() for your platform, + ** you can remove the above #error and use the following + ** stub function. You will lose timing support for many + ** of the debugging and testing utilities, but it should at + ** least compile and run. + */ +SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } + +#endif + +#endif /* !defined(_HWTIME_H_) */ + +/************** End of hwtime.h **********************************************/ +/************** Continuing where we left off in os_common.h ******************/ + +static sqlite_uint64 g_start; +static sqlite_uint64 g_elapsed; +#define TIMER_START g_start=sqlite3Hwtime() +#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start +#define TIMER_ELAPSED g_elapsed +#else +#define TIMER_START +#define TIMER_END +#define TIMER_ELAPSED ((sqlite_uint64)0) +#endif + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_io_error_hit = 0; /* Total number of I/O Errors */ +SQLITE_API int sqlite3_io_error_hardhit = 0; /* Number of non-benign errors */ +SQLITE_API int sqlite3_io_error_pending = 0; /* Count down to first I/O error */ +SQLITE_API int sqlite3_io_error_persist = 0; /* True if I/O errors persist */ +SQLITE_API int sqlite3_io_error_benign = 0; /* True if errors are benign */ +SQLITE_API int sqlite3_diskfull_pending = 0; +SQLITE_API int sqlite3_diskfull = 0; +#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) +#define SimulateIOError(CODE) \ + if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ + || sqlite3_io_error_pending-- == 1 ) \ + { local_ioerr(); CODE; } +static void local_ioerr(){ + IOTRACE(("IOERR\n")); + sqlite3_io_error_hit++; + if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; +} +#define SimulateDiskfullError(CODE) \ + if( sqlite3_diskfull_pending ){ \ + if( sqlite3_diskfull_pending == 1 ){ \ + local_ioerr(); \ + sqlite3_diskfull = 1; \ + sqlite3_io_error_hit = 1; \ + CODE; \ + }else{ \ + sqlite3_diskfull_pending--; \ + } \ + } +#else +#define SimulateIOErrorBenign(X) +#define SimulateIOError(A) +#define SimulateDiskfullError(A) +#endif + +/* +** When testing, keep a count of the number of open files. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_open_file_count = 0; +#define OpenCounter(X) sqlite3_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif + +#endif /* !defined(_OS_COMMON_H_) */ + +/************** End of os_common.h *******************************************/ +/************** Continuing where we left off in os_unix.c ********************/ + +/* +** Define various macros that are missing from some systems. +*/ +#ifndef O_LARGEFILE +# define O_LARGEFILE 0 +#endif +#ifdef SQLITE_DISABLE_LFS +# undef O_LARGEFILE +# define O_LARGEFILE 0 +#endif +#ifndef O_NOFOLLOW +# define O_NOFOLLOW 0 +#endif +#ifndef O_BINARY +# define O_BINARY 0 +#endif + +/* +** The threadid macro resolves to the thread-id or to 0. Used for +** testing and debugging only. +*/ +#if SQLITE_THREADSAFE +#define threadid pthread_self() +#else +#define threadid 0 +#endif + +/* +** HAVE_MREMAP defaults to true on Linux and false everywhere else. +*/ +#if !defined(HAVE_MREMAP) +# if defined(__linux__) && defined(_GNU_SOURCE) +# define HAVE_MREMAP 1 +# else +# define HAVE_MREMAP 0 +# endif +#endif + +/* +** Explicitly call the 64-bit version of lseek() on Android. Otherwise, lseek() +** is the 32-bit version, even if _FILE_OFFSET_BITS=64 is defined. +*/ +#ifdef __ANDROID__ +# define lseek lseek64 +#endif + +/* +** Different Unix systems declare open() in different ways. Same use +** open(const char*,int,mode_t). Others use open(const char*,int,...). +** The difference is important when using a pointer to the function. +** +** The safest way to deal with the problem is to always use this wrapper +** which always has the same well-defined interface. +*/ +static int posixOpen(const char *zFile, int flags, int mode){ + return open(zFile, flags, mode); +} + +/* +** On some systems, calls to fchown() will trigger a message in a security +** log if they come from non-root processes. So avoid calling fchown() if +** we are not running as root. +*/ +static int posixFchown(int fd, uid_t uid, gid_t gid){ +#if OS_VXWORKS + return 0; +#else + return geteuid() ? 0 : fchown(fd,uid,gid); +#endif +} + +/* Forward reference */ +static int openDirectory(const char*, int*); +static int unixGetpagesize(void); + +/* +** Many system calls are accessed through pointer-to-functions so that +** they may be overridden at runtime to facilitate fault injection during +** testing and sandboxing. The following array holds the names and pointers +** to all overrideable system calls. +*/ +static struct unix_syscall { + const char *zName; /* Name of the system call */ + sqlite3_syscall_ptr pCurrent; /* Current value of the system call */ + sqlite3_syscall_ptr pDefault; /* Default value */ +} aSyscall[] = { + { "open", (sqlite3_syscall_ptr)posixOpen, 0 }, +#define osOpen ((int(*)(const char*,int,int))aSyscall[0].pCurrent) + + { "close", (sqlite3_syscall_ptr)close, 0 }, +#define osClose ((int(*)(int))aSyscall[1].pCurrent) + + { "access", (sqlite3_syscall_ptr)access, 0 }, +#define osAccess ((int(*)(const char*,int))aSyscall[2].pCurrent) + + { "getcwd", (sqlite3_syscall_ptr)getcwd, 0 }, +#define osGetcwd ((char*(*)(char*,size_t))aSyscall[3].pCurrent) + + { "stat", (sqlite3_syscall_ptr)stat, 0 }, +#define osStat ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent) + +/* +** The DJGPP compiler environment looks mostly like Unix, but it +** lacks the fcntl() system call. So redefine fcntl() to be something +** that always succeeds. This means that locking does not occur under +** DJGPP. But it is DOS - what did you expect? +*/ +#ifdef __DJGPP__ + { "fstat", 0, 0 }, +#define osFstat(a,b,c) 0 +#else + { "fstat", (sqlite3_syscall_ptr)fstat, 0 }, +#define osFstat ((int(*)(int,struct stat*))aSyscall[5].pCurrent) +#endif + + { "ftruncate", (sqlite3_syscall_ptr)ftruncate, 0 }, +#define osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent) + + { "fcntl", (sqlite3_syscall_ptr)fcntl, 0 }, +#define osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent) + + { "read", (sqlite3_syscall_ptr)read, 0 }, +#define osRead ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent) + +#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE + { "pread", (sqlite3_syscall_ptr)pread, 0 }, +#else + { "pread", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent) + +#if defined(USE_PREAD64) + { "pread64", (sqlite3_syscall_ptr)pread64, 0 }, +#else + { "pread64", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPread64 ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent) + + { "write", (sqlite3_syscall_ptr)write, 0 }, +#define osWrite ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent) + +#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE + { "pwrite", (sqlite3_syscall_ptr)pwrite, 0 }, +#else + { "pwrite", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPwrite ((ssize_t(*)(int,const void*,size_t,off_t))\ + aSyscall[12].pCurrent) + +#if defined(USE_PREAD64) + { "pwrite64", (sqlite3_syscall_ptr)pwrite64, 0 }, +#else + { "pwrite64", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPwrite64 ((ssize_t(*)(int,const void*,size_t,off_t))\ + aSyscall[13].pCurrent) + + { "fchmod", (sqlite3_syscall_ptr)fchmod, 0 }, +#define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent) + +#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE + { "fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 }, +#else + { "fallocate", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent) + + { "unlink", (sqlite3_syscall_ptr)unlink, 0 }, +#define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent) + + { "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 }, +#define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent) + + { "mkdir", (sqlite3_syscall_ptr)mkdir, 0 }, +#define osMkdir ((int(*)(const char*,mode_t))aSyscall[18].pCurrent) + + { "rmdir", (sqlite3_syscall_ptr)rmdir, 0 }, +#define osRmdir ((int(*)(const char*))aSyscall[19].pCurrent) + + { "fchown", (sqlite3_syscall_ptr)posixFchown, 0 }, +#define osFchown ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent) + +#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + { "mmap", (sqlite3_syscall_ptr)mmap, 0 }, +#define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[21].pCurrent) + + { "munmap", (sqlite3_syscall_ptr)munmap, 0 }, +#define osMunmap ((void*(*)(void*,size_t))aSyscall[22].pCurrent) + +#if HAVE_MREMAP + { "mremap", (sqlite3_syscall_ptr)mremap, 0 }, +#else + { "mremap", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osMremap ((void*(*)(void*,size_t,size_t,int,...))aSyscall[23].pCurrent) + { "getpagesize", (sqlite3_syscall_ptr)unixGetpagesize, 0 }, +#define osGetpagesize ((int(*)(void))aSyscall[24].pCurrent) + +#endif + +}; /* End of the overrideable system calls */ + +/* +** This is the xSetSystemCall() method of sqlite3_vfs for all of the +** "unix" VFSes. Return SQLITE_OK opon successfully updating the +** system call pointer, or SQLITE_NOTFOUND if there is no configurable +** system call named zName. +*/ +static int unixSetSystemCall( + sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */ + const char *zName, /* Name of system call to override */ + sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */ +){ + unsigned int i; + int rc = SQLITE_NOTFOUND; + + UNUSED_PARAMETER(pNotUsed); + if( zName==0 ){ + /* If no zName is given, restore all system calls to their default + ** settings and return NULL + */ + rc = SQLITE_OK; + for(i=0; i=SQLITE_MINIMUM_FILE_DESCRIPTOR ) break; + osClose(fd); + sqlite3_log(SQLITE_WARNING, + "attempt to open \"%s\" as file descriptor %d", z, fd); + fd = -1; + if( osOpen("/dev/null", f, m)<0 ) break; + } + if( fd>=0 ){ + if( m!=0 ){ + struct stat statbuf; + if( osFstat(fd, &statbuf)==0 + && statbuf.st_size==0 + && (statbuf.st_mode&0777)!=m + ){ + osFchmod(fd, m); + } + } +#if defined(FD_CLOEXEC) && (!defined(O_CLOEXEC) || O_CLOEXEC==0) + osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC); +#endif + } + return fd; +} + +/* +** Helper functions to obtain and relinquish the global mutex. The +** global mutex is used to protect the unixInodeInfo and +** vxworksFileId objects used by this file, all of which may be +** shared by multiple threads. +** +** Function unixMutexHeld() is used to assert() that the global mutex +** is held when required. This function is only used as part of assert() +** statements. e.g. +** +** unixEnterMutex() +** assert( unixMutexHeld() ); +** unixEnterLeave() +*/ +static void unixEnterMutex(void){ + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1)); +} +static void unixLeaveMutex(void){ + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1)); +} +#ifdef SQLITE_DEBUG +static int unixMutexHeld(void) { + return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1)); +} +#endif + + +#ifdef SQLITE_HAVE_OS_TRACE +/* +** Helper function for printing out trace information from debugging +** binaries. This returns the string representation of the supplied +** integer lock-type. +*/ +static const char *azFileLock(int eFileLock){ + switch( eFileLock ){ + case NO_LOCK: return "NONE"; + case SHARED_LOCK: return "SHARED"; + case RESERVED_LOCK: return "RESERVED"; + case PENDING_LOCK: return "PENDING"; + case EXCLUSIVE_LOCK: return "EXCLUSIVE"; + } + return "ERROR"; +} +#endif + +#ifdef SQLITE_LOCK_TRACE +/* +** Print out information about all locking operations. +** +** This routine is used for troubleshooting locks on multithreaded +** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE +** command-line option on the compiler. This code is normally +** turned off. +*/ +static int lockTrace(int fd, int op, struct flock *p){ + char *zOpName, *zType; + int s; + int savedErrno; + if( op==F_GETLK ){ + zOpName = "GETLK"; + }else if( op==F_SETLK ){ + zOpName = "SETLK"; + }else{ + s = osFcntl(fd, op, p); + sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s); + return s; + } + if( p->l_type==F_RDLCK ){ + zType = "RDLCK"; + }else if( p->l_type==F_WRLCK ){ + zType = "WRLCK"; + }else if( p->l_type==F_UNLCK ){ + zType = "UNLCK"; + }else{ + assert( 0 ); + } + assert( p->l_whence==SEEK_SET ); + s = osFcntl(fd, op, p); + savedErrno = errno; + sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n", + threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len, + (int)p->l_pid, s); + if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){ + struct flock l2; + l2 = *p; + osFcntl(fd, F_GETLK, &l2); + if( l2.l_type==F_RDLCK ){ + zType = "RDLCK"; + }else if( l2.l_type==F_WRLCK ){ + zType = "WRLCK"; + }else if( l2.l_type==F_UNLCK ){ + zType = "UNLCK"; + }else{ + assert( 0 ); + } + sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n", + zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid); + } + errno = savedErrno; + return s; +} +#undef osFcntl +#define osFcntl lockTrace +#endif /* SQLITE_LOCK_TRACE */ + +/* +** Retry ftruncate() calls that fail due to EINTR +** +** All calls to ftruncate() within this file should be made through +** this wrapper. On the Android platform, bypassing the logic below +** could lead to a corrupt database. +*/ +static int robust_ftruncate(int h, sqlite3_int64 sz){ + int rc; +#ifdef __ANDROID__ + /* On Android, ftruncate() always uses 32-bit offsets, even if + ** _FILE_OFFSET_BITS=64 is defined. This means it is unsafe to attempt to + ** truncate a file to any size larger than 2GiB. Silently ignore any + ** such attempts. */ + if( sz>(sqlite3_int64)0x7FFFFFFF ){ + rc = SQLITE_OK; + }else +#endif + do{ rc = osFtruncate(h,sz); }while( rc<0 && errno==EINTR ); + return rc; +} + +/* +** This routine translates a standard POSIX errno code into something +** useful to the clients of the sqlite3 functions. Specifically, it is +** intended to translate a variety of "try again" errors into SQLITE_BUSY +** and a variety of "please close the file descriptor NOW" errors into +** SQLITE_IOERR +** +** Errors during initialization of locks, or file system support for locks, +** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately. +*/ +static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) { + switch (posixError) { +#if 0 + /* At one point this code was not commented out. In theory, this branch + ** should never be hit, as this function should only be called after + ** a locking-related function (i.e. fcntl()) has returned non-zero with + ** the value of errno as the first argument. Since a system call has failed, + ** errno should be non-zero. + ** + ** Despite this, if errno really is zero, we still don't want to return + ** SQLITE_OK. The system call failed, and *some* SQLite error should be + ** propagated back to the caller. Commenting this branch out means errno==0 + ** will be handled by the "default:" case below. + */ + case 0: + return SQLITE_OK; +#endif + + case EAGAIN: + case ETIMEDOUT: + case EBUSY: + case EINTR: + case ENOLCK: + /* random NFS retry error, unless during file system support + * introspection, in which it actually means what it says */ + return SQLITE_BUSY; + + case EACCES: + /* EACCES is like EAGAIN during locking operations, but not any other time*/ + if( (sqliteIOErr == SQLITE_IOERR_LOCK) || + (sqliteIOErr == SQLITE_IOERR_UNLOCK) || + (sqliteIOErr == SQLITE_IOERR_RDLOCK) || + (sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK) ){ + return SQLITE_BUSY; + } + /* else fall through */ + case EPERM: + return SQLITE_PERM; + +#if EOPNOTSUPP!=ENOTSUP + case EOPNOTSUPP: + /* something went terribly awry, unless during file system support + * introspection, in which it actually means what it says */ +#endif +#ifdef ENOTSUP + case ENOTSUP: + /* invalid fd, unless during file system support introspection, in which + * it actually means what it says */ +#endif + case EIO: + case EBADF: + case EINVAL: + case ENOTCONN: + case ENODEV: + case ENXIO: + case ENOENT: +#ifdef ESTALE /* ESTALE is not defined on Interix systems */ + case ESTALE: +#endif + case ENOSYS: + /* these should force the client to close the file and reconnect */ + + default: + return sqliteIOErr; + } +} + + +/****************************************************************************** +****************** Begin Unique File ID Utility Used By VxWorks *************** +** +** On most versions of unix, we can get a unique ID for a file by concatenating +** the device number and the inode number. But this does not work on VxWorks. +** On VxWorks, a unique file id must be based on the canonical filename. +** +** A pointer to an instance of the following structure can be used as a +** unique file ID in VxWorks. Each instance of this structure contains +** a copy of the canonical filename. There is also a reference count. +** The structure is reclaimed when the number of pointers to it drops to +** zero. +** +** There are never very many files open at one time and lookups are not +** a performance-critical path, so it is sufficient to put these +** structures on a linked list. +*/ +struct vxworksFileId { + struct vxworksFileId *pNext; /* Next in a list of them all */ + int nRef; /* Number of references to this one */ + int nName; /* Length of the zCanonicalName[] string */ + char *zCanonicalName; /* Canonical filename */ +}; + +#if OS_VXWORKS +/* +** All unique filenames are held on a linked list headed by this +** variable: +*/ +static struct vxworksFileId *vxworksFileList = 0; + +/* +** Simplify a filename into its canonical form +** by making the following changes: +** +** * removing any trailing and duplicate / +** * convert /./ into just / +** * convert /A/../ where A is any simple name into just / +** +** Changes are made in-place. Return the new name length. +** +** The original filename is in z[0..n-1]. Return the number of +** characters in the simplified name. +*/ +static int vxworksSimplifyName(char *z, int n){ + int i, j; + while( n>1 && z[n-1]=='/' ){ n--; } + for(i=j=0; i0 && z[j-1]!='/' ){ j--; } + if( j>0 ){ j--; } + i += 2; + continue; + } + } + z[j++] = z[i]; + } + z[j] = 0; + return j; +} + +/* +** Find a unique file ID for the given absolute pathname. Return +** a pointer to the vxworksFileId object. This pointer is the unique +** file ID. +** +** The nRef field of the vxworksFileId object is incremented before +** the object is returned. A new vxworksFileId object is created +** and added to the global list if necessary. +** +** If a memory allocation error occurs, return NULL. +*/ +static struct vxworksFileId *vxworksFindFileId(const char *zAbsoluteName){ + struct vxworksFileId *pNew; /* search key and new file ID */ + struct vxworksFileId *pCandidate; /* For looping over existing file IDs */ + int n; /* Length of zAbsoluteName string */ + + assert( zAbsoluteName[0]=='/' ); + n = (int)strlen(zAbsoluteName); + pNew = sqlite3_malloc64( sizeof(*pNew) + (n+1) ); + if( pNew==0 ) return 0; + pNew->zCanonicalName = (char*)&pNew[1]; + memcpy(pNew->zCanonicalName, zAbsoluteName, n+1); + n = vxworksSimplifyName(pNew->zCanonicalName, n); + + /* Search for an existing entry that matching the canonical name. + ** If found, increment the reference count and return a pointer to + ** the existing file ID. + */ + unixEnterMutex(); + for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){ + if( pCandidate->nName==n + && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0 + ){ + sqlite3_free(pNew); + pCandidate->nRef++; + unixLeaveMutex(); + return pCandidate; + } + } + + /* No match was found. We will make a new file ID */ + pNew->nRef = 1; + pNew->nName = n; + pNew->pNext = vxworksFileList; + vxworksFileList = pNew; + unixLeaveMutex(); + return pNew; +} + +/* +** Decrement the reference count on a vxworksFileId object. Free +** the object when the reference count reaches zero. +*/ +static void vxworksReleaseFileId(struct vxworksFileId *pId){ + unixEnterMutex(); + assert( pId->nRef>0 ); + pId->nRef--; + if( pId->nRef==0 ){ + struct vxworksFileId **pp; + for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){} + assert( *pp==pId ); + *pp = pId->pNext; + sqlite3_free(pId); + } + unixLeaveMutex(); +} +#endif /* OS_VXWORKS */ +/*************** End of Unique File ID Utility Used By VxWorks **************** +******************************************************************************/ + + +/****************************************************************************** +*************************** Posix Advisory Locking **************************** +** +** POSIX advisory locks are broken by design. ANSI STD 1003.1 (1996) +** section 6.5.2.2 lines 483 through 490 specify that when a process +** sets or clears a lock, that operation overrides any prior locks set +** by the same process. It does not explicitly say so, but this implies +** that it overrides locks set by the same process using a different +** file descriptor. Consider this test case: +** +** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644); +** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644); +** +** Suppose ./file1 and ./file2 are really the same file (because +** one is a hard or symbolic link to the other) then if you set +** an exclusive lock on fd1, then try to get an exclusive lock +** on fd2, it works. I would have expected the second lock to +** fail since there was already a lock on the file due to fd1. +** But not so. Since both locks came from the same process, the +** second overrides the first, even though they were on different +** file descriptors opened on different file names. +** +** This means that we cannot use POSIX locks to synchronize file access +** among competing threads of the same process. POSIX locks will work fine +** to synchronize access for threads in separate processes, but not +** threads within the same process. +** +** To work around the problem, SQLite has to manage file locks internally +** on its own. Whenever a new database is opened, we have to find the +** specific inode of the database file (the inode is determined by the +** st_dev and st_ino fields of the stat structure that fstat() fills in) +** and check for locks already existing on that inode. When locks are +** created or removed, we have to look at our own internal record of the +** locks to see if another thread has previously set a lock on that same +** inode. +** +** (Aside: The use of inode numbers as unique IDs does not work on VxWorks. +** For VxWorks, we have to use the alternative unique ID system based on +** canonical filename and implemented in the previous division.) +** +** The sqlite3_file structure for POSIX is no longer just an integer file +** descriptor. It is now a structure that holds the integer file +** descriptor and a pointer to a structure that describes the internal +** locks on the corresponding inode. There is one locking structure +** per inode, so if the same inode is opened twice, both unixFile structures +** point to the same locking structure. The locking structure keeps +** a reference count (so we will know when to delete it) and a "cnt" +** field that tells us its internal lock status. cnt==0 means the +** file is unlocked. cnt==-1 means the file has an exclusive lock. +** cnt>0 means there are cnt shared locks on the file. +** +** Any attempt to lock or unlock a file first checks the locking +** structure. The fcntl() system call is only invoked to set a +** POSIX lock if the internal lock structure transitions between +** a locked and an unlocked state. +** +** But wait: there are yet more problems with POSIX advisory locks. +** +** If you close a file descriptor that points to a file that has locks, +** all locks on that file that are owned by the current process are +** released. To work around this problem, each unixInodeInfo object +** maintains a count of the number of pending locks on tha inode. +** When an attempt is made to close an unixFile, if there are +** other unixFile open on the same inode that are holding locks, the call +** to close() the file descriptor is deferred until all of the locks clear. +** The unixInodeInfo structure keeps a list of file descriptors that need to +** be closed and that list is walked (and cleared) when the last lock +** clears. +** +** Yet another problem: LinuxThreads do not play well with posix locks. +** +** Many older versions of linux use the LinuxThreads library which is +** not posix compliant. Under LinuxThreads, a lock created by thread +** A cannot be modified or overridden by a different thread B. +** Only thread A can modify the lock. Locking behavior is correct +** if the appliation uses the newer Native Posix Thread Library (NPTL) +** on linux - with NPTL a lock created by thread A can override locks +** in thread B. But there is no way to know at compile-time which +** threading library is being used. So there is no way to know at +** compile-time whether or not thread A can override locks on thread B. +** One has to do a run-time check to discover the behavior of the +** current process. +** +** SQLite used to support LinuxThreads. But support for LinuxThreads +** was dropped beginning with version 3.7.0. SQLite will still work with +** LinuxThreads provided that (1) there is no more than one connection +** per database file in the same process and (2) database connections +** do not move across threads. +*/ + +/* +** An instance of the following structure serves as the key used +** to locate a particular unixInodeInfo object. +*/ +struct unixFileId { + dev_t dev; /* Device number */ +#if OS_VXWORKS + struct vxworksFileId *pId; /* Unique file ID for vxworks. */ +#else + ino_t ino; /* Inode number */ +#endif +}; + +/* +** An instance of the following structure is allocated for each open +** inode. Or, on LinuxThreads, there is one of these structures for +** each inode opened by each thread. +** +** A single inode can have multiple file descriptors, so each unixFile +** structure contains a pointer to an instance of this object and this +** object keeps a count of the number of unixFile pointing to it. +*/ +struct unixInodeInfo { + struct unixFileId fileId; /* The lookup key */ + int nShared; /* Number of SHARED locks held */ + unsigned char eFileLock; /* One of SHARED_LOCK, RESERVED_LOCK etc. */ + unsigned char bProcessLock; /* An exclusive process lock is held */ + int nRef; /* Number of pointers to this structure */ + unixShmNode *pShmNode; /* Shared memory associated with this inode */ + int nLock; /* Number of outstanding file locks */ + UnixUnusedFd *pUnused; /* Unused file descriptors to close */ + unixInodeInfo *pNext; /* List of all unixInodeInfo objects */ + unixInodeInfo *pPrev; /* .... doubly linked */ +#if SQLITE_ENABLE_LOCKING_STYLE + unsigned long long sharedByte; /* for AFP simulated shared lock */ +#endif +#if OS_VXWORKS + sem_t *pSem; /* Named POSIX semaphore */ + char aSemName[MAX_PATHNAME+2]; /* Name of that semaphore */ +#endif +}; + +/* +** A lists of all unixInodeInfo objects. +*/ +static unixInodeInfo *inodeList = 0; + +/* +** +** This function - unixLogError_x(), is only ever called via the macro +** unixLogError(). +** +** It is invoked after an error occurs in an OS function and errno has been +** set. It logs a message using sqlite3_log() containing the current value of +** errno and, if possible, the human-readable equivalent from strerror() or +** strerror_r(). +** +** The first argument passed to the macro should be the error code that +** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN). +** The two subsequent arguments should be the name of the OS function that +** failed (e.g. "unlink", "open") and the associated file-system path, +** if any. +*/ +#define unixLogError(a,b,c) unixLogErrorAtLine(a,b,c,__LINE__) +static int unixLogErrorAtLine( + int errcode, /* SQLite error code */ + const char *zFunc, /* Name of OS function that failed */ + const char *zPath, /* File path associated with error */ + int iLine /* Source line number where error occurred */ +){ + char *zErr; /* Message from strerror() or equivalent */ + int iErrno = errno; /* Saved syscall error number */ + + /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use + ** the strerror() function to obtain the human-readable error message + ** equivalent to errno. Otherwise, use strerror_r(). + */ +#if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R) + char aErr[80]; + memset(aErr, 0, sizeof(aErr)); + zErr = aErr; + + /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined, + ** assume that the system provides the GNU version of strerror_r() that + ** returns a pointer to a buffer containing the error message. That pointer + ** may point to aErr[], or it may point to some static storage somewhere. + ** Otherwise, assume that the system provides the POSIX version of + ** strerror_r(), which always writes an error message into aErr[]. + ** + ** If the code incorrectly assumes that it is the POSIX version that is + ** available, the error message will often be an empty string. Not a + ** huge problem. Incorrectly concluding that the GNU version is available + ** could lead to a segfault though. + */ +#if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU) + zErr = +# endif + strerror_r(iErrno, aErr, sizeof(aErr)-1); + +#elif SQLITE_THREADSAFE + /* This is a threadsafe build, but strerror_r() is not available. */ + zErr = ""; +#else + /* Non-threadsafe build, use strerror(). */ + zErr = strerror(iErrno); +#endif + + if( zPath==0 ) zPath = ""; + sqlite3_log(errcode, + "os_unix.c:%d: (%d) %s(%s) - %s", + iLine, iErrno, zFunc, zPath, zErr + ); + + return errcode; +} + +/* +** Close a file descriptor. +** +** We assume that close() almost always works, since it is only in a +** very sick application or on a very sick platform that it might fail. +** If it does fail, simply leak the file descriptor, but do log the +** error. +** +** Note that it is not safe to retry close() after EINTR since the +** file descriptor might have already been reused by another thread. +** So we don't even try to recover from an EINTR. Just log the error +** and move on. +*/ +static void robust_close(unixFile *pFile, int h, int lineno){ + if( osClose(h) ){ + unixLogErrorAtLine(SQLITE_IOERR_CLOSE, "close", + pFile ? pFile->zPath : 0, lineno); + } +} + +/* +** Set the pFile->lastErrno. Do this in a subroutine as that provides +** a convenient place to set a breakpoint. +*/ +static void storeLastErrno(unixFile *pFile, int error){ + pFile->lastErrno = error; +} + +/* +** Close all file descriptors accumuated in the unixInodeInfo->pUnused list. +*/ +static void closePendingFds(unixFile *pFile){ + unixInodeInfo *pInode = pFile->pInode; + UnixUnusedFd *p; + UnixUnusedFd *pNext; + for(p=pInode->pUnused; p; p=pNext){ + pNext = p->pNext; + robust_close(pFile, p->fd, __LINE__); + sqlite3_free(p); + } + pInode->pUnused = 0; +} + +/* +** Release a unixInodeInfo structure previously allocated by findInodeInfo(). +** +** The mutex entered using the unixEnterMutex() function must be held +** when this function is called. +*/ +static void releaseInodeInfo(unixFile *pFile){ + unixInodeInfo *pInode = pFile->pInode; + assert( unixMutexHeld() ); + if( ALWAYS(pInode) ){ + pInode->nRef--; + if( pInode->nRef==0 ){ + assert( pInode->pShmNode==0 ); + closePendingFds(pFile); + if( pInode->pPrev ){ + assert( pInode->pPrev->pNext==pInode ); + pInode->pPrev->pNext = pInode->pNext; + }else{ + assert( inodeList==pInode ); + inodeList = pInode->pNext; + } + if( pInode->pNext ){ + assert( pInode->pNext->pPrev==pInode ); + pInode->pNext->pPrev = pInode->pPrev; + } + sqlite3_free(pInode); + } + } +} + +/* +** Given a file descriptor, locate the unixInodeInfo object that +** describes that file descriptor. Create a new one if necessary. The +** return value might be uninitialized if an error occurs. +** +** The mutex entered using the unixEnterMutex() function must be held +** when this function is called. +** +** Return an appropriate error code. +*/ +static int findInodeInfo( + unixFile *pFile, /* Unix file with file desc used in the key */ + unixInodeInfo **ppInode /* Return the unixInodeInfo object here */ +){ + int rc; /* System call return code */ + int fd; /* The file descriptor for pFile */ + struct unixFileId fileId; /* Lookup key for the unixInodeInfo */ + struct stat statbuf; /* Low-level file information */ + unixInodeInfo *pInode = 0; /* Candidate unixInodeInfo object */ + + assert( unixMutexHeld() ); + + /* Get low-level information about the file that we can used to + ** create a unique name for the file. + */ + fd = pFile->h; + rc = osFstat(fd, &statbuf); + if( rc!=0 ){ + storeLastErrno(pFile, errno); +#ifdef EOVERFLOW + if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS; +#endif + return SQLITE_IOERR; + } + +#ifdef __APPLE__ + /* On OS X on an msdos filesystem, the inode number is reported + ** incorrectly for zero-size files. See ticket #3260. To work + ** around this problem (we consider it a bug in OS X, not SQLite) + ** we always increase the file size to 1 by writing a single byte + ** prior to accessing the inode number. The one byte written is + ** an ASCII 'S' character which also happens to be the first byte + ** in the header of every SQLite database. In this way, if there + ** is a race condition such that another thread has already populated + ** the first page of the database, no damage is done. + */ + if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){ + do{ rc = osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR ); + if( rc!=1 ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR; + } + rc = osFstat(fd, &statbuf); + if( rc!=0 ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR; + } + } +#endif + + memset(&fileId, 0, sizeof(fileId)); + fileId.dev = statbuf.st_dev; +#if OS_VXWORKS + fileId.pId = pFile->pId; +#else + fileId.ino = statbuf.st_ino; +#endif + pInode = inodeList; + while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){ + pInode = pInode->pNext; + } + if( pInode==0 ){ + pInode = sqlite3_malloc64( sizeof(*pInode) ); + if( pInode==0 ){ + return SQLITE_NOMEM; + } + memset(pInode, 0, sizeof(*pInode)); + memcpy(&pInode->fileId, &fileId, sizeof(fileId)); + pInode->nRef = 1; + pInode->pNext = inodeList; + pInode->pPrev = 0; + if( inodeList ) inodeList->pPrev = pInode; + inodeList = pInode; + }else{ + pInode->nRef++; + } + *ppInode = pInode; + return SQLITE_OK; +} + +/* +** Return TRUE if pFile has been renamed or unlinked since it was first opened. +*/ +static int fileHasMoved(unixFile *pFile){ +#if OS_VXWORKS + return pFile->pInode!=0 && pFile->pId!=pFile->pInode->fileId.pId; +#else + struct stat buf; + return pFile->pInode!=0 && + (osStat(pFile->zPath, &buf)!=0 || buf.st_ino!=pFile->pInode->fileId.ino); +#endif +} + + +/* +** Check a unixFile that is a database. Verify the following: +** +** (1) There is exactly one hard link on the file +** (2) The file is not a symbolic link +** (3) The file has not been renamed or unlinked +** +** Issue sqlite3_log(SQLITE_WARNING,...) messages if anything is not right. +*/ +static void verifyDbFile(unixFile *pFile){ + struct stat buf; + int rc; + if( pFile->ctrlFlags & UNIXFILE_WARNED ){ + /* One or more of the following warnings have already been issued. Do not + ** repeat them so as not to clutter the error log */ + return; + } + rc = osFstat(pFile->h, &buf); + if( rc!=0 ){ + sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath); + pFile->ctrlFlags |= UNIXFILE_WARNED; + return; + } + if( buf.st_nlink==0 && (pFile->ctrlFlags & UNIXFILE_DELETE)==0 ){ + sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath); + pFile->ctrlFlags |= UNIXFILE_WARNED; + return; + } + if( buf.st_nlink>1 ){ + sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath); + pFile->ctrlFlags |= UNIXFILE_WARNED; + return; + } + if( fileHasMoved(pFile) ){ + sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath); + pFile->ctrlFlags |= UNIXFILE_WARNED; + return; + } +} + + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){ + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + unixEnterMutex(); /* Because pFile->pInode is shared across threads */ + + /* Check if a thread in this process holds such a lock */ + if( pFile->pInode->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. + */ +#ifndef __DJGPP__ + if( !reserved && !pFile->pInode->bProcessLock ){ + struct flock lock; + lock.l_whence = SEEK_SET; + lock.l_start = RESERVED_BYTE; + lock.l_len = 1; + lock.l_type = F_WRLCK; + if( osFcntl(pFile->h, F_GETLK, &lock) ){ + rc = SQLITE_IOERR_CHECKRESERVEDLOCK; + storeLastErrno(pFile, errno); + } else if( lock.l_type!=F_UNLCK ){ + reserved = 1; + } + } +#endif + + unixLeaveMutex(); + OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved)); + + *pResOut = reserved; + return rc; +} + +/* +** Attempt to set a system-lock on the file pFile. The lock is +** described by pLock. +** +** If the pFile was opened read/write from unix-excl, then the only lock +** ever obtained is an exclusive lock, and it is obtained exactly once +** the first time any lock is attempted. All subsequent system locking +** operations become no-ops. Locking operations still happen internally, +** in order to coordinate access between separate database connections +** within this process, but all of that is handled in memory and the +** operating system does not participate. +** +** This function is a pass-through to fcntl(F_SETLK) if pFile is using +** any VFS other than "unix-excl" or if pFile is opened on "unix-excl" +** and is read-only. +** +** Zero is returned if the call completes successfully, or -1 if a call +** to fcntl() fails. In this case, errno is set appropriately (by fcntl()). +*/ +static int unixFileLock(unixFile *pFile, struct flock *pLock){ + int rc; + unixInodeInfo *pInode = pFile->pInode; + assert( unixMutexHeld() ); + assert( pInode!=0 ); + if( ((pFile->ctrlFlags & UNIXFILE_EXCL)!=0 || pInode->bProcessLock) + && ((pFile->ctrlFlags & UNIXFILE_RDONLY)==0) + ){ + if( pInode->bProcessLock==0 ){ + struct flock lock; + assert( pInode->nLock==0 ); + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + lock.l_type = F_WRLCK; + rc = osFcntl(pFile->h, F_SETLK, &lock); + if( rc<0 ) return rc; + pInode->bProcessLock = 1; + pInode->nLock++; + }else{ + rc = 0; + } + }else{ + rc = osFcntl(pFile->h, F_SETLK, pLock); + } + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int unixLock(sqlite3_file *id, int eFileLock){ + /* The following describes the implementation of the various locks and + ** lock transitions in terms of the POSIX advisory shared and exclusive + ** lock primitives (called read-locks and write-locks below, to avoid + ** confusion with SQLite lock names). The algorithms are complicated + ** slightly in order to be compatible with windows systems simultaneously + ** accessing the same database file, in case that is ever required. + ** + ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved + ** byte', each single bytes at well known offsets, and the 'shared byte + ** range', a range of 510 bytes at a well known offset. + ** + ** To obtain a SHARED lock, a read-lock is obtained on the 'pending + ** byte'. If this is successful, a random byte from the 'shared byte + ** range' is read-locked and the lock on the 'pending byte' released. + ** + ** A process may only obtain a RESERVED lock after it has a SHARED lock. + ** A RESERVED lock is implemented by grabbing a write-lock on the + ** 'reserved byte'. + ** + ** A process may only obtain a PENDING lock after it has obtained a + ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock + ** on the 'pending byte'. This ensures that no new SHARED locks can be + ** obtained, but existing SHARED locks are allowed to persist. A process + ** does not have to obtain a RESERVED lock on the way to a PENDING lock. + ** This property is used by the algorithm for rolling back a journal file + ** after a crash. + ** + ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is + ** implemented by obtaining a write-lock on the entire 'shared byte + ** range'. Since all other locks require a read-lock on one of the bytes + ** within this range, this ensures that no other locks are held on the + ** database. + ** + ** The reason a single byte cannot be used instead of the 'shared byte + ** range' is that some versions of windows do not support read-locks. By + ** locking a random byte from a range, concurrent SHARED locks may exist + ** even if the locking primitive used is always a write-lock. + */ + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode; + struct flock lock; + int tErrno = 0; + + assert( pFile ); + OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h, + azFileLock(eFileLock), azFileLock(pFile->eFileLock), + azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared, + osGetpid(0))); + + /* If there is already a lock of this type or more restrictive on the + ** unixFile, do nothing. Don't use the end_lock: exit path, as + ** unixEnterMutex() hasn't been called yet. + */ + if( pFile->eFileLock>=eFileLock ){ + OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h, + azFileLock(eFileLock))); + return SQLITE_OK; + } + + /* Make sure the locking sequence is correct. + ** (1) We never move from unlocked to anything higher than shared lock. + ** (2) SQLite never explicitly requests a pendig lock. + ** (3) A shared lock is always held when a reserve lock is requested. + */ + assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK ); + assert( eFileLock!=PENDING_LOCK ); + assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK ); + + /* This mutex is needed because pFile->pInode is shared across threads + */ + unixEnterMutex(); + pInode = pFile->pInode; + + /* If some thread using this PID has a lock via a different unixFile* + ** handle that precludes the requested lock, return BUSY. + */ + if( (pFile->eFileLock!=pInode->eFileLock && + (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK)) + ){ + rc = SQLITE_BUSY; + goto end_lock; + } + + /* If a SHARED lock is requested, and some thread using this PID already + ** has a SHARED or RESERVED lock, then increment reference counts and + ** return SQLITE_OK. + */ + if( eFileLock==SHARED_LOCK && + (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){ + assert( eFileLock==SHARED_LOCK ); + assert( pFile->eFileLock==0 ); + assert( pInode->nShared>0 ); + pFile->eFileLock = SHARED_LOCK; + pInode->nShared++; + pInode->nLock++; + goto end_lock; + } + + + /* A PENDING lock is needed before acquiring a SHARED lock and before + ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will + ** be released. + */ + lock.l_len = 1L; + lock.l_whence = SEEK_SET; + if( eFileLock==SHARED_LOCK + || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLocknShared==0 ); + assert( pInode->eFileLock==0 ); + assert( rc==SQLITE_OK ); + + /* Now get the read-lock */ + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + if( unixFileLock(pFile, &lock) ){ + tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + } + + /* Drop the temporary PENDING lock */ + lock.l_start = PENDING_BYTE; + lock.l_len = 1L; + lock.l_type = F_UNLCK; + if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){ + /* This could happen with a network mount */ + tErrno = errno; + rc = SQLITE_IOERR_UNLOCK; + } + + if( rc ){ + if( rc!=SQLITE_BUSY ){ + storeLastErrno(pFile, tErrno); + } + goto end_lock; + }else{ + pFile->eFileLock = SHARED_LOCK; + pInode->nLock++; + pInode->nShared = 1; + } + }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){ + /* We are trying for an exclusive lock but another thread in this + ** same process is still holding a shared lock. */ + rc = SQLITE_BUSY; + }else{ + /* The request was for a RESERVED or EXCLUSIVE lock. It is + ** assumed that there is a SHARED or greater lock on the file + ** already. + */ + assert( 0!=pFile->eFileLock ); + lock.l_type = F_WRLCK; + + assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK ); + if( eFileLock==RESERVED_LOCK ){ + lock.l_start = RESERVED_BYTE; + lock.l_len = 1L; + }else{ + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + } + + if( unixFileLock(pFile, &lock) ){ + tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( rc!=SQLITE_BUSY ){ + storeLastErrno(pFile, tErrno); + } + } + } + + +#ifdef SQLITE_DEBUG + /* Set up the transaction-counter change checking flags when + ** transitioning from a SHARED to a RESERVED lock. The change + ** from SHARED to RESERVED marks the beginning of a normal + ** write operation (not a hot journal rollback). + */ + if( rc==SQLITE_OK + && pFile->eFileLock<=SHARED_LOCK + && eFileLock==RESERVED_LOCK + ){ + pFile->transCntrChng = 0; + pFile->dbUpdate = 0; + pFile->inNormalWrite = 1; + } +#endif + + + if( rc==SQLITE_OK ){ + pFile->eFileLock = eFileLock; + pInode->eFileLock = eFileLock; + }else if( eFileLock==EXCLUSIVE_LOCK ){ + pFile->eFileLock = PENDING_LOCK; + pInode->eFileLock = PENDING_LOCK; + } + +end_lock: + unixLeaveMutex(); + OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock), + rc==SQLITE_OK ? "ok" : "failed")); + return rc; +} + +/* +** Add the file descriptor used by file handle pFile to the corresponding +** pUnused list. +*/ +static void setPendingFd(unixFile *pFile){ + unixInodeInfo *pInode = pFile->pInode; + UnixUnusedFd *p = pFile->pUnused; + p->pNext = pInode->pUnused; + pInode->pUnused = p; + pFile->h = -1; + pFile->pUnused = 0; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED +** the byte range is divided into 2 parts and the first part is unlocked then +** set to a read lock, then the other part is simply unlocked. This works +** around a bug in BSD NFS lockd (also seen on MacOSX 10.3+) that fails to +** remove the write lock on a region when a read lock is set. +*/ +static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){ + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode; + struct flock lock; + int rc = SQLITE_OK; + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock, + pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared, + osGetpid(0))); + + assert( eFileLock<=SHARED_LOCK ); + if( pFile->eFileLock<=eFileLock ){ + return SQLITE_OK; + } + unixEnterMutex(); + pInode = pFile->pInode; + assert( pInode->nShared!=0 ); + if( pFile->eFileLock>SHARED_LOCK ){ + assert( pInode->eFileLock==pFile->eFileLock ); + +#ifdef SQLITE_DEBUG + /* When reducing a lock such that other processes can start + ** reading the database file again, make sure that the + ** transaction counter was updated if any part of the database + ** file changed. If the transaction counter is not updated, + ** other connections to the same file might not realize that + ** the file has changed and hence might not know to flush their + ** cache. The use of a stale cache can lead to database corruption. + */ + pFile->inNormalWrite = 0; +#endif + + /* downgrading to a shared lock on NFS involves clearing the write lock + ** before establishing the readlock - to avoid a race condition we downgrade + ** the lock in 2 blocks, so that part of the range will be covered by a + ** write lock until the rest is covered by a read lock: + ** 1: [WWWWW] + ** 2: [....W] + ** 3: [RRRRW] + ** 4: [RRRR.] + */ + if( eFileLock==SHARED_LOCK ){ +#if !defined(__APPLE__) || !SQLITE_ENABLE_LOCKING_STYLE + (void)handleNFSUnlock; + assert( handleNFSUnlock==0 ); +#endif +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE + if( handleNFSUnlock ){ + int tErrno; /* Error code from system call errors */ + off_t divSize = SHARED_SIZE - 1; + + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = divSize; + if( unixFileLock(pFile, &lock)==(-1) ){ + tErrno = errno; + rc = SQLITE_IOERR_UNLOCK; + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + goto end_unlock; + } + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = divSize; + if( unixFileLock(pFile, &lock)==(-1) ){ + tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK); + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + goto end_unlock; + } + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST+divSize; + lock.l_len = SHARED_SIZE-divSize; + if( unixFileLock(pFile, &lock)==(-1) ){ + tErrno = errno; + rc = SQLITE_IOERR_UNLOCK; + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + goto end_unlock; + } + }else +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ + { + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + if( unixFileLock(pFile, &lock) ){ + /* In theory, the call to unixFileLock() cannot fail because another + ** process is holding an incompatible lock. If it does, this + ** indicates that the other process is not following the locking + ** protocol. If this happens, return SQLITE_IOERR_RDLOCK. Returning + ** SQLITE_BUSY would confuse the upper layer (in practice it causes + ** an assert to fail). */ + rc = SQLITE_IOERR_RDLOCK; + storeLastErrno(pFile, errno); + goto end_unlock; + } + } + } + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = PENDING_BYTE; + lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE ); + if( unixFileLock(pFile, &lock)==0 ){ + pInode->eFileLock = SHARED_LOCK; + }else{ + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, errno); + goto end_unlock; + } + } + if( eFileLock==NO_LOCK ){ + /* Decrement the shared lock counter. Release the lock using an + ** OS call only when all threads in this same process have released + ** the lock. + */ + pInode->nShared--; + if( pInode->nShared==0 ){ + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = lock.l_len = 0L; + if( unixFileLock(pFile, &lock)==0 ){ + pInode->eFileLock = NO_LOCK; + }else{ + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, errno); + pInode->eFileLock = NO_LOCK; + pFile->eFileLock = NO_LOCK; + } + } + + /* Decrement the count of locks against this same file. When the + ** count reaches zero, close any other file descriptors whose close + ** was deferred because of outstanding locks. + */ + pInode->nLock--; + assert( pInode->nLock>=0 ); + if( pInode->nLock==0 ){ + closePendingFds(pFile); + } + } + +end_unlock: + unixLeaveMutex(); + if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock; + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int unixUnlock(sqlite3_file *id, int eFileLock){ +#if SQLITE_MAX_MMAP_SIZE>0 + assert( eFileLock==SHARED_LOCK || ((unixFile *)id)->nFetchOut==0 ); +#endif + return posixUnlock(id, eFileLock, 0); +} + +#if SQLITE_MAX_MMAP_SIZE>0 +static int unixMapfile(unixFile *pFd, i64 nByte); +static void unixUnmapfile(unixFile *pFd); +#endif + +/* +** This function performs the parts of the "close file" operation +** common to all locking schemes. It closes the directory and file +** handles, if they are valid, and sets all fields of the unixFile +** structure to 0. +** +** It is *not* necessary to hold the mutex when this routine is called, +** even on VxWorks. A mutex will be acquired on VxWorks by the +** vxworksReleaseFileId() routine. +*/ +static int closeUnixFile(sqlite3_file *id){ + unixFile *pFile = (unixFile*)id; +#if SQLITE_MAX_MMAP_SIZE>0 + unixUnmapfile(pFile); +#endif + if( pFile->h>=0 ){ + robust_close(pFile, pFile->h, __LINE__); + pFile->h = -1; + } +#if OS_VXWORKS + if( pFile->pId ){ + if( pFile->ctrlFlags & UNIXFILE_DELETE ){ + osUnlink(pFile->pId->zCanonicalName); + } + vxworksReleaseFileId(pFile->pId); + pFile->pId = 0; + } +#endif +#ifdef SQLITE_UNLINK_AFTER_CLOSE + if( pFile->ctrlFlags & UNIXFILE_DELETE ){ + osUnlink(pFile->zPath); + sqlite3_free(*(char**)&pFile->zPath); + pFile->zPath = 0; + } +#endif + OSTRACE(("CLOSE %-3d\n", pFile->h)); + OpenCounter(-1); + sqlite3_free(pFile->pUnused); + memset(pFile, 0, sizeof(unixFile)); + return SQLITE_OK; +} + +/* +** Close a file. +*/ +static int unixClose(sqlite3_file *id){ + int rc = SQLITE_OK; + unixFile *pFile = (unixFile *)id; + verifyDbFile(pFile); + unixUnlock(id, NO_LOCK); + unixEnterMutex(); + + /* unixFile.pInode is always valid here. Otherwise, a different close + ** routine (e.g. nolockClose()) would be called instead. + */ + assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 ); + if( ALWAYS(pFile->pInode) && pFile->pInode->nLock ){ + /* If there are outstanding locks, do not actually close the file just + ** yet because that would clear those locks. Instead, add the file + ** descriptor to pInode->pUnused list. It will be automatically closed + ** when the last lock is cleared. + */ + setPendingFd(pFile); + } + releaseInodeInfo(pFile); + rc = closeUnixFile(id); + unixLeaveMutex(); + return rc; +} + +/************** End of the posix advisory lock implementation ***************** +******************************************************************************/ + +/****************************************************************************** +****************************** No-op Locking ********************************** +** +** Of the various locking implementations available, this is by far the +** simplest: locking is ignored. No attempt is made to lock the database +** file for reading or writing. +** +** This locking mode is appropriate for use on read-only databases +** (ex: databases that are burned into CD-ROM, for example.) It can +** also be used if the application employs some external mechanism to +** prevent simultaneous access of the same database by two or more +** database connections. But there is a serious risk of database +** corruption if this locking mode is used in situations where multiple +** database connections are accessing the same database file at the same +** time and one or more of those connections are writing. +*/ + +static int nolockCheckReservedLock(sqlite3_file *NotUsed, int *pResOut){ + UNUSED_PARAMETER(NotUsed); + *pResOut = 0; + return SQLITE_OK; +} +static int nolockLock(sqlite3_file *NotUsed, int NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return SQLITE_OK; +} +static int nolockUnlock(sqlite3_file *NotUsed, int NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return SQLITE_OK; +} + +/* +** Close the file. +*/ +static int nolockClose(sqlite3_file *id) { + return closeUnixFile(id); +} + +/******************* End of the no-op lock implementation ********************* +******************************************************************************/ + +/****************************************************************************** +************************* Begin dot-file Locking ****************************** +** +** The dotfile locking implementation uses the existence of separate lock +** files (really a directory) to control access to the database. This works +** on just about every filesystem imaginable. But there are serious downsides: +** +** (1) There is zero concurrency. A single reader blocks all other +** connections from reading or writing the database. +** +** (2) An application crash or power loss can leave stale lock files +** sitting around that need to be cleared manually. +** +** Nevertheless, a dotlock is an appropriate locking mode for use if no +** other locking strategy is available. +** +** Dotfile locking works by creating a subdirectory in the same directory as +** the database and with the same name but with a ".lock" extension added. +** The existence of a lock directory implies an EXCLUSIVE lock. All other +** lock types (SHARED, RESERVED, PENDING) are mapped into EXCLUSIVE. +*/ + +/* +** The file suffix added to the data base filename in order to create the +** lock directory. +*/ +#define DOTLOCK_SUFFIX ".lock" + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +** +** In dotfile locking, either a lock exists or it does not. So in this +** variation of CheckReservedLock(), *pResOut is set to true if any lock +** is held on the file and false if the file is unlocked. +*/ +static int dotlockCheckReservedLock(sqlite3_file *id, int *pResOut) { + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + + /* Check if a thread in this process holds such a lock */ + if( pFile->eFileLock>SHARED_LOCK ){ + /* Either this connection or some other connection in the same process + ** holds a lock on the file. No need to check further. */ + reserved = 1; + }else{ + /* The lock is held if and only if the lockfile exists */ + const char *zLockFile = (const char*)pFile->lockingContext; + reserved = osAccess(zLockFile, 0)==0; + } + OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved)); + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +** +** With dotfile locking, we really only support state (4): EXCLUSIVE. +** But we track the other locking levels internally. +*/ +static int dotlockLock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + char *zLockFile = (char *)pFile->lockingContext; + int rc = SQLITE_OK; + + + /* If we have any lock, then the lock file already exists. All we have + ** to do is adjust our internal record of the lock level. + */ + if( pFile->eFileLock > NO_LOCK ){ + pFile->eFileLock = eFileLock; + /* Always update the timestamp on the old file */ +#ifdef HAVE_UTIME + utime(zLockFile, NULL); +#else + utimes(zLockFile, NULL); +#endif + return SQLITE_OK; + } + + /* grab an exclusive lock */ + rc = osMkdir(zLockFile, 0777); + if( rc<0 ){ + /* failed to open/create the lock directory */ + int tErrno = errno; + if( EEXIST == tErrno ){ + rc = SQLITE_BUSY; + } else { + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + } + return rc; + } + + /* got it, set the type and return ok */ + pFile->eFileLock = eFileLock; + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** When the locking level reaches NO_LOCK, delete the lock file. +*/ +static int dotlockUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + char *zLockFile = (char *)pFile->lockingContext; + int rc; + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock, + pFile->eFileLock, osGetpid(0))); + assert( eFileLock<=SHARED_LOCK ); + + /* no-op if possible */ + if( pFile->eFileLock==eFileLock ){ + return SQLITE_OK; + } + + /* To downgrade to shared, simply update our internal notion of the + ** lock state. No need to mess with the file on disk. + */ + if( eFileLock==SHARED_LOCK ){ + pFile->eFileLock = SHARED_LOCK; + return SQLITE_OK; + } + + /* To fully unlock the database, delete the lock file */ + assert( eFileLock==NO_LOCK ); + rc = osRmdir(zLockFile); + if( rc<0 && errno==ENOTDIR ) rc = osUnlink(zLockFile); + if( rc<0 ){ + int tErrno = errno; + rc = 0; + if( ENOENT != tErrno ){ + rc = SQLITE_IOERR_UNLOCK; + } + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + return rc; + } + pFile->eFileLock = NO_LOCK; + return SQLITE_OK; +} + +/* +** Close a file. Make sure the lock has been released before closing. +*/ +static int dotlockClose(sqlite3_file *id) { + int rc = SQLITE_OK; + if( id ){ + unixFile *pFile = (unixFile*)id; + dotlockUnlock(id, NO_LOCK); + sqlite3_free(pFile->lockingContext); + rc = closeUnixFile(id); + } + return rc; +} +/****************** End of the dot-file lock implementation ******************* +******************************************************************************/ + +/****************************************************************************** +************************** Begin flock Locking ******************************** +** +** Use the flock() system call to do file locking. +** +** flock() locking is like dot-file locking in that the various +** fine-grain locking levels supported by SQLite are collapsed into +** a single exclusive lock. In other words, SHARED, RESERVED, and +** PENDING locks are the same thing as an EXCLUSIVE lock. SQLite +** still works when you do this, but concurrency is reduced since +** only a single process can be reading the database at a time. +** +** Omit this section if SQLITE_ENABLE_LOCKING_STYLE is turned off +*/ +#if SQLITE_ENABLE_LOCKING_STYLE + +/* +** Retry flock() calls that fail with EINTR +*/ +#ifdef EINTR +static int robust_flock(int fd, int op){ + int rc; + do{ rc = flock(fd,op); }while( rc<0 && errno==EINTR ); + return rc; +} +#else +# define robust_flock(a,b) flock(a,b) +#endif + + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int flockCheckReservedLock(sqlite3_file *id, int *pResOut){ + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + + /* Check if a thread in this process holds such a lock */ + if( pFile->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. */ + if( !reserved ){ + /* attempt to get the lock */ + int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB); + if( !lrc ){ + /* got the lock, unlock it */ + lrc = robust_flock(pFile->h, LOCK_UN); + if ( lrc ) { + int tErrno = errno; + /* unlock failed with an error */ + lrc = SQLITE_IOERR_UNLOCK; + if( IS_LOCK_ERROR(lrc) ){ + storeLastErrno(pFile, tErrno); + rc = lrc; + } + } + } else { + int tErrno = errno; + reserved = 1; + /* someone else might have it reserved */ + lrc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( IS_LOCK_ERROR(lrc) ){ + storeLastErrno(pFile, tErrno); + rc = lrc; + } + } + } + OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved)); + +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){ + rc = SQLITE_OK; + reserved=1; + } +#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */ + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** flock() only really support EXCLUSIVE locks. We track intermediate +** lock states in the sqlite3_file structure, but all locks SHARED or +** above are really EXCLUSIVE locks and exclude all other processes from +** access the file. +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int flockLock(sqlite3_file *id, int eFileLock) { + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + + assert( pFile ); + + /* if we already have a lock, it is exclusive. + ** Just adjust level and punt on outta here. */ + if (pFile->eFileLock > NO_LOCK) { + pFile->eFileLock = eFileLock; + return SQLITE_OK; + } + + /* grab an exclusive lock */ + + if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) { + int tErrno = errno; + /* didn't get, must be busy */ + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + } else { + /* got it, set the type and return ok */ + pFile->eFileLock = eFileLock; + } + OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock), + rc==SQLITE_OK ? "ok" : "failed")); +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){ + rc = SQLITE_BUSY; + } +#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */ + return rc; +} + + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int flockUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock, + pFile->eFileLock, osGetpid(0))); + assert( eFileLock<=SHARED_LOCK ); + + /* no-op if possible */ + if( pFile->eFileLock==eFileLock ){ + return SQLITE_OK; + } + + /* shared can just be set because we always have an exclusive */ + if (eFileLock==SHARED_LOCK) { + pFile->eFileLock = eFileLock; + return SQLITE_OK; + } + + /* no, really, unlock. */ + if( robust_flock(pFile->h, LOCK_UN) ){ +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + return SQLITE_OK; +#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */ + return SQLITE_IOERR_UNLOCK; + }else{ + pFile->eFileLock = NO_LOCK; + return SQLITE_OK; + } +} + +/* +** Close a file. +*/ +static int flockClose(sqlite3_file *id) { + int rc = SQLITE_OK; + if( id ){ + flockUnlock(id, NO_LOCK); + rc = closeUnixFile(id); + } + return rc; +} + +#endif /* SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORK */ + +/******************* End of the flock lock implementation ********************* +******************************************************************************/ + +/****************************************************************************** +************************ Begin Named Semaphore Locking ************************ +** +** Named semaphore locking is only supported on VxWorks. +** +** Semaphore locking is like dot-lock and flock in that it really only +** supports EXCLUSIVE locking. Only a single process can read or write +** the database file at a time. This reduces potential concurrency, but +** makes the lock implementation much easier. +*/ +#if OS_VXWORKS + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int semXCheckReservedLock(sqlite3_file *id, int *pResOut) { + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + + /* Check if a thread in this process holds such a lock */ + if( pFile->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. */ + if( !reserved ){ + sem_t *pSem = pFile->pInode->pSem; + + if( sem_trywait(pSem)==-1 ){ + int tErrno = errno; + if( EAGAIN != tErrno ){ + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_CHECKRESERVEDLOCK); + storeLastErrno(pFile, tErrno); + } else { + /* someone else has the lock when we are in NO_LOCK */ + reserved = (pFile->eFileLock < SHARED_LOCK); + } + }else{ + /* we could have it if we want it */ + sem_post(pSem); + } + } + OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved)); + + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** Semaphore locks only really support EXCLUSIVE locks. We track intermediate +** lock states in the sqlite3_file structure, but all locks SHARED or +** above are really EXCLUSIVE locks and exclude all other processes from +** access the file. +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int semXLock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + sem_t *pSem = pFile->pInode->pSem; + int rc = SQLITE_OK; + + /* if we already have a lock, it is exclusive. + ** Just adjust level and punt on outta here. */ + if (pFile->eFileLock > NO_LOCK) { + pFile->eFileLock = eFileLock; + rc = SQLITE_OK; + goto sem_end_lock; + } + + /* lock semaphore now but bail out when already locked. */ + if( sem_trywait(pSem)==-1 ){ + rc = SQLITE_BUSY; + goto sem_end_lock; + } + + /* got it, set the type and return ok */ + pFile->eFileLock = eFileLock; + + sem_end_lock: + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int semXUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + sem_t *pSem = pFile->pInode->pSem; + + assert( pFile ); + assert( pSem ); + OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock, + pFile->eFileLock, osGetpid(0))); + assert( eFileLock<=SHARED_LOCK ); + + /* no-op if possible */ + if( pFile->eFileLock==eFileLock ){ + return SQLITE_OK; + } + + /* shared can just be set because we always have an exclusive */ + if (eFileLock==SHARED_LOCK) { + pFile->eFileLock = eFileLock; + return SQLITE_OK; + } + + /* no, really unlock. */ + if ( sem_post(pSem)==-1 ) { + int rc, tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK); + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + return rc; + } + pFile->eFileLock = NO_LOCK; + return SQLITE_OK; +} + +/* + ** Close a file. + */ +static int semXClose(sqlite3_file *id) { + if( id ){ + unixFile *pFile = (unixFile*)id; + semXUnlock(id, NO_LOCK); + assert( pFile ); + unixEnterMutex(); + releaseInodeInfo(pFile); + unixLeaveMutex(); + closeUnixFile(id); + } + return SQLITE_OK; +} + +#endif /* OS_VXWORKS */ +/* +** Named semaphore locking is only available on VxWorks. +** +*************** End of the named semaphore lock implementation **************** +******************************************************************************/ + + +/****************************************************************************** +*************************** Begin AFP Locking ********************************* +** +** AFP is the Apple Filing Protocol. AFP is a network filesystem found +** on Apple Macintosh computers - both OS9 and OSX. +** +** Third-party implementations of AFP are available. But this code here +** only works on OSX. +*/ + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +/* +** The afpLockingContext structure contains all afp lock specific state +*/ +typedef struct afpLockingContext afpLockingContext; +struct afpLockingContext { + int reserved; + const char *dbPath; /* Name of the open file */ +}; + +struct ByteRangeLockPB2 +{ + unsigned long long offset; /* offset to first byte to lock */ + unsigned long long length; /* nbr of bytes to lock */ + unsigned long long retRangeStart; /* nbr of 1st byte locked if successful */ + unsigned char unLockFlag; /* 1 = unlock, 0 = lock */ + unsigned char startEndFlag; /* 1=rel to end of fork, 0=rel to start */ + int fd; /* file desc to assoc this lock with */ +}; + +#define afpfsByteRangeLock2FSCTL _IOWR('z', 23, struct ByteRangeLockPB2) + +/* +** This is a utility for setting or clearing a bit-range lock on an +** AFP filesystem. +** +** Return SQLITE_OK on success, SQLITE_BUSY on failure. +*/ +static int afpSetLock( + const char *path, /* Name of the file to be locked or unlocked */ + unixFile *pFile, /* Open file descriptor on path */ + unsigned long long offset, /* First byte to be locked */ + unsigned long long length, /* Number of bytes to lock */ + int setLockFlag /* True to set lock. False to clear lock */ +){ + struct ByteRangeLockPB2 pb; + int err; + + pb.unLockFlag = setLockFlag ? 0 : 1; + pb.startEndFlag = 0; + pb.offset = offset; + pb.length = length; + pb.fd = pFile->h; + + OSTRACE(("AFPSETLOCK [%s] for %d%s in range %llx:%llx\n", + (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""), + offset, length)); + err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0); + if ( err==-1 ) { + int rc; + int tErrno = errno; + OSTRACE(("AFPSETLOCK failed to fsctl() '%s' %d %s\n", + path, tErrno, strerror(tErrno))); +#ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS + rc = SQLITE_BUSY; +#else + rc = sqliteErrorFromPosixError(tErrno, + setLockFlag ? SQLITE_IOERR_LOCK : SQLITE_IOERR_UNLOCK); +#endif /* SQLITE_IGNORE_AFP_LOCK_ERRORS */ + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + return rc; + } else { + return SQLITE_OK; + } +} + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int afpCheckReservedLock(sqlite3_file *id, int *pResOut){ + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + afpLockingContext *context; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + context = (afpLockingContext *) pFile->lockingContext; + if( context->reserved ){ + *pResOut = 1; + return SQLITE_OK; + } + unixEnterMutex(); /* Because pFile->pInode is shared across threads */ + + /* Check if a thread in this process holds such a lock */ + if( pFile->pInode->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. + */ + if( !reserved ){ + /* lock the RESERVED byte */ + int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1); + if( SQLITE_OK==lrc ){ + /* if we succeeded in taking the reserved lock, unlock it to restore + ** the original state */ + lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0); + } else { + /* if we failed to get the lock then someone else must have it */ + reserved = 1; + } + if( IS_LOCK_ERROR(lrc) ){ + rc=lrc; + } + } + + unixLeaveMutex(); + OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved)); + + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int afpLock(sqlite3_file *id, int eFileLock){ + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode = pFile->pInode; + afpLockingContext *context = (afpLockingContext *) pFile->lockingContext; + + assert( pFile ); + OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h, + azFileLock(eFileLock), azFileLock(pFile->eFileLock), + azFileLock(pInode->eFileLock), pInode->nShared , osGetpid(0))); + + /* If there is already a lock of this type or more restrictive on the + ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as + ** unixEnterMutex() hasn't been called yet. + */ + if( pFile->eFileLock>=eFileLock ){ + OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h, + azFileLock(eFileLock))); + return SQLITE_OK; + } + + /* Make sure the locking sequence is correct + ** (1) We never move from unlocked to anything higher than shared lock. + ** (2) SQLite never explicitly requests a pendig lock. + ** (3) A shared lock is always held when a reserve lock is requested. + */ + assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK ); + assert( eFileLock!=PENDING_LOCK ); + assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK ); + + /* This mutex is needed because pFile->pInode is shared across threads + */ + unixEnterMutex(); + pInode = pFile->pInode; + + /* If some thread using this PID has a lock via a different unixFile* + ** handle that precludes the requested lock, return BUSY. + */ + if( (pFile->eFileLock!=pInode->eFileLock && + (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK)) + ){ + rc = SQLITE_BUSY; + goto afp_end_lock; + } + + /* If a SHARED lock is requested, and some thread using this PID already + ** has a SHARED or RESERVED lock, then increment reference counts and + ** return SQLITE_OK. + */ + if( eFileLock==SHARED_LOCK && + (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){ + assert( eFileLock==SHARED_LOCK ); + assert( pFile->eFileLock==0 ); + assert( pInode->nShared>0 ); + pFile->eFileLock = SHARED_LOCK; + pInode->nShared++; + pInode->nLock++; + goto afp_end_lock; + } + + /* A PENDING lock is needed before acquiring a SHARED lock and before + ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will + ** be released. + */ + if( eFileLock==SHARED_LOCK + || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLockdbPath, pFile, PENDING_BYTE, 1, 1); + if (failed) { + rc = failed; + goto afp_end_lock; + } + } + + /* If control gets to this point, then actually go ahead and make + ** operating system calls for the specified lock. + */ + if( eFileLock==SHARED_LOCK ){ + int lrc1, lrc2, lrc1Errno = 0; + long lk, mask; + + assert( pInode->nShared==0 ); + assert( pInode->eFileLock==0 ); + + mask = (sizeof(long)==8) ? LARGEST_INT64 : 0x7fffffff; + /* Now get the read-lock SHARED_LOCK */ + /* note that the quality of the randomness doesn't matter that much */ + lk = random(); + pInode->sharedByte = (lk & mask)%(SHARED_SIZE - 1); + lrc1 = afpSetLock(context->dbPath, pFile, + SHARED_FIRST+pInode->sharedByte, 1, 1); + if( IS_LOCK_ERROR(lrc1) ){ + lrc1Errno = pFile->lastErrno; + } + /* Drop the temporary PENDING lock */ + lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0); + + if( IS_LOCK_ERROR(lrc1) ) { + storeLastErrno(pFile, lrc1Errno); + rc = lrc1; + goto afp_end_lock; + } else if( IS_LOCK_ERROR(lrc2) ){ + rc = lrc2; + goto afp_end_lock; + } else if( lrc1 != SQLITE_OK ) { + rc = lrc1; + } else { + pFile->eFileLock = SHARED_LOCK; + pInode->nLock++; + pInode->nShared = 1; + } + }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){ + /* We are trying for an exclusive lock but another thread in this + ** same process is still holding a shared lock. */ + rc = SQLITE_BUSY; + }else{ + /* The request was for a RESERVED or EXCLUSIVE lock. It is + ** assumed that there is a SHARED or greater lock on the file + ** already. + */ + int failed = 0; + assert( 0!=pFile->eFileLock ); + if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) { + /* Acquire a RESERVED lock */ + failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1); + if( !failed ){ + context->reserved = 1; + } + } + if (!failed && eFileLock == EXCLUSIVE_LOCK) { + /* Acquire an EXCLUSIVE lock */ + + /* Remove the shared lock before trying the range. we'll need to + ** reestablish the shared lock if we can't get the afpUnlock + */ + if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST + + pInode->sharedByte, 1, 0)) ){ + int failed2 = SQLITE_OK; + /* now attemmpt to get the exclusive lock range */ + failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST, + SHARED_SIZE, 1); + if( failed && (failed2 = afpSetLock(context->dbPath, pFile, + SHARED_FIRST + pInode->sharedByte, 1, 1)) ){ + /* Can't reestablish the shared lock. Sqlite can't deal, this is + ** a critical I/O error + */ + rc = ((failed & SQLITE_IOERR) == SQLITE_IOERR) ? failed2 : + SQLITE_IOERR_LOCK; + goto afp_end_lock; + } + }else{ + rc = failed; + } + } + if( failed ){ + rc = failed; + } + } + + if( rc==SQLITE_OK ){ + pFile->eFileLock = eFileLock; + pInode->eFileLock = eFileLock; + }else if( eFileLock==EXCLUSIVE_LOCK ){ + pFile->eFileLock = PENDING_LOCK; + pInode->eFileLock = PENDING_LOCK; + } + +afp_end_lock: + unixLeaveMutex(); + OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock), + rc==SQLITE_OK ? "ok" : "failed")); + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int afpUnlock(sqlite3_file *id, int eFileLock) { + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode; + afpLockingContext *context = (afpLockingContext *) pFile->lockingContext; + int skipShared = 0; +#ifdef SQLITE_TEST + int h = pFile->h; +#endif + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock, + pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared, + osGetpid(0))); + + assert( eFileLock<=SHARED_LOCK ); + if( pFile->eFileLock<=eFileLock ){ + return SQLITE_OK; + } + unixEnterMutex(); + pInode = pFile->pInode; + assert( pInode->nShared!=0 ); + if( pFile->eFileLock>SHARED_LOCK ){ + assert( pInode->eFileLock==pFile->eFileLock ); + SimulateIOErrorBenign(1); + SimulateIOError( h=(-1) ) + SimulateIOErrorBenign(0); + +#ifdef SQLITE_DEBUG + /* When reducing a lock such that other processes can start + ** reading the database file again, make sure that the + ** transaction counter was updated if any part of the database + ** file changed. If the transaction counter is not updated, + ** other connections to the same file might not realize that + ** the file has changed and hence might not know to flush their + ** cache. The use of a stale cache can lead to database corruption. + */ + assert( pFile->inNormalWrite==0 + || pFile->dbUpdate==0 + || pFile->transCntrChng==1 ); + pFile->inNormalWrite = 0; +#endif + + if( pFile->eFileLock==EXCLUSIVE_LOCK ){ + rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0); + if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){ + /* only re-establish the shared lock if necessary */ + int sharedLockByte = SHARED_FIRST+pInode->sharedByte; + rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1); + } else { + skipShared = 1; + } + } + if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){ + rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0); + } + if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){ + rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0); + if( !rc ){ + context->reserved = 0; + } + } + if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){ + pInode->eFileLock = SHARED_LOCK; + } + } + if( rc==SQLITE_OK && eFileLock==NO_LOCK ){ + + /* Decrement the shared lock counter. Release the lock using an + ** OS call only when all threads in this same process have released + ** the lock. + */ + unsigned long long sharedLockByte = SHARED_FIRST+pInode->sharedByte; + pInode->nShared--; + if( pInode->nShared==0 ){ + SimulateIOErrorBenign(1); + SimulateIOError( h=(-1) ) + SimulateIOErrorBenign(0); + if( !skipShared ){ + rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0); + } + if( !rc ){ + pInode->eFileLock = NO_LOCK; + pFile->eFileLock = NO_LOCK; + } + } + if( rc==SQLITE_OK ){ + pInode->nLock--; + assert( pInode->nLock>=0 ); + if( pInode->nLock==0 ){ + closePendingFds(pFile); + } + } + } + + unixLeaveMutex(); + if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock; + return rc; +} + +/* +** Close a file & cleanup AFP specific locking context +*/ +static int afpClose(sqlite3_file *id) { + int rc = SQLITE_OK; + if( id ){ + unixFile *pFile = (unixFile*)id; + afpUnlock(id, NO_LOCK); + unixEnterMutex(); + if( pFile->pInode && pFile->pInode->nLock ){ + /* If there are outstanding locks, do not actually close the file just + ** yet because that would clear those locks. Instead, add the file + ** descriptor to pInode->aPending. It will be automatically closed when + ** the last lock is cleared. + */ + setPendingFd(pFile); + } + releaseInodeInfo(pFile); + sqlite3_free(pFile->lockingContext); + rc = closeUnixFile(id); + unixLeaveMutex(); + } + return rc; +} + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ +/* +** The code above is the AFP lock implementation. The code is specific +** to MacOSX and does not work on other unix platforms. No alternative +** is available. If you don't compile for a mac, then the "unix-afp" +** VFS is not available. +** +********************* End of the AFP lock implementation ********************** +******************************************************************************/ + +/****************************************************************************** +*************************** Begin NFS Locking ********************************/ + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +/* + ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock + ** must be either NO_LOCK or SHARED_LOCK. + ** + ** If the locking level of the file descriptor is already at or below + ** the requested locking level, this routine is a no-op. + */ +static int nfsUnlock(sqlite3_file *id, int eFileLock){ + return posixUnlock(id, eFileLock, 1); +} + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ +/* +** The code above is the NFS lock implementation. The code is specific +** to MacOSX and does not work on other unix platforms. No alternative +** is available. +** +********************* End of the NFS lock implementation ********************** +******************************************************************************/ + +/****************************************************************************** +**************** Non-locking sqlite3_file methods ***************************** +** +** The next division contains implementations for all methods of the +** sqlite3_file object other than the locking methods. The locking +** methods were defined in divisions above (one locking method per +** division). Those methods that are common to all locking modes +** are gather together into this division. +*/ + +/* +** Seek to the offset passed as the second argument, then read cnt +** bytes into pBuf. Return the number of bytes actually read. +** +** NB: If you define USE_PREAD or USE_PREAD64, then it might also +** be necessary to define _XOPEN_SOURCE to be 500. This varies from +** one system to another. Since SQLite does not define USE_PREAD +** in any form by default, we will not attempt to define _XOPEN_SOURCE. +** See tickets #2741 and #2681. +** +** To avoid stomping the errno value on a failed read the lastErrno value +** is set before returning. +*/ +static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){ + int got; + int prior = 0; +#if (!defined(USE_PREAD) && !defined(USE_PREAD64)) + i64 newOffset; +#endif + TIMER_START; + assert( cnt==(cnt&0x1ffff) ); + assert( id->h>2 ); + do{ +#if defined(USE_PREAD) + got = osPread(id->h, pBuf, cnt, offset); + SimulateIOError( got = -1 ); +#elif defined(USE_PREAD64) + got = osPread64(id->h, pBuf, cnt, offset); + SimulateIOError( got = -1 ); +#else + newOffset = lseek(id->h, offset, SEEK_SET); + SimulateIOError( newOffset-- ); + if( newOffset!=offset ){ + if( newOffset == -1 ){ + storeLastErrno((unixFile*)id, errno); + }else{ + storeLastErrno((unixFile*)id, 0); + } + return -1; + } + got = osRead(id->h, pBuf, cnt); +#endif + if( got==cnt ) break; + if( got<0 ){ + if( errno==EINTR ){ got = 1; continue; } + prior = 0; + storeLastErrno((unixFile*)id, errno); + break; + }else if( got>0 ){ + cnt -= got; + offset += got; + prior += got; + pBuf = (void*)(got + (char*)pBuf); + } + }while( got>0 ); + TIMER_END; + OSTRACE(("READ %-3d %5d %7lld %llu\n", + id->h, got+prior, offset-prior, TIMER_ELAPSED)); + return got+prior; +} + +/* +** Read data from a file into a buffer. Return SQLITE_OK if all +** bytes were read successfully and SQLITE_IOERR if anything goes +** wrong. +*/ +static int unixRead( + sqlite3_file *id, + void *pBuf, + int amt, + sqlite3_int64 offset +){ + unixFile *pFile = (unixFile *)id; + int got; + assert( id ); + assert( offset>=0 ); + assert( amt>0 ); + + /* If this is a database file (not a journal, master-journal or temp + ** file), the bytes in the locking range should never be read or written. */ +#if 0 + assert( pFile->pUnused==0 + || offset>=PENDING_BYTE+512 + || offset+amt<=PENDING_BYTE + ); +#endif + +#if SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this read request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt); + return SQLITE_OK; + }else{ + int nCopy = pFile->mmapSize - offset; + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + + got = seekAndRead(pFile, offset, pBuf, amt); + if( got==amt ){ + return SQLITE_OK; + }else if( got<0 ){ + /* lastErrno set by seekAndRead */ + return SQLITE_IOERR_READ; + }else{ + storeLastErrno(pFile, 0); /* not a system error */ + /* Unread parts of the buffer must be zero-filled */ + memset(&((char*)pBuf)[got], 0, amt-got); + return SQLITE_IOERR_SHORT_READ; + } +} + +/* +** Attempt to seek the file-descriptor passed as the first argument to +** absolute offset iOff, then attempt to write nBuf bytes of data from +** pBuf to it. If an error occurs, return -1 and set *piErrno. Otherwise, +** return the actual number of bytes written (which may be less than +** nBuf). +*/ +static int seekAndWriteFd( + int fd, /* File descriptor to write to */ + i64 iOff, /* File offset to begin writing at */ + const void *pBuf, /* Copy data from this buffer to the file */ + int nBuf, /* Size of buffer pBuf in bytes */ + int *piErrno /* OUT: Error number if error occurs */ +){ + int rc = 0; /* Value returned by system call */ + + assert( nBuf==(nBuf&0x1ffff) ); + assert( fd>2 ); + nBuf &= 0x1ffff; + TIMER_START; + +#if defined(USE_PREAD) + do{ rc = (int)osPwrite(fd, pBuf, nBuf, iOff); }while( rc<0 && errno==EINTR ); +#elif defined(USE_PREAD64) + do{ rc = (int)osPwrite64(fd, pBuf, nBuf, iOff);}while( rc<0 && errno==EINTR); +#else + do{ + i64 iSeek = lseek(fd, iOff, SEEK_SET); + SimulateIOError( iSeek-- ); + + if( iSeek!=iOff ){ + if( piErrno ) *piErrno = (iSeek==-1 ? errno : 0); + return -1; + } + rc = osWrite(fd, pBuf, nBuf); + }while( rc<0 && errno==EINTR ); +#endif + + TIMER_END; + OSTRACE(("WRITE %-3d %5d %7lld %llu\n", fd, rc, iOff, TIMER_ELAPSED)); + + if( rc<0 && piErrno ) *piErrno = errno; + return rc; +} + + +/* +** Seek to the offset in id->offset then read cnt bytes into pBuf. +** Return the number of bytes actually read. Update the offset. +** +** To avoid stomping the errno value on a failed write the lastErrno value +** is set before returning. +*/ +static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){ + return seekAndWriteFd(id->h, offset, pBuf, cnt, &id->lastErrno); +} + + +/* +** Write data from a buffer into a file. Return SQLITE_OK on success +** or some other error code on failure. +*/ +static int unixWrite( + sqlite3_file *id, + const void *pBuf, + int amt, + sqlite3_int64 offset +){ + unixFile *pFile = (unixFile*)id; + int wrote = 0; + assert( id ); + assert( amt>0 ); + + /* If this is a database file (not a journal, master-journal or temp + ** file), the bytes in the locking range should never be read or written. */ +#if 0 + assert( pFile->pUnused==0 + || offset>=PENDING_BYTE+512 + || offset+amt<=PENDING_BYTE + ); +#endif + +#ifdef SQLITE_DEBUG + /* If we are doing a normal write to a database file (as opposed to + ** doing a hot-journal rollback or a write to some file other than a + ** normal database file) then record the fact that the database + ** has changed. If the transaction counter is modified, record that + ** fact too. + */ + if( pFile->inNormalWrite ){ + pFile->dbUpdate = 1; /* The database has been modified */ + if( offset<=24 && offset+amt>=27 ){ + int rc; + char oldCntr[4]; + SimulateIOErrorBenign(1); + rc = seekAndRead(pFile, 24, oldCntr, 4); + SimulateIOErrorBenign(0); + if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){ + pFile->transCntrChng = 1; /* The transaction counter has changed */ + } + } + } +#endif + +#if SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this write request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt); + return SQLITE_OK; + }else{ + int nCopy = pFile->mmapSize - offset; + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + + while( (wrote = seekAndWrite(pFile, offset, pBuf, amt))0 ){ + amt -= wrote; + offset += wrote; + pBuf = &((char*)pBuf)[wrote]; + } + SimulateIOError(( wrote=(-1), amt=1 )); + SimulateDiskfullError(( wrote=0, amt=1 )); + + if( amt>wrote ){ + if( wrote<0 && pFile->lastErrno!=ENOSPC ){ + /* lastErrno set by seekAndWrite */ + return SQLITE_IOERR_WRITE; + }else{ + storeLastErrno(pFile, 0); /* not a system error */ + return SQLITE_FULL; + } + } + + return SQLITE_OK; +} + +#ifdef SQLITE_TEST +/* +** Count the number of fullsyncs and normal syncs. This is used to test +** that syncs and fullsyncs are occurring at the right times. +*/ +SQLITE_API int sqlite3_sync_count = 0; +SQLITE_API int sqlite3_fullsync_count = 0; +#endif + +/* +** We do not trust systems to provide a working fdatasync(). Some do. +** Others do no. To be safe, we will stick with the (slightly slower) +** fsync(). If you know that your system does support fdatasync() correctly, +** then simply compile with -Dfdatasync=fdatasync or -DHAVE_FDATASYNC +*/ +#if !defined(fdatasync) && !HAVE_FDATASYNC +# define fdatasync fsync +#endif + +/* +** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not +** the F_FULLFSYNC macro is defined. F_FULLFSYNC is currently +** only available on Mac OS X. But that could change. +*/ +#ifdef F_FULLFSYNC +# define HAVE_FULLFSYNC 1 +#else +# define HAVE_FULLFSYNC 0 +#endif + + +/* +** The fsync() system call does not work as advertised on many +** unix systems. The following procedure is an attempt to make +** it work better. +** +** The SQLITE_NO_SYNC macro disables all fsync()s. This is useful +** for testing when we want to run through the test suite quickly. +** You are strongly advised *not* to deploy with SQLITE_NO_SYNC +** enabled, however, since with SQLITE_NO_SYNC enabled, an OS crash +** or power failure will likely corrupt the database file. +** +** SQLite sets the dataOnly flag if the size of the file is unchanged. +** The idea behind dataOnly is that it should only write the file content +** to disk, not the inode. We only set dataOnly if the file size is +** unchanged since the file size is part of the inode. However, +** Ted Ts'o tells us that fdatasync() will also write the inode if the +** file size has changed. The only real difference between fdatasync() +** and fsync(), Ted tells us, is that fdatasync() will not flush the +** inode if the mtime or owner or other inode attributes have changed. +** We only care about the file size, not the other file attributes, so +** as far as SQLite is concerned, an fdatasync() is always adequate. +** So, we always use fdatasync() if it is available, regardless of +** the value of the dataOnly flag. +*/ +static int full_fsync(int fd, int fullSync, int dataOnly){ + int rc; + + /* The following "ifdef/elif/else/" block has the same structure as + ** the one below. It is replicated here solely to avoid cluttering + ** up the real code with the UNUSED_PARAMETER() macros. + */ +#ifdef SQLITE_NO_SYNC + UNUSED_PARAMETER(fd); + UNUSED_PARAMETER(fullSync); + UNUSED_PARAMETER(dataOnly); +#elif HAVE_FULLFSYNC + UNUSED_PARAMETER(dataOnly); +#else + UNUSED_PARAMETER(fullSync); + UNUSED_PARAMETER(dataOnly); +#endif + + /* Record the number of times that we do a normal fsync() and + ** FULLSYNC. This is used during testing to verify that this procedure + ** gets called with the correct arguments. + */ +#ifdef SQLITE_TEST + if( fullSync ) sqlite3_fullsync_count++; + sqlite3_sync_count++; +#endif + + /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a + ** no-op + */ +#ifdef SQLITE_NO_SYNC + rc = SQLITE_OK; +#elif HAVE_FULLFSYNC + if( fullSync ){ + rc = osFcntl(fd, F_FULLFSYNC, 0); + }else{ + rc = 1; + } + /* If the FULLFSYNC failed, fall back to attempting an fsync(). + ** It shouldn't be possible for fullfsync to fail on the local + ** file system (on OSX), so failure indicates that FULLFSYNC + ** isn't supported for this file system. So, attempt an fsync + ** and (for now) ignore the overhead of a superfluous fcntl call. + ** It'd be better to detect fullfsync support once and avoid + ** the fcntl call every time sync is called. + */ + if( rc ) rc = fsync(fd); + +#elif defined(__APPLE__) + /* fdatasync() on HFS+ doesn't yet flush the file size if it changed correctly + ** so currently we default to the macro that redefines fdatasync to fsync + */ + rc = fsync(fd); +#else + rc = fdatasync(fd); +#if OS_VXWORKS + if( rc==-1 && errno==ENOTSUP ){ + rc = fsync(fd); + } +#endif /* OS_VXWORKS */ +#endif /* ifdef SQLITE_NO_SYNC elif HAVE_FULLFSYNC */ + + if( OS_VXWORKS && rc!= -1 ){ + rc = 0; + } + return rc; +} + +/* +** Open a file descriptor to the directory containing file zFilename. +** If successful, *pFd is set to the opened file descriptor and +** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM +** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined +** value. +** +** The directory file descriptor is used for only one thing - to +** fsync() a directory to make sure file creation and deletion events +** are flushed to disk. Such fsyncs are not needed on newer +** journaling filesystems, but are required on older filesystems. +** +** This routine can be overridden using the xSetSysCall interface. +** The ability to override this routine was added in support of the +** chromium sandbox. Opening a directory is a security risk (we are +** told) so making it overrideable allows the chromium sandbox to +** replace this routine with a harmless no-op. To make this routine +** a no-op, replace it with a stub that returns SQLITE_OK but leaves +** *pFd set to a negative number. +** +** If SQLITE_OK is returned, the caller is responsible for closing +** the file descriptor *pFd using close(). +*/ +static int openDirectory(const char *zFilename, int *pFd){ + int ii; + int fd = -1; + char zDirname[MAX_PATHNAME+1]; + + sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename); + for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--); + if( ii>0 ){ + zDirname[ii] = '\0'; + fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0); + if( fd>=0 ){ + OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname)); + } + } + *pFd = fd; + return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname)); +} + +/* +** Make sure all writes to a particular file are committed to disk. +** +** If dataOnly==0 then both the file itself and its metadata (file +** size, access time, etc) are synced. If dataOnly!=0 then only the +** file data is synced. +** +** Under Unix, also make sure that the directory entry for the file +** has been created by fsync-ing the directory that contains the file. +** If we do not do this and we encounter a power failure, the directory +** entry for the journal might not exist after we reboot. The next +** SQLite to access the file will not know that the journal exists (because +** the directory entry for the journal was never created) and the transaction +** will not roll back - possibly leading to database corruption. +*/ +static int unixSync(sqlite3_file *id, int flags){ + int rc; + unixFile *pFile = (unixFile*)id; + + int isDataOnly = (flags&SQLITE_SYNC_DATAONLY); + int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL; + + /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */ + assert((flags&0x0F)==SQLITE_SYNC_NORMAL + || (flags&0x0F)==SQLITE_SYNC_FULL + ); + + /* Unix cannot, but some systems may return SQLITE_FULL from here. This + ** line is to test that doing so does not cause any problems. + */ + SimulateDiskfullError( return SQLITE_FULL ); + + assert( pFile ); + OSTRACE(("SYNC %-3d\n", pFile->h)); + rc = full_fsync(pFile->h, isFullsync, isDataOnly); + SimulateIOError( rc=1 ); + if( rc ){ + storeLastErrno(pFile, errno); + return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath); + } + + /* Also fsync the directory containing the file if the DIRSYNC flag + ** is set. This is a one-time occurrence. Many systems (examples: AIX) + ** are unable to fsync a directory, so ignore errors on the fsync. + */ + if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){ + int dirfd; + OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath, + HAVE_FULLFSYNC, isFullsync)); + rc = osOpenDirectory(pFile->zPath, &dirfd); + if( rc==SQLITE_OK && dirfd>=0 ){ + full_fsync(dirfd, 0, 0); + robust_close(pFile, dirfd, __LINE__); + }else if( rc==SQLITE_CANTOPEN ){ + rc = SQLITE_OK; + } + pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC; + } + return rc; +} + +/* +** Truncate an open file to a specified size +*/ +static int unixTruncate(sqlite3_file *id, i64 nByte){ + unixFile *pFile = (unixFile *)id; + int rc; + assert( pFile ); + SimulateIOError( return SQLITE_IOERR_TRUNCATE ); + + /* If the user has configured a chunk-size for this file, truncate the + ** file so that it consists of an integer number of chunks (i.e. the + ** actual file size after the operation may be larger than the requested + ** size). + */ + if( pFile->szChunk>0 ){ + nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk; + } + + rc = robust_ftruncate(pFile->h, nByte); + if( rc ){ + storeLastErrno(pFile, errno); + return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath); + }else{ +#ifdef SQLITE_DEBUG + /* If we are doing a normal write to a database file (as opposed to + ** doing a hot-journal rollback or a write to some file other than a + ** normal database file) and we truncate the file to zero length, + ** that effectively updates the change counter. This might happen + ** when restoring a database using the backup API from a zero-length + ** source. + */ + if( pFile->inNormalWrite && nByte==0 ){ + pFile->transCntrChng = 1; + } +#endif + +#if SQLITE_MAX_MMAP_SIZE>0 + /* If the file was just truncated to a size smaller than the currently + ** mapped region, reduce the effective mapping size as well. SQLite will + ** use read() and write() to access data beyond this point from now on. + */ + if( nBytemmapSize ){ + pFile->mmapSize = nByte; + } +#endif + + return SQLITE_OK; + } +} + +/* +** Determine the current size of a file in bytes +*/ +static int unixFileSize(sqlite3_file *id, i64 *pSize){ + int rc; + struct stat buf; + assert( id ); + rc = osFstat(((unixFile*)id)->h, &buf); + SimulateIOError( rc=1 ); + if( rc!=0 ){ + storeLastErrno((unixFile*)id, errno); + return SQLITE_IOERR_FSTAT; + } + *pSize = buf.st_size; + + /* When opening a zero-size database, the findInodeInfo() procedure + ** writes a single byte into that file in order to work around a bug + ** in the OS-X msdos filesystem. In order to avoid problems with upper + ** layers, we need to report this file size as zero even though it is + ** really 1. Ticket #3260. + */ + if( *pSize==1 ) *pSize = 0; + + + return SQLITE_OK; +} + +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) +/* +** Handler for proxy-locking file-control verbs. Defined below in the +** proxying locking division. +*/ +static int proxyFileControl(sqlite3_file*,int,void*); +#endif + +/* +** This function is called to handle the SQLITE_FCNTL_SIZE_HINT +** file-control operation. Enlarge the database to nBytes in size +** (rounded up to the next chunk-size). If the database is already +** nBytes or larger, this routine is a no-op. +*/ +static int fcntlSizeHint(unixFile *pFile, i64 nByte){ + if( pFile->szChunk>0 ){ + i64 nSize; /* Required file size */ + struct stat buf; /* Used to hold return values of fstat() */ + + if( osFstat(pFile->h, &buf) ){ + return SQLITE_IOERR_FSTAT; + } + + nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk; + if( nSize>(i64)buf.st_size ){ + +#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE + /* The code below is handling the return value of osFallocate() + ** correctly. posix_fallocate() is defined to "returns zero on success, + ** or an error number on failure". See the manpage for details. */ + int err; + do{ + err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size); + }while( err==EINTR ); + if( err ) return SQLITE_IOERR_WRITE; +#else + /* If the OS does not have posix_fallocate(), fake it. Write a + ** single byte to the last byte in each block that falls entirely + ** within the extended region. Then, if required, a single byte + ** at offset (nSize-1), to set the size of the file correctly. + ** This is a similar technique to that used by glibc on systems + ** that do not have a real fallocate() call. + */ + int nBlk = buf.st_blksize; /* File-system block size */ + int nWrite = 0; /* Number of bytes written by seekAndWrite */ + i64 iWrite; /* Next offset to write to */ + + iWrite = ((buf.st_size + 2*nBlk - 1)/nBlk)*nBlk-1; + assert( iWrite>=buf.st_size ); + assert( (iWrite/nBlk)==((buf.st_size+nBlk-1)/nBlk) ); + assert( ((iWrite+1)%nBlk)==0 ); + for(/*no-op*/; iWrite0 + if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){ + int rc; + if( pFile->szChunk<=0 ){ + if( robust_ftruncate(pFile->h, nByte) ){ + storeLastErrno(pFile, errno); + return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath); + } + } + + rc = unixMapfile(pFile, nByte); + return rc; + } +#endif + + return SQLITE_OK; +} + +/* +** If *pArg is initially negative then this is a query. Set *pArg to +** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set. +** +** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags. +*/ +static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){ + if( *pArg<0 ){ + *pArg = (pFile->ctrlFlags & mask)!=0; + }else if( (*pArg)==0 ){ + pFile->ctrlFlags &= ~mask; + }else{ + pFile->ctrlFlags |= mask; + } +} + +/* Forward declaration */ +static int unixGetTempname(int nBuf, char *zBuf); + +/* +** Information and control of an open file handle. +*/ +static int unixFileControl(sqlite3_file *id, int op, void *pArg){ + unixFile *pFile = (unixFile*)id; + switch( op ){ + case SQLITE_FCNTL_WAL_BLOCK: { + /* pFile->ctrlFlags |= UNIXFILE_BLOCK; // Deferred feature */ + return SQLITE_OK; + } + case SQLITE_FCNTL_LOCKSTATE: { + *(int*)pArg = pFile->eFileLock; + return SQLITE_OK; + } + case SQLITE_FCNTL_LAST_ERRNO: { + *(int*)pArg = pFile->lastErrno; + return SQLITE_OK; + } + case SQLITE_FCNTL_CHUNK_SIZE: { + pFile->szChunk = *(int *)pArg; + return SQLITE_OK; + } + case SQLITE_FCNTL_SIZE_HINT: { + int rc; + SimulateIOErrorBenign(1); + rc = fcntlSizeHint(pFile, *(i64 *)pArg); + SimulateIOErrorBenign(0); + return rc; + } + case SQLITE_FCNTL_PERSIST_WAL: { + unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg); + return SQLITE_OK; + } + case SQLITE_FCNTL_POWERSAFE_OVERWRITE: { + unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg); + return SQLITE_OK; + } + case SQLITE_FCNTL_VFSNAME: { + *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName); + return SQLITE_OK; + } + case SQLITE_FCNTL_TEMPFILENAME: { + char *zTFile = sqlite3_malloc64( pFile->pVfs->mxPathname ); + if( zTFile ){ + unixGetTempname(pFile->pVfs->mxPathname, zTFile); + *(char**)pArg = zTFile; + } + return SQLITE_OK; + } + case SQLITE_FCNTL_HAS_MOVED: { + *(int*)pArg = fileHasMoved(pFile); + return SQLITE_OK; + } +#if SQLITE_MAX_MMAP_SIZE>0 + case SQLITE_FCNTL_MMAP_SIZE: { + i64 newLimit = *(i64*)pArg; + int rc = SQLITE_OK; + if( newLimit>sqlite3GlobalConfig.mxMmap ){ + newLimit = sqlite3GlobalConfig.mxMmap; + } + *(i64*)pArg = pFile->mmapSizeMax; + if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){ + pFile->mmapSizeMax = newLimit; + if( pFile->mmapSize>0 ){ + unixUnmapfile(pFile); + rc = unixMapfile(pFile, -1); + } + } + return rc; + } +#endif +#ifdef SQLITE_DEBUG + /* The pager calls this method to signal that it has done + ** a rollback and that the database is therefore unchanged and + ** it hence it is OK for the transaction change counter to be + ** unchanged. + */ + case SQLITE_FCNTL_DB_UNCHANGED: { + ((unixFile*)id)->dbUpdate = 0; + return SQLITE_OK; + } +#endif +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + case SQLITE_FCNTL_SET_LOCKPROXYFILE: + case SQLITE_FCNTL_GET_LOCKPROXYFILE: { + return proxyFileControl(id,op,pArg); + } +#endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */ + } + return SQLITE_NOTFOUND; +} + +/* +** Return the sector size in bytes of the underlying block device for +** the specified file. This is almost always 512 bytes, but may be +** larger for some devices. +** +** SQLite code assumes this function cannot fail. It also assumes that +** if two files are created in the same file-system directory (i.e. +** a database and its journal file) that the sector size will be the +** same for both. +*/ +#ifndef __QNXNTO__ +static int unixSectorSize(sqlite3_file *NotUsed){ + UNUSED_PARAMETER(NotUsed); + return SQLITE_DEFAULT_SECTOR_SIZE; +} +#endif + +/* +** The following version of unixSectorSize() is optimized for QNX. +*/ +#ifdef __QNXNTO__ +#include +#include +static int unixSectorSize(sqlite3_file *id){ + unixFile *pFile = (unixFile*)id; + if( pFile->sectorSize == 0 ){ + struct statvfs fsInfo; + + /* Set defaults for non-supported filesystems */ + pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE; + pFile->deviceCharacteristics = 0; + if( fstatvfs(pFile->h, &fsInfo) == -1 ) { + return pFile->sectorSize; + } + + if( !strcmp(fsInfo.f_basetype, "tmp") ) { + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + SQLITE_IOCAP_ATOMIC4K | /* All ram filesystem writes are atomic */ + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( strstr(fsInfo.f_basetype, "etfs") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + /* etfs cluster size writes are atomic */ + (pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) | + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( !strcmp(fsInfo.f_basetype, "qnx6") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + SQLITE_IOCAP_ATOMIC | /* All filesystem writes are atomic */ + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( !strcmp(fsInfo.f_basetype, "qnx4") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + /* full bitset of atomics from max sector size and smaller */ + ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 | + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( strstr(fsInfo.f_basetype, "dos") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + /* full bitset of atomics from max sector size and smaller */ + ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 | + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else{ + pFile->deviceCharacteristics = + SQLITE_IOCAP_ATOMIC512 | /* blocks are atomic */ + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + 0; + } + } + /* Last chance verification. If the sector size isn't a multiple of 512 + ** then it isn't valid.*/ + if( pFile->sectorSize % 512 != 0 ){ + pFile->deviceCharacteristics = 0; + pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE; + } + return pFile->sectorSize; +} +#endif /* __QNXNTO__ */ + +/* +** Return the device characteristics for the file. +** +** This VFS is set up to return SQLITE_IOCAP_POWERSAFE_OVERWRITE by default. +** However, that choice is controversial since technically the underlying +** file system does not always provide powersafe overwrites. (In other +** words, after a power-loss event, parts of the file that were never +** written might end up being altered.) However, non-PSOW behavior is very, +** very rare. And asserting PSOW makes a large reduction in the amount +** of required I/O for journaling, since a lot of padding is eliminated. +** Hence, while POWERSAFE_OVERWRITE is on by default, there is a file-control +** available to turn it off and URI query parameter available to turn it off. +*/ +static int unixDeviceCharacteristics(sqlite3_file *id){ + unixFile *p = (unixFile*)id; + int rc = 0; +#ifdef __QNXNTO__ + if( p->sectorSize==0 ) unixSectorSize(id); + rc = p->deviceCharacteristics; +#endif + if( p->ctrlFlags & UNIXFILE_PSOW ){ + rc |= SQLITE_IOCAP_POWERSAFE_OVERWRITE; + } + return rc; +} + +#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + +/* +** Return the system page size. +** +** This function should not be called directly by other code in this file. +** Instead, it should be called via macro osGetpagesize(). +*/ +static int unixGetpagesize(void){ +#if OS_VXWORKS + return 1024; +#elif defined(_BSD_SOURCE) + return getpagesize(); +#else + return (int)sysconf(_SC_PAGESIZE); +#endif +} + +#endif /* !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 */ + +#ifndef SQLITE_OMIT_WAL + +/* +** Object used to represent an shared memory buffer. +** +** When multiple threads all reference the same wal-index, each thread +** has its own unixShm object, but they all point to a single instance +** of this unixShmNode object. In other words, each wal-index is opened +** only once per process. +** +** Each unixShmNode object is connected to a single unixInodeInfo object. +** We could coalesce this object into unixInodeInfo, but that would mean +** every open file that does not use shared memory (in other words, most +** open files) would have to carry around this extra information. So +** the unixInodeInfo object contains a pointer to this unixShmNode object +** and the unixShmNode object is created only when needed. +** +** unixMutexHeld() must be true when creating or destroying +** this object or while reading or writing the following fields: +** +** nRef +** +** The following fields are read-only after the object is created: +** +** fid +** zFilename +** +** Either unixShmNode.mutex must be held or unixShmNode.nRef==0 and +** unixMutexHeld() is true when reading or writing any other field +** in this structure. +*/ +struct unixShmNode { + unixInodeInfo *pInode; /* unixInodeInfo that owns this SHM node */ + sqlite3_mutex *mutex; /* Mutex to access this object */ + char *zFilename; /* Name of the mmapped file */ + int h; /* Open file descriptor */ + int szRegion; /* Size of shared-memory regions */ + u16 nRegion; /* Size of array apRegion */ + u8 isReadonly; /* True if read-only */ + char **apRegion; /* Array of mapped shared-memory regions */ + int nRef; /* Number of unixShm objects pointing to this */ + unixShm *pFirst; /* All unixShm objects pointing to this */ +#ifdef SQLITE_DEBUG + u8 exclMask; /* Mask of exclusive locks held */ + u8 sharedMask; /* Mask of shared locks held */ + u8 nextShmId; /* Next available unixShm.id value */ +#endif +}; + +/* +** Structure used internally by this VFS to record the state of an +** open shared memory connection. +** +** The following fields are initialized when this object is created and +** are read-only thereafter: +** +** unixShm.pFile +** unixShm.id +** +** All other fields are read/write. The unixShm.pFile->mutex must be held +** while accessing any read/write fields. +*/ +struct unixShm { + unixShmNode *pShmNode; /* The underlying unixShmNode object */ + unixShm *pNext; /* Next unixShm with the same unixShmNode */ + u8 hasMutex; /* True if holding the unixShmNode mutex */ + u8 id; /* Id of this connection within its unixShmNode */ + u16 sharedMask; /* Mask of shared locks held */ + u16 exclMask; /* Mask of exclusive locks held */ +}; + +/* +** Constants used for locking +*/ +#define UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */ +#define UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */ + +/* +** Apply posix advisory locks for all bytes from ofst through ofst+n-1. +** +** Locks block if the mask is exactly UNIX_SHM_C and are non-blocking +** otherwise. +*/ +static int unixShmSystemLock( + unixFile *pFile, /* Open connection to the WAL file */ + int lockType, /* F_UNLCK, F_RDLCK, or F_WRLCK */ + int ofst, /* First byte of the locking range */ + int n /* Number of bytes to lock */ +){ + unixShmNode *pShmNode; /* Apply locks to this open shared-memory segment */ + struct flock f; /* The posix advisory locking structure */ + int rc = SQLITE_OK; /* Result code form fcntl() */ + + /* Access to the unixShmNode object is serialized by the caller */ + pShmNode = pFile->pInode->pShmNode; + assert( sqlite3_mutex_held(pShmNode->mutex) || pShmNode->nRef==0 ); + + /* Shared locks never span more than one byte */ + assert( n==1 || lockType!=F_RDLCK ); + + /* Locks are within range */ + assert( n>=1 && nh>=0 ){ + int lkType; + /* Initialize the locking parameters */ + memset(&f, 0, sizeof(f)); + f.l_type = lockType; + f.l_whence = SEEK_SET; + f.l_start = ofst; + f.l_len = n; + + lkType = (pFile->ctrlFlags & UNIXFILE_BLOCK)!=0 ? F_SETLKW : F_SETLK; + rc = osFcntl(pShmNode->h, lkType, &f); + rc = (rc!=(-1)) ? SQLITE_OK : SQLITE_BUSY; + pFile->ctrlFlags &= ~UNIXFILE_BLOCK; + } + + /* Update the global lock state and do debug tracing */ +#ifdef SQLITE_DEBUG + { u16 mask; + OSTRACE(("SHM-LOCK ")); + mask = ofst>31 ? 0xffff : (1<<(ofst+n)) - (1<exclMask &= ~mask; + pShmNode->sharedMask &= ~mask; + }else if( lockType==F_RDLCK ){ + OSTRACE(("read-lock %d ok", ofst)); + pShmNode->exclMask &= ~mask; + pShmNode->sharedMask |= mask; + }else{ + assert( lockType==F_WRLCK ); + OSTRACE(("write-lock %d ok", ofst)); + pShmNode->exclMask |= mask; + pShmNode->sharedMask &= ~mask; + } + }else{ + if( lockType==F_UNLCK ){ + OSTRACE(("unlock %d failed", ofst)); + }else if( lockType==F_RDLCK ){ + OSTRACE(("read-lock failed")); + }else{ + assert( lockType==F_WRLCK ); + OSTRACE(("write-lock %d failed", ofst)); + } + } + OSTRACE((" - afterwards %03x,%03x\n", + pShmNode->sharedMask, pShmNode->exclMask)); + } +#endif + + return rc; +} + +/* +** Return the minimum number of 32KB shm regions that should be mapped at +** a time, assuming that each mapping must be an integer multiple of the +** current system page-size. +** +** Usually, this is 1. The exception seems to be systems that are configured +** to use 64KB pages - in this case each mapping must cover at least two +** shm regions. +*/ +static int unixShmRegionPerMap(void){ + int shmsz = 32*1024; /* SHM region size */ + int pgsz = osGetpagesize(); /* System page size */ + assert( ((pgsz-1)&pgsz)==0 ); /* Page size must be a power of 2 */ + if( pgszpInode->pShmNode; + assert( unixMutexHeld() ); + if( p && p->nRef==0 ){ + int nShmPerMap = unixShmRegionPerMap(); + int i; + assert( p->pInode==pFd->pInode ); + sqlite3_mutex_free(p->mutex); + for(i=0; inRegion; i+=nShmPerMap){ + if( p->h>=0 ){ + osMunmap(p->apRegion[i], p->szRegion); + }else{ + sqlite3_free(p->apRegion[i]); + } + } + sqlite3_free(p->apRegion); + if( p->h>=0 ){ + robust_close(pFd, p->h, __LINE__); + p->h = -1; + } + p->pInode->pShmNode = 0; + sqlite3_free(p); + } +} + +/* +** Open a shared-memory area associated with open database file pDbFd. +** This particular implementation uses mmapped files. +** +** The file used to implement shared-memory is in the same directory +** as the open database file and has the same name as the open database +** file with the "-shm" suffix added. For example, if the database file +** is "/home/user1/config.db" then the file that is created and mmapped +** for shared memory will be called "/home/user1/config.db-shm". +** +** Another approach to is to use files in /dev/shm or /dev/tmp or an +** some other tmpfs mount. But if a file in a different directory +** from the database file is used, then differing access permissions +** or a chroot() might cause two different processes on the same +** database to end up using different files for shared memory - +** meaning that their memory would not really be shared - resulting +** in database corruption. Nevertheless, this tmpfs file usage +** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm" +** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time +** option results in an incompatible build of SQLite; builds of SQLite +** that with differing SQLITE_SHM_DIRECTORY settings attempt to use the +** same database file at the same time, database corruption will likely +** result. The SQLITE_SHM_DIRECTORY compile-time option is considered +** "unsupported" and may go away in a future SQLite release. +** +** When opening a new shared-memory file, if no other instances of that +** file are currently open, in this process or in other processes, then +** the file must be truncated to zero length or have its header cleared. +** +** If the original database file (pDbFd) is using the "unix-excl" VFS +** that means that an exclusive lock is held on the database file and +** that no other processes are able to read or write the database. In +** that case, we do not really need shared memory. No shared memory +** file is created. The shared memory will be simulated with heap memory. +*/ +static int unixOpenSharedMemory(unixFile *pDbFd){ + struct unixShm *p = 0; /* The connection to be opened */ + struct unixShmNode *pShmNode; /* The underlying mmapped file */ + int rc; /* Result code */ + unixInodeInfo *pInode; /* The inode of fd */ + char *zShmFilename; /* Name of the file used for SHM */ + int nShmFilename; /* Size of the SHM filename in bytes */ + + /* Allocate space for the new unixShm object. */ + p = sqlite3_malloc64( sizeof(*p) ); + if( p==0 ) return SQLITE_NOMEM; + memset(p, 0, sizeof(*p)); + assert( pDbFd->pShm==0 ); + + /* Check to see if a unixShmNode object already exists. Reuse an existing + ** one if present. Create a new one if necessary. + */ + unixEnterMutex(); + pInode = pDbFd->pInode; + pShmNode = pInode->pShmNode; + if( pShmNode==0 ){ + struct stat sStat; /* fstat() info for database file */ +#ifndef SQLITE_SHM_DIRECTORY + const char *zBasePath = pDbFd->zPath; +#endif + + /* Call fstat() to figure out the permissions on the database file. If + ** a new *-shm file is created, an attempt will be made to create it + ** with the same permissions. + */ + if( osFstat(pDbFd->h, &sStat) && pInode->bProcessLock==0 ){ + rc = SQLITE_IOERR_FSTAT; + goto shm_open_err; + } + +#ifdef SQLITE_SHM_DIRECTORY + nShmFilename = sizeof(SQLITE_SHM_DIRECTORY) + 31; +#else + nShmFilename = 6 + (int)strlen(zBasePath); +#endif + pShmNode = sqlite3_malloc64( sizeof(*pShmNode) + nShmFilename ); + if( pShmNode==0 ){ + rc = SQLITE_NOMEM; + goto shm_open_err; + } + memset(pShmNode, 0, sizeof(*pShmNode)+nShmFilename); + zShmFilename = pShmNode->zFilename = (char*)&pShmNode[1]; +#ifdef SQLITE_SHM_DIRECTORY + sqlite3_snprintf(nShmFilename, zShmFilename, + SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x", + (u32)sStat.st_ino, (u32)sStat.st_dev); +#else + sqlite3_snprintf(nShmFilename, zShmFilename, "%s-shm", zBasePath); + sqlite3FileSuffix3(pDbFd->zPath, zShmFilename); +#endif + pShmNode->h = -1; + pDbFd->pInode->pShmNode = pShmNode; + pShmNode->pInode = pDbFd->pInode; + pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( pShmNode->mutex==0 ){ + rc = SQLITE_NOMEM; + goto shm_open_err; + } + + if( pInode->bProcessLock==0 ){ + int openFlags = O_RDWR | O_CREAT; + if( sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){ + openFlags = O_RDONLY; + pShmNode->isReadonly = 1; + } + pShmNode->h = robust_open(zShmFilename, openFlags, (sStat.st_mode&0777)); + if( pShmNode->h<0 ){ + rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShmFilename); + goto shm_open_err; + } + + /* If this process is running as root, make sure that the SHM file + ** is owned by the same user that owns the original database. Otherwise, + ** the original owner will not be able to connect. + */ + osFchown(pShmNode->h, sStat.st_uid, sStat.st_gid); + + /* Check to see if another process is holding the dead-man switch. + ** If not, truncate the file to zero length. + */ + rc = SQLITE_OK; + if( unixShmSystemLock(pDbFd, F_WRLCK, UNIX_SHM_DMS, 1)==SQLITE_OK ){ + if( robust_ftruncate(pShmNode->h, 0) ){ + rc = unixLogError(SQLITE_IOERR_SHMOPEN, "ftruncate", zShmFilename); + } + } + if( rc==SQLITE_OK ){ + rc = unixShmSystemLock(pDbFd, F_RDLCK, UNIX_SHM_DMS, 1); + } + if( rc ) goto shm_open_err; + } + } + + /* Make the new connection a child of the unixShmNode */ + p->pShmNode = pShmNode; +#ifdef SQLITE_DEBUG + p->id = pShmNode->nextShmId++; +#endif + pShmNode->nRef++; + pDbFd->pShm = p; + unixLeaveMutex(); + + /* The reference count on pShmNode has already been incremented under + ** the cover of the unixEnterMutex() mutex and the pointer from the + ** new (struct unixShm) object to the pShmNode has been set. All that is + ** left to do is to link the new object into the linked list starting + ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex + ** mutex. + */ + sqlite3_mutex_enter(pShmNode->mutex); + p->pNext = pShmNode->pFirst; + pShmNode->pFirst = p; + sqlite3_mutex_leave(pShmNode->mutex); + return SQLITE_OK; + + /* Jump here on any error */ +shm_open_err: + unixShmPurge(pDbFd); /* This call frees pShmNode if required */ + sqlite3_free(p); + unixLeaveMutex(); + return rc; +} + +/* +** This function is called to obtain a pointer to region iRegion of the +** shared-memory associated with the database file fd. Shared-memory regions +** are numbered starting from zero. Each shared-memory region is szRegion +** bytes in size. +** +** If an error occurs, an error code is returned and *pp is set to NULL. +** +** Otherwise, if the bExtend parameter is 0 and the requested shared-memory +** region has not been allocated (by any client, including one running in a +** separate process), then *pp is set to NULL and SQLITE_OK returned. If +** bExtend is non-zero and the requested shared-memory region has not yet +** been allocated, it is allocated by this function. +** +** If the shared-memory region has already been allocated or is allocated by +** this call as described above, then it is mapped into this processes +** address space (if it is not already), *pp is set to point to the mapped +** memory and SQLITE_OK returned. +*/ +static int unixShmMap( + sqlite3_file *fd, /* Handle open on database file */ + int iRegion, /* Region to retrieve */ + int szRegion, /* Size of regions */ + int bExtend, /* True to extend file if necessary */ + void volatile **pp /* OUT: Mapped memory */ +){ + unixFile *pDbFd = (unixFile*)fd; + unixShm *p; + unixShmNode *pShmNode; + int rc = SQLITE_OK; + int nShmPerMap = unixShmRegionPerMap(); + int nReqRegion; + + /* If the shared-memory file has not yet been opened, open it now. */ + if( pDbFd->pShm==0 ){ + rc = unixOpenSharedMemory(pDbFd); + if( rc!=SQLITE_OK ) return rc; + } + + p = pDbFd->pShm; + pShmNode = p->pShmNode; + sqlite3_mutex_enter(pShmNode->mutex); + assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 ); + assert( pShmNode->pInode==pDbFd->pInode ); + assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 ); + assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 ); + + /* Minimum number of regions required to be mapped. */ + nReqRegion = ((iRegion+nShmPerMap) / nShmPerMap) * nShmPerMap; + + if( pShmNode->nRegionszRegion = szRegion; + + if( pShmNode->h>=0 ){ + /* The requested region is not mapped into this processes address space. + ** Check to see if it has been allocated (i.e. if the wal-index file is + ** large enough to contain the requested region). + */ + if( osFstat(pShmNode->h, &sStat) ){ + rc = SQLITE_IOERR_SHMSIZE; + goto shmpage_out; + } + + if( sStat.st_sizeh, iPg*pgsz + pgsz-1, "", 1, 0)!=1 ){ + const char *zFile = pShmNode->zFilename; + rc = unixLogError(SQLITE_IOERR_SHMSIZE, "write", zFile); + goto shmpage_out; + } + } + } + } + } + + /* Map the requested memory region into this processes address space. */ + apNew = (char **)sqlite3_realloc( + pShmNode->apRegion, nReqRegion*sizeof(char *) + ); + if( !apNew ){ + rc = SQLITE_IOERR_NOMEM; + goto shmpage_out; + } + pShmNode->apRegion = apNew; + while( pShmNode->nRegionh>=0 ){ + pMem = osMmap(0, nMap, + pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE, + MAP_SHARED, pShmNode->h, szRegion*(i64)pShmNode->nRegion + ); + if( pMem==MAP_FAILED ){ + rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename); + goto shmpage_out; + } + }else{ + pMem = sqlite3_malloc64(szRegion); + if( pMem==0 ){ + rc = SQLITE_NOMEM; + goto shmpage_out; + } + memset(pMem, 0, szRegion); + } + + for(i=0; iapRegion[pShmNode->nRegion+i] = &((char*)pMem)[szRegion*i]; + } + pShmNode->nRegion += nShmPerMap; + } + } + +shmpage_out: + if( pShmNode->nRegion>iRegion ){ + *pp = pShmNode->apRegion[iRegion]; + }else{ + *pp = 0; + } + if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY; + sqlite3_mutex_leave(pShmNode->mutex); + return rc; +} + +/* +** Change the lock state for a shared-memory segment. +** +** Note that the relationship between SHAREd and EXCLUSIVE locks is a little +** different here than in posix. In xShmLock(), one can go from unlocked +** to shared and back or from unlocked to exclusive and back. But one may +** not go from shared to exclusive or from exclusive to shared. +*/ +static int unixShmLock( + sqlite3_file *fd, /* Database file holding the shared memory */ + int ofst, /* First lock to acquire or release */ + int n, /* Number of locks to acquire or release */ + int flags /* What to do with the lock */ +){ + unixFile *pDbFd = (unixFile*)fd; /* Connection holding shared memory */ + unixShm *p = pDbFd->pShm; /* The shared memory being locked */ + unixShm *pX; /* For looping over all siblings */ + unixShmNode *pShmNode = p->pShmNode; /* The underlying file iNode */ + int rc = SQLITE_OK; /* Result code */ + u16 mask; /* Mask of locks to take or release */ + + assert( pShmNode==pDbFd->pInode->pShmNode ); + assert( pShmNode->pInode==pDbFd->pInode ); + assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK ); + assert( n>=1 ); + assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) ); + assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 ); + assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 ); + assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 ); + + mask = (1<<(ofst+n)) - (1<1 || mask==(1<mutex); + if( flags & SQLITE_SHM_UNLOCK ){ + u16 allMask = 0; /* Mask of locks held by siblings */ + + /* See if any siblings hold this same lock */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( pX==p ) continue; + assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 ); + allMask |= pX->sharedMask; + } + + /* Unlock the system-level locks */ + if( (mask & allMask)==0 ){ + rc = unixShmSystemLock(pDbFd, F_UNLCK, ofst+UNIX_SHM_BASE, n); + }else{ + rc = SQLITE_OK; + } + + /* Undo the local locks */ + if( rc==SQLITE_OK ){ + p->exclMask &= ~mask; + p->sharedMask &= ~mask; + } + }else if( flags & SQLITE_SHM_SHARED ){ + u16 allShared = 0; /* Union of locks held by connections other than "p" */ + + /* Find out which shared locks are already held by sibling connections. + ** If any sibling already holds an exclusive lock, go ahead and return + ** SQLITE_BUSY. + */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( (pX->exclMask & mask)!=0 ){ + rc = SQLITE_BUSY; + break; + } + allShared |= pX->sharedMask; + } + + /* Get shared locks at the system level, if necessary */ + if( rc==SQLITE_OK ){ + if( (allShared & mask)==0 ){ + rc = unixShmSystemLock(pDbFd, F_RDLCK, ofst+UNIX_SHM_BASE, n); + }else{ + rc = SQLITE_OK; + } + } + + /* Get the local shared locks */ + if( rc==SQLITE_OK ){ + p->sharedMask |= mask; + } + }else{ + /* Make sure no sibling connections hold locks that will block this + ** lock. If any do, return SQLITE_BUSY right away. + */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){ + rc = SQLITE_BUSY; + break; + } + } + + /* Get the exclusive locks at the system level. Then if successful + ** also mark the local connection as being locked. + */ + if( rc==SQLITE_OK ){ + rc = unixShmSystemLock(pDbFd, F_WRLCK, ofst+UNIX_SHM_BASE, n); + if( rc==SQLITE_OK ){ + assert( (p->sharedMask & mask)==0 ); + p->exclMask |= mask; + } + } + } + sqlite3_mutex_leave(pShmNode->mutex); + OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n", + p->id, osGetpid(0), p->sharedMask, p->exclMask)); + return rc; +} + +/* +** Implement a memory barrier or memory fence on shared memory. +** +** All loads and stores begun before the barrier must complete before +** any load or store begun after the barrier. +*/ +static void unixShmBarrier( + sqlite3_file *fd /* Database file holding the shared memory */ +){ + UNUSED_PARAMETER(fd); + sqlite3MemoryBarrier(); /* compiler-defined memory barrier */ + unixEnterMutex(); /* Also mutex, for redundancy */ + unixLeaveMutex(); +} + +/* +** Close a connection to shared-memory. Delete the underlying +** storage if deleteFlag is true. +** +** If there is no shared memory associated with the connection then this +** routine is a harmless no-op. +*/ +static int unixShmUnmap( + sqlite3_file *fd, /* The underlying database file */ + int deleteFlag /* Delete shared-memory if true */ +){ + unixShm *p; /* The connection to be closed */ + unixShmNode *pShmNode; /* The underlying shared-memory file */ + unixShm **pp; /* For looping over sibling connections */ + unixFile *pDbFd; /* The underlying database file */ + + pDbFd = (unixFile*)fd; + p = pDbFd->pShm; + if( p==0 ) return SQLITE_OK; + pShmNode = p->pShmNode; + + assert( pShmNode==pDbFd->pInode->pShmNode ); + assert( pShmNode->pInode==pDbFd->pInode ); + + /* Remove connection p from the set of connections associated + ** with pShmNode */ + sqlite3_mutex_enter(pShmNode->mutex); + for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){} + *pp = p->pNext; + + /* Free the connection p */ + sqlite3_free(p); + pDbFd->pShm = 0; + sqlite3_mutex_leave(pShmNode->mutex); + + /* If pShmNode->nRef has reached 0, then close the underlying + ** shared-memory file, too */ + unixEnterMutex(); + assert( pShmNode->nRef>0 ); + pShmNode->nRef--; + if( pShmNode->nRef==0 ){ + if( deleteFlag && pShmNode->h>=0 ){ + osUnlink(pShmNode->zFilename); + } + unixShmPurge(pDbFd); + } + unixLeaveMutex(); + + return SQLITE_OK; +} + + +#else +# define unixShmMap 0 +# define unixShmLock 0 +# define unixShmBarrier 0 +# define unixShmUnmap 0 +#endif /* #ifndef SQLITE_OMIT_WAL */ + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** If it is currently memory mapped, unmap file pFd. +*/ +static void unixUnmapfile(unixFile *pFd){ + assert( pFd->nFetchOut==0 ); + if( pFd->pMapRegion ){ + osMunmap(pFd->pMapRegion, pFd->mmapSizeActual); + pFd->pMapRegion = 0; + pFd->mmapSize = 0; + pFd->mmapSizeActual = 0; + } +} + +/* +** Attempt to set the size of the memory mapping maintained by file +** descriptor pFd to nNew bytes. Any existing mapping is discarded. +** +** If successful, this function sets the following variables: +** +** unixFile.pMapRegion +** unixFile.mmapSize +** unixFile.mmapSizeActual +** +** If unsuccessful, an error message is logged via sqlite3_log() and +** the three variables above are zeroed. In this case SQLite should +** continue accessing the database using the xRead() and xWrite() +** methods. +*/ +static void unixRemapfile( + unixFile *pFd, /* File descriptor object */ + i64 nNew /* Required mapping size */ +){ + const char *zErr = "mmap"; + int h = pFd->h; /* File descriptor open on db file */ + u8 *pOrig = (u8 *)pFd->pMapRegion; /* Pointer to current file mapping */ + i64 nOrig = pFd->mmapSizeActual; /* Size of pOrig region in bytes */ + u8 *pNew = 0; /* Location of new mapping */ + int flags = PROT_READ; /* Flags to pass to mmap() */ + + assert( pFd->nFetchOut==0 ); + assert( nNew>pFd->mmapSize ); + assert( nNew<=pFd->mmapSizeMax ); + assert( nNew>0 ); + assert( pFd->mmapSizeActual>=pFd->mmapSize ); + assert( MAP_FAILED!=0 ); + + if( (pFd->ctrlFlags & UNIXFILE_RDONLY)==0 ) flags |= PROT_WRITE; + + if( pOrig ){ +#if HAVE_MREMAP + i64 nReuse = pFd->mmapSize; +#else + const int szSyspage = osGetpagesize(); + i64 nReuse = (pFd->mmapSize & ~(szSyspage-1)); +#endif + u8 *pReq = &pOrig[nReuse]; + + /* Unmap any pages of the existing mapping that cannot be reused. */ + if( nReuse!=nOrig ){ + osMunmap(pReq, nOrig-nReuse); + } + +#if HAVE_MREMAP + pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE); + zErr = "mremap"; +#else + pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse); + if( pNew!=MAP_FAILED ){ + if( pNew!=pReq ){ + osMunmap(pNew, nNew - nReuse); + pNew = 0; + }else{ + pNew = pOrig; + } + } +#endif + + /* The attempt to extend the existing mapping failed. Free it. */ + if( pNew==MAP_FAILED || pNew==0 ){ + osMunmap(pOrig, nReuse); + } + } + + /* If pNew is still NULL, try to create an entirely new mapping. */ + if( pNew==0 ){ + pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0); + } + + if( pNew==MAP_FAILED ){ + pNew = 0; + nNew = 0; + unixLogError(SQLITE_OK, zErr, pFd->zPath); + + /* If the mmap() above failed, assume that all subsequent mmap() calls + ** will probably fail too. Fall back to using xRead/xWrite exclusively + ** in this case. */ + pFd->mmapSizeMax = 0; + } + pFd->pMapRegion = (void *)pNew; + pFd->mmapSize = pFd->mmapSizeActual = nNew; +} + +/* +** Memory map or remap the file opened by file-descriptor pFd (if the file +** is already mapped, the existing mapping is replaced by the new). Or, if +** there already exists a mapping for this file, and there are still +** outstanding xFetch() references to it, this function is a no-op. +** +** If parameter nByte is non-negative, then it is the requested size of +** the mapping to create. Otherwise, if nByte is less than zero, then the +** requested size is the size of the file on disk. The actual size of the +** created mapping is either the requested size or the value configured +** using SQLITE_FCNTL_MMAP_LIMIT, whichever is smaller. +** +** SQLITE_OK is returned if no error occurs (even if the mapping is not +** recreated as a result of outstanding references) or an SQLite error +** code otherwise. +*/ +static int unixMapfile(unixFile *pFd, i64 nByte){ + i64 nMap = nByte; + int rc; + + assert( nMap>=0 || pFd->nFetchOut==0 ); + if( pFd->nFetchOut>0 ) return SQLITE_OK; + + if( nMap<0 ){ + struct stat statbuf; /* Low-level file information */ + rc = osFstat(pFd->h, &statbuf); + if( rc!=SQLITE_OK ){ + return SQLITE_IOERR_FSTAT; + } + nMap = statbuf.st_size; + } + if( nMap>pFd->mmapSizeMax ){ + nMap = pFd->mmapSizeMax; + } + + if( nMap!=pFd->mmapSize ){ + if( nMap>0 ){ + unixRemapfile(pFd, nMap); + }else{ + unixUnmapfile(pFd); + } + } + + return SQLITE_OK; +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* +** If possible, return a pointer to a mapping of file fd starting at offset +** iOff. The mapping must be valid for at least nAmt bytes. +** +** If such a pointer can be obtained, store it in *pp and return SQLITE_OK. +** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK. +** Finally, if an error does occur, return an SQLite error code. The final +** value of *pp is undefined in this case. +** +** If this function does return a pointer, the caller must eventually +** release the reference by calling unixUnfetch(). +*/ +static int unixFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){ +#if SQLITE_MAX_MMAP_SIZE>0 + unixFile *pFd = (unixFile *)fd; /* The underlying database file */ +#endif + *pp = 0; + +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFd->mmapSizeMax>0 ){ + if( pFd->pMapRegion==0 ){ + int rc = unixMapfile(pFd, -1); + if( rc!=SQLITE_OK ) return rc; + } + if( pFd->mmapSize >= iOff+nAmt ){ + *pp = &((u8 *)pFd->pMapRegion)[iOff]; + pFd->nFetchOut++; + } + } +#endif + return SQLITE_OK; +} + +/* +** If the third argument is non-NULL, then this function releases a +** reference obtained by an earlier call to unixFetch(). The second +** argument passed to this function must be the same as the corresponding +** argument that was passed to the unixFetch() invocation. +** +** Or, if the third argument is NULL, then this function is being called +** to inform the VFS layer that, according to POSIX, any existing mapping +** may now be invalid and should be unmapped. +*/ +static int unixUnfetch(sqlite3_file *fd, i64 iOff, void *p){ +#if SQLITE_MAX_MMAP_SIZE>0 + unixFile *pFd = (unixFile *)fd; /* The underlying database file */ + UNUSED_PARAMETER(iOff); + + /* If p==0 (unmap the entire file) then there must be no outstanding + ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference), + ** then there must be at least one outstanding. */ + assert( (p==0)==(pFd->nFetchOut==0) ); + + /* If p!=0, it must match the iOff value. */ + assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] ); + + if( p ){ + pFd->nFetchOut--; + }else{ + unixUnmapfile(pFd); + } + + assert( pFd->nFetchOut>=0 ); +#else + UNUSED_PARAMETER(fd); + UNUSED_PARAMETER(p); + UNUSED_PARAMETER(iOff); +#endif + return SQLITE_OK; +} + +/* +** Here ends the implementation of all sqlite3_file methods. +** +********************** End sqlite3_file Methods ******************************* +******************************************************************************/ + +/* +** This division contains definitions of sqlite3_io_methods objects that +** implement various file locking strategies. It also contains definitions +** of "finder" functions. A finder-function is used to locate the appropriate +** sqlite3_io_methods object for a particular database file. The pAppData +** field of the sqlite3_vfs VFS objects are initialized to be pointers to +** the correct finder-function for that VFS. +** +** Most finder functions return a pointer to a fixed sqlite3_io_methods +** object. The only interesting finder-function is autolockIoFinder, which +** looks at the filesystem type and tries to guess the best locking +** strategy from that. +** +** For finder-function F, two objects are created: +** +** (1) The real finder-function named "FImpt()". +** +** (2) A constant pointer to this function named just "F". +** +** +** A pointer to the F pointer is used as the pAppData value for VFS +** objects. We have to do this instead of letting pAppData point +** directly at the finder-function since C90 rules prevent a void* +** from be cast into a function pointer. +** +** +** Each instance of this macro generates two objects: +** +** * A constant sqlite3_io_methods object call METHOD that has locking +** methods CLOSE, LOCK, UNLOCK, CKRESLOCK. +** +** * An I/O method finder function called FINDER that returns a pointer +** to the METHOD object in the previous bullet. +*/ +#define IOMETHODS(FINDER,METHOD,VERSION,CLOSE,LOCK,UNLOCK,CKLOCK,SHMMAP) \ +static const sqlite3_io_methods METHOD = { \ + VERSION, /* iVersion */ \ + CLOSE, /* xClose */ \ + unixRead, /* xRead */ \ + unixWrite, /* xWrite */ \ + unixTruncate, /* xTruncate */ \ + unixSync, /* xSync */ \ + unixFileSize, /* xFileSize */ \ + LOCK, /* xLock */ \ + UNLOCK, /* xUnlock */ \ + CKLOCK, /* xCheckReservedLock */ \ + unixFileControl, /* xFileControl */ \ + unixSectorSize, /* xSectorSize */ \ + unixDeviceCharacteristics, /* xDeviceCapabilities */ \ + SHMMAP, /* xShmMap */ \ + unixShmLock, /* xShmLock */ \ + unixShmBarrier, /* xShmBarrier */ \ + unixShmUnmap, /* xShmUnmap */ \ + unixFetch, /* xFetch */ \ + unixUnfetch, /* xUnfetch */ \ +}; \ +static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){ \ + UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \ + return &METHOD; \ +} \ +static const sqlite3_io_methods *(*const FINDER)(const char*,unixFile *p) \ + = FINDER##Impl; + +/* +** Here are all of the sqlite3_io_methods objects for each of the +** locking strategies. Functions that return pointers to these methods +** are also created. +*/ +IOMETHODS( + posixIoFinder, /* Finder function name */ + posixIoMethods, /* sqlite3_io_methods object name */ + 3, /* shared memory and mmap are enabled */ + unixClose, /* xClose method */ + unixLock, /* xLock method */ + unixUnlock, /* xUnlock method */ + unixCheckReservedLock, /* xCheckReservedLock method */ + unixShmMap /* xShmMap method */ +) +IOMETHODS( + nolockIoFinder, /* Finder function name */ + nolockIoMethods, /* sqlite3_io_methods object name */ + 3, /* shared memory is disabled */ + nolockClose, /* xClose method */ + nolockLock, /* xLock method */ + nolockUnlock, /* xUnlock method */ + nolockCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +IOMETHODS( + dotlockIoFinder, /* Finder function name */ + dotlockIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + dotlockClose, /* xClose method */ + dotlockLock, /* xLock method */ + dotlockUnlock, /* xUnlock method */ + dotlockCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) + +#if SQLITE_ENABLE_LOCKING_STYLE +IOMETHODS( + flockIoFinder, /* Finder function name */ + flockIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + flockClose, /* xClose method */ + flockLock, /* xLock method */ + flockUnlock, /* xUnlock method */ + flockCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +#if OS_VXWORKS +IOMETHODS( + semIoFinder, /* Finder function name */ + semIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + semXClose, /* xClose method */ + semXLock, /* xLock method */ + semXUnlock, /* xUnlock method */ + semXCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +IOMETHODS( + afpIoFinder, /* Finder function name */ + afpIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + afpClose, /* xClose method */ + afpLock, /* xLock method */ + afpUnlock, /* xUnlock method */ + afpCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +/* +** The proxy locking method is a "super-method" in the sense that it +** opens secondary file descriptors for the conch and lock files and +** it uses proxy, dot-file, AFP, and flock() locking methods on those +** secondary files. For this reason, the division that implements +** proxy locking is located much further down in the file. But we need +** to go ahead and define the sqlite3_io_methods and finder function +** for proxy locking here. So we forward declare the I/O methods. +*/ +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +static int proxyClose(sqlite3_file*); +static int proxyLock(sqlite3_file*, int); +static int proxyUnlock(sqlite3_file*, int); +static int proxyCheckReservedLock(sqlite3_file*, int*); +IOMETHODS( + proxyIoFinder, /* Finder function name */ + proxyIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + proxyClose, /* xClose method */ + proxyLock, /* xLock method */ + proxyUnlock, /* xUnlock method */ + proxyCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +/* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */ +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +IOMETHODS( + nfsIoFinder, /* Finder function name */ + nfsIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + unixClose, /* xClose method */ + unixLock, /* xLock method */ + nfsUnlock, /* xUnlock method */ + unixCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +/* +** This "finder" function attempts to determine the best locking strategy +** for the database file "filePath". It then returns the sqlite3_io_methods +** object that implements that strategy. +** +** This is for MacOSX only. +*/ +static const sqlite3_io_methods *autolockIoFinderImpl( + const char *filePath, /* name of the database file */ + unixFile *pNew /* open file object for the database file */ +){ + static const struct Mapping { + const char *zFilesystem; /* Filesystem type name */ + const sqlite3_io_methods *pMethods; /* Appropriate locking method */ + } aMap[] = { + { "hfs", &posixIoMethods }, + { "ufs", &posixIoMethods }, + { "afpfs", &afpIoMethods }, + { "smbfs", &afpIoMethods }, + { "webdav", &nolockIoMethods }, + { 0, 0 } + }; + int i; + struct statfs fsInfo; + struct flock lockInfo; + + if( !filePath ){ + /* If filePath==NULL that means we are dealing with a transient file + ** that does not need to be locked. */ + return &nolockIoMethods; + } + if( statfs(filePath, &fsInfo) != -1 ){ + if( fsInfo.f_flags & MNT_RDONLY ){ + return &nolockIoMethods; + } + for(i=0; aMap[i].zFilesystem; i++){ + if( strcmp(fsInfo.f_fstypename, aMap[i].zFilesystem)==0 ){ + return aMap[i].pMethods; + } + } + } + + /* Default case. Handles, amongst others, "nfs". + ** Test byte-range lock using fcntl(). If the call succeeds, + ** assume that the file-system supports POSIX style locks. + */ + lockInfo.l_len = 1; + lockInfo.l_start = 0; + lockInfo.l_whence = SEEK_SET; + lockInfo.l_type = F_RDLCK; + if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) { + if( strcmp(fsInfo.f_fstypename, "nfs")==0 ){ + return &nfsIoMethods; + } else { + return &posixIoMethods; + } + }else{ + return &dotlockIoMethods; + } +} +static const sqlite3_io_methods + *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl; + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ + +#if OS_VXWORKS +/* +** This "finder" function for VxWorks checks to see if posix advisory +** locking works. If it does, then that is what is used. If it does not +** work, then fallback to named semaphore locking. +*/ +static const sqlite3_io_methods *vxworksIoFinderImpl( + const char *filePath, /* name of the database file */ + unixFile *pNew /* the open file object */ +){ + struct flock lockInfo; + + if( !filePath ){ + /* If filePath==NULL that means we are dealing with a transient file + ** that does not need to be locked. */ + return &nolockIoMethods; + } + + /* Test if fcntl() is supported and use POSIX style locks. + ** Otherwise fall back to the named semaphore method. + */ + lockInfo.l_len = 1; + lockInfo.l_start = 0; + lockInfo.l_whence = SEEK_SET; + lockInfo.l_type = F_RDLCK; + if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) { + return &posixIoMethods; + }else{ + return &semIoMethods; + } +} +static const sqlite3_io_methods + *(*const vxworksIoFinder)(const char*,unixFile*) = vxworksIoFinderImpl; + +#endif /* OS_VXWORKS */ + +/* +** An abstract type for a pointer to an IO method finder function: +*/ +typedef const sqlite3_io_methods *(*finder_type)(const char*,unixFile*); + + +/**************************************************************************** +**************************** sqlite3_vfs methods **************************** +** +** This division contains the implementation of methods on the +** sqlite3_vfs object. +*/ + +/* +** Initialize the contents of the unixFile structure pointed to by pId. +*/ +static int fillInUnixFile( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + int h, /* Open file descriptor of file being opened */ + sqlite3_file *pId, /* Write to the unixFile structure here */ + const char *zFilename, /* Name of the file being opened */ + int ctrlFlags /* Zero or more UNIXFILE_* values */ +){ + const sqlite3_io_methods *pLockingStyle; + unixFile *pNew = (unixFile *)pId; + int rc = SQLITE_OK; + + assert( pNew->pInode==NULL ); + + /* Usually the path zFilename should not be a relative pathname. The + ** exception is when opening the proxy "conch" file in builds that + ** include the special Apple locking styles. + */ +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE + assert( zFilename==0 || zFilename[0]=='/' + || pVfs->pAppData==(void*)&autolockIoFinder ); +#else + assert( zFilename==0 || zFilename[0]=='/' ); +#endif + + /* No locking occurs in temporary files */ + assert( zFilename!=0 || (ctrlFlags & UNIXFILE_NOLOCK)!=0 ); + + OSTRACE(("OPEN %-3d %s\n", h, zFilename)); + pNew->h = h; + pNew->pVfs = pVfs; + pNew->zPath = zFilename; + pNew->ctrlFlags = (u8)ctrlFlags; +#if SQLITE_MAX_MMAP_SIZE>0 + pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap; +#endif + if( sqlite3_uri_boolean(((ctrlFlags & UNIXFILE_URI) ? zFilename : 0), + "psow", SQLITE_POWERSAFE_OVERWRITE) ){ + pNew->ctrlFlags |= UNIXFILE_PSOW; + } + if( strcmp(pVfs->zName,"unix-excl")==0 ){ + pNew->ctrlFlags |= UNIXFILE_EXCL; + } + +#if OS_VXWORKS + pNew->pId = vxworksFindFileId(zFilename); + if( pNew->pId==0 ){ + ctrlFlags |= UNIXFILE_NOLOCK; + rc = SQLITE_NOMEM; + } +#endif + + if( ctrlFlags & UNIXFILE_NOLOCK ){ + pLockingStyle = &nolockIoMethods; + }else{ + pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew); +#if SQLITE_ENABLE_LOCKING_STYLE + /* Cache zFilename in the locking context (AFP and dotlock override) for + ** proxyLock activation is possible (remote proxy is based on db name) + ** zFilename remains valid until file is closed, to support */ + pNew->lockingContext = (void*)zFilename; +#endif + } + + if( pLockingStyle == &posixIoMethods +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE + || pLockingStyle == &nfsIoMethods +#endif + ){ + unixEnterMutex(); + rc = findInodeInfo(pNew, &pNew->pInode); + if( rc!=SQLITE_OK ){ + /* If an error occurred in findInodeInfo(), close the file descriptor + ** immediately, before releasing the mutex. findInodeInfo() may fail + ** in two scenarios: + ** + ** (a) A call to fstat() failed. + ** (b) A malloc failed. + ** + ** Scenario (b) may only occur if the process is holding no other + ** file descriptors open on the same file. If there were other file + ** descriptors on this file, then no malloc would be required by + ** findInodeInfo(). If this is the case, it is quite safe to close + ** handle h - as it is guaranteed that no posix locks will be released + ** by doing so. + ** + ** If scenario (a) caused the error then things are not so safe. The + ** implicit assumption here is that if fstat() fails, things are in + ** such bad shape that dropping a lock or two doesn't matter much. + */ + robust_close(pNew, h, __LINE__); + h = -1; + } + unixLeaveMutex(); + } + +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + else if( pLockingStyle == &afpIoMethods ){ + /* AFP locking uses the file path so it needs to be included in + ** the afpLockingContext. + */ + afpLockingContext *pCtx; + pNew->lockingContext = pCtx = sqlite3_malloc64( sizeof(*pCtx) ); + if( pCtx==0 ){ + rc = SQLITE_NOMEM; + }else{ + /* NB: zFilename exists and remains valid until the file is closed + ** according to requirement F11141. So we do not need to make a + ** copy of the filename. */ + pCtx->dbPath = zFilename; + pCtx->reserved = 0; + srandomdev(); + unixEnterMutex(); + rc = findInodeInfo(pNew, &pNew->pInode); + if( rc!=SQLITE_OK ){ + sqlite3_free(pNew->lockingContext); + robust_close(pNew, h, __LINE__); + h = -1; + } + unixLeaveMutex(); + } + } +#endif + + else if( pLockingStyle == &dotlockIoMethods ){ + /* Dotfile locking uses the file path so it needs to be included in + ** the dotlockLockingContext + */ + char *zLockFile; + int nFilename; + assert( zFilename!=0 ); + nFilename = (int)strlen(zFilename) + 6; + zLockFile = (char *)sqlite3_malloc64(nFilename); + if( zLockFile==0 ){ + rc = SQLITE_NOMEM; + }else{ + sqlite3_snprintf(nFilename, zLockFile, "%s" DOTLOCK_SUFFIX, zFilename); + } + pNew->lockingContext = zLockFile; + } + +#if OS_VXWORKS + else if( pLockingStyle == &semIoMethods ){ + /* Named semaphore locking uses the file path so it needs to be + ** included in the semLockingContext + */ + unixEnterMutex(); + rc = findInodeInfo(pNew, &pNew->pInode); + if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){ + char *zSemName = pNew->pInode->aSemName; + int n; + sqlite3_snprintf(MAX_PATHNAME, zSemName, "/%s.sem", + pNew->pId->zCanonicalName); + for( n=1; zSemName[n]; n++ ) + if( zSemName[n]=='/' ) zSemName[n] = '_'; + pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1); + if( pNew->pInode->pSem == SEM_FAILED ){ + rc = SQLITE_NOMEM; + pNew->pInode->aSemName[0] = '\0'; + } + } + unixLeaveMutex(); + } +#endif + + storeLastErrno(pNew, 0); +#if OS_VXWORKS + if( rc!=SQLITE_OK ){ + if( h>=0 ) robust_close(pNew, h, __LINE__); + h = -1; + osUnlink(zFilename); + pNew->ctrlFlags |= UNIXFILE_DELETE; + } +#endif + if( rc!=SQLITE_OK ){ + if( h>=0 ) robust_close(pNew, h, __LINE__); + }else{ + pNew->pMethod = pLockingStyle; + OpenCounter(+1); + verifyDbFile(pNew); + } + return rc; +} + +/* +** Return the name of a directory in which to put temporary files. +** If no suitable temporary file directory can be found, return NULL. +*/ +static const char *unixTempFileDir(void){ + static const char *azDirs[] = { + 0, + 0, + 0, + "/var/tmp", + "/usr/tmp", + "/tmp", + 0 /* List terminator */ + }; + unsigned int i; + struct stat buf; + const char *zDir = 0; + + azDirs[0] = sqlite3_temp_directory; + if( !azDirs[1] ) azDirs[1] = getenv("SQLITE_TMPDIR"); + if( !azDirs[2] ) azDirs[2] = getenv("TMPDIR"); + for(i=0; imxPathname bytes. +*/ +static int unixGetTempname(int nBuf, char *zBuf){ + static const unsigned char zChars[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"; + unsigned int i, j; + const char *zDir; + + /* It's odd to simulate an io-error here, but really this is just + ** using the io-error infrastructure to test that SQLite handles this + ** function failing. + */ + SimulateIOError( return SQLITE_IOERR ); + + zDir = unixTempFileDir(); + if( zDir==0 ) zDir = "."; + + /* Check that the output buffer is large enough for the temporary file + ** name. If it is not, return SQLITE_ERROR. + */ + if( (strlen(zDir) + strlen(SQLITE_TEMP_FILE_PREFIX) + 18) >= (size_t)nBuf ){ + return SQLITE_ERROR; + } + + do{ + sqlite3_snprintf(nBuf-18, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX, zDir); + j = (int)strlen(zBuf); + sqlite3_randomness(15, &zBuf[j]); + for(i=0; i<15; i++, j++){ + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; + } + zBuf[j] = 0; + zBuf[j+1] = 0; + }while( osAccess(zBuf,0)==0 ); + return SQLITE_OK; +} + +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) +/* +** Routine to transform a unixFile into a proxy-locking unixFile. +** Implementation in the proxy-lock division, but used by unixOpen() +** if SQLITE_PREFER_PROXY_LOCKING is defined. +*/ +static int proxyTransformUnixFile(unixFile*, const char*); +#endif + +/* +** Search for an unused file descriptor that was opened on the database +** file (not a journal or master-journal file) identified by pathname +** zPath with SQLITE_OPEN_XXX flags matching those passed as the second +** argument to this function. +** +** Such a file descriptor may exist if a database connection was closed +** but the associated file descriptor could not be closed because some +** other file descriptor open on the same file is holding a file-lock. +** Refer to comments in the unixClose() function and the lengthy comment +** describing "Posix Advisory Locking" at the start of this file for +** further details. Also, ticket #4018. +** +** If a suitable file descriptor is found, then it is returned. If no +** such file descriptor is located, -1 is returned. +*/ +static UnixUnusedFd *findReusableFd(const char *zPath, int flags){ + UnixUnusedFd *pUnused = 0; + + /* Do not search for an unused file descriptor on vxworks. Not because + ** vxworks would not benefit from the change (it might, we're not sure), + ** but because no way to test it is currently available. It is better + ** not to risk breaking vxworks support for the sake of such an obscure + ** feature. */ +#if !OS_VXWORKS + struct stat sStat; /* Results of stat() call */ + + /* A stat() call may fail for various reasons. If this happens, it is + ** almost certain that an open() call on the same path will also fail. + ** For this reason, if an error occurs in the stat() call here, it is + ** ignored and -1 is returned. The caller will try to open a new file + ** descriptor on the same path, fail, and return an error to SQLite. + ** + ** Even if a subsequent open() call does succeed, the consequences of + ** not searching for a reusable file descriptor are not dire. */ + if( 0==osStat(zPath, &sStat) ){ + unixInodeInfo *pInode; + + unixEnterMutex(); + pInode = inodeList; + while( pInode && (pInode->fileId.dev!=sStat.st_dev + || pInode->fileId.ino!=sStat.st_ino) ){ + pInode = pInode->pNext; + } + if( pInode ){ + UnixUnusedFd **pp; + for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext)); + pUnused = *pp; + if( pUnused ){ + *pp = pUnused->pNext; + } + } + unixLeaveMutex(); + } +#endif /* if !OS_VXWORKS */ + return pUnused; +} + +/* +** This function is called by unixOpen() to determine the unix permissions +** to create new files with. If no error occurs, then SQLITE_OK is returned +** and a value suitable for passing as the third argument to open(2) is +** written to *pMode. If an IO error occurs, an SQLite error code is +** returned and the value of *pMode is not modified. +** +** In most cases, this routine sets *pMode to 0, which will become +** an indication to robust_open() to create the file using +** SQLITE_DEFAULT_FILE_PERMISSIONS adjusted by the umask. +** But if the file being opened is a WAL or regular journal file, then +** this function queries the file-system for the permissions on the +** corresponding database file and sets *pMode to this value. Whenever +** possible, WAL and journal files are created using the same permissions +** as the associated database file. +** +** If the SQLITE_ENABLE_8_3_NAMES option is enabled, then the +** original filename is unavailable. But 8_3_NAMES is only used for +** FAT filesystems and permissions do not matter there, so just use +** the default permissions. +*/ +static int findCreateFileMode( + const char *zPath, /* Path of file (possibly) being created */ + int flags, /* Flags passed as 4th argument to xOpen() */ + mode_t *pMode, /* OUT: Permissions to open file with */ + uid_t *pUid, /* OUT: uid to set on the file */ + gid_t *pGid /* OUT: gid to set on the file */ +){ + int rc = SQLITE_OK; /* Return Code */ + *pMode = 0; + *pUid = 0; + *pGid = 0; + if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){ + char zDb[MAX_PATHNAME+1]; /* Database file path */ + int nDb; /* Number of valid bytes in zDb */ + struct stat sStat; /* Output of stat() on database file */ + + /* zPath is a path to a WAL or journal file. The following block derives + ** the path to the associated database file from zPath. This block handles + ** the following naming conventions: + ** + ** "-journal" + ** "-wal" + ** "-journalNN" + ** "-walNN" + ** + ** where NN is a decimal number. The NN naming schemes are + ** used by the test_multiplex.c module. + */ + nDb = sqlite3Strlen30(zPath) - 1; +#ifdef SQLITE_ENABLE_8_3_NAMES + while( nDb>0 && sqlite3Isalnum(zPath[nDb]) ) nDb--; + if( nDb==0 || zPath[nDb]!='-' ) return SQLITE_OK; +#else + while( zPath[nDb]!='-' ){ + assert( nDb>0 ); + assert( zPath[nDb]!='\n' ); + nDb--; + } +#endif + memcpy(zDb, zPath, nDb); + zDb[nDb] = '\0'; + + if( 0==osStat(zDb, &sStat) ){ + *pMode = sStat.st_mode & 0777; + *pUid = sStat.st_uid; + *pGid = sStat.st_gid; + }else{ + rc = SQLITE_IOERR_FSTAT; + } + }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){ + *pMode = 0600; + } + return rc; +} + +/* +** Open the file zPath. +** +** Previously, the SQLite OS layer used three functions in place of this +** one: +** +** sqlite3OsOpenReadWrite(); +** sqlite3OsOpenReadOnly(); +** sqlite3OsOpenExclusive(); +** +** These calls correspond to the following combinations of flags: +** +** ReadWrite() -> (READWRITE | CREATE) +** ReadOnly() -> (READONLY) +** OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE) +** +** The old OpenExclusive() accepted a boolean argument - "delFlag". If +** true, the file was configured to be automatically deleted when the +** file handle closed. To achieve the same effect using this new +** interface, add the DELETEONCLOSE flag to those specified above for +** OpenExclusive(). +*/ +static int unixOpen( + sqlite3_vfs *pVfs, /* The VFS for which this is the xOpen method */ + const char *zPath, /* Pathname of file to be opened */ + sqlite3_file *pFile, /* The file descriptor to be filled in */ + int flags, /* Input flags to control the opening */ + int *pOutFlags /* Output flags returned to SQLite core */ +){ + unixFile *p = (unixFile *)pFile; + int fd = -1; /* File descriptor returned by open() */ + int openFlags = 0; /* Flags to pass to open() */ + int eType = flags&0xFFFFFF00; /* Type of file to open */ + int noLock; /* True to omit locking primitives */ + int rc = SQLITE_OK; /* Function Return Code */ + int ctrlFlags = 0; /* UNIXFILE_* flags */ + + int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE); + int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE); + int isCreate = (flags & SQLITE_OPEN_CREATE); + int isReadonly = (flags & SQLITE_OPEN_READONLY); + int isReadWrite = (flags & SQLITE_OPEN_READWRITE); +#if SQLITE_ENABLE_LOCKING_STYLE + int isAutoProxy = (flags & SQLITE_OPEN_AUTOPROXY); +#endif +#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE + struct statfs fsInfo; +#endif + + /* If creating a master or main-file journal, this function will open + ** a file-descriptor on the directory too. The first time unixSync() + ** is called the directory file descriptor will be fsync()ed and close()d. + */ + int syncDir = (isCreate && ( + eType==SQLITE_OPEN_MASTER_JOURNAL + || eType==SQLITE_OPEN_MAIN_JOURNAL + || eType==SQLITE_OPEN_WAL + )); + + /* If argument zPath is a NULL pointer, this function is required to open + ** a temporary file. Use this buffer to store the file name in. + */ + char zTmpname[MAX_PATHNAME+2]; + const char *zName = zPath; + + /* Check the following statements are true: + ** + ** (a) Exactly one of the READWRITE and READONLY flags must be set, and + ** (b) if CREATE is set, then READWRITE must also be set, and + ** (c) if EXCLUSIVE is set, then CREATE must also be set. + ** (d) if DELETEONCLOSE is set, then CREATE must also be set. + */ + assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly)); + assert(isCreate==0 || isReadWrite); + assert(isExclusive==0 || isCreate); + assert(isDelete==0 || isCreate); + + /* The main DB, main journal, WAL file and master journal are never + ** automatically deleted. Nor are they ever temporary files. */ + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL ); + + /* Assert that the upper layer has set one of the "file-type" flags. */ + assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB + || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL + || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL + || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL + ); + + /* Detect a pid change and reset the PRNG. There is a race condition + ** here such that two or more threads all trying to open databases at + ** the same instant might all reset the PRNG. But multiple resets + ** are harmless. + */ + if( randomnessPid!=osGetpid(0) ){ + randomnessPid = osGetpid(0); + sqlite3_randomness(0,0); + } + + memset(p, 0, sizeof(unixFile)); + + if( eType==SQLITE_OPEN_MAIN_DB ){ + UnixUnusedFd *pUnused; + pUnused = findReusableFd(zName, flags); + if( pUnused ){ + fd = pUnused->fd; + }else{ + pUnused = sqlite3_malloc64(sizeof(*pUnused)); + if( !pUnused ){ + return SQLITE_NOMEM; + } + } + p->pUnused = pUnused; + + /* Database filenames are double-zero terminated if they are not + ** URIs with parameters. Hence, they can always be passed into + ** sqlite3_uri_parameter(). */ + assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 ); + + }else if( !zName ){ + /* If zName is NULL, the upper layer is requesting a temp file. */ + assert(isDelete && !syncDir); + rc = unixGetTempname(MAX_PATHNAME+2, zTmpname); + if( rc!=SQLITE_OK ){ + return rc; + } + zName = zTmpname; + + /* Generated temporary filenames are always double-zero terminated + ** for use by sqlite3_uri_parameter(). */ + assert( zName[strlen(zName)+1]==0 ); + } + + /* Determine the value of the flags parameter passed to POSIX function + ** open(). These must be calculated even if open() is not called, as + ** they may be stored as part of the file handle and used by the + ** 'conch file' locking functions later on. */ + if( isReadonly ) openFlags |= O_RDONLY; + if( isReadWrite ) openFlags |= O_RDWR; + if( isCreate ) openFlags |= O_CREAT; + if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW); + openFlags |= (O_LARGEFILE|O_BINARY); + + if( fd<0 ){ + mode_t openMode; /* Permissions to create file with */ + uid_t uid; /* Userid for the file */ + gid_t gid; /* Groupid for the file */ + rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid); + if( rc!=SQLITE_OK ){ + assert( !p->pUnused ); + assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL ); + return rc; + } + fd = robust_open(zName, openFlags, openMode); + OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags)); + if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){ + /* Failed to open the file for read/write access. Try read-only. */ + flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); + openFlags &= ~(O_RDWR|O_CREAT); + flags |= SQLITE_OPEN_READONLY; + openFlags |= O_RDONLY; + isReadonly = 1; + fd = robust_open(zName, openFlags, openMode); + } + if( fd<0 ){ + rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName); + goto open_finished; + } + + /* If this process is running as root and if creating a new rollback + ** journal or WAL file, set the ownership of the journal or WAL to be + ** the same as the original database. + */ + if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){ + osFchown(fd, uid, gid); + } + } + assert( fd>=0 ); + if( pOutFlags ){ + *pOutFlags = flags; + } + + if( p->pUnused ){ + p->pUnused->fd = fd; + p->pUnused->flags = flags; + } + + if( isDelete ){ +#if OS_VXWORKS + zPath = zName; +#elif defined(SQLITE_UNLINK_AFTER_CLOSE) + zPath = sqlite3_mprintf("%s", zName); + if( zPath==0 ){ + robust_close(p, fd, __LINE__); + return SQLITE_NOMEM; + } +#else + osUnlink(zName); +#endif + } +#if SQLITE_ENABLE_LOCKING_STYLE + else{ + p->openFlags = openFlags; + } +#endif + + noLock = eType!=SQLITE_OPEN_MAIN_DB; + + +#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE + if( fstatfs(fd, &fsInfo) == -1 ){ + storeLastErrno(p, errno); + robust_close(p, fd, __LINE__); + return SQLITE_IOERR_ACCESS; + } + if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) { + ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS; + } + if (0 == strncmp("exfat", fsInfo.f_fstypename, 5)) { + ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS; + } +#endif + + /* Set up appropriate ctrlFlags */ + if( isDelete ) ctrlFlags |= UNIXFILE_DELETE; + if( isReadonly ) ctrlFlags |= UNIXFILE_RDONLY; + if( noLock ) ctrlFlags |= UNIXFILE_NOLOCK; + if( syncDir ) ctrlFlags |= UNIXFILE_DIRSYNC; + if( flags & SQLITE_OPEN_URI ) ctrlFlags |= UNIXFILE_URI; + +#if SQLITE_ENABLE_LOCKING_STYLE +#if SQLITE_PREFER_PROXY_LOCKING + isAutoProxy = 1; +#endif + if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){ + char *envforce = getenv("SQLITE_FORCE_PROXY_LOCKING"); + int useProxy = 0; + + /* SQLITE_FORCE_PROXY_LOCKING==1 means force always use proxy, 0 means + ** never use proxy, NULL means use proxy for non-local files only. */ + if( envforce!=NULL ){ + useProxy = atoi(envforce)>0; + }else{ + useProxy = !(fsInfo.f_flags&MNT_LOCAL); + } + if( useProxy ){ + rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags); + if( rc==SQLITE_OK ){ + rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:"); + if( rc!=SQLITE_OK ){ + /* Use unixClose to clean up the resources added in fillInUnixFile + ** and clear all the structure's references. Specifically, + ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op + */ + unixClose(pFile); + return rc; + } + } + goto open_finished; + } + } +#endif + + rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags); + +open_finished: + if( rc!=SQLITE_OK ){ + sqlite3_free(p->pUnused); + } + return rc; +} + + +/* +** Delete the file at zPath. If the dirSync argument is true, fsync() +** the directory after deleting the file. +*/ +static int unixDelete( + sqlite3_vfs *NotUsed, /* VFS containing this as the xDelete method */ + const char *zPath, /* Name of file to be deleted */ + int dirSync /* If true, fsync() directory after deleting file */ +){ + int rc = SQLITE_OK; + UNUSED_PARAMETER(NotUsed); + SimulateIOError(return SQLITE_IOERR_DELETE); + if( osUnlink(zPath)==(-1) ){ + if( errno==ENOENT +#if OS_VXWORKS + || osAccess(zPath,0)!=0 +#endif + ){ + rc = SQLITE_IOERR_DELETE_NOENT; + }else{ + rc = unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath); + } + return rc; + } +#ifndef SQLITE_DISABLE_DIRSYNC + if( (dirSync & 1)!=0 ){ + int fd; + rc = osOpenDirectory(zPath, &fd); + if( rc==SQLITE_OK ){ +#if OS_VXWORKS + if( fsync(fd)==-1 ) +#else + if( fsync(fd) ) +#endif + { + rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath); + } + robust_close(0, fd, __LINE__); + }else if( rc==SQLITE_CANTOPEN ){ + rc = SQLITE_OK; + } + } +#endif + return rc; +} + +/* +** Test the existence of or access permissions of file zPath. The +** test performed depends on the value of flags: +** +** SQLITE_ACCESS_EXISTS: Return 1 if the file exists +** SQLITE_ACCESS_READWRITE: Return 1 if the file is read and writable. +** SQLITE_ACCESS_READONLY: Return 1 if the file is readable. +** +** Otherwise return 0. +*/ +static int unixAccess( + sqlite3_vfs *NotUsed, /* The VFS containing this xAccess method */ + const char *zPath, /* Path of the file to examine */ + int flags, /* What do we want to learn about the zPath file? */ + int *pResOut /* Write result boolean here */ +){ + int amode = 0; + UNUSED_PARAMETER(NotUsed); + SimulateIOError( return SQLITE_IOERR_ACCESS; ); + switch( flags ){ + case SQLITE_ACCESS_EXISTS: + amode = F_OK; + break; + case SQLITE_ACCESS_READWRITE: + amode = W_OK|R_OK; + break; + case SQLITE_ACCESS_READ: + amode = R_OK; + break; + + default: + assert(!"Invalid flags argument"); + } + *pResOut = (osAccess(zPath, amode)==0); + if( flags==SQLITE_ACCESS_EXISTS && *pResOut ){ + struct stat buf; + if( 0==osStat(zPath, &buf) && buf.st_size==0 ){ + *pResOut = 0; + } + } + return SQLITE_OK; +} + + +/* +** Turn a relative pathname into a full pathname. The relative path +** is stored as a nul-terminated string in the buffer pointed to by +** zPath. +** +** zOut points to a buffer of at least sqlite3_vfs.mxPathname bytes +** (in this case, MAX_PATHNAME bytes). The full-path is written to +** this buffer before returning. +*/ +static int unixFullPathname( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zPath, /* Possibly relative input path */ + int nOut, /* Size of output buffer in bytes */ + char *zOut /* Output buffer */ +){ + + /* It's odd to simulate an io-error here, but really this is just + ** using the io-error infrastructure to test that SQLite handles this + ** function failing. This function could fail if, for example, the + ** current working directory has been unlinked. + */ + SimulateIOError( return SQLITE_ERROR ); + + assert( pVfs->mxPathname==MAX_PATHNAME ); + UNUSED_PARAMETER(pVfs); + + zOut[nOut-1] = '\0'; + if( zPath[0]=='/' ){ + sqlite3_snprintf(nOut, zOut, "%s", zPath); + }else{ + int nCwd; + if( osGetcwd(zOut, nOut-1)==0 ){ + return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath); + } + nCwd = (int)strlen(zOut); + sqlite3_snprintf(nOut-nCwd, &zOut[nCwd], "/%s", zPath); + } + return SQLITE_OK; +} + + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** Interfaces for opening a shared library, finding entry points +** within the shared library, and closing the shared library. +*/ +#include +static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){ + UNUSED_PARAMETER(NotUsed); + return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL); +} + +/* +** SQLite calls this function immediately after a call to unixDlSym() or +** unixDlOpen() fails (returns a null pointer). If a more detailed error +** message is available, it is written to zBufOut. If no error message +** is available, zBufOut is left unmodified and SQLite uses a default +** error message. +*/ +static void unixDlError(sqlite3_vfs *NotUsed, int nBuf, char *zBufOut){ + const char *zErr; + UNUSED_PARAMETER(NotUsed); + unixEnterMutex(); + zErr = dlerror(); + if( zErr ){ + sqlite3_snprintf(nBuf, zBufOut, "%s", zErr); + } + unixLeaveMutex(); +} +static void (*unixDlSym(sqlite3_vfs *NotUsed, void *p, const char*zSym))(void){ + /* + ** GCC with -pedantic-errors says that C90 does not allow a void* to be + ** cast into a pointer to a function. And yet the library dlsym() routine + ** returns a void* which is really a pointer to a function. So how do we + ** use dlsym() with -pedantic-errors? + ** + ** Variable x below is defined to be a pointer to a function taking + ** parameters void* and const char* and returning a pointer to a function. + ** We initialize x by assigning it a pointer to the dlsym() function. + ** (That assignment requires a cast.) Then we call the function that + ** x points to. + ** + ** This work-around is unlikely to work correctly on any system where + ** you really cannot cast a function pointer into void*. But then, on the + ** other hand, dlsym() will not work on such a system either, so we have + ** not really lost anything. + */ + void (*(*x)(void*,const char*))(void); + UNUSED_PARAMETER(NotUsed); + x = (void(*(*)(void*,const char*))(void))dlsym; + return (*x)(p, zSym); +} +static void unixDlClose(sqlite3_vfs *NotUsed, void *pHandle){ + UNUSED_PARAMETER(NotUsed); + dlclose(pHandle); +} +#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */ + #define unixDlOpen 0 + #define unixDlError 0 + #define unixDlSym 0 + #define unixDlClose 0 +#endif + +/* +** Write nBuf bytes of random data to the supplied buffer zBuf. +*/ +static int unixRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){ + UNUSED_PARAMETER(NotUsed); + assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int))); + + /* We have to initialize zBuf to prevent valgrind from reporting + ** errors. The reports issued by valgrind are incorrect - we would + ** prefer that the randomness be increased by making use of the + ** uninitialized space in zBuf - but valgrind errors tend to worry + ** some users. Rather than argue, it seems easier just to initialize + ** the whole array and silence valgrind, even if that means less randomness + ** in the random seed. + ** + ** When testing, initializing zBuf[] to zero is all we do. That means + ** that we always use the same random number sequence. This makes the + ** tests repeatable. + */ + memset(zBuf, 0, nBuf); + randomnessPid = osGetpid(0); +#if !defined(SQLITE_TEST) && !defined(SQLITE_OMIT_RANDOMNESS) + { + int fd, got; + fd = robust_open("/dev/urandom", O_RDONLY, 0); + if( fd<0 ){ + time_t t; + time(&t); + memcpy(zBuf, &t, sizeof(t)); + memcpy(&zBuf[sizeof(t)], &randomnessPid, sizeof(randomnessPid)); + assert( sizeof(t)+sizeof(randomnessPid)<=(size_t)nBuf ); + nBuf = sizeof(t) + sizeof(randomnessPid); + }else{ + do{ got = osRead(fd, zBuf, nBuf); }while( got<0 && errno==EINTR ); + robust_close(0, fd, __LINE__); + } + } +#endif + return nBuf; +} + + +/* +** Sleep for a little while. Return the amount of time slept. +** The argument is the number of microseconds we want to sleep. +** The return value is the number of microseconds of sleep actually +** requested from the underlying operating system, a number which +** might be greater than or equal to the argument, but not less +** than the argument. +*/ +static int unixSleep(sqlite3_vfs *NotUsed, int microseconds){ +#if OS_VXWORKS + struct timespec sp; + + sp.tv_sec = microseconds / 1000000; + sp.tv_nsec = (microseconds % 1000000) * 1000; + nanosleep(&sp, NULL); + UNUSED_PARAMETER(NotUsed); + return microseconds; +#elif defined(HAVE_USLEEP) && HAVE_USLEEP + usleep(microseconds); + UNUSED_PARAMETER(NotUsed); + return microseconds; +#else + int seconds = (microseconds+999999)/1000000; + sleep(seconds); + UNUSED_PARAMETER(NotUsed); + return seconds*1000000; +#endif +} + +/* +** The following variable, if set to a non-zero value, is interpreted as +** the number of seconds since 1970 and is used to set the result of +** sqlite3OsCurrentTime() during testing. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */ +#endif + +/* +** Find the current time (in Universal Coordinated Time). Write into *piNow +** the current time and date as a Julian Day number times 86_400_000. In +** other words, write into *piNow the number of milliseconds since the Julian +** epoch of noon in Greenwich on November 24, 4714 B.C according to the +** proleptic Gregorian calendar. +** +** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date +** cannot be found. +*/ +static int unixCurrentTimeInt64(sqlite3_vfs *NotUsed, sqlite3_int64 *piNow){ + static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000; + int rc = SQLITE_OK; +#if defined(NO_GETTOD) + time_t t; + time(&t); + *piNow = ((sqlite3_int64)t)*1000 + unixEpoch; +#elif OS_VXWORKS + struct timespec sNow; + clock_gettime(CLOCK_REALTIME, &sNow); + *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_nsec/1000000; +#else + struct timeval sNow; + if( gettimeofday(&sNow, 0)==0 ){ + *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_usec/1000; + }else{ + rc = SQLITE_ERROR; + } +#endif + +#ifdef SQLITE_TEST + if( sqlite3_current_time ){ + *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch; + } +#endif + UNUSED_PARAMETER(NotUsed); + return rc; +} + +/* +** Find the current time (in Universal Coordinated Time). Write the +** current time and date as a Julian Day number into *prNow and +** return 0. Return 1 if the time and date cannot be found. +*/ +static int unixCurrentTime(sqlite3_vfs *NotUsed, double *prNow){ + sqlite3_int64 i = 0; + int rc; + UNUSED_PARAMETER(NotUsed); + rc = unixCurrentTimeInt64(0, &i); + *prNow = i/86400000.0; + return rc; +} + +/* +** We added the xGetLastError() method with the intention of providing +** better low-level error messages when operating-system problems come up +** during SQLite operation. But so far, none of that has been implemented +** in the core. So this routine is never called. For now, it is merely +** a place-holder. +*/ +static int unixGetLastError(sqlite3_vfs *NotUsed, int NotUsed2, char *NotUsed3){ + UNUSED_PARAMETER(NotUsed); + UNUSED_PARAMETER(NotUsed2); + UNUSED_PARAMETER(NotUsed3); + return 0; +} + + +/* +************************ End of sqlite3_vfs methods *************************** +******************************************************************************/ + +/****************************************************************************** +************************** Begin Proxy Locking ******************************** +** +** Proxy locking is a "uber-locking-method" in this sense: It uses the +** other locking methods on secondary lock files. Proxy locking is a +** meta-layer over top of the primitive locking implemented above. For +** this reason, the division that implements of proxy locking is deferred +** until late in the file (here) after all of the other I/O methods have +** been defined - so that the primitive locking methods are available +** as services to help with the implementation of proxy locking. +** +**** +** +** The default locking schemes in SQLite use byte-range locks on the +** database file to coordinate safe, concurrent access by multiple readers +** and writers [http://sqlite.org/lockingv3.html]. The five file locking +** states (UNLOCKED, PENDING, SHARED, RESERVED, EXCLUSIVE) are implemented +** as POSIX read & write locks over fixed set of locations (via fsctl), +** on AFP and SMB only exclusive byte-range locks are available via fsctl +** with _IOWR('z', 23, struct ByteRangeLockPB2) to track the same 5 states. +** To simulate a F_RDLCK on the shared range, on AFP a randomly selected +** address in the shared range is taken for a SHARED lock, the entire +** shared range is taken for an EXCLUSIVE lock): +** +** PENDING_BYTE 0x40000000 +** RESERVED_BYTE 0x40000001 +** SHARED_RANGE 0x40000002 -> 0x40000200 +** +** This works well on the local file system, but shows a nearly 100x +** slowdown in read performance on AFP because the AFP client disables +** the read cache when byte-range locks are present. Enabling the read +** cache exposes a cache coherency problem that is present on all OS X +** supported network file systems. NFS and AFP both observe the +** close-to-open semantics for ensuring cache coherency +** [http://nfs.sourceforge.net/#faq_a8], which does not effectively +** address the requirements for concurrent database access by multiple +** readers and writers +** [http://www.nabble.com/SQLite-on-NFS-cache-coherency-td15655701.html]. +** +** To address the performance and cache coherency issues, proxy file locking +** changes the way database access is controlled by limiting access to a +** single host at a time and moving file locks off of the database file +** and onto a proxy file on the local file system. +** +** +** Using proxy locks +** ----------------- +** +** C APIs +** +** sqlite3_file_control(db, dbname, SQLITE_FCNTL_SET_LOCKPROXYFILE, +** | ":auto:"); +** sqlite3_file_control(db, dbname, SQLITE_FCNTL_GET_LOCKPROXYFILE, +** &); +** +** +** SQL pragmas +** +** PRAGMA [database.]lock_proxy_file= | :auto: +** PRAGMA [database.]lock_proxy_file +** +** Specifying ":auto:" means that if there is a conch file with a matching +** host ID in it, the proxy path in the conch file will be used, otherwise +** a proxy path based on the user's temp dir +** (via confstr(_CS_DARWIN_USER_TEMP_DIR,...)) will be used and the +** actual proxy file name is generated from the name and path of the +** database file. For example: +** +** For database path "/Users/me/foo.db" +** The lock path will be "/sqliteplocks/_Users_me_foo.db:auto:") +** +** Once a lock proxy is configured for a database connection, it can not +** be removed, however it may be switched to a different proxy path via +** the above APIs (assuming the conch file is not being held by another +** connection or process). +** +** +** How proxy locking works +** ----------------------- +** +** Proxy file locking relies primarily on two new supporting files: +** +** * conch file to limit access to the database file to a single host +** at a time +** +** * proxy file to act as a proxy for the advisory locks normally +** taken on the database +** +** The conch file - to use a proxy file, sqlite must first "hold the conch" +** by taking an sqlite-style shared lock on the conch file, reading the +** contents and comparing the host's unique host ID (see below) and lock +** proxy path against the values stored in the conch. The conch file is +** stored in the same directory as the database file and the file name +** is patterned after the database file name as ".-conch". +** If the conch file does not exist, or its contents do not match the +** host ID and/or proxy path, then the lock is escalated to an exclusive +** lock and the conch file contents is updated with the host ID and proxy +** path and the lock is downgraded to a shared lock again. If the conch +** is held by another process (with a shared lock), the exclusive lock +** will fail and SQLITE_BUSY is returned. +** +** The proxy file - a single-byte file used for all advisory file locks +** normally taken on the database file. This allows for safe sharing +** of the database file for multiple readers and writers on the same +** host (the conch ensures that they all use the same local lock file). +** +** Requesting the lock proxy does not immediately take the conch, it is +** only taken when the first request to lock database file is made. +** This matches the semantics of the traditional locking behavior, where +** opening a connection to a database file does not take a lock on it. +** The shared lock and an open file descriptor are maintained until +** the connection to the database is closed. +** +** The proxy file and the lock file are never deleted so they only need +** to be created the first time they are used. +** +** Configuration options +** --------------------- +** +** SQLITE_PREFER_PROXY_LOCKING +** +** Database files accessed on non-local file systems are +** automatically configured for proxy locking, lock files are +** named automatically using the same logic as +** PRAGMA lock_proxy_file=":auto:" +** +** SQLITE_PROXY_DEBUG +** +** Enables the logging of error messages during host id file +** retrieval and creation +** +** LOCKPROXYDIR +** +** Overrides the default directory used for lock proxy files that +** are named automatically via the ":auto:" setting +** +** SQLITE_DEFAULT_PROXYDIR_PERMISSIONS +** +** Permissions to use when creating a directory for storing the +** lock proxy files, only used when LOCKPROXYDIR is not set. +** +** +** As mentioned above, when compiled with SQLITE_PREFER_PROXY_LOCKING, +** setting the environment variable SQLITE_FORCE_PROXY_LOCKING to 1 will +** force proxy locking to be used for every database file opened, and 0 +** will force automatic proxy locking to be disabled for all database +** files (explicitly calling the SQLITE_FCNTL_SET_LOCKPROXYFILE pragma or +** sqlite_file_control API is not affected by SQLITE_FORCE_PROXY_LOCKING). +*/ + +/* +** Proxy locking is only available on MacOSX +*/ +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE + +/* +** The proxyLockingContext has the path and file structures for the remote +** and local proxy files in it +*/ +typedef struct proxyLockingContext proxyLockingContext; +struct proxyLockingContext { + unixFile *conchFile; /* Open conch file */ + char *conchFilePath; /* Name of the conch file */ + unixFile *lockProxy; /* Open proxy lock file */ + char *lockProxyPath; /* Name of the proxy lock file */ + char *dbPath; /* Name of the open file */ + int conchHeld; /* 1 if the conch is held, -1 if lockless */ + int nFails; /* Number of conch taking failures */ + void *oldLockingContext; /* Original lockingcontext to restore on close */ + sqlite3_io_methods const *pOldMethod; /* Original I/O methods for close */ +}; + +/* +** The proxy lock file path for the database at dbPath is written into lPath, +** which must point to valid, writable memory large enough for a maxLen length +** file path. +*/ +static int proxyGetLockPath(const char *dbPath, char *lPath, size_t maxLen){ + int len; + int dbLen; + int i; + +#ifdef LOCKPROXYDIR + len = strlcpy(lPath, LOCKPROXYDIR, maxLen); +#else +# ifdef _CS_DARWIN_USER_TEMP_DIR + { + if( !confstr(_CS_DARWIN_USER_TEMP_DIR, lPath, maxLen) ){ + OSTRACE(("GETLOCKPATH failed %s errno=%d pid=%d\n", + lPath, errno, osGetpid(0))); + return SQLITE_IOERR_LOCK; + } + len = strlcat(lPath, "sqliteplocks", maxLen); + } +# else + len = strlcpy(lPath, "/tmp/", maxLen); +# endif +#endif + + if( lPath[len-1]!='/' ){ + len = strlcat(lPath, "/", maxLen); + } + + /* transform the db path to a unique cache name */ + dbLen = (int)strlen(dbPath); + for( i=0; i 0) ){ + /* only mkdir if leaf dir != "." or "/" or ".." */ + if( i-start>2 || (i-start==1 && buf[start] != '.' && buf[start] != '/') + || (i-start==2 && buf[start] != '.' && buf[start+1] != '.') ){ + buf[i]='\0'; + if( osMkdir(buf, SQLITE_DEFAULT_PROXYDIR_PERMISSIONS) ){ + int err=errno; + if( err!=EEXIST ) { + OSTRACE(("CREATELOCKPATH FAILED creating %s, " + "'%s' proxy lock path=%s pid=%d\n", + buf, strerror(err), lockPath, osGetpid(0))); + return err; + } + } + } + start=i+1; + } + buf[i] = lockPath[i]; + } + OSTRACE(("CREATELOCKPATH proxy lock path=%s pid=%d\n", lockPath, osGetpid(0))); + return 0; +} + +/* +** Create a new VFS file descriptor (stored in memory obtained from +** sqlite3_malloc) and open the file named "path" in the file descriptor. +** +** The caller is responsible not only for closing the file descriptor +** but also for freeing the memory associated with the file descriptor. +*/ +static int proxyCreateUnixFile( + const char *path, /* path for the new unixFile */ + unixFile **ppFile, /* unixFile created and returned by ref */ + int islockfile /* if non zero missing dirs will be created */ +) { + int fd = -1; + unixFile *pNew; + int rc = SQLITE_OK; + int openFlags = O_RDWR | O_CREAT; + sqlite3_vfs dummyVfs; + int terrno = 0; + UnixUnusedFd *pUnused = NULL; + + /* 1. first try to open/create the file + ** 2. if that fails, and this is a lock file (not-conch), try creating + ** the parent directories and then try again. + ** 3. if that fails, try to open the file read-only + ** otherwise return BUSY (if lock file) or CANTOPEN for the conch file + */ + pUnused = findReusableFd(path, openFlags); + if( pUnused ){ + fd = pUnused->fd; + }else{ + pUnused = sqlite3_malloc64(sizeof(*pUnused)); + if( !pUnused ){ + return SQLITE_NOMEM; + } + } + if( fd<0 ){ + fd = robust_open(path, openFlags, 0); + terrno = errno; + if( fd<0 && errno==ENOENT && islockfile ){ + if( proxyCreateLockPath(path) == SQLITE_OK ){ + fd = robust_open(path, openFlags, 0); + } + } + } + if( fd<0 ){ + openFlags = O_RDONLY; + fd = robust_open(path, openFlags, 0); + terrno = errno; + } + if( fd<0 ){ + if( islockfile ){ + return SQLITE_BUSY; + } + switch (terrno) { + case EACCES: + return SQLITE_PERM; + case EIO: + return SQLITE_IOERR_LOCK; /* even though it is the conch */ + default: + return SQLITE_CANTOPEN_BKPT; + } + } + + pNew = (unixFile *)sqlite3_malloc64(sizeof(*pNew)); + if( pNew==NULL ){ + rc = SQLITE_NOMEM; + goto end_create_proxy; + } + memset(pNew, 0, sizeof(unixFile)); + pNew->openFlags = openFlags; + memset(&dummyVfs, 0, sizeof(dummyVfs)); + dummyVfs.pAppData = (void*)&autolockIoFinder; + dummyVfs.zName = "dummy"; + pUnused->fd = fd; + pUnused->flags = openFlags; + pNew->pUnused = pUnused; + + rc = fillInUnixFile(&dummyVfs, fd, (sqlite3_file*)pNew, path, 0); + if( rc==SQLITE_OK ){ + *ppFile = pNew; + return SQLITE_OK; + } +end_create_proxy: + robust_close(pNew, fd, __LINE__); + sqlite3_free(pNew); + sqlite3_free(pUnused); + return rc; +} + +#ifdef SQLITE_TEST +/* simulate multiple hosts by creating unique hostid file paths */ +SQLITE_API int sqlite3_hostid_num = 0; +#endif + +#define PROXY_HOSTIDLEN 16 /* conch file host id length */ + +#ifdef HAVE_GETHOSTUUID +/* Not always defined in the headers as it ought to be */ +extern int gethostuuid(uuid_t id, const struct timespec *wait); +#endif + +/* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN +** bytes of writable memory. +*/ +static int proxyGetHostID(unsigned char *pHostID, int *pError){ + assert(PROXY_HOSTIDLEN == sizeof(uuid_t)); + memset(pHostID, 0, PROXY_HOSTIDLEN); +#ifdef HAVE_GETHOSTUUID + { + struct timespec timeout = {1, 0}; /* 1 sec timeout */ + if( gethostuuid(pHostID, &timeout) ){ + int err = errno; + if( pError ){ + *pError = err; + } + return SQLITE_IOERR; + } + } +#else + UNUSED_PARAMETER(pError); +#endif +#ifdef SQLITE_TEST + /* simulate multiple hosts by creating unique hostid file paths */ + if( sqlite3_hostid_num != 0){ + pHostID[0] = (char)(pHostID[0] + (char)(sqlite3_hostid_num & 0xFF)); + } +#endif + + return SQLITE_OK; +} + +/* The conch file contains the header, host id and lock file path + */ +#define PROXY_CONCHVERSION 2 /* 1-byte header, 16-byte host id, path */ +#define PROXY_HEADERLEN 1 /* conch file header length */ +#define PROXY_PATHINDEX (PROXY_HEADERLEN+PROXY_HOSTIDLEN) +#define PROXY_MAXCONCHLEN (PROXY_HEADERLEN+PROXY_HOSTIDLEN+MAXPATHLEN) + +/* +** Takes an open conch file, copies the contents to a new path and then moves +** it back. The newly created file's file descriptor is assigned to the +** conch file structure and finally the original conch file descriptor is +** closed. Returns zero if successful. +*/ +static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + unixFile *conchFile = pCtx->conchFile; + char tPath[MAXPATHLEN]; + char buf[PROXY_MAXCONCHLEN]; + char *cPath = pCtx->conchFilePath; + size_t readLen = 0; + size_t pathLen = 0; + char errmsg[64] = ""; + int fd = -1; + int rc = -1; + UNUSED_PARAMETER(myHostID); + + /* create a new path by replace the trailing '-conch' with '-break' */ + pathLen = strlcpy(tPath, cPath, MAXPATHLEN); + if( pathLen>MAXPATHLEN || pathLen<6 || + (strlcpy(&tPath[pathLen-5], "break", 6) != 5) ){ + sqlite3_snprintf(sizeof(errmsg),errmsg,"path error (len %d)",(int)pathLen); + goto end_breaklock; + } + /* read the conch content */ + readLen = osPread(conchFile->h, buf, PROXY_MAXCONCHLEN, 0); + if( readLenh, __LINE__); + conchFile->h = fd; + conchFile->openFlags = O_RDWR | O_CREAT; + +end_breaklock: + if( rc ){ + if( fd>=0 ){ + osUnlink(tPath); + robust_close(pFile, fd, __LINE__); + } + fprintf(stderr, "failed to break stale lock on %s, %s\n", cPath, errmsg); + } + return rc; +} + +/* Take the requested lock on the conch file and break a stale lock if the +** host id matches. +*/ +static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + unixFile *conchFile = pCtx->conchFile; + int rc = SQLITE_OK; + int nTries = 0; + struct timespec conchModTime; + + memset(&conchModTime, 0, sizeof(conchModTime)); + do { + rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType); + nTries ++; + if( rc==SQLITE_BUSY ){ + /* If the lock failed (busy): + * 1st try: get the mod time of the conch, wait 0.5s and try again. + * 2nd try: fail if the mod time changed or host id is different, wait + * 10 sec and try again + * 3rd try: break the lock unless the mod time has changed. + */ + struct stat buf; + if( osFstat(conchFile->h, &buf) ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR_LOCK; + } + + if( nTries==1 ){ + conchModTime = buf.st_mtimespec; + usleep(500000); /* wait 0.5 sec and try the lock again*/ + continue; + } + + assert( nTries>1 ); + if( conchModTime.tv_sec != buf.st_mtimespec.tv_sec || + conchModTime.tv_nsec != buf.st_mtimespec.tv_nsec ){ + return SQLITE_BUSY; + } + + if( nTries==2 ){ + char tBuf[PROXY_MAXCONCHLEN]; + int len = osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0); + if( len<0 ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR_LOCK; + } + if( len>PROXY_PATHINDEX && tBuf[0]==(char)PROXY_CONCHVERSION){ + /* don't break the lock if the host id doesn't match */ + if( 0!=memcmp(&tBuf[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN) ){ + return SQLITE_BUSY; + } + }else{ + /* don't break the lock on short read or a version mismatch */ + return SQLITE_BUSY; + } + usleep(10000000); /* wait 10 sec and try the lock again */ + continue; + } + + assert( nTries==3 ); + if( 0==proxyBreakConchLock(pFile, myHostID) ){ + rc = SQLITE_OK; + if( lockType==EXCLUSIVE_LOCK ){ + rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, SHARED_LOCK); + } + if( !rc ){ + rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType); + } + } + } + } while( rc==SQLITE_BUSY && nTries<3 ); + + return rc; +} + +/* Takes the conch by taking a shared lock and read the contents conch, if +** lockPath is non-NULL, the host ID and lock file path must match. A NULL +** lockPath means that the lockPath in the conch file will be used if the +** host IDs match, or a new lock path will be generated automatically +** and written to the conch file. +*/ +static int proxyTakeConch(unixFile *pFile){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + + if( pCtx->conchHeld!=0 ){ + return SQLITE_OK; + }else{ + unixFile *conchFile = pCtx->conchFile; + uuid_t myHostID; + int pError = 0; + char readBuf[PROXY_MAXCONCHLEN]; + char lockPath[MAXPATHLEN]; + char *tempLockPath = NULL; + int rc = SQLITE_OK; + int createConch = 0; + int hostIdMatch = 0; + int readLen = 0; + int tryOldLockPath = 0; + int forceNewLockPath = 0; + + OSTRACE(("TAKECONCH %d for %s pid=%d\n", conchFile->h, + (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), + osGetpid(0))); + + rc = proxyGetHostID(myHostID, &pError); + if( (rc&0xff)==SQLITE_IOERR ){ + storeLastErrno(pFile, pError); + goto end_takeconch; + } + rc = proxyConchLock(pFile, myHostID, SHARED_LOCK); + if( rc!=SQLITE_OK ){ + goto end_takeconch; + } + /* read the existing conch file */ + readLen = seekAndRead((unixFile*)conchFile, 0, readBuf, PROXY_MAXCONCHLEN); + if( readLen<0 ){ + /* I/O error: lastErrno set by seekAndRead */ + storeLastErrno(pFile, conchFile->lastErrno); + rc = SQLITE_IOERR_READ; + goto end_takeconch; + }else if( readLen<=(PROXY_HEADERLEN+PROXY_HOSTIDLEN) || + readBuf[0]!=(char)PROXY_CONCHVERSION ){ + /* a short read or version format mismatch means we need to create a new + ** conch file. + */ + createConch = 1; + } + /* if the host id matches and the lock path already exists in the conch + ** we'll try to use the path there, if we can't open that path, we'll + ** retry with a new auto-generated path + */ + do { /* in case we need to try again for an :auto: named lock file */ + + if( !createConch && !forceNewLockPath ){ + hostIdMatch = !memcmp(&readBuf[PROXY_HEADERLEN], myHostID, + PROXY_HOSTIDLEN); + /* if the conch has data compare the contents */ + if( !pCtx->lockProxyPath ){ + /* for auto-named local lock file, just check the host ID and we'll + ** use the local lock file path that's already in there + */ + if( hostIdMatch ){ + size_t pathLen = (readLen - PROXY_PATHINDEX); + + if( pathLen>=MAXPATHLEN ){ + pathLen=MAXPATHLEN-1; + } + memcpy(lockPath, &readBuf[PROXY_PATHINDEX], pathLen); + lockPath[pathLen] = 0; + tempLockPath = lockPath; + tryOldLockPath = 1; + /* create a copy of the lock path if the conch is taken */ + goto end_takeconch; + } + }else if( hostIdMatch + && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX], + readLen-PROXY_PATHINDEX) + ){ + /* conch host and lock path match */ + goto end_takeconch; + } + } + + /* if the conch isn't writable and doesn't match, we can't take it */ + if( (conchFile->openFlags&O_RDWR) == 0 ){ + rc = SQLITE_BUSY; + goto end_takeconch; + } + + /* either the conch didn't match or we need to create a new one */ + if( !pCtx->lockProxyPath ){ + proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN); + tempLockPath = lockPath; + /* create a copy of the lock path _only_ if the conch is taken */ + } + + /* update conch with host and path (this will fail if other process + ** has a shared lock already), if the host id matches, use the big + ** stick. + */ + futimes(conchFile->h, NULL); + if( hostIdMatch && !createConch ){ + if( conchFile->pInode && conchFile->pInode->nShared>1 ){ + /* We are trying for an exclusive lock but another thread in this + ** same process is still holding a shared lock. */ + rc = SQLITE_BUSY; + } else { + rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK); + } + }else{ + rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK); + } + if( rc==SQLITE_OK ){ + char writeBuffer[PROXY_MAXCONCHLEN]; + int writeSize = 0; + + writeBuffer[0] = (char)PROXY_CONCHVERSION; + memcpy(&writeBuffer[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN); + if( pCtx->lockProxyPath!=NULL ){ + strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath, + MAXPATHLEN); + }else{ + strlcpy(&writeBuffer[PROXY_PATHINDEX], tempLockPath, MAXPATHLEN); + } + writeSize = PROXY_PATHINDEX + strlen(&writeBuffer[PROXY_PATHINDEX]); + robust_ftruncate(conchFile->h, writeSize); + rc = unixWrite((sqlite3_file *)conchFile, writeBuffer, writeSize, 0); + fsync(conchFile->h); + /* If we created a new conch file (not just updated the contents of a + ** valid conch file), try to match the permissions of the database + */ + if( rc==SQLITE_OK && createConch ){ + struct stat buf; + int err = osFstat(pFile->h, &buf); + if( err==0 ){ + mode_t cmode = buf.st_mode&(S_IRUSR|S_IWUSR | S_IRGRP|S_IWGRP | + S_IROTH|S_IWOTH); + /* try to match the database file R/W permissions, ignore failure */ +#ifndef SQLITE_PROXY_DEBUG + osFchmod(conchFile->h, cmode); +#else + do{ + rc = osFchmod(conchFile->h, cmode); + }while( rc==(-1) && errno==EINTR ); + if( rc!=0 ){ + int code = errno; + fprintf(stderr, "fchmod %o FAILED with %d %s\n", + cmode, code, strerror(code)); + } else { + fprintf(stderr, "fchmod %o SUCCEDED\n",cmode); + } + }else{ + int code = errno; + fprintf(stderr, "STAT FAILED[%d] with %d %s\n", + err, code, strerror(code)); +#endif + } + } + } + conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, SHARED_LOCK); + + end_takeconch: + OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h)); + if( rc==SQLITE_OK && pFile->openFlags ){ + int fd; + if( pFile->h>=0 ){ + robust_close(pFile, pFile->h, __LINE__); + } + pFile->h = -1; + fd = robust_open(pCtx->dbPath, pFile->openFlags, 0); + OSTRACE(("TRANSPROXY: OPEN %d\n", fd)); + if( fd>=0 ){ + pFile->h = fd; + }else{ + rc=SQLITE_CANTOPEN_BKPT; /* SQLITE_BUSY? proxyTakeConch called + during locking */ + } + } + if( rc==SQLITE_OK && !pCtx->lockProxy ){ + char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath; + rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1); + if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){ + /* we couldn't create the proxy lock file with the old lock file path + ** so try again via auto-naming + */ + forceNewLockPath = 1; + tryOldLockPath = 0; + continue; /* go back to the do {} while start point, try again */ + } + } + if( rc==SQLITE_OK ){ + /* Need to make a copy of path if we extracted the value + ** from the conch file or the path was allocated on the stack + */ + if( tempLockPath ){ + pCtx->lockProxyPath = sqlite3DbStrDup(0, tempLockPath); + if( !pCtx->lockProxyPath ){ + rc = SQLITE_NOMEM; + } + } + } + if( rc==SQLITE_OK ){ + pCtx->conchHeld = 1; + + if( pCtx->lockProxy->pMethod == &afpIoMethods ){ + afpLockingContext *afpCtx; + afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext; + afpCtx->dbPath = pCtx->lockProxyPath; + } + } else { + conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK); + } + OSTRACE(("TAKECONCH %d %s\n", conchFile->h, + rc==SQLITE_OK?"ok":"failed")); + return rc; + } while (1); /* in case we need to retry the :auto: lock file - + ** we should never get here except via the 'continue' call. */ + } +} + +/* +** If pFile holds a lock on a conch file, then release that lock. +*/ +static int proxyReleaseConch(unixFile *pFile){ + int rc = SQLITE_OK; /* Subroutine return code */ + proxyLockingContext *pCtx; /* The locking context for the proxy lock */ + unixFile *conchFile; /* Name of the conch file */ + + pCtx = (proxyLockingContext *)pFile->lockingContext; + conchFile = pCtx->conchFile; + OSTRACE(("RELEASECONCH %d for %s pid=%d\n", conchFile->h, + (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), + osGetpid(0))); + if( pCtx->conchHeld>0 ){ + rc = conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK); + } + pCtx->conchHeld = 0; + OSTRACE(("RELEASECONCH %d %s\n", conchFile->h, + (rc==SQLITE_OK ? "ok" : "failed"))); + return rc; +} + +/* +** Given the name of a database file, compute the name of its conch file. +** Store the conch filename in memory obtained from sqlite3_malloc64(). +** Make *pConchPath point to the new name. Return SQLITE_OK on success +** or SQLITE_NOMEM if unable to obtain memory. +** +** The caller is responsible for ensuring that the allocated memory +** space is eventually freed. +** +** *pConchPath is set to NULL if a memory allocation error occurs. +*/ +static int proxyCreateConchPathname(char *dbPath, char **pConchPath){ + int i; /* Loop counter */ + int len = (int)strlen(dbPath); /* Length of database filename - dbPath */ + char *conchPath; /* buffer in which to construct conch name */ + + /* Allocate space for the conch filename and initialize the name to + ** the name of the original database file. */ + *pConchPath = conchPath = (char *)sqlite3_malloc64(len + 8); + if( conchPath==0 ){ + return SQLITE_NOMEM; + } + memcpy(conchPath, dbPath, len+1); + + /* now insert a "." before the last / character */ + for( i=(len-1); i>=0; i-- ){ + if( conchPath[i]=='/' ){ + i++; + break; + } + } + conchPath[i]='.'; + while ( ilockingContext; + char *oldPath = pCtx->lockProxyPath; + int rc = SQLITE_OK; + + if( pFile->eFileLock!=NO_LOCK ){ + return SQLITE_BUSY; + } + + /* nothing to do if the path is NULL, :auto: or matches the existing path */ + if( !path || path[0]=='\0' || !strcmp(path, ":auto:") || + (oldPath && !strncmp(oldPath, path, MAXPATHLEN)) ){ + return SQLITE_OK; + }else{ + unixFile *lockProxy = pCtx->lockProxy; + pCtx->lockProxy=NULL; + pCtx->conchHeld = 0; + if( lockProxy!=NULL ){ + rc=lockProxy->pMethod->xClose((sqlite3_file *)lockProxy); + if( rc ) return rc; + sqlite3_free(lockProxy); + } + sqlite3_free(oldPath); + pCtx->lockProxyPath = sqlite3DbStrDup(0, path); + } + + return rc; +} + +/* +** pFile is a file that has been opened by a prior xOpen call. dbPath +** is a string buffer at least MAXPATHLEN+1 characters in size. +** +** This routine find the filename associated with pFile and writes it +** int dbPath. +*/ +static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){ +#if defined(__APPLE__) + if( pFile->pMethod == &afpIoMethods ){ + /* afp style keeps a reference to the db path in the filePath field + ** of the struct */ + assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN ); + strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath, + MAXPATHLEN); + } else +#endif + if( pFile->pMethod == &dotlockIoMethods ){ + /* dot lock style uses the locking context to store the dot lock + ** file path */ + int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX); + memcpy(dbPath, (char *)pFile->lockingContext, len + 1); + }else{ + /* all other styles use the locking context to store the db file path */ + assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN ); + strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN); + } + return SQLITE_OK; +} + +/* +** Takes an already filled in unix file and alters it so all file locking +** will be performed on the local proxy lock file. The following fields +** are preserved in the locking context so that they can be restored and +** the unix structure properly cleaned up at close time: +** ->lockingContext +** ->pMethod +*/ +static int proxyTransformUnixFile(unixFile *pFile, const char *path) { + proxyLockingContext *pCtx; + char dbPath[MAXPATHLEN+1]; /* Name of the database file */ + char *lockPath=NULL; + int rc = SQLITE_OK; + + if( pFile->eFileLock!=NO_LOCK ){ + return SQLITE_BUSY; + } + proxyGetDbPathForUnixFile(pFile, dbPath); + if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ){ + lockPath=NULL; + }else{ + lockPath=(char *)path; + } + + OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h, + (lockPath ? lockPath : ":auto:"), osGetpid(0))); + + pCtx = sqlite3_malloc64( sizeof(*pCtx) ); + if( pCtx==0 ){ + return SQLITE_NOMEM; + } + memset(pCtx, 0, sizeof(*pCtx)); + + rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath); + if( rc==SQLITE_OK ){ + rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0); + if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){ + /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and + ** (c) the file system is read-only, then enable no-locking access. + ** Ugh, since O_RDONLY==0x0000 we test for !O_RDWR since unixOpen asserts + ** that openFlags will have only one of O_RDONLY or O_RDWR. + */ + struct statfs fsInfo; + struct stat conchInfo; + int goLockless = 0; + + if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) { + int err = errno; + if( (err==ENOENT) && (statfs(dbPath, &fsInfo) != -1) ){ + goLockless = (fsInfo.f_flags&MNT_RDONLY) == MNT_RDONLY; + } + } + if( goLockless ){ + pCtx->conchHeld = -1; /* read only FS/ lockless */ + rc = SQLITE_OK; + } + } + } + if( rc==SQLITE_OK && lockPath ){ + pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath); + } + + if( rc==SQLITE_OK ){ + pCtx->dbPath = sqlite3DbStrDup(0, dbPath); + if( pCtx->dbPath==NULL ){ + rc = SQLITE_NOMEM; + } + } + if( rc==SQLITE_OK ){ + /* all memory is allocated, proxys are created and assigned, + ** switch the locking context and pMethod then return. + */ + pCtx->oldLockingContext = pFile->lockingContext; + pFile->lockingContext = pCtx; + pCtx->pOldMethod = pFile->pMethod; + pFile->pMethod = &proxyIoMethods; + }else{ + if( pCtx->conchFile ){ + pCtx->conchFile->pMethod->xClose((sqlite3_file *)pCtx->conchFile); + sqlite3_free(pCtx->conchFile); + } + sqlite3DbFree(0, pCtx->lockProxyPath); + sqlite3_free(pCtx->conchFilePath); + sqlite3_free(pCtx); + } + OSTRACE(("TRANSPROXY %d %s\n", pFile->h, + (rc==SQLITE_OK ? "ok" : "failed"))); + return rc; +} + + +/* +** This routine handles sqlite3_file_control() calls that are specific +** to proxy locking. +*/ +static int proxyFileControl(sqlite3_file *id, int op, void *pArg){ + switch( op ){ + case SQLITE_FCNTL_GET_LOCKPROXYFILE: { + unixFile *pFile = (unixFile*)id; + if( pFile->pMethod == &proxyIoMethods ){ + proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext; + proxyTakeConch(pFile); + if( pCtx->lockProxyPath ){ + *(const char **)pArg = pCtx->lockProxyPath; + }else{ + *(const char **)pArg = ":auto: (not held)"; + } + } else { + *(const char **)pArg = NULL; + } + return SQLITE_OK; + } + case SQLITE_FCNTL_SET_LOCKPROXYFILE: { + unixFile *pFile = (unixFile*)id; + int rc = SQLITE_OK; + int isProxyStyle = (pFile->pMethod == &proxyIoMethods); + if( pArg==NULL || (const char *)pArg==0 ){ + if( isProxyStyle ){ + /* turn off proxy locking - not supported. If support is added for + ** switching proxy locking mode off then it will need to fail if + ** the journal mode is WAL mode. + */ + rc = SQLITE_ERROR /*SQLITE_PROTOCOL? SQLITE_MISUSE?*/; + }else{ + /* turn off proxy locking - already off - NOOP */ + rc = SQLITE_OK; + } + }else{ + const char *proxyPath = (const char *)pArg; + if( isProxyStyle ){ + proxyLockingContext *pCtx = + (proxyLockingContext*)pFile->lockingContext; + if( !strcmp(pArg, ":auto:") + || (pCtx->lockProxyPath && + !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN)) + ){ + rc = SQLITE_OK; + }else{ + rc = switchLockProxyPath(pFile, proxyPath); + } + }else{ + /* turn on proxy file locking */ + rc = proxyTransformUnixFile(pFile, proxyPath); + } + } + return rc; + } + default: { + assert( 0 ); /* The call assures that only valid opcodes are sent */ + } + } + /*NOTREACHED*/ + return SQLITE_ERROR; +} + +/* +** Within this division (the proxying locking implementation) the procedures +** above this point are all utilities. The lock-related methods of the +** proxy-locking sqlite3_io_method object follow. +*/ + + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int proxyCheckReservedLock(sqlite3_file *id, int *pResOut) { + unixFile *pFile = (unixFile*)id; + int rc = proxyTakeConch(pFile); + if( rc==SQLITE_OK ){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + if( pCtx->conchHeld>0 ){ + unixFile *proxy = pCtx->lockProxy; + return proxy->pMethod->xCheckReservedLock((sqlite3_file*)proxy, pResOut); + }else{ /* conchHeld < 0 is lockless */ + pResOut=0; + } + } + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int proxyLock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + int rc = proxyTakeConch(pFile); + if( rc==SQLITE_OK ){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + if( pCtx->conchHeld>0 ){ + unixFile *proxy = pCtx->lockProxy; + rc = proxy->pMethod->xLock((sqlite3_file*)proxy, eFileLock); + pFile->eFileLock = proxy->eFileLock; + }else{ + /* conchHeld < 0 is lockless */ + } + } + return rc; +} + + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int proxyUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + int rc = proxyTakeConch(pFile); + if( rc==SQLITE_OK ){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + if( pCtx->conchHeld>0 ){ + unixFile *proxy = pCtx->lockProxy; + rc = proxy->pMethod->xUnlock((sqlite3_file*)proxy, eFileLock); + pFile->eFileLock = proxy->eFileLock; + }else{ + /* conchHeld < 0 is lockless */ + } + } + return rc; +} + +/* +** Close a file that uses proxy locks. +*/ +static int proxyClose(sqlite3_file *id) { + if( id ){ + unixFile *pFile = (unixFile*)id; + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + unixFile *lockProxy = pCtx->lockProxy; + unixFile *conchFile = pCtx->conchFile; + int rc = SQLITE_OK; + + if( lockProxy ){ + rc = lockProxy->pMethod->xUnlock((sqlite3_file*)lockProxy, NO_LOCK); + if( rc ) return rc; + rc = lockProxy->pMethod->xClose((sqlite3_file*)lockProxy); + if( rc ) return rc; + sqlite3_free(lockProxy); + pCtx->lockProxy = 0; + } + if( conchFile ){ + if( pCtx->conchHeld ){ + rc = proxyReleaseConch(pFile); + if( rc ) return rc; + } + rc = conchFile->pMethod->xClose((sqlite3_file*)conchFile); + if( rc ) return rc; + sqlite3_free(conchFile); + } + sqlite3DbFree(0, pCtx->lockProxyPath); + sqlite3_free(pCtx->conchFilePath); + sqlite3DbFree(0, pCtx->dbPath); + /* restore the original locking context and pMethod then close it */ + pFile->lockingContext = pCtx->oldLockingContext; + pFile->pMethod = pCtx->pOldMethod; + sqlite3_free(pCtx); + return pFile->pMethod->xClose(id); + } + return SQLITE_OK; +} + + + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ +/* +** The proxy locking style is intended for use with AFP filesystems. +** And since AFP is only supported on MacOSX, the proxy locking is also +** restricted to MacOSX. +** +** +******************* End of the proxy lock implementation ********************** +******************************************************************************/ + +/* +** Initialize the operating system interface. +** +** This routine registers all VFS implementations for unix-like operating +** systems. This routine, and the sqlite3_os_end() routine that follows, +** should be the only routines in this file that are visible from other +** files. +** +** This routine is called once during SQLite initialization and by a +** single thread. The memory allocation and mutex subsystems have not +** necessarily been initialized when this routine is called, and so they +** should not be used. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_os_init(void){ + /* + ** The following macro defines an initializer for an sqlite3_vfs object. + ** The name of the VFS is NAME. The pAppData is a pointer to a pointer + ** to the "finder" function. (pAppData is a pointer to a pointer because + ** silly C90 rules prohibit a void* from being cast to a function pointer + ** and so we have to go through the intermediate pointer to avoid problems + ** when compiling with -pedantic-errors on GCC.) + ** + ** The FINDER parameter to this macro is the name of the pointer to the + ** finder-function. The finder-function returns a pointer to the + ** sqlite_io_methods object that implements the desired locking + ** behaviors. See the division above that contains the IOMETHODS + ** macro for addition information on finder-functions. + ** + ** Most finders simply return a pointer to a fixed sqlite3_io_methods + ** object. But the "autolockIoFinder" available on MacOSX does a little + ** more than that; it looks at the filesystem type that hosts the + ** database file and tries to choose an locking method appropriate for + ** that filesystem time. + */ + #define UNIXVFS(VFSNAME, FINDER) { \ + 3, /* iVersion */ \ + sizeof(unixFile), /* szOsFile */ \ + MAX_PATHNAME, /* mxPathname */ \ + 0, /* pNext */ \ + VFSNAME, /* zName */ \ + (void*)&FINDER, /* pAppData */ \ + unixOpen, /* xOpen */ \ + unixDelete, /* xDelete */ \ + unixAccess, /* xAccess */ \ + unixFullPathname, /* xFullPathname */ \ + unixDlOpen, /* xDlOpen */ \ + unixDlError, /* xDlError */ \ + unixDlSym, /* xDlSym */ \ + unixDlClose, /* xDlClose */ \ + unixRandomness, /* xRandomness */ \ + unixSleep, /* xSleep */ \ + unixCurrentTime, /* xCurrentTime */ \ + unixGetLastError, /* xGetLastError */ \ + unixCurrentTimeInt64, /* xCurrentTimeInt64 */ \ + unixSetSystemCall, /* xSetSystemCall */ \ + unixGetSystemCall, /* xGetSystemCall */ \ + unixNextSystemCall, /* xNextSystemCall */ \ + } + + /* + ** All default VFSes for unix are contained in the following array. + ** + ** Note that the sqlite3_vfs.pNext field of the VFS object is modified + ** by the SQLite core when the VFS is registered. So the following + ** array cannot be const. + */ + static sqlite3_vfs aVfs[] = { +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + UNIXVFS("unix", autolockIoFinder ), +#elif OS_VXWORKS + UNIXVFS("unix", vxworksIoFinder ), +#else + UNIXVFS("unix", posixIoFinder ), +#endif + UNIXVFS("unix-none", nolockIoFinder ), + UNIXVFS("unix-dotfile", dotlockIoFinder ), + UNIXVFS("unix-excl", posixIoFinder ), +#if OS_VXWORKS + UNIXVFS("unix-namedsem", semIoFinder ), +#endif +#if SQLITE_ENABLE_LOCKING_STYLE || OS_VXWORKS + UNIXVFS("unix-posix", posixIoFinder ), +#endif +#if SQLITE_ENABLE_LOCKING_STYLE + UNIXVFS("unix-flock", flockIoFinder ), +#endif +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + UNIXVFS("unix-afp", afpIoFinder ), + UNIXVFS("unix-nfs", nfsIoFinder ), + UNIXVFS("unix-proxy", proxyIoFinder ), +#endif + }; + unsigned int i; /* Loop counter */ + + /* Double-check that the aSyscall[] array has been constructed + ** correctly. See ticket [bb3a86e890c8e96ab] */ + assert( ArraySize(aSyscall)==25 ); + + /* Register all VFSes defined in the aVfs[] array */ + for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){ + sqlite3_vfs_register(&aVfs[i], i==0); + } + return SQLITE_OK; +} + +/* +** Shutdown the operating system interface. +** +** Some operating systems might need to do some cleanup in this routine, +** to release dynamically allocated objects. But not on unix. +** This routine is a no-op for unix. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_os_end(void){ + return SQLITE_OK; +} + +#endif /* SQLITE_OS_UNIX */ + +/************** End of os_unix.c *********************************************/ +/************** Begin file os_win.c ******************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to Windows. +*/ +/* #include "sqliteInt.h" */ +#if SQLITE_OS_WIN /* This file is used for Windows only */ + +/* +** Include code that is common to all os_*.c files +*/ +/************** Include os_common.h in the middle of os_win.c ****************/ +/************** Begin file os_common.h ***************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains macros and a little bit of code that is common to +** all of the platform-specific files (os_*.c) and is #included into those +** files. +** +** This file should be #included by the os_*.c files only. It is not a +** general purpose header file. +*/ +#ifndef _OS_COMMON_H_ +#define _OS_COMMON_H_ + +/* +** At least two bugs have slipped in because we changed the MEMORY_DEBUG +** macro to SQLITE_DEBUG and some older makefiles have not yet made the +** switch. The following code should catch this problem at compile-time. +*/ +#ifdef MEMORY_DEBUG +# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." +#endif + +/* +** Macros for performance tracing. Normally turned off. Only works +** on i486 hardware. +*/ +#ifdef SQLITE_PERFORMANCE_TRACE + +/* +** hwtime.h contains inline assembler code for implementing +** high-performance timing routines. +*/ +/************** Include hwtime.h in the middle of os_common.h ****************/ +/************** Begin file hwtime.h ******************************************/ +/* +** 2008 May 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains inline asm code for retrieving "high-performance" +** counters for x86 class CPUs. +*/ +#ifndef _HWTIME_H_ +#define _HWTIME_H_ + +/* +** The following routine only works on pentium-class (or newer) processors. +** It uses the RDTSC opcode to read the cycle count value out of the +** processor and returns that value. This can be used for high-res +** profiling. +*/ +#if (defined(__GNUC__) || defined(_MSC_VER)) && \ + (defined(i386) || defined(__i386__) || defined(_M_IX86)) + + #if defined(__GNUC__) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned int lo, hi; + __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); + return (sqlite_uint64)hi << 32 | lo; + } + + #elif defined(_MSC_VER) + + __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ + __asm { + rdtsc + ret ; return value at EDX:EAX + } + } + + #endif + +#elif (defined(__GNUC__) && defined(__x86_64__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long val; + __asm__ __volatile__ ("rdtsc" : "=A" (val)); + return val; + } + +#elif (defined(__GNUC__) && defined(__ppc__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long long retval; + unsigned long junk; + __asm__ __volatile__ ("\n\ + 1: mftbu %1\n\ + mftb %L0\n\ + mftbu %0\n\ + cmpw %0,%1\n\ + bne 1b" + : "=r" (retval), "=r" (junk)); + return retval; + } + +#else + + #error Need implementation of sqlite3Hwtime() for your platform. + + /* + ** To compile without implementing sqlite3Hwtime() for your platform, + ** you can remove the above #error and use the following + ** stub function. You will lose timing support for many + ** of the debugging and testing utilities, but it should at + ** least compile and run. + */ +SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } + +#endif + +#endif /* !defined(_HWTIME_H_) */ + +/************** End of hwtime.h **********************************************/ +/************** Continuing where we left off in os_common.h ******************/ + +static sqlite_uint64 g_start; +static sqlite_uint64 g_elapsed; +#define TIMER_START g_start=sqlite3Hwtime() +#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start +#define TIMER_ELAPSED g_elapsed +#else +#define TIMER_START +#define TIMER_END +#define TIMER_ELAPSED ((sqlite_uint64)0) +#endif + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_io_error_hit = 0; /* Total number of I/O Errors */ +SQLITE_API int sqlite3_io_error_hardhit = 0; /* Number of non-benign errors */ +SQLITE_API int sqlite3_io_error_pending = 0; /* Count down to first I/O error */ +SQLITE_API int sqlite3_io_error_persist = 0; /* True if I/O errors persist */ +SQLITE_API int sqlite3_io_error_benign = 0; /* True if errors are benign */ +SQLITE_API int sqlite3_diskfull_pending = 0; +SQLITE_API int sqlite3_diskfull = 0; +#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) +#define SimulateIOError(CODE) \ + if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ + || sqlite3_io_error_pending-- == 1 ) \ + { local_ioerr(); CODE; } +static void local_ioerr(){ + IOTRACE(("IOERR\n")); + sqlite3_io_error_hit++; + if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; +} +#define SimulateDiskfullError(CODE) \ + if( sqlite3_diskfull_pending ){ \ + if( sqlite3_diskfull_pending == 1 ){ \ + local_ioerr(); \ + sqlite3_diskfull = 1; \ + sqlite3_io_error_hit = 1; \ + CODE; \ + }else{ \ + sqlite3_diskfull_pending--; \ + } \ + } +#else +#define SimulateIOErrorBenign(X) +#define SimulateIOError(A) +#define SimulateDiskfullError(A) +#endif + +/* +** When testing, keep a count of the number of open files. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_open_file_count = 0; +#define OpenCounter(X) sqlite3_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif + +#endif /* !defined(_OS_COMMON_H_) */ + +/************** End of os_common.h *******************************************/ +/************** Continuing where we left off in os_win.c *********************/ + +/* +** Include the header file for the Windows VFS. +*/ +/* #include "os_win.h" */ + +/* +** Compiling and using WAL mode requires several APIs that are only +** available in Windows platforms based on the NT kernel. +*/ +#if !SQLITE_OS_WINNT && !defined(SQLITE_OMIT_WAL) +# error "WAL mode requires support from the Windows NT kernel, compile\ + with SQLITE_OMIT_WAL." +#endif + +#if !SQLITE_OS_WINNT && SQLITE_MAX_MMAP_SIZE>0 +# error "Memory mapped files require support from the Windows NT kernel,\ + compile with SQLITE_MAX_MMAP_SIZE=0." +#endif + +/* +** Are most of the Win32 ANSI APIs available (i.e. with certain exceptions +** based on the sub-platform)? +*/ +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && !defined(SQLITE_WIN32_NO_ANSI) +# define SQLITE_WIN32_HAS_ANSI +#endif + +/* +** Are most of the Win32 Unicode APIs available (i.e. with certain exceptions +** based on the sub-platform)? +*/ +#if (SQLITE_OS_WINCE || SQLITE_OS_WINNT || SQLITE_OS_WINRT) && \ + !defined(SQLITE_WIN32_NO_WIDE) +# define SQLITE_WIN32_HAS_WIDE +#endif + +/* +** Make sure at least one set of Win32 APIs is available. +*/ +#if !defined(SQLITE_WIN32_HAS_ANSI) && !defined(SQLITE_WIN32_HAS_WIDE) +# error "At least one of SQLITE_WIN32_HAS_ANSI and SQLITE_WIN32_HAS_WIDE\ + must be defined." +#endif + +/* +** Define the required Windows SDK version constants if they are not +** already available. +*/ +#ifndef NTDDI_WIN8 +# define NTDDI_WIN8 0x06020000 +#endif + +#ifndef NTDDI_WINBLUE +# define NTDDI_WINBLUE 0x06030000 +#endif + +/* +** Check to see if the GetVersionEx[AW] functions are deprecated on the +** target system. GetVersionEx was first deprecated in Win8.1. +*/ +#ifndef SQLITE_WIN32_GETVERSIONEX +# if defined(NTDDI_VERSION) && NTDDI_VERSION >= NTDDI_WINBLUE +# define SQLITE_WIN32_GETVERSIONEX 0 /* GetVersionEx() is deprecated */ +# else +# define SQLITE_WIN32_GETVERSIONEX 1 /* GetVersionEx() is current */ +# endif +#endif + +/* +** This constant should already be defined (in the "WinDef.h" SDK file). +*/ +#ifndef MAX_PATH +# define MAX_PATH (260) +#endif + +/* +** Maximum pathname length (in chars) for Win32. This should normally be +** MAX_PATH. +*/ +#ifndef SQLITE_WIN32_MAX_PATH_CHARS +# define SQLITE_WIN32_MAX_PATH_CHARS (MAX_PATH) +#endif + +/* +** This constant should already be defined (in the "WinNT.h" SDK file). +*/ +#ifndef UNICODE_STRING_MAX_CHARS +# define UNICODE_STRING_MAX_CHARS (32767) +#endif + +/* +** Maximum pathname length (in chars) for WinNT. This should normally be +** UNICODE_STRING_MAX_CHARS. +*/ +#ifndef SQLITE_WINNT_MAX_PATH_CHARS +# define SQLITE_WINNT_MAX_PATH_CHARS (UNICODE_STRING_MAX_CHARS) +#endif + +/* +** Maximum pathname length (in bytes) for Win32. The MAX_PATH macro is in +** characters, so we allocate 4 bytes per character assuming worst-case of +** 4-bytes-per-character for UTF8. +*/ +#ifndef SQLITE_WIN32_MAX_PATH_BYTES +# define SQLITE_WIN32_MAX_PATH_BYTES (SQLITE_WIN32_MAX_PATH_CHARS*4) +#endif + +/* +** Maximum pathname length (in bytes) for WinNT. This should normally be +** UNICODE_STRING_MAX_CHARS * sizeof(WCHAR). +*/ +#ifndef SQLITE_WINNT_MAX_PATH_BYTES +# define SQLITE_WINNT_MAX_PATH_BYTES \ + (sizeof(WCHAR) * SQLITE_WINNT_MAX_PATH_CHARS) +#endif + +/* +** Maximum error message length (in chars) for WinRT. +*/ +#ifndef SQLITE_WIN32_MAX_ERRMSG_CHARS +# define SQLITE_WIN32_MAX_ERRMSG_CHARS (1024) +#endif + +/* +** Returns non-zero if the character should be treated as a directory +** separator. +*/ +#ifndef winIsDirSep +# define winIsDirSep(a) (((a) == '/') || ((a) == '\\')) +#endif + +/* +** This macro is used when a local variable is set to a value that is +** [sometimes] not used by the code (e.g. via conditional compilation). +*/ +#ifndef UNUSED_VARIABLE_VALUE +# define UNUSED_VARIABLE_VALUE(x) (void)(x) +#endif + +/* +** Returns the character that should be used as the directory separator. +*/ +#ifndef winGetDirSep +# define winGetDirSep() '\\' +#endif + +/* +** Do we need to manually define the Win32 file mapping APIs for use with WAL +** mode or memory mapped files (e.g. these APIs are available in the Windows +** CE SDK; however, they are not present in the header file)? +*/ +#if SQLITE_WIN32_FILEMAPPING_API && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) +/* +** Two of the file mapping APIs are different under WinRT. Figure out which +** set we need. +*/ +#if SQLITE_OS_WINRT +WINBASEAPI HANDLE WINAPI CreateFileMappingFromApp(HANDLE, \ + LPSECURITY_ATTRIBUTES, ULONG, ULONG64, LPCWSTR); + +WINBASEAPI LPVOID WINAPI MapViewOfFileFromApp(HANDLE, ULONG, ULONG64, SIZE_T); +#else +#if defined(SQLITE_WIN32_HAS_ANSI) +WINBASEAPI HANDLE WINAPI CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, \ + DWORD, DWORD, DWORD, LPCSTR); +#endif /* defined(SQLITE_WIN32_HAS_ANSI) */ + +#if defined(SQLITE_WIN32_HAS_WIDE) +WINBASEAPI HANDLE WINAPI CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, \ + DWORD, DWORD, DWORD, LPCWSTR); +#endif /* defined(SQLITE_WIN32_HAS_WIDE) */ + +WINBASEAPI LPVOID WINAPI MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, SIZE_T); +#endif /* SQLITE_OS_WINRT */ + +/* +** These file mapping APIs are common to both Win32 and WinRT. +*/ + +WINBASEAPI BOOL WINAPI FlushViewOfFile(LPCVOID, SIZE_T); +WINBASEAPI BOOL WINAPI UnmapViewOfFile(LPCVOID); +#endif /* SQLITE_WIN32_FILEMAPPING_API */ + +/* +** Some Microsoft compilers lack this definition. +*/ +#ifndef INVALID_FILE_ATTRIBUTES +# define INVALID_FILE_ATTRIBUTES ((DWORD)-1) +#endif + +#ifndef FILE_FLAG_MASK +# define FILE_FLAG_MASK (0xFF3C0000) +#endif + +#ifndef FILE_ATTRIBUTE_MASK +# define FILE_ATTRIBUTE_MASK (0x0003FFF7) +#endif + +#ifndef SQLITE_OMIT_WAL +/* Forward references to structures used for WAL */ +typedef struct winShm winShm; /* A connection to shared-memory */ +typedef struct winShmNode winShmNode; /* A region of shared-memory */ +#endif + +/* +** WinCE lacks native support for file locking so we have to fake it +** with some code of our own. +*/ +#if SQLITE_OS_WINCE +typedef struct winceLock { + int nReaders; /* Number of reader locks obtained */ + BOOL bPending; /* Indicates a pending lock has been obtained */ + BOOL bReserved; /* Indicates a reserved lock has been obtained */ + BOOL bExclusive; /* Indicates an exclusive lock has been obtained */ +} winceLock; +#endif + +/* +** The winFile structure is a subclass of sqlite3_file* specific to the win32 +** portability layer. +*/ +typedef struct winFile winFile; +struct winFile { + const sqlite3_io_methods *pMethod; /*** Must be first ***/ + sqlite3_vfs *pVfs; /* The VFS used to open this file */ + HANDLE h; /* Handle for accessing the file */ + u8 locktype; /* Type of lock currently held on this file */ + short sharedLockByte; /* Randomly chosen byte used as a shared lock */ + u8 ctrlFlags; /* Flags. See WINFILE_* below */ + DWORD lastErrno; /* The Windows errno from the last I/O error */ +#ifndef SQLITE_OMIT_WAL + winShm *pShm; /* Instance of shared memory on this file */ +#endif + const char *zPath; /* Full pathname of this file */ + int szChunk; /* Chunk size configured by FCNTL_CHUNK_SIZE */ +#if SQLITE_OS_WINCE + LPWSTR zDeleteOnClose; /* Name of file to delete when closing */ + HANDLE hMutex; /* Mutex used to control access to shared lock */ + HANDLE hShared; /* Shared memory segment used for locking */ + winceLock local; /* Locks obtained by this instance of winFile */ + winceLock *shared; /* Global shared lock memory for the file */ +#endif +#if SQLITE_MAX_MMAP_SIZE>0 + int nFetchOut; /* Number of outstanding xFetch references */ + HANDLE hMap; /* Handle for accessing memory mapping */ + void *pMapRegion; /* Area memory mapped */ + sqlite3_int64 mmapSize; /* Usable size of mapped region */ + sqlite3_int64 mmapSizeActual; /* Actual size of mapped region */ + sqlite3_int64 mmapSizeMax; /* Configured FCNTL_MMAP_SIZE value */ +#endif +}; + +/* +** Allowed values for winFile.ctrlFlags +*/ +#define WINFILE_RDONLY 0x02 /* Connection is read only */ +#define WINFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */ +#define WINFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */ + +/* + * The size of the buffer used by sqlite3_win32_write_debug(). + */ +#ifndef SQLITE_WIN32_DBG_BUF_SIZE +# define SQLITE_WIN32_DBG_BUF_SIZE ((int)(4096-sizeof(DWORD))) +#endif + +/* + * The value used with sqlite3_win32_set_directory() to specify that + * the data directory should be changed. + */ +#ifndef SQLITE_WIN32_DATA_DIRECTORY_TYPE +# define SQLITE_WIN32_DATA_DIRECTORY_TYPE (1) +#endif + +/* + * The value used with sqlite3_win32_set_directory() to specify that + * the temporary directory should be changed. + */ +#ifndef SQLITE_WIN32_TEMP_DIRECTORY_TYPE +# define SQLITE_WIN32_TEMP_DIRECTORY_TYPE (2) +#endif + +/* + * If compiled with SQLITE_WIN32_MALLOC on Windows, we will use the + * various Win32 API heap functions instead of our own. + */ +#ifdef SQLITE_WIN32_MALLOC + +/* + * If this is non-zero, an isolated heap will be created by the native Win32 + * allocator subsystem; otherwise, the default process heap will be used. This + * setting has no effect when compiling for WinRT. By default, this is enabled + * and an isolated heap will be created to store all allocated data. + * + ****************************************************************************** + * WARNING: It is important to note that when this setting is non-zero and the + * winMemShutdown function is called (e.g. by the sqlite3_shutdown + * function), all data that was allocated using the isolated heap will + * be freed immediately and any attempt to access any of that freed + * data will almost certainly result in an immediate access violation. + ****************************************************************************** + */ +#ifndef SQLITE_WIN32_HEAP_CREATE +# define SQLITE_WIN32_HEAP_CREATE (TRUE) +#endif + +/* + * The initial size of the Win32-specific heap. This value may be zero. + */ +#ifndef SQLITE_WIN32_HEAP_INIT_SIZE +# define SQLITE_WIN32_HEAP_INIT_SIZE ((SQLITE_DEFAULT_CACHE_SIZE) * \ + (SQLITE_DEFAULT_PAGE_SIZE) + 4194304) +#endif + +/* + * The maximum size of the Win32-specific heap. This value may be zero. + */ +#ifndef SQLITE_WIN32_HEAP_MAX_SIZE +# define SQLITE_WIN32_HEAP_MAX_SIZE (0) +#endif + +/* + * The extra flags to use in calls to the Win32 heap APIs. This value may be + * zero for the default behavior. + */ +#ifndef SQLITE_WIN32_HEAP_FLAGS +# define SQLITE_WIN32_HEAP_FLAGS (0) +#endif + + +/* +** The winMemData structure stores information required by the Win32-specific +** sqlite3_mem_methods implementation. +*/ +typedef struct winMemData winMemData; +struct winMemData { +#ifndef NDEBUG + u32 magic1; /* Magic number to detect structure corruption. */ +#endif + HANDLE hHeap; /* The handle to our heap. */ + BOOL bOwned; /* Do we own the heap (i.e. destroy it on shutdown)? */ +#ifndef NDEBUG + u32 magic2; /* Magic number to detect structure corruption. */ +#endif +}; + +#ifndef NDEBUG +#define WINMEM_MAGIC1 0x42b2830b +#define WINMEM_MAGIC2 0xbd4d7cf4 +#endif + +static struct winMemData win_mem_data = { +#ifndef NDEBUG + WINMEM_MAGIC1, +#endif + NULL, FALSE +#ifndef NDEBUG + ,WINMEM_MAGIC2 +#endif +}; + +#ifndef NDEBUG +#define winMemAssertMagic1() assert( win_mem_data.magic1==WINMEM_MAGIC1 ) +#define winMemAssertMagic2() assert( win_mem_data.magic2==WINMEM_MAGIC2 ) +#define winMemAssertMagic() winMemAssertMagic1(); winMemAssertMagic2(); +#else +#define winMemAssertMagic() +#endif + +#define winMemGetDataPtr() &win_mem_data +#define winMemGetHeap() win_mem_data.hHeap +#define winMemGetOwned() win_mem_data.bOwned + +static void *winMemMalloc(int nBytes); +static void winMemFree(void *pPrior); +static void *winMemRealloc(void *pPrior, int nBytes); +static int winMemSize(void *p); +static int winMemRoundup(int n); +static int winMemInit(void *pAppData); +static void winMemShutdown(void *pAppData); + +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetWin32(void); +#endif /* SQLITE_WIN32_MALLOC */ + +/* +** The following variable is (normally) set once and never changes +** thereafter. It records whether the operating system is Win9x +** or WinNT. +** +** 0: Operating system unknown. +** 1: Operating system is Win9x. +** 2: Operating system is WinNT. +** +** In order to facilitate testing on a WinNT system, the test fixture +** can manually set this value to 1 to emulate Win98 behavior. +*/ +#ifdef SQLITE_TEST +SQLITE_API LONG SQLITE_WIN32_VOLATILE sqlite3_os_type = 0; +#else +static LONG SQLITE_WIN32_VOLATILE sqlite3_os_type = 0; +#endif + +#ifndef SYSCALL +# define SYSCALL sqlite3_syscall_ptr +#endif + +/* +** This function is not available on Windows CE or WinRT. + */ + +#if SQLITE_OS_WINCE || SQLITE_OS_WINRT +# define osAreFileApisANSI() 1 +#endif + +/* +** Many system calls are accessed through pointer-to-functions so that +** they may be overridden at runtime to facilitate fault injection during +** testing and sandboxing. The following array holds the names and pointers +** to all overrideable system calls. +*/ +static struct win_syscall { + const char *zName; /* Name of the system call */ + sqlite3_syscall_ptr pCurrent; /* Current value of the system call */ + sqlite3_syscall_ptr pDefault; /* Default value */ +} aSyscall[] = { +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "AreFileApisANSI", (SYSCALL)AreFileApisANSI, 0 }, +#else + { "AreFileApisANSI", (SYSCALL)0, 0 }, +#endif + +#ifndef osAreFileApisANSI +#define osAreFileApisANSI ((BOOL(WINAPI*)(VOID))aSyscall[0].pCurrent) +#endif + +#if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE) + { "CharLowerW", (SYSCALL)CharLowerW, 0 }, +#else + { "CharLowerW", (SYSCALL)0, 0 }, +#endif + +#define osCharLowerW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[1].pCurrent) + +#if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE) + { "CharUpperW", (SYSCALL)CharUpperW, 0 }, +#else + { "CharUpperW", (SYSCALL)0, 0 }, +#endif + +#define osCharUpperW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[2].pCurrent) + + { "CloseHandle", (SYSCALL)CloseHandle, 0 }, + +#define osCloseHandle ((BOOL(WINAPI*)(HANDLE))aSyscall[3].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "CreateFileA", (SYSCALL)CreateFileA, 0 }, +#else + { "CreateFileA", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileA ((HANDLE(WINAPI*)(LPCSTR,DWORD,DWORD, \ + LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[4].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "CreateFileW", (SYSCALL)CreateFileW, 0 }, +#else + { "CreateFileW", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileW ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD, \ + LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[5].pCurrent) + +#if (!SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_ANSI) && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)) + { "CreateFileMappingA", (SYSCALL)CreateFileMappingA, 0 }, +#else + { "CreateFileMappingA", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileMappingA ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \ + DWORD,DWORD,DWORD,LPCSTR))aSyscall[6].pCurrent) + +#if SQLITE_OS_WINCE || (!SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)) + { "CreateFileMappingW", (SYSCALL)CreateFileMappingW, 0 }, +#else + { "CreateFileMappingW", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileMappingW ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \ + DWORD,DWORD,DWORD,LPCWSTR))aSyscall[7].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "CreateMutexW", (SYSCALL)CreateMutexW, 0 }, +#else + { "CreateMutexW", (SYSCALL)0, 0 }, +#endif + +#define osCreateMutexW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,BOOL, \ + LPCWSTR))aSyscall[8].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "DeleteFileA", (SYSCALL)DeleteFileA, 0 }, +#else + { "DeleteFileA", (SYSCALL)0, 0 }, +#endif + +#define osDeleteFileA ((BOOL(WINAPI*)(LPCSTR))aSyscall[9].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "DeleteFileW", (SYSCALL)DeleteFileW, 0 }, +#else + { "DeleteFileW", (SYSCALL)0, 0 }, +#endif + +#define osDeleteFileW ((BOOL(WINAPI*)(LPCWSTR))aSyscall[10].pCurrent) + +#if SQLITE_OS_WINCE + { "FileTimeToLocalFileTime", (SYSCALL)FileTimeToLocalFileTime, 0 }, +#else + { "FileTimeToLocalFileTime", (SYSCALL)0, 0 }, +#endif + +#define osFileTimeToLocalFileTime ((BOOL(WINAPI*)(CONST FILETIME*, \ + LPFILETIME))aSyscall[11].pCurrent) + +#if SQLITE_OS_WINCE + { "FileTimeToSystemTime", (SYSCALL)FileTimeToSystemTime, 0 }, +#else + { "FileTimeToSystemTime", (SYSCALL)0, 0 }, +#endif + +#define osFileTimeToSystemTime ((BOOL(WINAPI*)(CONST FILETIME*, \ + LPSYSTEMTIME))aSyscall[12].pCurrent) + + { "FlushFileBuffers", (SYSCALL)FlushFileBuffers, 0 }, + +#define osFlushFileBuffers ((BOOL(WINAPI*)(HANDLE))aSyscall[13].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "FormatMessageA", (SYSCALL)FormatMessageA, 0 }, +#else + { "FormatMessageA", (SYSCALL)0, 0 }, +#endif + +#define osFormatMessageA ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPSTR, \ + DWORD,va_list*))aSyscall[14].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "FormatMessageW", (SYSCALL)FormatMessageW, 0 }, +#else + { "FormatMessageW", (SYSCALL)0, 0 }, +#endif + +#define osFormatMessageW ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPWSTR, \ + DWORD,va_list*))aSyscall[15].pCurrent) + +#if !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "FreeLibrary", (SYSCALL)FreeLibrary, 0 }, +#else + { "FreeLibrary", (SYSCALL)0, 0 }, +#endif + +#define osFreeLibrary ((BOOL(WINAPI*)(HMODULE))aSyscall[16].pCurrent) + + { "GetCurrentProcessId", (SYSCALL)GetCurrentProcessId, 0 }, + +#define osGetCurrentProcessId ((DWORD(WINAPI*)(VOID))aSyscall[17].pCurrent) + +#if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI) + { "GetDiskFreeSpaceA", (SYSCALL)GetDiskFreeSpaceA, 0 }, +#else + { "GetDiskFreeSpaceA", (SYSCALL)0, 0 }, +#endif + +#define osGetDiskFreeSpaceA ((BOOL(WINAPI*)(LPCSTR,LPDWORD,LPDWORD,LPDWORD, \ + LPDWORD))aSyscall[18].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetDiskFreeSpaceW", (SYSCALL)GetDiskFreeSpaceW, 0 }, +#else + { "GetDiskFreeSpaceW", (SYSCALL)0, 0 }, +#endif + +#define osGetDiskFreeSpaceW ((BOOL(WINAPI*)(LPCWSTR,LPDWORD,LPDWORD,LPDWORD, \ + LPDWORD))aSyscall[19].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "GetFileAttributesA", (SYSCALL)GetFileAttributesA, 0 }, +#else + { "GetFileAttributesA", (SYSCALL)0, 0 }, +#endif + +#define osGetFileAttributesA ((DWORD(WINAPI*)(LPCSTR))aSyscall[20].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetFileAttributesW", (SYSCALL)GetFileAttributesW, 0 }, +#else + { "GetFileAttributesW", (SYSCALL)0, 0 }, +#endif + +#define osGetFileAttributesW ((DWORD(WINAPI*)(LPCWSTR))aSyscall[21].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "GetFileAttributesExW", (SYSCALL)GetFileAttributesExW, 0 }, +#else + { "GetFileAttributesExW", (SYSCALL)0, 0 }, +#endif + +#define osGetFileAttributesExW ((BOOL(WINAPI*)(LPCWSTR,GET_FILEEX_INFO_LEVELS, \ + LPVOID))aSyscall[22].pCurrent) + +#if !SQLITE_OS_WINRT + { "GetFileSize", (SYSCALL)GetFileSize, 0 }, +#else + { "GetFileSize", (SYSCALL)0, 0 }, +#endif + +#define osGetFileSize ((DWORD(WINAPI*)(HANDLE,LPDWORD))aSyscall[23].pCurrent) + +#if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI) + { "GetFullPathNameA", (SYSCALL)GetFullPathNameA, 0 }, +#else + { "GetFullPathNameA", (SYSCALL)0, 0 }, +#endif + +#define osGetFullPathNameA ((DWORD(WINAPI*)(LPCSTR,DWORD,LPSTR, \ + LPSTR*))aSyscall[24].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetFullPathNameW", (SYSCALL)GetFullPathNameW, 0 }, +#else + { "GetFullPathNameW", (SYSCALL)0, 0 }, +#endif + +#define osGetFullPathNameW ((DWORD(WINAPI*)(LPCWSTR,DWORD,LPWSTR, \ + LPWSTR*))aSyscall[25].pCurrent) + + { "GetLastError", (SYSCALL)GetLastError, 0 }, + +#define osGetLastError ((DWORD(WINAPI*)(VOID))aSyscall[26].pCurrent) + +#if !defined(SQLITE_OMIT_LOAD_EXTENSION) +#if SQLITE_OS_WINCE + /* The GetProcAddressA() routine is only available on Windows CE. */ + { "GetProcAddressA", (SYSCALL)GetProcAddressA, 0 }, +#else + /* All other Windows platforms expect GetProcAddress() to take + ** an ANSI string regardless of the _UNICODE setting */ + { "GetProcAddressA", (SYSCALL)GetProcAddress, 0 }, +#endif +#else + { "GetProcAddressA", (SYSCALL)0, 0 }, +#endif + +#define osGetProcAddressA ((FARPROC(WINAPI*)(HMODULE, \ + LPCSTR))aSyscall[27].pCurrent) + +#if !SQLITE_OS_WINRT + { "GetSystemInfo", (SYSCALL)GetSystemInfo, 0 }, +#else + { "GetSystemInfo", (SYSCALL)0, 0 }, +#endif + +#define osGetSystemInfo ((VOID(WINAPI*)(LPSYSTEM_INFO))aSyscall[28].pCurrent) + + { "GetSystemTime", (SYSCALL)GetSystemTime, 0 }, + +#define osGetSystemTime ((VOID(WINAPI*)(LPSYSTEMTIME))aSyscall[29].pCurrent) + +#if !SQLITE_OS_WINCE + { "GetSystemTimeAsFileTime", (SYSCALL)GetSystemTimeAsFileTime, 0 }, +#else + { "GetSystemTimeAsFileTime", (SYSCALL)0, 0 }, +#endif + +#define osGetSystemTimeAsFileTime ((VOID(WINAPI*)( \ + LPFILETIME))aSyscall[30].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "GetTempPathA", (SYSCALL)GetTempPathA, 0 }, +#else + { "GetTempPathA", (SYSCALL)0, 0 }, +#endif + +#define osGetTempPathA ((DWORD(WINAPI*)(DWORD,LPSTR))aSyscall[31].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetTempPathW", (SYSCALL)GetTempPathW, 0 }, +#else + { "GetTempPathW", (SYSCALL)0, 0 }, +#endif + +#define osGetTempPathW ((DWORD(WINAPI*)(DWORD,LPWSTR))aSyscall[32].pCurrent) + +#if !SQLITE_OS_WINRT + { "GetTickCount", (SYSCALL)GetTickCount, 0 }, +#else + { "GetTickCount", (SYSCALL)0, 0 }, +#endif + +#define osGetTickCount ((DWORD(WINAPI*)(VOID))aSyscall[33].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) && defined(SQLITE_WIN32_GETVERSIONEX) && \ + SQLITE_WIN32_GETVERSIONEX + { "GetVersionExA", (SYSCALL)GetVersionExA, 0 }, +#else + { "GetVersionExA", (SYSCALL)0, 0 }, +#endif + +#define osGetVersionExA ((BOOL(WINAPI*)( \ + LPOSVERSIONINFOA))aSyscall[34].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \ + defined(SQLITE_WIN32_GETVERSIONEX) && SQLITE_WIN32_GETVERSIONEX + { "GetVersionExW", (SYSCALL)GetVersionExW, 0 }, +#else + { "GetVersionExW", (SYSCALL)0, 0 }, +#endif + +#define osGetVersionExW ((BOOL(WINAPI*)( \ + LPOSVERSIONINFOW))aSyscall[35].pCurrent) + + { "HeapAlloc", (SYSCALL)HeapAlloc, 0 }, + +#define osHeapAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD, \ + SIZE_T))aSyscall[36].pCurrent) + +#if !SQLITE_OS_WINRT + { "HeapCreate", (SYSCALL)HeapCreate, 0 }, +#else + { "HeapCreate", (SYSCALL)0, 0 }, +#endif + +#define osHeapCreate ((HANDLE(WINAPI*)(DWORD,SIZE_T, \ + SIZE_T))aSyscall[37].pCurrent) + +#if !SQLITE_OS_WINRT + { "HeapDestroy", (SYSCALL)HeapDestroy, 0 }, +#else + { "HeapDestroy", (SYSCALL)0, 0 }, +#endif + +#define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[38].pCurrent) + + { "HeapFree", (SYSCALL)HeapFree, 0 }, + +#define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[39].pCurrent) + + { "HeapReAlloc", (SYSCALL)HeapReAlloc, 0 }, + +#define osHeapReAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD,LPVOID, \ + SIZE_T))aSyscall[40].pCurrent) + + { "HeapSize", (SYSCALL)HeapSize, 0 }, + +#define osHeapSize ((SIZE_T(WINAPI*)(HANDLE,DWORD, \ + LPCVOID))aSyscall[41].pCurrent) + +#if !SQLITE_OS_WINRT + { "HeapValidate", (SYSCALL)HeapValidate, 0 }, +#else + { "HeapValidate", (SYSCALL)0, 0 }, +#endif + +#define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \ + LPCVOID))aSyscall[42].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "HeapCompact", (SYSCALL)HeapCompact, 0 }, +#else + { "HeapCompact", (SYSCALL)0, 0 }, +#endif + +#define osHeapCompact ((UINT(WINAPI*)(HANDLE,DWORD))aSyscall[43].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) && !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "LoadLibraryA", (SYSCALL)LoadLibraryA, 0 }, +#else + { "LoadLibraryA", (SYSCALL)0, 0 }, +#endif + +#define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[44].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \ + !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "LoadLibraryW", (SYSCALL)LoadLibraryW, 0 }, +#else + { "LoadLibraryW", (SYSCALL)0, 0 }, +#endif + +#define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[45].pCurrent) + +#if !SQLITE_OS_WINRT + { "LocalFree", (SYSCALL)LocalFree, 0 }, +#else + { "LocalFree", (SYSCALL)0, 0 }, +#endif + +#define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[46].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "LockFile", (SYSCALL)LockFile, 0 }, +#else + { "LockFile", (SYSCALL)0, 0 }, +#endif + +#ifndef osLockFile +#define osLockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + DWORD))aSyscall[47].pCurrent) +#endif + +#if !SQLITE_OS_WINCE + { "LockFileEx", (SYSCALL)LockFileEx, 0 }, +#else + { "LockFileEx", (SYSCALL)0, 0 }, +#endif + +#ifndef osLockFileEx +#define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \ + LPOVERLAPPED))aSyscall[48].pCurrent) +#endif + +#if SQLITE_OS_WINCE || (!SQLITE_OS_WINRT && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)) + { "MapViewOfFile", (SYSCALL)MapViewOfFile, 0 }, +#else + { "MapViewOfFile", (SYSCALL)0, 0 }, +#endif + +#define osMapViewOfFile ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + SIZE_T))aSyscall[49].pCurrent) + + { "MultiByteToWideChar", (SYSCALL)MultiByteToWideChar, 0 }, + +#define osMultiByteToWideChar ((int(WINAPI*)(UINT,DWORD,LPCSTR,int,LPWSTR, \ + int))aSyscall[50].pCurrent) + + { "QueryPerformanceCounter", (SYSCALL)QueryPerformanceCounter, 0 }, + +#define osQueryPerformanceCounter ((BOOL(WINAPI*)( \ + LARGE_INTEGER*))aSyscall[51].pCurrent) + + { "ReadFile", (SYSCALL)ReadFile, 0 }, + +#define osReadFile ((BOOL(WINAPI*)(HANDLE,LPVOID,DWORD,LPDWORD, \ + LPOVERLAPPED))aSyscall[52].pCurrent) + + { "SetEndOfFile", (SYSCALL)SetEndOfFile, 0 }, + +#define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[53].pCurrent) + +#if !SQLITE_OS_WINRT + { "SetFilePointer", (SYSCALL)SetFilePointer, 0 }, +#else + { "SetFilePointer", (SYSCALL)0, 0 }, +#endif + +#define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \ + DWORD))aSyscall[54].pCurrent) + +#if !SQLITE_OS_WINRT + { "Sleep", (SYSCALL)Sleep, 0 }, +#else + { "Sleep", (SYSCALL)0, 0 }, +#endif + +#define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[55].pCurrent) + + { "SystemTimeToFileTime", (SYSCALL)SystemTimeToFileTime, 0 }, + +#define osSystemTimeToFileTime ((BOOL(WINAPI*)(CONST SYSTEMTIME*, \ + LPFILETIME))aSyscall[56].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "UnlockFile", (SYSCALL)UnlockFile, 0 }, +#else + { "UnlockFile", (SYSCALL)0, 0 }, +#endif + +#ifndef osUnlockFile +#define osUnlockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + DWORD))aSyscall[57].pCurrent) +#endif + +#if !SQLITE_OS_WINCE + { "UnlockFileEx", (SYSCALL)UnlockFileEx, 0 }, +#else + { "UnlockFileEx", (SYSCALL)0, 0 }, +#endif + +#define osUnlockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + LPOVERLAPPED))aSyscall[58].pCurrent) + +#if SQLITE_OS_WINCE || !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + { "UnmapViewOfFile", (SYSCALL)UnmapViewOfFile, 0 }, +#else + { "UnmapViewOfFile", (SYSCALL)0, 0 }, +#endif + +#define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[59].pCurrent) + + { "WideCharToMultiByte", (SYSCALL)WideCharToMultiByte, 0 }, + +#define osWideCharToMultiByte ((int(WINAPI*)(UINT,DWORD,LPCWSTR,int,LPSTR,int, \ + LPCSTR,LPBOOL))aSyscall[60].pCurrent) + + { "WriteFile", (SYSCALL)WriteFile, 0 }, + +#define osWriteFile ((BOOL(WINAPI*)(HANDLE,LPCVOID,DWORD,LPDWORD, \ + LPOVERLAPPED))aSyscall[61].pCurrent) + +#if SQLITE_OS_WINRT + { "CreateEventExW", (SYSCALL)CreateEventExW, 0 }, +#else + { "CreateEventExW", (SYSCALL)0, 0 }, +#endif + +#define osCreateEventExW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,LPCWSTR, \ + DWORD,DWORD))aSyscall[62].pCurrent) + +#if !SQLITE_OS_WINRT + { "WaitForSingleObject", (SYSCALL)WaitForSingleObject, 0 }, +#else + { "WaitForSingleObject", (SYSCALL)0, 0 }, +#endif + +#define osWaitForSingleObject ((DWORD(WINAPI*)(HANDLE, \ + DWORD))aSyscall[63].pCurrent) + +#if !SQLITE_OS_WINCE + { "WaitForSingleObjectEx", (SYSCALL)WaitForSingleObjectEx, 0 }, +#else + { "WaitForSingleObjectEx", (SYSCALL)0, 0 }, +#endif + +#define osWaitForSingleObjectEx ((DWORD(WINAPI*)(HANDLE,DWORD, \ + BOOL))aSyscall[64].pCurrent) + +#if SQLITE_OS_WINRT + { "SetFilePointerEx", (SYSCALL)SetFilePointerEx, 0 }, +#else + { "SetFilePointerEx", (SYSCALL)0, 0 }, +#endif + +#define osSetFilePointerEx ((BOOL(WINAPI*)(HANDLE,LARGE_INTEGER, \ + PLARGE_INTEGER,DWORD))aSyscall[65].pCurrent) + +#if SQLITE_OS_WINRT + { "GetFileInformationByHandleEx", (SYSCALL)GetFileInformationByHandleEx, 0 }, +#else + { "GetFileInformationByHandleEx", (SYSCALL)0, 0 }, +#endif + +#define osGetFileInformationByHandleEx ((BOOL(WINAPI*)(HANDLE, \ + FILE_INFO_BY_HANDLE_CLASS,LPVOID,DWORD))aSyscall[66].pCurrent) + +#if SQLITE_OS_WINRT && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) + { "MapViewOfFileFromApp", (SYSCALL)MapViewOfFileFromApp, 0 }, +#else + { "MapViewOfFileFromApp", (SYSCALL)0, 0 }, +#endif + +#define osMapViewOfFileFromApp ((LPVOID(WINAPI*)(HANDLE,ULONG,ULONG64, \ + SIZE_T))aSyscall[67].pCurrent) + +#if SQLITE_OS_WINRT + { "CreateFile2", (SYSCALL)CreateFile2, 0 }, +#else + { "CreateFile2", (SYSCALL)0, 0 }, +#endif + +#define osCreateFile2 ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD,DWORD, \ + LPCREATEFILE2_EXTENDED_PARAMETERS))aSyscall[68].pCurrent) + +#if SQLITE_OS_WINRT && !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "LoadPackagedLibrary", (SYSCALL)LoadPackagedLibrary, 0 }, +#else + { "LoadPackagedLibrary", (SYSCALL)0, 0 }, +#endif + +#define osLoadPackagedLibrary ((HMODULE(WINAPI*)(LPCWSTR, \ + DWORD))aSyscall[69].pCurrent) + +#if SQLITE_OS_WINRT + { "GetTickCount64", (SYSCALL)GetTickCount64, 0 }, +#else + { "GetTickCount64", (SYSCALL)0, 0 }, +#endif + +#define osGetTickCount64 ((ULONGLONG(WINAPI*)(VOID))aSyscall[70].pCurrent) + +#if SQLITE_OS_WINRT + { "GetNativeSystemInfo", (SYSCALL)GetNativeSystemInfo, 0 }, +#else + { "GetNativeSystemInfo", (SYSCALL)0, 0 }, +#endif + +#define osGetNativeSystemInfo ((VOID(WINAPI*)( \ + LPSYSTEM_INFO))aSyscall[71].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "OutputDebugStringA", (SYSCALL)OutputDebugStringA, 0 }, +#else + { "OutputDebugStringA", (SYSCALL)0, 0 }, +#endif + +#define osOutputDebugStringA ((VOID(WINAPI*)(LPCSTR))aSyscall[72].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "OutputDebugStringW", (SYSCALL)OutputDebugStringW, 0 }, +#else + { "OutputDebugStringW", (SYSCALL)0, 0 }, +#endif + +#define osOutputDebugStringW ((VOID(WINAPI*)(LPCWSTR))aSyscall[73].pCurrent) + + { "GetProcessHeap", (SYSCALL)GetProcessHeap, 0 }, + +#define osGetProcessHeap ((HANDLE(WINAPI*)(VOID))aSyscall[74].pCurrent) + +#if SQLITE_OS_WINRT && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) + { "CreateFileMappingFromApp", (SYSCALL)CreateFileMappingFromApp, 0 }, +#else + { "CreateFileMappingFromApp", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileMappingFromApp ((HANDLE(WINAPI*)(HANDLE, \ + LPSECURITY_ATTRIBUTES,ULONG,ULONG64,LPCWSTR))aSyscall[75].pCurrent) + +/* +** NOTE: On some sub-platforms, the InterlockedCompareExchange "function" +** is really just a macro that uses a compiler intrinsic (e.g. x64). +** So do not try to make this is into a redefinable interface. +*/ +#if defined(InterlockedCompareExchange) + { "InterlockedCompareExchange", (SYSCALL)0, 0 }, + +#define osInterlockedCompareExchange InterlockedCompareExchange +#else + { "InterlockedCompareExchange", (SYSCALL)InterlockedCompareExchange, 0 }, + +#define osInterlockedCompareExchange ((LONG(WINAPI*)(LONG \ + SQLITE_WIN32_VOLATILE*, LONG,LONG))aSyscall[76].pCurrent) +#endif /* defined(InterlockedCompareExchange) */ + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID + { "UuidCreate", (SYSCALL)UuidCreate, 0 }, +#else + { "UuidCreate", (SYSCALL)0, 0 }, +#endif + +#define osUuidCreate ((RPC_STATUS(RPC_ENTRY*)(UUID*))aSyscall[77].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID + { "UuidCreateSequential", (SYSCALL)UuidCreateSequential, 0 }, +#else + { "UuidCreateSequential", (SYSCALL)0, 0 }, +#endif + +#define osUuidCreateSequential \ + ((RPC_STATUS(RPC_ENTRY*)(UUID*))aSyscall[78].pCurrent) + +#if !defined(SQLITE_NO_SYNC) && SQLITE_MAX_MMAP_SIZE>0 + { "FlushViewOfFile", (SYSCALL)FlushViewOfFile, 0 }, +#else + { "FlushViewOfFile", (SYSCALL)0, 0 }, +#endif + +#define osFlushViewOfFile \ + ((BOOL(WINAPI*)(LPCVOID,SIZE_T))aSyscall[79].pCurrent) + +}; /* End of the overrideable system calls */ + +/* +** This is the xSetSystemCall() method of sqlite3_vfs for all of the +** "win32" VFSes. Return SQLITE_OK opon successfully updating the +** system call pointer, or SQLITE_NOTFOUND if there is no configurable +** system call named zName. +*/ +static int winSetSystemCall( + sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */ + const char *zName, /* Name of system call to override */ + sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */ +){ + unsigned int i; + int rc = SQLITE_NOTFOUND; + + UNUSED_PARAMETER(pNotUsed); + if( zName==0 ){ + /* If no zName is given, restore all system calls to their default + ** settings and return NULL + */ + rc = SQLITE_OK; + for(i=0; i0 ){ + memset(zDbgBuf, 0, SQLITE_WIN32_DBG_BUF_SIZE); + memcpy(zDbgBuf, zBuf, nMin); + osOutputDebugStringA(zDbgBuf); + }else{ + osOutputDebugStringA(zBuf); + } +#elif defined(SQLITE_WIN32_HAS_WIDE) + memset(zDbgBuf, 0, SQLITE_WIN32_DBG_BUF_SIZE); + if ( osMultiByteToWideChar( + osAreFileApisANSI() ? CP_ACP : CP_OEMCP, 0, zBuf, + nMin, (LPWSTR)zDbgBuf, SQLITE_WIN32_DBG_BUF_SIZE/sizeof(WCHAR))<=0 ){ + return; + } + osOutputDebugStringW((LPCWSTR)zDbgBuf); +#else + if( nMin>0 ){ + memset(zDbgBuf, 0, SQLITE_WIN32_DBG_BUF_SIZE); + memcpy(zDbgBuf, zBuf, nMin); + fprintf(stderr, "%s", zDbgBuf); + }else{ + fprintf(stderr, "%s", zBuf); + } +#endif +} + +/* +** The following routine suspends the current thread for at least ms +** milliseconds. This is equivalent to the Win32 Sleep() interface. +*/ +#if SQLITE_OS_WINRT +static HANDLE sleepObj = NULL; +#endif + +SQLITE_API void SQLITE_STDCALL sqlite3_win32_sleep(DWORD milliseconds){ +#if SQLITE_OS_WINRT + if ( sleepObj==NULL ){ + sleepObj = osCreateEventExW(NULL, NULL, CREATE_EVENT_MANUAL_RESET, + SYNCHRONIZE); + } + assert( sleepObj!=NULL ); + osWaitForSingleObjectEx(sleepObj, milliseconds, FALSE); +#else + osSleep(milliseconds); +#endif +} + +#if SQLITE_MAX_WORKER_THREADS>0 && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && \ + SQLITE_THREADSAFE>0 +SQLITE_PRIVATE DWORD sqlite3Win32Wait(HANDLE hObject){ + DWORD rc; + while( (rc = osWaitForSingleObjectEx(hObject, INFINITE, + TRUE))==WAIT_IO_COMPLETION ){} + return rc; +} +#endif + +/* +** Return true (non-zero) if we are running under WinNT, Win2K, WinXP, +** or WinCE. Return false (zero) for Win95, Win98, or WinME. +** +** Here is an interesting observation: Win95, Win98, and WinME lack +** the LockFileEx() API. But we can still statically link against that +** API as long as we don't call it when running Win95/98/ME. A call to +** this routine is used to determine if the host is Win95/98/ME or +** WinNT/2K/XP so that we will know whether or not we can safely call +** the LockFileEx() API. +*/ + +#if !defined(SQLITE_WIN32_GETVERSIONEX) || !SQLITE_WIN32_GETVERSIONEX +# define osIsNT() (1) +#elif SQLITE_OS_WINCE || SQLITE_OS_WINRT || !defined(SQLITE_WIN32_HAS_ANSI) +# define osIsNT() (1) +#elif !defined(SQLITE_WIN32_HAS_WIDE) +# define osIsNT() (0) +#else +# define osIsNT() ((sqlite3_os_type==2) || sqlite3_win32_is_nt()) +#endif + +/* +** This function determines if the machine is running a version of Windows +** based on the NT kernel. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_win32_is_nt(void){ +#if SQLITE_OS_WINRT + /* + ** NOTE: The WinRT sub-platform is always assumed to be based on the NT + ** kernel. + */ + return 1; +#elif defined(SQLITE_WIN32_GETVERSIONEX) && SQLITE_WIN32_GETVERSIONEX + if( osInterlockedCompareExchange(&sqlite3_os_type, 0, 0)==0 ){ +#if defined(SQLITE_WIN32_HAS_ANSI) + OSVERSIONINFOA sInfo; + sInfo.dwOSVersionInfoSize = sizeof(sInfo); + osGetVersionExA(&sInfo); + osInterlockedCompareExchange(&sqlite3_os_type, + (sInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) ? 2 : 1, 0); +#elif defined(SQLITE_WIN32_HAS_WIDE) + OSVERSIONINFOW sInfo; + sInfo.dwOSVersionInfoSize = sizeof(sInfo); + osGetVersionExW(&sInfo); + osInterlockedCompareExchange(&sqlite3_os_type, + (sInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) ? 2 : 1, 0); +#endif + } + return osInterlockedCompareExchange(&sqlite3_os_type, 2, 2)==2; +#elif SQLITE_TEST + return osInterlockedCompareExchange(&sqlite3_os_type, 2, 2)==2; +#else + /* + ** NOTE: All sub-platforms where the GetVersionEx[AW] functions are + ** deprecated are always assumed to be based on the NT kernel. + */ + return 1; +#endif +} + +#ifdef SQLITE_WIN32_MALLOC +/* +** Allocate nBytes of memory. +*/ +static void *winMemMalloc(int nBytes){ + HANDLE hHeap; + void *p; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) ); +#endif + assert( nBytes>=0 ); + p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes); + if( !p ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapAlloc %u bytes (%lu), heap=%p", + nBytes, osGetLastError(), (void*)hHeap); + } + return p; +} + +/* +** Free memory. +*/ +static void winMemFree(void *pPrior){ + HANDLE hHeap; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ); +#endif + if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */ + if( !osHeapFree(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapFree block %p (%lu), heap=%p", + pPrior, osGetLastError(), (void*)hHeap); + } +} + +/* +** Change the size of an existing memory allocation +*/ +static void *winMemRealloc(void *pPrior, int nBytes){ + HANDLE hHeap; + void *p; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ); +#endif + assert( nBytes>=0 ); + if( !pPrior ){ + p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes); + }else{ + p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes); + } + if( !p ){ + sqlite3_log(SQLITE_NOMEM, "failed to %s %u bytes (%lu), heap=%p", + pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, osGetLastError(), + (void*)hHeap); + } + return p; +} + +/* +** Return the size of an outstanding allocation, in bytes. +*/ +static int winMemSize(void *p){ + HANDLE hHeap; + SIZE_T n; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, p) ); +#endif + if( !p ) return 0; + n = osHeapSize(hHeap, SQLITE_WIN32_HEAP_FLAGS, p); + if( n==(SIZE_T)-1 ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapSize block %p (%lu), heap=%p", + p, osGetLastError(), (void*)hHeap); + return 0; + } + return (int)n; +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int winMemRoundup(int n){ + return n; +} + +/* +** Initialize this module. +*/ +static int winMemInit(void *pAppData){ + winMemData *pWinMemData = (winMemData *)pAppData; + + if( !pWinMemData ) return SQLITE_ERROR; + assert( pWinMemData->magic1==WINMEM_MAGIC1 ); + assert( pWinMemData->magic2==WINMEM_MAGIC2 ); + +#if !SQLITE_OS_WINRT && SQLITE_WIN32_HEAP_CREATE + if( !pWinMemData->hHeap ){ + DWORD dwInitialSize = SQLITE_WIN32_HEAP_INIT_SIZE; + DWORD dwMaximumSize = (DWORD)sqlite3GlobalConfig.nHeap; + if( dwMaximumSize==0 ){ + dwMaximumSize = SQLITE_WIN32_HEAP_MAX_SIZE; + }else if( dwInitialSize>dwMaximumSize ){ + dwInitialSize = dwMaximumSize; + } + pWinMemData->hHeap = osHeapCreate(SQLITE_WIN32_HEAP_FLAGS, + dwInitialSize, dwMaximumSize); + if( !pWinMemData->hHeap ){ + sqlite3_log(SQLITE_NOMEM, + "failed to HeapCreate (%lu), flags=%u, initSize=%lu, maxSize=%lu", + osGetLastError(), SQLITE_WIN32_HEAP_FLAGS, dwInitialSize, + dwMaximumSize); + return SQLITE_NOMEM; + } + pWinMemData->bOwned = TRUE; + assert( pWinMemData->bOwned ); + } +#else + pWinMemData->hHeap = osGetProcessHeap(); + if( !pWinMemData->hHeap ){ + sqlite3_log(SQLITE_NOMEM, + "failed to GetProcessHeap (%lu)", osGetLastError()); + return SQLITE_NOMEM; + } + pWinMemData->bOwned = FALSE; + assert( !pWinMemData->bOwned ); +#endif + assert( pWinMemData->hHeap!=0 ); + assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) ); +#endif + return SQLITE_OK; +} + +/* +** Deinitialize this module. +*/ +static void winMemShutdown(void *pAppData){ + winMemData *pWinMemData = (winMemData *)pAppData; + + if( !pWinMemData ) return; + assert( pWinMemData->magic1==WINMEM_MAGIC1 ); + assert( pWinMemData->magic2==WINMEM_MAGIC2 ); + + if( pWinMemData->hHeap ){ + assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) ); +#endif + if( pWinMemData->bOwned ){ + if( !osHeapDestroy(pWinMemData->hHeap) ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapDestroy (%lu), heap=%p", + osGetLastError(), (void*)pWinMemData->hHeap); + } + pWinMemData->bOwned = FALSE; + } + pWinMemData->hHeap = NULL; + } +} + +/* +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. The +** arguments specify the block of memory to manage. +** +** This routine is only called by sqlite3_config(), and therefore +** is not required to be threadsafe (it is not). +*/ +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetWin32(void){ + static const sqlite3_mem_methods winMemMethods = { + winMemMalloc, + winMemFree, + winMemRealloc, + winMemSize, + winMemRoundup, + winMemInit, + winMemShutdown, + &win_mem_data + }; + return &winMemMethods; +} + +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetWin32()); +} +#endif /* SQLITE_WIN32_MALLOC */ + +/* +** Convert a UTF-8 string to Microsoft Unicode (UTF-16?). +** +** Space to hold the returned string is obtained from malloc. +*/ +static LPWSTR winUtf8ToUnicode(const char *zFilename){ + int nChar; + LPWSTR zWideFilename; + + nChar = osMultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0); + if( nChar==0 ){ + return 0; + } + zWideFilename = sqlite3MallocZero( nChar*sizeof(zWideFilename[0]) ); + if( zWideFilename==0 ){ + return 0; + } + nChar = osMultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, + nChar); + if( nChar==0 ){ + sqlite3_free(zWideFilename); + zWideFilename = 0; + } + return zWideFilename; +} + +/* +** Convert Microsoft Unicode to UTF-8. Space to hold the returned string is +** obtained from sqlite3_malloc(). +*/ +static char *winUnicodeToUtf8(LPCWSTR zWideFilename){ + int nByte; + char *zFilename; + + nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0); + if( nByte == 0 ){ + return 0; + } + zFilename = sqlite3MallocZero( nByte ); + if( zFilename==0 ){ + return 0; + } + nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte, + 0, 0); + if( nByte == 0 ){ + sqlite3_free(zFilename); + zFilename = 0; + } + return zFilename; +} + +/* +** Convert an ANSI string to Microsoft Unicode, based on the +** current codepage settings for file apis. +** +** Space to hold the returned string is obtained +** from sqlite3_malloc. +*/ +static LPWSTR winMbcsToUnicode(const char *zFilename){ + int nByte; + LPWSTR zMbcsFilename; + int codepage = osAreFileApisANSI() ? CP_ACP : CP_OEMCP; + + nByte = osMultiByteToWideChar(codepage, 0, zFilename, -1, NULL, + 0)*sizeof(WCHAR); + if( nByte==0 ){ + return 0; + } + zMbcsFilename = sqlite3MallocZero( nByte*sizeof(zMbcsFilename[0]) ); + if( zMbcsFilename==0 ){ + return 0; + } + nByte = osMultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, + nByte); + if( nByte==0 ){ + sqlite3_free(zMbcsFilename); + zMbcsFilename = 0; + } + return zMbcsFilename; +} + +/* +** Convert Microsoft Unicode to multi-byte character string, based on the +** user's ANSI codepage. +** +** Space to hold the returned string is obtained from +** sqlite3_malloc(). +*/ +static char *winUnicodeToMbcs(LPCWSTR zWideFilename){ + int nByte; + char *zFilename; + int codepage = osAreFileApisANSI() ? CP_ACP : CP_OEMCP; + + nByte = osWideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0); + if( nByte == 0 ){ + return 0; + } + zFilename = sqlite3MallocZero( nByte ); + if( zFilename==0 ){ + return 0; + } + nByte = osWideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename, + nByte, 0, 0); + if( nByte == 0 ){ + sqlite3_free(zFilename); + zFilename = 0; + } + return zFilename; +} + +/* +** Convert multibyte character string to UTF-8. Space to hold the +** returned string is obtained from sqlite3_malloc(). +*/ +SQLITE_API char *SQLITE_STDCALL sqlite3_win32_mbcs_to_utf8(const char *zFilename){ + char *zFilenameUtf8; + LPWSTR zTmpWide; + + zTmpWide = winMbcsToUnicode(zFilename); + if( zTmpWide==0 ){ + return 0; + } + zFilenameUtf8 = winUnicodeToUtf8(zTmpWide); + sqlite3_free(zTmpWide); + return zFilenameUtf8; +} + +/* +** Convert UTF-8 to multibyte character string. Space to hold the +** returned string is obtained from sqlite3_malloc(). +*/ +SQLITE_API char *SQLITE_STDCALL sqlite3_win32_utf8_to_mbcs(const char *zFilename){ + char *zFilenameMbcs; + LPWSTR zTmpWide; + + zTmpWide = winUtf8ToUnicode(zFilename); + if( zTmpWide==0 ){ + return 0; + } + zFilenameMbcs = winUnicodeToMbcs(zTmpWide); + sqlite3_free(zTmpWide); + return zFilenameMbcs; +} + +/* +** This function sets the data directory or the temporary directory based on +** the provided arguments. The type argument must be 1 in order to set the +** data directory or 2 in order to set the temporary directory. The zValue +** argument is the name of the directory to use. The return value will be +** SQLITE_OK if successful. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_win32_set_directory(DWORD type, LPCWSTR zValue){ + char **ppDirectory = 0; +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + if( type==SQLITE_WIN32_DATA_DIRECTORY_TYPE ){ + ppDirectory = &sqlite3_data_directory; + }else if( type==SQLITE_WIN32_TEMP_DIRECTORY_TYPE ){ + ppDirectory = &sqlite3_temp_directory; + } + assert( !ppDirectory || type==SQLITE_WIN32_DATA_DIRECTORY_TYPE + || type==SQLITE_WIN32_TEMP_DIRECTORY_TYPE + ); + assert( !ppDirectory || sqlite3MemdebugHasType(*ppDirectory, MEMTYPE_HEAP) ); + if( ppDirectory ){ + char *zValueUtf8 = 0; + if( zValue && zValue[0] ){ + zValueUtf8 = winUnicodeToUtf8(zValue); + if ( zValueUtf8==0 ){ + return SQLITE_NOMEM; + } + } + sqlite3_free(*ppDirectory); + *ppDirectory = zValueUtf8; + return SQLITE_OK; + } + return SQLITE_ERROR; +} + +/* +** The return value of winGetLastErrorMsg +** is zero if the error message fits in the buffer, or non-zero +** otherwise (if the message was truncated). +*/ +static int winGetLastErrorMsg(DWORD lastErrno, int nBuf, char *zBuf){ + /* FormatMessage returns 0 on failure. Otherwise it + ** returns the number of TCHARs written to the output + ** buffer, excluding the terminating null char. + */ + DWORD dwLen = 0; + char *zOut = 0; + + if( osIsNT() ){ +#if SQLITE_OS_WINRT + WCHAR zTempWide[SQLITE_WIN32_MAX_ERRMSG_CHARS+1]; + dwLen = osFormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + lastErrno, + 0, + zTempWide, + SQLITE_WIN32_MAX_ERRMSG_CHARS, + 0); +#else + LPWSTR zTempWide = NULL; + dwLen = osFormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + lastErrno, + 0, + (LPWSTR) &zTempWide, + 0, + 0); +#endif + if( dwLen > 0 ){ + /* allocate a buffer and convert to UTF8 */ + sqlite3BeginBenignMalloc(); + zOut = winUnicodeToUtf8(zTempWide); + sqlite3EndBenignMalloc(); +#if !SQLITE_OS_WINRT + /* free the system buffer allocated by FormatMessage */ + osLocalFree(zTempWide); +#endif + } + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + char *zTemp = NULL; + dwLen = osFormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + lastErrno, + 0, + (LPSTR) &zTemp, + 0, + 0); + if( dwLen > 0 ){ + /* allocate a buffer and convert to UTF8 */ + sqlite3BeginBenignMalloc(); + zOut = sqlite3_win32_mbcs_to_utf8(zTemp); + sqlite3EndBenignMalloc(); + /* free the system buffer allocated by FormatMessage */ + osLocalFree(zTemp); + } + } +#endif + if( 0 == dwLen ){ + sqlite3_snprintf(nBuf, zBuf, "OsError 0x%lx (%lu)", lastErrno, lastErrno); + }else{ + /* copy a maximum of nBuf chars to output buffer */ + sqlite3_snprintf(nBuf, zBuf, "%s", zOut); + /* free the UTF8 buffer */ + sqlite3_free(zOut); + } + return 0; +} + +/* +** +** This function - winLogErrorAtLine() - is only ever called via the macro +** winLogError(). +** +** This routine is invoked after an error occurs in an OS function. +** It logs a message using sqlite3_log() containing the current value of +** error code and, if possible, the human-readable equivalent from +** FormatMessage. +** +** The first argument passed to the macro should be the error code that +** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN). +** The two subsequent arguments should be the name of the OS function that +** failed and the associated file-system path, if any. +*/ +#define winLogError(a,b,c,d) winLogErrorAtLine(a,b,c,d,__LINE__) +static int winLogErrorAtLine( + int errcode, /* SQLite error code */ + DWORD lastErrno, /* Win32 last error */ + const char *zFunc, /* Name of OS function that failed */ + const char *zPath, /* File path associated with error */ + int iLine /* Source line number where error occurred */ +){ + char zMsg[500]; /* Human readable error text */ + int i; /* Loop counter */ + + zMsg[0] = 0; + winGetLastErrorMsg(lastErrno, sizeof(zMsg), zMsg); + assert( errcode!=SQLITE_OK ); + if( zPath==0 ) zPath = ""; + for(i=0; zMsg[i] && zMsg[i]!='\r' && zMsg[i]!='\n'; i++){} + zMsg[i] = 0; + sqlite3_log(errcode, + "os_win.c:%d: (%lu) %s(%s) - %s", + iLine, lastErrno, zFunc, zPath, zMsg + ); + + return errcode; +} + +/* +** The number of times that a ReadFile(), WriteFile(), and DeleteFile() +** will be retried following a locking error - probably caused by +** antivirus software. Also the initial delay before the first retry. +** The delay increases linearly with each retry. +*/ +#ifndef SQLITE_WIN32_IOERR_RETRY +# define SQLITE_WIN32_IOERR_RETRY 10 +#endif +#ifndef SQLITE_WIN32_IOERR_RETRY_DELAY +# define SQLITE_WIN32_IOERR_RETRY_DELAY 25 +#endif +static int winIoerrRetry = SQLITE_WIN32_IOERR_RETRY; +static int winIoerrRetryDelay = SQLITE_WIN32_IOERR_RETRY_DELAY; + +/* +** The "winIoerrCanRetry1" macro is used to determine if a particular I/O +** error code obtained via GetLastError() is eligible to be retried. It +** must accept the error code DWORD as its only argument and should return +** non-zero if the error code is transient in nature and the operation +** responsible for generating the original error might succeed upon being +** retried. The argument to this macro should be a variable. +** +** Additionally, a macro named "winIoerrCanRetry2" may be defined. If it +** is defined, it will be consulted only when the macro "winIoerrCanRetry1" +** returns zero. The "winIoerrCanRetry2" macro is completely optional and +** may be used to include additional error codes in the set that should +** result in the failing I/O operation being retried by the caller. If +** defined, the "winIoerrCanRetry2" macro must exhibit external semantics +** identical to those of the "winIoerrCanRetry1" macro. +*/ +#if !defined(winIoerrCanRetry1) +#define winIoerrCanRetry1(a) (((a)==ERROR_ACCESS_DENIED) || \ + ((a)==ERROR_SHARING_VIOLATION) || \ + ((a)==ERROR_LOCK_VIOLATION) || \ + ((a)==ERROR_DEV_NOT_EXIST) || \ + ((a)==ERROR_NETNAME_DELETED) || \ + ((a)==ERROR_SEM_TIMEOUT) || \ + ((a)==ERROR_NETWORK_UNREACHABLE)) +#endif + +/* +** If a ReadFile() or WriteFile() error occurs, invoke this routine +** to see if it should be retried. Return TRUE to retry. Return FALSE +** to give up with an error. +*/ +static int winRetryIoerr(int *pnRetry, DWORD *pError){ + DWORD e = osGetLastError(); + if( *pnRetry>=winIoerrRetry ){ + if( pError ){ + *pError = e; + } + return 0; + } + if( winIoerrCanRetry1(e) ){ + sqlite3_win32_sleep(winIoerrRetryDelay*(1+*pnRetry)); + ++*pnRetry; + return 1; + } +#if defined(winIoerrCanRetry2) + else if( winIoerrCanRetry2(e) ){ + sqlite3_win32_sleep(winIoerrRetryDelay*(1+*pnRetry)); + ++*pnRetry; + return 1; + } +#endif + if( pError ){ + *pError = e; + } + return 0; +} + +/* +** Log a I/O error retry episode. +*/ +static void winLogIoerr(int nRetry, int lineno){ + if( nRetry ){ + sqlite3_log(SQLITE_NOTICE, + "delayed %dms for lock/sharing conflict at line %d", + winIoerrRetryDelay*nRetry*(nRetry+1)/2, lineno + ); + } +} + +#if SQLITE_OS_WINCE +/************************************************************************* +** This section contains code for WinCE only. +*/ +#if !defined(SQLITE_MSVC_LOCALTIME_API) || !SQLITE_MSVC_LOCALTIME_API +/* +** The MSVC CRT on Windows CE may not have a localtime() function. So +** create a substitute. +*/ +/* #include */ +struct tm *__cdecl localtime(const time_t *t) +{ + static struct tm y; + FILETIME uTm, lTm; + SYSTEMTIME pTm; + sqlite3_int64 t64; + t64 = *t; + t64 = (t64 + 11644473600)*10000000; + uTm.dwLowDateTime = (DWORD)(t64 & 0xFFFFFFFF); + uTm.dwHighDateTime= (DWORD)(t64 >> 32); + osFileTimeToLocalFileTime(&uTm,&lTm); + osFileTimeToSystemTime(&lTm,&pTm); + y.tm_year = pTm.wYear - 1900; + y.tm_mon = pTm.wMonth - 1; + y.tm_wday = pTm.wDayOfWeek; + y.tm_mday = pTm.wDay; + y.tm_hour = pTm.wHour; + y.tm_min = pTm.wMinute; + y.tm_sec = pTm.wSecond; + return &y; +} +#endif + +#define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-(int)offsetof(winFile,h)] + +/* +** Acquire a lock on the handle h +*/ +static void winceMutexAcquire(HANDLE h){ + DWORD dwErr; + do { + dwErr = osWaitForSingleObject(h, INFINITE); + } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED); +} +/* +** Release a lock acquired by winceMutexAcquire() +*/ +#define winceMutexRelease(h) ReleaseMutex(h) + +/* +** Create the mutex and shared memory used for locking in the file +** descriptor pFile +*/ +static int winceCreateLock(const char *zFilename, winFile *pFile){ + LPWSTR zTok; + LPWSTR zName; + DWORD lastErrno; + BOOL bLogged = FALSE; + BOOL bInit = TRUE; + + zName = winUtf8ToUnicode(zFilename); + if( zName==0 ){ + /* out of memory */ + return SQLITE_IOERR_NOMEM; + } + + /* Initialize the local lockdata */ + memset(&pFile->local, 0, sizeof(pFile->local)); + + /* Replace the backslashes from the filename and lowercase it + ** to derive a mutex name. */ + zTok = osCharLowerW(zName); + for (;*zTok;zTok++){ + if (*zTok == '\\') *zTok = '_'; + } + + /* Create/open the named mutex */ + pFile->hMutex = osCreateMutexW(NULL, FALSE, zName); + if (!pFile->hMutex){ + pFile->lastErrno = osGetLastError(); + sqlite3_free(zName); + return winLogError(SQLITE_IOERR, pFile->lastErrno, + "winceCreateLock1", zFilename); + } + + /* Acquire the mutex before continuing */ + winceMutexAcquire(pFile->hMutex); + + /* Since the names of named mutexes, semaphores, file mappings etc are + ** case-sensitive, take advantage of that by uppercasing the mutex name + ** and using that as the shared filemapping name. + */ + osCharUpperW(zName); + pFile->hShared = osCreateFileMappingW(INVALID_HANDLE_VALUE, NULL, + PAGE_READWRITE, 0, sizeof(winceLock), + zName); + + /* Set a flag that indicates we're the first to create the memory so it + ** must be zero-initialized */ + lastErrno = osGetLastError(); + if (lastErrno == ERROR_ALREADY_EXISTS){ + bInit = FALSE; + } + + sqlite3_free(zName); + + /* If we succeeded in making the shared memory handle, map it. */ + if( pFile->hShared ){ + pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared, + FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock)); + /* If mapping failed, close the shared memory handle and erase it */ + if( !pFile->shared ){ + pFile->lastErrno = osGetLastError(); + winLogError(SQLITE_IOERR, pFile->lastErrno, + "winceCreateLock2", zFilename); + bLogged = TRUE; + osCloseHandle(pFile->hShared); + pFile->hShared = NULL; + } + } + + /* If shared memory could not be created, then close the mutex and fail */ + if( pFile->hShared==NULL ){ + if( !bLogged ){ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_IOERR, pFile->lastErrno, + "winceCreateLock3", zFilename); + bLogged = TRUE; + } + winceMutexRelease(pFile->hMutex); + osCloseHandle(pFile->hMutex); + pFile->hMutex = NULL; + return SQLITE_IOERR; + } + + /* Initialize the shared memory if we're supposed to */ + if( bInit ){ + memset(pFile->shared, 0, sizeof(winceLock)); + } + + winceMutexRelease(pFile->hMutex); + return SQLITE_OK; +} + +/* +** Destroy the part of winFile that deals with wince locks +*/ +static void winceDestroyLock(winFile *pFile){ + if (pFile->hMutex){ + /* Acquire the mutex */ + winceMutexAcquire(pFile->hMutex); + + /* The following blocks should probably assert in debug mode, but they + are to cleanup in case any locks remained open */ + if (pFile->local.nReaders){ + pFile->shared->nReaders --; + } + if (pFile->local.bReserved){ + pFile->shared->bReserved = FALSE; + } + if (pFile->local.bPending){ + pFile->shared->bPending = FALSE; + } + if (pFile->local.bExclusive){ + pFile->shared->bExclusive = FALSE; + } + + /* De-reference and close our copy of the shared memory handle */ + osUnmapViewOfFile(pFile->shared); + osCloseHandle(pFile->hShared); + + /* Done with the mutex */ + winceMutexRelease(pFile->hMutex); + osCloseHandle(pFile->hMutex); + pFile->hMutex = NULL; + } +} + +/* +** An implementation of the LockFile() API of Windows for CE +*/ +static BOOL winceLockFile( + LPHANDLE phFile, + DWORD dwFileOffsetLow, + DWORD dwFileOffsetHigh, + DWORD nNumberOfBytesToLockLow, + DWORD nNumberOfBytesToLockHigh +){ + winFile *pFile = HANDLE_TO_WINFILE(phFile); + BOOL bReturn = FALSE; + + UNUSED_PARAMETER(dwFileOffsetHigh); + UNUSED_PARAMETER(nNumberOfBytesToLockHigh); + + if (!pFile->hMutex) return TRUE; + winceMutexAcquire(pFile->hMutex); + + /* Wanting an exclusive lock? */ + if (dwFileOffsetLow == (DWORD)SHARED_FIRST + && nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){ + if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){ + pFile->shared->bExclusive = TRUE; + pFile->local.bExclusive = TRUE; + bReturn = TRUE; + } + } + + /* Want a read-only lock? */ + else if (dwFileOffsetLow == (DWORD)SHARED_FIRST && + nNumberOfBytesToLockLow == 1){ + if (pFile->shared->bExclusive == 0){ + pFile->local.nReaders ++; + if (pFile->local.nReaders == 1){ + pFile->shared->nReaders ++; + } + bReturn = TRUE; + } + } + + /* Want a pending lock? */ + else if (dwFileOffsetLow == (DWORD)PENDING_BYTE + && nNumberOfBytesToLockLow == 1){ + /* If no pending lock has been acquired, then acquire it */ + if (pFile->shared->bPending == 0) { + pFile->shared->bPending = TRUE; + pFile->local.bPending = TRUE; + bReturn = TRUE; + } + } + + /* Want a reserved lock? */ + else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE + && nNumberOfBytesToLockLow == 1){ + if (pFile->shared->bReserved == 0) { + pFile->shared->bReserved = TRUE; + pFile->local.bReserved = TRUE; + bReturn = TRUE; + } + } + + winceMutexRelease(pFile->hMutex); + return bReturn; +} + +/* +** An implementation of the UnlockFile API of Windows for CE +*/ +static BOOL winceUnlockFile( + LPHANDLE phFile, + DWORD dwFileOffsetLow, + DWORD dwFileOffsetHigh, + DWORD nNumberOfBytesToUnlockLow, + DWORD nNumberOfBytesToUnlockHigh +){ + winFile *pFile = HANDLE_TO_WINFILE(phFile); + BOOL bReturn = FALSE; + + UNUSED_PARAMETER(dwFileOffsetHigh); + UNUSED_PARAMETER(nNumberOfBytesToUnlockHigh); + + if (!pFile->hMutex) return TRUE; + winceMutexAcquire(pFile->hMutex); + + /* Releasing a reader lock or an exclusive lock */ + if (dwFileOffsetLow == (DWORD)SHARED_FIRST){ + /* Did we have an exclusive lock? */ + if (pFile->local.bExclusive){ + assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE); + pFile->local.bExclusive = FALSE; + pFile->shared->bExclusive = FALSE; + bReturn = TRUE; + } + + /* Did we just have a reader lock? */ + else if (pFile->local.nReaders){ + assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE + || nNumberOfBytesToUnlockLow == 1); + pFile->local.nReaders --; + if (pFile->local.nReaders == 0) + { + pFile->shared->nReaders --; + } + bReturn = TRUE; + } + } + + /* Releasing a pending lock */ + else if (dwFileOffsetLow == (DWORD)PENDING_BYTE + && nNumberOfBytesToUnlockLow == 1){ + if (pFile->local.bPending){ + pFile->local.bPending = FALSE; + pFile->shared->bPending = FALSE; + bReturn = TRUE; + } + } + /* Releasing a reserved lock */ + else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE + && nNumberOfBytesToUnlockLow == 1){ + if (pFile->local.bReserved) { + pFile->local.bReserved = FALSE; + pFile->shared->bReserved = FALSE; + bReturn = TRUE; + } + } + + winceMutexRelease(pFile->hMutex); + return bReturn; +} +/* +** End of the special code for wince +*****************************************************************************/ +#endif /* SQLITE_OS_WINCE */ + +/* +** Lock a file region. +*/ +static BOOL winLockFile( + LPHANDLE phFile, + DWORD flags, + DWORD offsetLow, + DWORD offsetHigh, + DWORD numBytesLow, + DWORD numBytesHigh +){ +#if SQLITE_OS_WINCE + /* + ** NOTE: Windows CE is handled differently here due its lack of the Win32 + ** API LockFile. + */ + return winceLockFile(phFile, offsetLow, offsetHigh, + numBytesLow, numBytesHigh); +#else + if( osIsNT() ){ + OVERLAPPED ovlp; + memset(&ovlp, 0, sizeof(OVERLAPPED)); + ovlp.Offset = offsetLow; + ovlp.OffsetHigh = offsetHigh; + return osLockFileEx(*phFile, flags, 0, numBytesLow, numBytesHigh, &ovlp); + }else{ + return osLockFile(*phFile, offsetLow, offsetHigh, numBytesLow, + numBytesHigh); + } +#endif +} + +/* +** Unlock a file region. + */ +static BOOL winUnlockFile( + LPHANDLE phFile, + DWORD offsetLow, + DWORD offsetHigh, + DWORD numBytesLow, + DWORD numBytesHigh +){ +#if SQLITE_OS_WINCE + /* + ** NOTE: Windows CE is handled differently here due its lack of the Win32 + ** API UnlockFile. + */ + return winceUnlockFile(phFile, offsetLow, offsetHigh, + numBytesLow, numBytesHigh); +#else + if( osIsNT() ){ + OVERLAPPED ovlp; + memset(&ovlp, 0, sizeof(OVERLAPPED)); + ovlp.Offset = offsetLow; + ovlp.OffsetHigh = offsetHigh; + return osUnlockFileEx(*phFile, 0, numBytesLow, numBytesHigh, &ovlp); + }else{ + return osUnlockFile(*phFile, offsetLow, offsetHigh, numBytesLow, + numBytesHigh); + } +#endif +} + +/***************************************************************************** +** The next group of routines implement the I/O methods specified +** by the sqlite3_io_methods object. +******************************************************************************/ + +/* +** Some Microsoft compilers lack this definition. +*/ +#ifndef INVALID_SET_FILE_POINTER +# define INVALID_SET_FILE_POINTER ((DWORD)-1) +#endif + +/* +** Move the current position of the file handle passed as the first +** argument to offset iOffset within the file. If successful, return 0. +** Otherwise, set pFile->lastErrno and return non-zero. +*/ +static int winSeekFile(winFile *pFile, sqlite3_int64 iOffset){ +#if !SQLITE_OS_WINRT + LONG upperBits; /* Most sig. 32 bits of new offset */ + LONG lowerBits; /* Least sig. 32 bits of new offset */ + DWORD dwRet; /* Value returned by SetFilePointer() */ + DWORD lastErrno; /* Value returned by GetLastError() */ + + OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset)); + + upperBits = (LONG)((iOffset>>32) & 0x7fffffff); + lowerBits = (LONG)(iOffset & 0xffffffff); + + /* API oddity: If successful, SetFilePointer() returns a dword + ** containing the lower 32-bits of the new file-offset. Or, if it fails, + ** it returns INVALID_SET_FILE_POINTER. However according to MSDN, + ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine + ** whether an error has actually occurred, it is also necessary to call + ** GetLastError(). + */ + dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN); + + if( (dwRet==INVALID_SET_FILE_POINTER + && ((lastErrno = osGetLastError())!=NO_ERROR)) ){ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno, + "winSeekFile", pFile->zPath); + OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h)); + return 1; + } + + OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h)); + return 0; +#else + /* + ** Same as above, except that this implementation works for WinRT. + */ + + LARGE_INTEGER x; /* The new offset */ + BOOL bRet; /* Value returned by SetFilePointerEx() */ + + x.QuadPart = iOffset; + bRet = osSetFilePointerEx(pFile->h, x, 0, FILE_BEGIN); + + if(!bRet){ + pFile->lastErrno = osGetLastError(); + winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno, + "winSeekFile", pFile->zPath); + OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h)); + return 1; + } + + OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h)); + return 0; +#endif +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* Forward references to VFS helper methods used for memory mapped files */ +static int winMapfile(winFile*, sqlite3_int64); +static int winUnmapfile(winFile*); +#endif + +/* +** Close a file. +** +** It is reported that an attempt to close a handle might sometimes +** fail. This is a very unreasonable result, but Windows is notorious +** for being unreasonable so I do not doubt that it might happen. If +** the close fails, we pause for 100 milliseconds and try again. As +** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before +** giving up and returning an error. +*/ +#define MX_CLOSE_ATTEMPT 3 +static int winClose(sqlite3_file *id){ + int rc, cnt = 0; + winFile *pFile = (winFile*)id; + + assert( id!=0 ); +#ifndef SQLITE_OMIT_WAL + assert( pFile->pShm==0 ); +#endif + assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE ); + OSTRACE(("CLOSE pid=%lu, pFile=%p, file=%p\n", + osGetCurrentProcessId(), pFile, pFile->h)); + +#if SQLITE_MAX_MMAP_SIZE>0 + winUnmapfile(pFile); +#endif + + do{ + rc = osCloseHandle(pFile->h); + /* SimulateIOError( rc=0; cnt=MX_CLOSE_ATTEMPT; ); */ + }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (sqlite3_win32_sleep(100), 1) ); +#if SQLITE_OS_WINCE +#define WINCE_DELETION_ATTEMPTS 3 + winceDestroyLock(pFile); + if( pFile->zDeleteOnClose ){ + int cnt = 0; + while( + osDeleteFileW(pFile->zDeleteOnClose)==0 + && osGetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff + && cnt++ < WINCE_DELETION_ATTEMPTS + ){ + sqlite3_win32_sleep(100); /* Wait a little before trying again */ + } + sqlite3_free(pFile->zDeleteOnClose); + } +#endif + if( rc ){ + pFile->h = NULL; + } + OpenCounter(-1); + OSTRACE(("CLOSE pid=%lu, pFile=%p, file=%p, rc=%s\n", + osGetCurrentProcessId(), pFile, pFile->h, rc ? "ok" : "failed")); + return rc ? SQLITE_OK + : winLogError(SQLITE_IOERR_CLOSE, osGetLastError(), + "winClose", pFile->zPath); +} + +/* +** Read data from a file into a buffer. Return SQLITE_OK if all +** bytes were read successfully and SQLITE_IOERR if anything goes +** wrong. +*/ +static int winRead( + sqlite3_file *id, /* File to read from */ + void *pBuf, /* Write content into this buffer */ + int amt, /* Number of bytes to read */ + sqlite3_int64 offset /* Begin reading at this offset */ +){ +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + OVERLAPPED overlapped; /* The offset for ReadFile. */ +#endif + winFile *pFile = (winFile*)id; /* file handle */ + DWORD nRead; /* Number of bytes actually read from file */ + int nRetry = 0; /* Number of retrys */ + + assert( id!=0 ); + assert( amt>0 ); + assert( offset>=0 ); + SimulateIOError(return SQLITE_IOERR_READ); + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, buffer=%p, amount=%d, " + "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile, + pFile->h, pBuf, amt, offset, pFile->locktype)); + +#if SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this read request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt); + OSTRACE(("READ-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; + }else{ + int nCopy = (int)(pFile->mmapSize - offset); + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + +#if SQLITE_OS_WINCE || defined(SQLITE_WIN32_NO_OVERLAPPED) + if( winSeekFile(pFile, offset) ){ + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_FULL\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_FULL; + } + while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){ +#else + memset(&overlapped, 0, sizeof(OVERLAPPED)); + overlapped.Offset = (LONG)(offset & 0xffffffff); + overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff); + while( !osReadFile(pFile->h, pBuf, amt, &nRead, &overlapped) && + osGetLastError()!=ERROR_HANDLE_EOF ){ +#endif + DWORD lastErrno; + if( winRetryIoerr(&nRetry, &lastErrno) ) continue; + pFile->lastErrno = lastErrno; + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_READ\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_IOERR_READ, pFile->lastErrno, + "winRead", pFile->zPath); + } + winLogIoerr(nRetry, __LINE__); + if( nRead<(DWORD)amt ){ + /* Unread parts of the buffer must be zero-filled */ + memset(&((char*)pBuf)[nRead], 0, amt-nRead); + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_SHORT_READ\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_IOERR_SHORT_READ; + } + + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; +} + +/* +** Write data from a buffer into a file. Return SQLITE_OK on success +** or some other error code on failure. +*/ +static int winWrite( + sqlite3_file *id, /* File to write into */ + const void *pBuf, /* The bytes to be written */ + int amt, /* Number of bytes to write */ + sqlite3_int64 offset /* Offset into the file to begin writing at */ +){ + int rc = 0; /* True if error has occurred, else false */ + winFile *pFile = (winFile*)id; /* File handle */ + int nRetry = 0; /* Number of retries */ + + assert( amt>0 ); + assert( pFile ); + SimulateIOError(return SQLITE_IOERR_WRITE); + SimulateDiskfullError(return SQLITE_FULL); + + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, buffer=%p, amount=%d, " + "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile, + pFile->h, pBuf, amt, offset, pFile->locktype)); + +#if SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this write request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt); + OSTRACE(("WRITE-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; + }else{ + int nCopy = (int)(pFile->mmapSize - offset); + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + +#if SQLITE_OS_WINCE || defined(SQLITE_WIN32_NO_OVERLAPPED) + rc = winSeekFile(pFile, offset); + if( rc==0 ){ +#else + { +#endif +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + OVERLAPPED overlapped; /* The offset for WriteFile. */ +#endif + u8 *aRem = (u8 *)pBuf; /* Data yet to be written */ + int nRem = amt; /* Number of bytes yet to be written */ + DWORD nWrite; /* Bytes written by each WriteFile() call */ + DWORD lastErrno = NO_ERROR; /* Value returned by GetLastError() */ + +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + memset(&overlapped, 0, sizeof(OVERLAPPED)); + overlapped.Offset = (LONG)(offset & 0xffffffff); + overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff); +#endif + + while( nRem>0 ){ +#if SQLITE_OS_WINCE || defined(SQLITE_WIN32_NO_OVERLAPPED) + if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){ +#else + if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, &overlapped) ){ +#endif + if( winRetryIoerr(&nRetry, &lastErrno) ) continue; + break; + } + assert( nWrite==0 || nWrite<=(DWORD)nRem ); + if( nWrite==0 || nWrite>(DWORD)nRem ){ + lastErrno = osGetLastError(); + break; + } +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + offset += nWrite; + overlapped.Offset = (LONG)(offset & 0xffffffff); + overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff); +#endif + aRem += nWrite; + nRem -= nWrite; + } + if( nRem>0 ){ + pFile->lastErrno = lastErrno; + rc = 1; + } + } + + if( rc ){ + if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL ) + || ( pFile->lastErrno==ERROR_DISK_FULL )){ + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_FULL\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_FULL, pFile->lastErrno, + "winWrite1", pFile->zPath); + } + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_WRITE\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno, + "winWrite2", pFile->zPath); + }else{ + winLogIoerr(nRetry, __LINE__); + } + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; +} + +/* +** Truncate an open file to a specified size +*/ +static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){ + winFile *pFile = (winFile*)id; /* File handle object */ + int rc = SQLITE_OK; /* Return code for this function */ + DWORD lastErrno; + + assert( pFile ); + SimulateIOError(return SQLITE_IOERR_TRUNCATE); + OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, size=%lld, lock=%d\n", + osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype)); + + /* If the user has configured a chunk-size for this file, truncate the + ** file so that it consists of an integer number of chunks (i.e. the + ** actual file size after the operation may be larger than the requested + ** size). + */ + if( pFile->szChunk>0 ){ + nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk; + } + + /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */ + if( winSeekFile(pFile, nByte) ){ + rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno, + "winTruncate1", pFile->zPath); + }else if( 0==osSetEndOfFile(pFile->h) && + ((lastErrno = osGetLastError())!=ERROR_USER_MAPPED_FILE) ){ + pFile->lastErrno = lastErrno; + rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno, + "winTruncate2", pFile->zPath); + } + +#if SQLITE_MAX_MMAP_SIZE>0 + /* If the file was truncated to a size smaller than the currently + ** mapped region, reduce the effective mapping size as well. SQLite will + ** use read() and write() to access data beyond this point from now on. + */ + if( pFile->pMapRegion && nBytemmapSize ){ + pFile->mmapSize = nByte; + } +#endif + + OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, rc=%s\n", + osGetCurrentProcessId(), pFile, pFile->h, sqlite3ErrName(rc))); + return rc; +} + +#ifdef SQLITE_TEST +/* +** Count the number of fullsyncs and normal syncs. This is used to test +** that syncs and fullsyncs are occuring at the right times. +*/ +SQLITE_API int sqlite3_sync_count = 0; +SQLITE_API int sqlite3_fullsync_count = 0; +#endif + +/* +** Make sure all writes to a particular file are committed to disk. +*/ +static int winSync(sqlite3_file *id, int flags){ +#ifndef SQLITE_NO_SYNC + /* + ** Used only when SQLITE_NO_SYNC is not defined. + */ + BOOL rc; +#endif +#if !defined(NDEBUG) || !defined(SQLITE_NO_SYNC) || \ + defined(SQLITE_HAVE_OS_TRACE) + /* + ** Used when SQLITE_NO_SYNC is not defined and by the assert() and/or + ** OSTRACE() macros. + */ + winFile *pFile = (winFile*)id; +#else + UNUSED_PARAMETER(id); +#endif + + assert( pFile ); + /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */ + assert((flags&0x0F)==SQLITE_SYNC_NORMAL + || (flags&0x0F)==SQLITE_SYNC_FULL + ); + + /* Unix cannot, but some systems may return SQLITE_FULL from here. This + ** line is to test that doing so does not cause any problems. + */ + SimulateDiskfullError( return SQLITE_FULL ); + + OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, flags=%x, lock=%d\n", + osGetCurrentProcessId(), pFile, pFile->h, flags, + pFile->locktype)); + +#ifndef SQLITE_TEST + UNUSED_PARAMETER(flags); +#else + if( (flags&0x0F)==SQLITE_SYNC_FULL ){ + sqlite3_fullsync_count++; + } + sqlite3_sync_count++; +#endif + + /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a + ** no-op + */ +#ifdef SQLITE_NO_SYNC + OSTRACE(("SYNC-NOP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; +#else +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFile->pMapRegion ){ + if( osFlushViewOfFile(pFile->pMapRegion, 0) ){ + OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, " + "rc=SQLITE_OK\n", osGetCurrentProcessId(), + pFile, pFile->pMapRegion)); + }else{ + pFile->lastErrno = osGetLastError(); + OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, " + "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), + pFile, pFile->pMapRegion)); + return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, + "winSync1", pFile->zPath); + } + } +#endif + rc = osFlushFileBuffers(pFile->h); + SimulateIOError( rc=FALSE ); + if( rc ){ + OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; + }else{ + pFile->lastErrno = osGetLastError(); + OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_FSYNC\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno, + "winSync2", pFile->zPath); + } +#endif +} + +/* +** Determine the current size of a file in bytes +*/ +static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){ + winFile *pFile = (winFile*)id; + int rc = SQLITE_OK; + + assert( id!=0 ); + assert( pSize!=0 ); + SimulateIOError(return SQLITE_IOERR_FSTAT); + OSTRACE(("SIZE file=%p, pSize=%p\n", pFile->h, pSize)); + +#if SQLITE_OS_WINRT + { + FILE_STANDARD_INFO info; + if( osGetFileInformationByHandleEx(pFile->h, FileStandardInfo, + &info, sizeof(info)) ){ + *pSize = info.EndOfFile.QuadPart; + }else{ + pFile->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno, + "winFileSize", pFile->zPath); + } + } +#else + { + DWORD upperBits; + DWORD lowerBits; + DWORD lastErrno; + + lowerBits = osGetFileSize(pFile->h, &upperBits); + *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits; + if( (lowerBits == INVALID_FILE_SIZE) + && ((lastErrno = osGetLastError())!=NO_ERROR) ){ + pFile->lastErrno = lastErrno; + rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno, + "winFileSize", pFile->zPath); + } + } +#endif + OSTRACE(("SIZE file=%p, pSize=%p, *pSize=%lld, rc=%s\n", + pFile->h, pSize, *pSize, sqlite3ErrName(rc))); + return rc; +} + +/* +** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems. +*/ +#ifndef LOCKFILE_FAIL_IMMEDIATELY +# define LOCKFILE_FAIL_IMMEDIATELY 1 +#endif + +#ifndef LOCKFILE_EXCLUSIVE_LOCK +# define LOCKFILE_EXCLUSIVE_LOCK 2 +#endif + +/* +** Historically, SQLite has used both the LockFile and LockFileEx functions. +** When the LockFile function was used, it was always expected to fail +** immediately if the lock could not be obtained. Also, it always expected to +** obtain an exclusive lock. These flags are used with the LockFileEx function +** and reflect those expectations; therefore, they should not be changed. +*/ +#ifndef SQLITE_LOCKFILE_FLAGS +# define SQLITE_LOCKFILE_FLAGS (LOCKFILE_FAIL_IMMEDIATELY | \ + LOCKFILE_EXCLUSIVE_LOCK) +#endif + +/* +** Currently, SQLite never calls the LockFileEx function without wanting the +** call to fail immediately if the lock cannot be obtained. +*/ +#ifndef SQLITE_LOCKFILEEX_FLAGS +# define SQLITE_LOCKFILEEX_FLAGS (LOCKFILE_FAIL_IMMEDIATELY) +#endif + +/* +** Acquire a reader lock. +** Different API routines are called depending on whether or not this +** is Win9x or WinNT. +*/ +static int winGetReadLock(winFile *pFile){ + int res; + OSTRACE(("READ-LOCK file=%p, lock=%d\n", pFile->h, pFile->locktype)); + if( osIsNT() ){ +#if SQLITE_OS_WINCE + /* + ** NOTE: Windows CE is handled differently here due its lack of the Win32 + ** API LockFileEx. + */ + res = winceLockFile(&pFile->h, SHARED_FIRST, 0, 1, 0); +#else + res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS, SHARED_FIRST, 0, + SHARED_SIZE, 0); +#endif + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + int lk; + sqlite3_randomness(sizeof(lk), &lk); + pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1)); + res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, + SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0); + } +#endif + if( res == 0 ){ + pFile->lastErrno = osGetLastError(); + /* No need to log a failure to lock */ + } + OSTRACE(("READ-LOCK file=%p, result=%d\n", pFile->h, res)); + return res; +} + +/* +** Undo a readlock +*/ +static int winUnlockReadLock(winFile *pFile){ + int res; + DWORD lastErrno; + OSTRACE(("READ-UNLOCK file=%p, lock=%d\n", pFile->h, pFile->locktype)); + if( osIsNT() ){ + res = winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + res = winUnlockFile(&pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0); + } +#endif + if( res==0 && ((lastErrno = osGetLastError())!=ERROR_NOT_LOCKED) ){ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno, + "winUnlockReadLock", pFile->zPath); + } + OSTRACE(("READ-UNLOCK file=%p, result=%d\n", pFile->h, res)); + return res; +} + +/* +** Lock the file with the lock specified by parameter locktype - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. The winUnlock() routine +** erases all locks at once and returns us immediately to locking level 0. +** It is not possible to lower the locking level one step at a time. You +** must go straight to locking level 0. +*/ +static int winLock(sqlite3_file *id, int locktype){ + int rc = SQLITE_OK; /* Return code from subroutines */ + int res = 1; /* Result of a Windows lock call */ + int newLocktype; /* Set pFile->locktype to this value before exiting */ + int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */ + winFile *pFile = (winFile*)id; + DWORD lastErrno = NO_ERROR; + + assert( id!=0 ); + OSTRACE(("LOCK file=%p, oldLock=%d(%d), newLock=%d\n", + pFile->h, pFile->locktype, pFile->sharedLockByte, locktype)); + + /* If there is already a lock of this type or more restrictive on the + ** OsFile, do nothing. Don't use the end_lock: exit path, as + ** sqlite3OsEnterMutex() hasn't been called yet. + */ + if( pFile->locktype>=locktype ){ + OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + + /* Do not allow any kind of write-lock on a read-only database + */ + if( (pFile->ctrlFlags & WINFILE_RDONLY)!=0 && locktype>=RESERVED_LOCK ){ + return SQLITE_IOERR_LOCK; + } + + /* Make sure the locking sequence is correct + */ + assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK ); + assert( locktype!=PENDING_LOCK ); + assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK ); + + /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or + ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of + ** the PENDING_LOCK byte is temporary. + */ + newLocktype = pFile->locktype; + if( (pFile->locktype==NO_LOCK) + || ( (locktype==EXCLUSIVE_LOCK) + && (pFile->locktype==RESERVED_LOCK)) + ){ + int cnt = 3; + while( cnt-->0 && (res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, + PENDING_BYTE, 0, 1, 0))==0 ){ + /* Try 3 times to get the pending lock. This is needed to work + ** around problems caused by indexing and/or anti-virus software on + ** Windows systems. + ** If you are using this code as a model for alternative VFSes, do not + ** copy this retry logic. It is a hack intended for Windows only. + */ + lastErrno = osGetLastError(); + OSTRACE(("LOCK-PENDING-FAIL file=%p, count=%d, result=%d\n", + pFile->h, cnt, res)); + if( lastErrno==ERROR_INVALID_HANDLE ){ + pFile->lastErrno = lastErrno; + rc = SQLITE_IOERR_LOCK; + OSTRACE(("LOCK-FAIL file=%p, count=%d, rc=%s\n", + pFile->h, cnt, sqlite3ErrName(rc))); + return rc; + } + if( cnt ) sqlite3_win32_sleep(1); + } + gotPendingLock = res; + if( !res ){ + lastErrno = osGetLastError(); + } + } + + /* Acquire a shared lock + */ + if( locktype==SHARED_LOCK && res ){ + assert( pFile->locktype==NO_LOCK ); + res = winGetReadLock(pFile); + if( res ){ + newLocktype = SHARED_LOCK; + }else{ + lastErrno = osGetLastError(); + } + } + + /* Acquire a RESERVED lock + */ + if( locktype==RESERVED_LOCK && res ){ + assert( pFile->locktype==SHARED_LOCK ); + res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, RESERVED_BYTE, 0, 1, 0); + if( res ){ + newLocktype = RESERVED_LOCK; + }else{ + lastErrno = osGetLastError(); + } + } + + /* Acquire a PENDING lock + */ + if( locktype==EXCLUSIVE_LOCK && res ){ + newLocktype = PENDING_LOCK; + gotPendingLock = 0; + } + + /* Acquire an EXCLUSIVE lock + */ + if( locktype==EXCLUSIVE_LOCK && res ){ + assert( pFile->locktype>=SHARED_LOCK ); + res = winUnlockReadLock(pFile); + res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, SHARED_FIRST, 0, + SHARED_SIZE, 0); + if( res ){ + newLocktype = EXCLUSIVE_LOCK; + }else{ + lastErrno = osGetLastError(); + winGetReadLock(pFile); + } + } + + /* If we are holding a PENDING lock that ought to be released, then + ** release it now. + */ + if( gotPendingLock && locktype==SHARED_LOCK ){ + winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0); + } + + /* Update the state of the lock has held in the file descriptor then + ** return the appropriate result code. + */ + if( res ){ + rc = SQLITE_OK; + }else{ + pFile->lastErrno = lastErrno; + rc = SQLITE_BUSY; + OSTRACE(("LOCK-FAIL file=%p, wanted=%d, got=%d\n", + pFile->h, locktype, newLocktype)); + } + pFile->locktype = (u8)newLocktype; + OSTRACE(("LOCK file=%p, lock=%d, rc=%s\n", + pFile->h, pFile->locktype, sqlite3ErrName(rc))); + return rc; +} + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, return +** non-zero, otherwise zero. +*/ +static int winCheckReservedLock(sqlite3_file *id, int *pResOut){ + int res; + winFile *pFile = (winFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p\n", pFile->h, pResOut)); + + assert( id!=0 ); + if( pFile->locktype>=RESERVED_LOCK ){ + res = 1; + OSTRACE(("TEST-WR-LOCK file=%p, result=%d (local)\n", pFile->h, res)); + }else{ + res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS,RESERVED_BYTE, 0, 1, 0); + if( res ){ + winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0); + } + res = !res; + OSTRACE(("TEST-WR-LOCK file=%p, result=%d (remote)\n", pFile->h, res)); + } + *pResOut = res; + OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n", + pFile->h, pResOut, *pResOut)); + return SQLITE_OK; +} + +/* +** Lower the locking level on file descriptor id to locktype. locktype +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** It is not possible for this routine to fail if the second argument +** is NO_LOCK. If the second argument is SHARED_LOCK then this routine +** might return SQLITE_IOERR; +*/ +static int winUnlock(sqlite3_file *id, int locktype){ + int type; + winFile *pFile = (winFile*)id; + int rc = SQLITE_OK; + assert( pFile!=0 ); + assert( locktype<=SHARED_LOCK ); + OSTRACE(("UNLOCK file=%p, oldLock=%d(%d), newLock=%d\n", + pFile->h, pFile->locktype, pFile->sharedLockByte, locktype)); + type = pFile->locktype; + if( type>=EXCLUSIVE_LOCK ){ + winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); + if( locktype==SHARED_LOCK && !winGetReadLock(pFile) ){ + /* This should never happen. We should always be able to + ** reacquire the read lock */ + rc = winLogError(SQLITE_IOERR_UNLOCK, osGetLastError(), + "winUnlock", pFile->zPath); + } + } + if( type>=RESERVED_LOCK ){ + winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0); + } + if( locktype==NO_LOCK && type>=SHARED_LOCK ){ + winUnlockReadLock(pFile); + } + if( type>=PENDING_LOCK ){ + winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0); + } + pFile->locktype = (u8)locktype; + OSTRACE(("UNLOCK file=%p, lock=%d, rc=%s\n", + pFile->h, pFile->locktype, sqlite3ErrName(rc))); + return rc; +} + +/* +** If *pArg is initially negative then this is a query. Set *pArg to +** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set. +** +** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags. +*/ +static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){ + if( *pArg<0 ){ + *pArg = (pFile->ctrlFlags & mask)!=0; + }else if( (*pArg)==0 ){ + pFile->ctrlFlags &= ~mask; + }else{ + pFile->ctrlFlags |= mask; + } +} + +/* Forward references to VFS helper methods used for temporary files */ +static int winGetTempname(sqlite3_vfs *, char **); +static int winIsDir(const void *); +static BOOL winIsDriveLetterAndColon(const char *); + +/* +** Control and query of the open file handle. +*/ +static int winFileControl(sqlite3_file *id, int op, void *pArg){ + winFile *pFile = (winFile*)id; + OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg)); + switch( op ){ + case SQLITE_FCNTL_LOCKSTATE: { + *(int*)pArg = pFile->locktype; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_LAST_ERRNO: { + *(int*)pArg = (int)pFile->lastErrno; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_CHUNK_SIZE: { + pFile->szChunk = *(int *)pArg; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_SIZE_HINT: { + if( pFile->szChunk>0 ){ + sqlite3_int64 oldSz; + int rc = winFileSize(id, &oldSz); + if( rc==SQLITE_OK ){ + sqlite3_int64 newSz = *(sqlite3_int64*)pArg; + if( newSz>oldSz ){ + SimulateIOErrorBenign(1); + rc = winTruncate(id, newSz); + SimulateIOErrorBenign(0); + } + } + OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc))); + return rc; + } + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_PERSIST_WAL: { + winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg); + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_POWERSAFE_OVERWRITE: { + winModeBit(pFile, WINFILE_PSOW, (int*)pArg); + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_VFSNAME: { + *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName); + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_WIN32_AV_RETRY: { + int *a = (int*)pArg; + if( a[0]>0 ){ + winIoerrRetry = a[0]; + }else{ + a[0] = winIoerrRetry; + } + if( a[1]>0 ){ + winIoerrRetryDelay = a[1]; + }else{ + a[1] = winIoerrRetryDelay; + } + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } +#ifdef SQLITE_TEST + case SQLITE_FCNTL_WIN32_SET_HANDLE: { + LPHANDLE phFile = (LPHANDLE)pArg; + HANDLE hOldFile = pFile->h; + pFile->h = *phFile; + *phFile = hOldFile; + OSTRACE(("FCNTL oldFile=%p, newFile=%p, rc=SQLITE_OK\n", + hOldFile, pFile->h)); + return SQLITE_OK; + } +#endif + case SQLITE_FCNTL_TEMPFILENAME: { + char *zTFile = 0; + int rc = winGetTempname(pFile->pVfs, &zTFile); + if( rc==SQLITE_OK ){ + *(char**)pArg = zTFile; + } + OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc))); + return rc; + } +#if SQLITE_MAX_MMAP_SIZE>0 + case SQLITE_FCNTL_MMAP_SIZE: { + i64 newLimit = *(i64*)pArg; + int rc = SQLITE_OK; + if( newLimit>sqlite3GlobalConfig.mxMmap ){ + newLimit = sqlite3GlobalConfig.mxMmap; + } + *(i64*)pArg = pFile->mmapSizeMax; + if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){ + pFile->mmapSizeMax = newLimit; + if( pFile->mmapSize>0 ){ + winUnmapfile(pFile); + rc = winMapfile(pFile, -1); + } + } + OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc))); + return rc; + } +#endif + } + OSTRACE(("FCNTL file=%p, rc=SQLITE_NOTFOUND\n", pFile->h)); + return SQLITE_NOTFOUND; +} + +/* +** Return the sector size in bytes of the underlying block device for +** the specified file. This is almost always 512 bytes, but may be +** larger for some devices. +** +** SQLite code assumes this function cannot fail. It also assumes that +** if two files are created in the same file-system directory (i.e. +** a database and its journal file) that the sector size will be the +** same for both. +*/ +static int winSectorSize(sqlite3_file *id){ + (void)id; + return SQLITE_DEFAULT_SECTOR_SIZE; +} + +/* +** Return a vector of device characteristics. +*/ +static int winDeviceCharacteristics(sqlite3_file *id){ + winFile *p = (winFile*)id; + return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN | + ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0); +} + +/* +** Windows will only let you create file view mappings +** on allocation size granularity boundaries. +** During sqlite3_os_init() we do a GetSystemInfo() +** to get the granularity size. +*/ +static SYSTEM_INFO winSysInfo; + +#ifndef SQLITE_OMIT_WAL + +/* +** Helper functions to obtain and relinquish the global mutex. The +** global mutex is used to protect the winLockInfo objects used by +** this file, all of which may be shared by multiple threads. +** +** Function winShmMutexHeld() is used to assert() that the global mutex +** is held when required. This function is only used as part of assert() +** statements. e.g. +** +** winShmEnterMutex() +** assert( winShmMutexHeld() ); +** winShmLeaveMutex() +*/ +static void winShmEnterMutex(void){ + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1)); +} +static void winShmLeaveMutex(void){ + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1)); +} +#ifndef NDEBUG +static int winShmMutexHeld(void) { + return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1)); +} +#endif + +/* +** Object used to represent a single file opened and mmapped to provide +** shared memory. When multiple threads all reference the same +** log-summary, each thread has its own winFile object, but they all +** point to a single instance of this object. In other words, each +** log-summary is opened only once per process. +** +** winShmMutexHeld() must be true when creating or destroying +** this object or while reading or writing the following fields: +** +** nRef +** pNext +** +** The following fields are read-only after the object is created: +** +** fid +** zFilename +** +** Either winShmNode.mutex must be held or winShmNode.nRef==0 and +** winShmMutexHeld() is true when reading or writing any other field +** in this structure. +** +*/ +struct winShmNode { + sqlite3_mutex *mutex; /* Mutex to access this object */ + char *zFilename; /* Name of the file */ + winFile hFile; /* File handle from winOpen */ + + int szRegion; /* Size of shared-memory regions */ + int nRegion; /* Size of array apRegion */ + struct ShmRegion { + HANDLE hMap; /* File handle from CreateFileMapping */ + void *pMap; + } *aRegion; + DWORD lastErrno; /* The Windows errno from the last I/O error */ + + int nRef; /* Number of winShm objects pointing to this */ + winShm *pFirst; /* All winShm objects pointing to this */ + winShmNode *pNext; /* Next in list of all winShmNode objects */ +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) + u8 nextShmId; /* Next available winShm.id value */ +#endif +}; + +/* +** A global array of all winShmNode objects. +** +** The winShmMutexHeld() must be true while reading or writing this list. +*/ +static winShmNode *winShmNodeList = 0; + +/* +** Structure used internally by this VFS to record the state of an +** open shared memory connection. +** +** The following fields are initialized when this object is created and +** are read-only thereafter: +** +** winShm.pShmNode +** winShm.id +** +** All other fields are read/write. The winShm.pShmNode->mutex must be held +** while accessing any read/write fields. +*/ +struct winShm { + winShmNode *pShmNode; /* The underlying winShmNode object */ + winShm *pNext; /* Next winShm with the same winShmNode */ + u8 hasMutex; /* True if holding the winShmNode mutex */ + u16 sharedMask; /* Mask of shared locks held */ + u16 exclMask; /* Mask of exclusive locks held */ +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) + u8 id; /* Id of this connection with its winShmNode */ +#endif +}; + +/* +** Constants used for locking +*/ +#define WIN_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */ +#define WIN_SHM_DMS (WIN_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */ + +/* +** Apply advisory locks for all n bytes beginning at ofst. +*/ +#define _SHM_UNLCK 1 +#define _SHM_RDLCK 2 +#define _SHM_WRLCK 3 +static int winShmSystemLock( + winShmNode *pFile, /* Apply locks to this open shared-memory segment */ + int lockType, /* _SHM_UNLCK, _SHM_RDLCK, or _SHM_WRLCK */ + int ofst, /* Offset to first byte to be locked/unlocked */ + int nByte /* Number of bytes to lock or unlock */ +){ + int rc = 0; /* Result code form Lock/UnlockFileEx() */ + + /* Access to the winShmNode object is serialized by the caller */ + assert( sqlite3_mutex_held(pFile->mutex) || pFile->nRef==0 ); + + OSTRACE(("SHM-LOCK file=%p, lock=%d, offset=%d, size=%d\n", + pFile->hFile.h, lockType, ofst, nByte)); + + /* Release/Acquire the system-level lock */ + if( lockType==_SHM_UNLCK ){ + rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0); + }else{ + /* Initialize the locking parameters */ + DWORD dwFlags = LOCKFILE_FAIL_IMMEDIATELY; + if( lockType == _SHM_WRLCK ) dwFlags |= LOCKFILE_EXCLUSIVE_LOCK; + rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0); + } + + if( rc!= 0 ){ + rc = SQLITE_OK; + }else{ + pFile->lastErrno = osGetLastError(); + rc = SQLITE_BUSY; + } + + OSTRACE(("SHM-LOCK file=%p, func=%s, errno=%lu, rc=%s\n", + pFile->hFile.h, (lockType == _SHM_UNLCK) ? "winUnlockFile" : + "winLockFile", pFile->lastErrno, sqlite3ErrName(rc))); + + return rc; +} + +/* Forward references to VFS methods */ +static int winOpen(sqlite3_vfs*,const char*,sqlite3_file*,int,int*); +static int winDelete(sqlite3_vfs *,const char*,int); + +/* +** Purge the winShmNodeList list of all entries with winShmNode.nRef==0. +** +** This is not a VFS shared-memory method; it is a utility function called +** by VFS shared-memory methods. +*/ +static void winShmPurge(sqlite3_vfs *pVfs, int deleteFlag){ + winShmNode **pp; + winShmNode *p; + assert( winShmMutexHeld() ); + OSTRACE(("SHM-PURGE pid=%lu, deleteFlag=%d\n", + osGetCurrentProcessId(), deleteFlag)); + pp = &winShmNodeList; + while( (p = *pp)!=0 ){ + if( p->nRef==0 ){ + int i; + if( p->mutex ){ sqlite3_mutex_free(p->mutex); } + for(i=0; inRegion; i++){ + BOOL bRc = osUnmapViewOfFile(p->aRegion[i].pMap); + OSTRACE(("SHM-PURGE-UNMAP pid=%lu, region=%d, rc=%s\n", + osGetCurrentProcessId(), i, bRc ? "ok" : "failed")); + UNUSED_VARIABLE_VALUE(bRc); + bRc = osCloseHandle(p->aRegion[i].hMap); + OSTRACE(("SHM-PURGE-CLOSE pid=%lu, region=%d, rc=%s\n", + osGetCurrentProcessId(), i, bRc ? "ok" : "failed")); + UNUSED_VARIABLE_VALUE(bRc); + } + if( p->hFile.h!=NULL && p->hFile.h!=INVALID_HANDLE_VALUE ){ + SimulateIOErrorBenign(1); + winClose((sqlite3_file *)&p->hFile); + SimulateIOErrorBenign(0); + } + if( deleteFlag ){ + SimulateIOErrorBenign(1); + sqlite3BeginBenignMalloc(); + winDelete(pVfs, p->zFilename, 0); + sqlite3EndBenignMalloc(); + SimulateIOErrorBenign(0); + } + *pp = p->pNext; + sqlite3_free(p->aRegion); + sqlite3_free(p); + }else{ + pp = &p->pNext; + } + } +} + +/* +** Open the shared-memory area associated with database file pDbFd. +** +** When opening a new shared-memory file, if no other instances of that +** file are currently open, in this process or in other processes, then +** the file must be truncated to zero length or have its header cleared. +*/ +static int winOpenSharedMemory(winFile *pDbFd){ + struct winShm *p; /* The connection to be opened */ + struct winShmNode *pShmNode = 0; /* The underlying mmapped file */ + int rc; /* Result code */ + struct winShmNode *pNew; /* Newly allocated winShmNode */ + int nName; /* Size of zName in bytes */ + + assert( pDbFd->pShm==0 ); /* Not previously opened */ + + /* Allocate space for the new sqlite3_shm object. Also speculatively + ** allocate space for a new winShmNode and filename. + */ + p = sqlite3MallocZero( sizeof(*p) ); + if( p==0 ) return SQLITE_IOERR_NOMEM; + nName = sqlite3Strlen30(pDbFd->zPath); + pNew = sqlite3MallocZero( sizeof(*pShmNode) + nName + 17 ); + if( pNew==0 ){ + sqlite3_free(p); + return SQLITE_IOERR_NOMEM; + } + pNew->zFilename = (char*)&pNew[1]; + sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath); + sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename); + + /* Look to see if there is an existing winShmNode that can be used. + ** If no matching winShmNode currently exists, create a new one. + */ + winShmEnterMutex(); + for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){ + /* TBD need to come up with better match here. Perhaps + ** use FILE_ID_BOTH_DIR_INFO Structure. + */ + if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break; + } + if( pShmNode ){ + sqlite3_free(pNew); + }else{ + pShmNode = pNew; + pNew = 0; + ((winFile*)(&pShmNode->hFile))->h = INVALID_HANDLE_VALUE; + pShmNode->pNext = winShmNodeList; + winShmNodeList = pShmNode; + + pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( pShmNode->mutex==0 ){ + rc = SQLITE_IOERR_NOMEM; + goto shm_open_err; + } + + rc = winOpen(pDbFd->pVfs, + pShmNode->zFilename, /* Name of the file (UTF-8) */ + (sqlite3_file*)&pShmNode->hFile, /* File handle here */ + SQLITE_OPEN_WAL | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, + 0); + if( SQLITE_OK!=rc ){ + goto shm_open_err; + } + + /* Check to see if another process is holding the dead-man switch. + ** If not, truncate the file to zero length. + */ + if( winShmSystemLock(pShmNode, _SHM_WRLCK, WIN_SHM_DMS, 1)==SQLITE_OK ){ + rc = winTruncate((sqlite3_file *)&pShmNode->hFile, 0); + if( rc!=SQLITE_OK ){ + rc = winLogError(SQLITE_IOERR_SHMOPEN, osGetLastError(), + "winOpenShm", pDbFd->zPath); + } + } + if( rc==SQLITE_OK ){ + winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1); + rc = winShmSystemLock(pShmNode, _SHM_RDLCK, WIN_SHM_DMS, 1); + } + if( rc ) goto shm_open_err; + } + + /* Make the new connection a child of the winShmNode */ + p->pShmNode = pShmNode; +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) + p->id = pShmNode->nextShmId++; +#endif + pShmNode->nRef++; + pDbFd->pShm = p; + winShmLeaveMutex(); + + /* The reference count on pShmNode has already been incremented under + ** the cover of the winShmEnterMutex() mutex and the pointer from the + ** new (struct winShm) object to the pShmNode has been set. All that is + ** left to do is to link the new object into the linked list starting + ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex + ** mutex. + */ + sqlite3_mutex_enter(pShmNode->mutex); + p->pNext = pShmNode->pFirst; + pShmNode->pFirst = p; + sqlite3_mutex_leave(pShmNode->mutex); + return SQLITE_OK; + + /* Jump here on any error */ +shm_open_err: + winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1); + winShmPurge(pDbFd->pVfs, 0); /* This call frees pShmNode if required */ + sqlite3_free(p); + sqlite3_free(pNew); + winShmLeaveMutex(); + return rc; +} + +/* +** Close a connection to shared-memory. Delete the underlying +** storage if deleteFlag is true. +*/ +static int winShmUnmap( + sqlite3_file *fd, /* Database holding shared memory */ + int deleteFlag /* Delete after closing if true */ +){ + winFile *pDbFd; /* Database holding shared-memory */ + winShm *p; /* The connection to be closed */ + winShmNode *pShmNode; /* The underlying shared-memory file */ + winShm **pp; /* For looping over sibling connections */ + + pDbFd = (winFile*)fd; + p = pDbFd->pShm; + if( p==0 ) return SQLITE_OK; + pShmNode = p->pShmNode; + + /* Remove connection p from the set of connections associated + ** with pShmNode */ + sqlite3_mutex_enter(pShmNode->mutex); + for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){} + *pp = p->pNext; + + /* Free the connection p */ + sqlite3_free(p); + pDbFd->pShm = 0; + sqlite3_mutex_leave(pShmNode->mutex); + + /* If pShmNode->nRef has reached 0, then close the underlying + ** shared-memory file, too */ + winShmEnterMutex(); + assert( pShmNode->nRef>0 ); + pShmNode->nRef--; + if( pShmNode->nRef==0 ){ + winShmPurge(pDbFd->pVfs, deleteFlag); + } + winShmLeaveMutex(); + + return SQLITE_OK; +} + +/* +** Change the lock state for a shared-memory segment. +*/ +static int winShmLock( + sqlite3_file *fd, /* Database file holding the shared memory */ + int ofst, /* First lock to acquire or release */ + int n, /* Number of locks to acquire or release */ + int flags /* What to do with the lock */ +){ + winFile *pDbFd = (winFile*)fd; /* Connection holding shared memory */ + winShm *p = pDbFd->pShm; /* The shared memory being locked */ + winShm *pX; /* For looping over all siblings */ + winShmNode *pShmNode = p->pShmNode; + int rc = SQLITE_OK; /* Result code */ + u16 mask; /* Mask of locks to take or release */ + + assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK ); + assert( n>=1 ); + assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) ); + assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 ); + + mask = (u16)((1U<<(ofst+n)) - (1U<1 || mask==(1<mutex); + if( flags & SQLITE_SHM_UNLOCK ){ + u16 allMask = 0; /* Mask of locks held by siblings */ + + /* See if any siblings hold this same lock */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( pX==p ) continue; + assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 ); + allMask |= pX->sharedMask; + } + + /* Unlock the system-level locks */ + if( (mask & allMask)==0 ){ + rc = winShmSystemLock(pShmNode, _SHM_UNLCK, ofst+WIN_SHM_BASE, n); + }else{ + rc = SQLITE_OK; + } + + /* Undo the local locks */ + if( rc==SQLITE_OK ){ + p->exclMask &= ~mask; + p->sharedMask &= ~mask; + } + }else if( flags & SQLITE_SHM_SHARED ){ + u16 allShared = 0; /* Union of locks held by connections other than "p" */ + + /* Find out which shared locks are already held by sibling connections. + ** If any sibling already holds an exclusive lock, go ahead and return + ** SQLITE_BUSY. + */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( (pX->exclMask & mask)!=0 ){ + rc = SQLITE_BUSY; + break; + } + allShared |= pX->sharedMask; + } + + /* Get shared locks at the system level, if necessary */ + if( rc==SQLITE_OK ){ + if( (allShared & mask)==0 ){ + rc = winShmSystemLock(pShmNode, _SHM_RDLCK, ofst+WIN_SHM_BASE, n); + }else{ + rc = SQLITE_OK; + } + } + + /* Get the local shared locks */ + if( rc==SQLITE_OK ){ + p->sharedMask |= mask; + } + }else{ + /* Make sure no sibling connections hold locks that will block this + ** lock. If any do, return SQLITE_BUSY right away. + */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){ + rc = SQLITE_BUSY; + break; + } + } + + /* Get the exclusive locks at the system level. Then if successful + ** also mark the local connection as being locked. + */ + if( rc==SQLITE_OK ){ + rc = winShmSystemLock(pShmNode, _SHM_WRLCK, ofst+WIN_SHM_BASE, n); + if( rc==SQLITE_OK ){ + assert( (p->sharedMask & mask)==0 ); + p->exclMask |= mask; + } + } + } + sqlite3_mutex_leave(pShmNode->mutex); + OSTRACE(("SHM-LOCK pid=%lu, id=%d, sharedMask=%03x, exclMask=%03x, rc=%s\n", + osGetCurrentProcessId(), p->id, p->sharedMask, p->exclMask, + sqlite3ErrName(rc))); + return rc; +} + +/* +** Implement a memory barrier or memory fence on shared memory. +** +** All loads and stores begun before the barrier must complete before +** any load or store begun after the barrier. +*/ +static void winShmBarrier( + sqlite3_file *fd /* Database holding the shared memory */ +){ + UNUSED_PARAMETER(fd); + sqlite3MemoryBarrier(); /* compiler-defined memory barrier */ + winShmEnterMutex(); /* Also mutex, for redundancy */ + winShmLeaveMutex(); +} + +/* +** This function is called to obtain a pointer to region iRegion of the +** shared-memory associated with the database file fd. Shared-memory regions +** are numbered starting from zero. Each shared-memory region is szRegion +** bytes in size. +** +** If an error occurs, an error code is returned and *pp is set to NULL. +** +** Otherwise, if the isWrite parameter is 0 and the requested shared-memory +** region has not been allocated (by any client, including one running in a +** separate process), then *pp is set to NULL and SQLITE_OK returned. If +** isWrite is non-zero and the requested shared-memory region has not yet +** been allocated, it is allocated by this function. +** +** If the shared-memory region has already been allocated or is allocated by +** this call as described above, then it is mapped into this processes +** address space (if it is not already), *pp is set to point to the mapped +** memory and SQLITE_OK returned. +*/ +static int winShmMap( + sqlite3_file *fd, /* Handle open on database file */ + int iRegion, /* Region to retrieve */ + int szRegion, /* Size of regions */ + int isWrite, /* True to extend file if necessary */ + void volatile **pp /* OUT: Mapped memory */ +){ + winFile *pDbFd = (winFile*)fd; + winShm *pShm = pDbFd->pShm; + winShmNode *pShmNode; + int rc = SQLITE_OK; + + if( !pShm ){ + rc = winOpenSharedMemory(pDbFd); + if( rc!=SQLITE_OK ) return rc; + pShm = pDbFd->pShm; + } + pShmNode = pShm->pShmNode; + + sqlite3_mutex_enter(pShmNode->mutex); + assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 ); + + if( pShmNode->nRegion<=iRegion ){ + struct ShmRegion *apNew; /* New aRegion[] array */ + int nByte = (iRegion+1)*szRegion; /* Minimum required file size */ + sqlite3_int64 sz; /* Current size of wal-index file */ + + pShmNode->szRegion = szRegion; + + /* The requested region is not mapped into this processes address space. + ** Check to see if it has been allocated (i.e. if the wal-index file is + ** large enough to contain the requested region). + */ + rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz); + if( rc!=SQLITE_OK ){ + rc = winLogError(SQLITE_IOERR_SHMSIZE, osGetLastError(), + "winShmMap1", pDbFd->zPath); + goto shmpage_out; + } + + if( szhFile, nByte); + if( rc!=SQLITE_OK ){ + rc = winLogError(SQLITE_IOERR_SHMSIZE, osGetLastError(), + "winShmMap2", pDbFd->zPath); + goto shmpage_out; + } + } + + /* Map the requested memory region into this processes address space. */ + apNew = (struct ShmRegion *)sqlite3_realloc64( + pShmNode->aRegion, (iRegion+1)*sizeof(apNew[0]) + ); + if( !apNew ){ + rc = SQLITE_IOERR_NOMEM; + goto shmpage_out; + } + pShmNode->aRegion = apNew; + + while( pShmNode->nRegion<=iRegion ){ + HANDLE hMap = NULL; /* file-mapping handle */ + void *pMap = 0; /* Mapped memory region */ + +#if SQLITE_OS_WINRT + hMap = osCreateFileMappingFromApp(pShmNode->hFile.h, + NULL, PAGE_READWRITE, nByte, NULL + ); +#elif defined(SQLITE_WIN32_HAS_WIDE) + hMap = osCreateFileMappingW(pShmNode->hFile.h, + NULL, PAGE_READWRITE, 0, nByte, NULL + ); +#elif defined(SQLITE_WIN32_HAS_ANSI) + hMap = osCreateFileMappingA(pShmNode->hFile.h, + NULL, PAGE_READWRITE, 0, nByte, NULL + ); +#endif + OSTRACE(("SHM-MAP-CREATE pid=%lu, region=%d, size=%d, rc=%s\n", + osGetCurrentProcessId(), pShmNode->nRegion, nByte, + hMap ? "ok" : "failed")); + if( hMap ){ + int iOffset = pShmNode->nRegion*szRegion; + int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity; +#if SQLITE_OS_WINRT + pMap = osMapViewOfFileFromApp(hMap, FILE_MAP_WRITE | FILE_MAP_READ, + iOffset - iOffsetShift, szRegion + iOffsetShift + ); +#else + pMap = osMapViewOfFile(hMap, FILE_MAP_WRITE | FILE_MAP_READ, + 0, iOffset - iOffsetShift, szRegion + iOffsetShift + ); +#endif + OSTRACE(("SHM-MAP-MAP pid=%lu, region=%d, offset=%d, size=%d, rc=%s\n", + osGetCurrentProcessId(), pShmNode->nRegion, iOffset, + szRegion, pMap ? "ok" : "failed")); + } + if( !pMap ){ + pShmNode->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_SHMMAP, pShmNode->lastErrno, + "winShmMap3", pDbFd->zPath); + if( hMap ) osCloseHandle(hMap); + goto shmpage_out; + } + + pShmNode->aRegion[pShmNode->nRegion].pMap = pMap; + pShmNode->aRegion[pShmNode->nRegion].hMap = hMap; + pShmNode->nRegion++; + } + } + +shmpage_out: + if( pShmNode->nRegion>iRegion ){ + int iOffset = iRegion*szRegion; + int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity; + char *p = (char *)pShmNode->aRegion[iRegion].pMap; + *pp = (void *)&p[iOffsetShift]; + }else{ + *pp = 0; + } + sqlite3_mutex_leave(pShmNode->mutex); + return rc; +} + +#else +# define winShmMap 0 +# define winShmLock 0 +# define winShmBarrier 0 +# define winShmUnmap 0 +#endif /* #ifndef SQLITE_OMIT_WAL */ + +/* +** Cleans up the mapped region of the specified file, if any. +*/ +#if SQLITE_MAX_MMAP_SIZE>0 +static int winUnmapfile(winFile *pFile){ + assert( pFile!=0 ); + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, pMapRegion=%p, " + "mmapSize=%lld, mmapSizeActual=%lld, mmapSizeMax=%lld\n", + osGetCurrentProcessId(), pFile, pFile->hMap, pFile->pMapRegion, + pFile->mmapSize, pFile->mmapSizeActual, pFile->mmapSizeMax)); + if( pFile->pMapRegion ){ + if( !osUnmapViewOfFile(pFile->pMapRegion) ){ + pFile->lastErrno = osGetLastError(); + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, pMapRegion=%p, " + "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), pFile, + pFile->pMapRegion)); + return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, + "winUnmapfile1", pFile->zPath); + } + pFile->pMapRegion = 0; + pFile->mmapSize = 0; + pFile->mmapSizeActual = 0; + } + if( pFile->hMap!=NULL ){ + if( !osCloseHandle(pFile->hMap) ){ + pFile->lastErrno = osGetLastError(); + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, rc=SQLITE_IOERR_MMAP\n", + osGetCurrentProcessId(), pFile, pFile->hMap)); + return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, + "winUnmapfile2", pFile->zPath); + } + pFile->hMap = NULL; + } + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile)); + return SQLITE_OK; +} + +/* +** Memory map or remap the file opened by file-descriptor pFd (if the file +** is already mapped, the existing mapping is replaced by the new). Or, if +** there already exists a mapping for this file, and there are still +** outstanding xFetch() references to it, this function is a no-op. +** +** If parameter nByte is non-negative, then it is the requested size of +** the mapping to create. Otherwise, if nByte is less than zero, then the +** requested size is the size of the file on disk. The actual size of the +** created mapping is either the requested size or the value configured +** using SQLITE_FCNTL_MMAP_SIZE, whichever is smaller. +** +** SQLITE_OK is returned if no error occurs (even if the mapping is not +** recreated as a result of outstanding references) or an SQLite error +** code otherwise. +*/ +static int winMapfile(winFile *pFd, sqlite3_int64 nByte){ + sqlite3_int64 nMap = nByte; + int rc; + + assert( nMap>=0 || pFd->nFetchOut==0 ); + OSTRACE(("MAP-FILE pid=%lu, pFile=%p, size=%lld\n", + osGetCurrentProcessId(), pFd, nByte)); + + if( pFd->nFetchOut>0 ) return SQLITE_OK; + + if( nMap<0 ){ + rc = winFileSize((sqlite3_file*)pFd, &nMap); + if( rc ){ + OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_IOERR_FSTAT\n", + osGetCurrentProcessId(), pFd)); + return SQLITE_IOERR_FSTAT; + } + } + if( nMap>pFd->mmapSizeMax ){ + nMap = pFd->mmapSizeMax; + } + nMap &= ~(sqlite3_int64)(winSysInfo.dwPageSize - 1); + + if( nMap==0 && pFd->mmapSize>0 ){ + winUnmapfile(pFd); + } + if( nMap!=pFd->mmapSize ){ + void *pNew = 0; + DWORD protect = PAGE_READONLY; + DWORD flags = FILE_MAP_READ; + + winUnmapfile(pFd); + if( (pFd->ctrlFlags & WINFILE_RDONLY)==0 ){ + protect = PAGE_READWRITE; + flags |= FILE_MAP_WRITE; + } +#if SQLITE_OS_WINRT + pFd->hMap = osCreateFileMappingFromApp(pFd->h, NULL, protect, nMap, NULL); +#elif defined(SQLITE_WIN32_HAS_WIDE) + pFd->hMap = osCreateFileMappingW(pFd->h, NULL, protect, + (DWORD)((nMap>>32) & 0xffffffff), + (DWORD)(nMap & 0xffffffff), NULL); +#elif defined(SQLITE_WIN32_HAS_ANSI) + pFd->hMap = osCreateFileMappingA(pFd->h, NULL, protect, + (DWORD)((nMap>>32) & 0xffffffff), + (DWORD)(nMap & 0xffffffff), NULL); +#endif + if( pFd->hMap==NULL ){ + pFd->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno, + "winMapfile1", pFd->zPath); + /* Log the error, but continue normal operation using xRead/xWrite */ + OSTRACE(("MAP-FILE-CREATE pid=%lu, pFile=%p, rc=%s\n", + osGetCurrentProcessId(), pFd, sqlite3ErrName(rc))); + return SQLITE_OK; + } + assert( (nMap % winSysInfo.dwPageSize)==0 ); + assert( sizeof(SIZE_T)==sizeof(sqlite3_int64) || nMap<=0xffffffff ); +#if SQLITE_OS_WINRT + pNew = osMapViewOfFileFromApp(pFd->hMap, flags, 0, (SIZE_T)nMap); +#else + pNew = osMapViewOfFile(pFd->hMap, flags, 0, 0, (SIZE_T)nMap); +#endif + if( pNew==NULL ){ + osCloseHandle(pFd->hMap); + pFd->hMap = NULL; + pFd->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno, + "winMapfile2", pFd->zPath); + /* Log the error, but continue normal operation using xRead/xWrite */ + OSTRACE(("MAP-FILE-MAP pid=%lu, pFile=%p, rc=%s\n", + osGetCurrentProcessId(), pFd, sqlite3ErrName(rc))); + return SQLITE_OK; + } + pFd->pMapRegion = pNew; + pFd->mmapSize = nMap; + pFd->mmapSizeActual = nMap; + } + + OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFd)); + return SQLITE_OK; +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* +** If possible, return a pointer to a mapping of file fd starting at offset +** iOff. The mapping must be valid for at least nAmt bytes. +** +** If such a pointer can be obtained, store it in *pp and return SQLITE_OK. +** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK. +** Finally, if an error does occur, return an SQLite error code. The final +** value of *pp is undefined in this case. +** +** If this function does return a pointer, the caller must eventually +** release the reference by calling winUnfetch(). +*/ +static int winFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){ +#if SQLITE_MAX_MMAP_SIZE>0 + winFile *pFd = (winFile*)fd; /* The underlying database file */ +#endif + *pp = 0; + + OSTRACE(("FETCH pid=%lu, pFile=%p, offset=%lld, amount=%d, pp=%p\n", + osGetCurrentProcessId(), fd, iOff, nAmt, pp)); + +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFd->mmapSizeMax>0 ){ + if( pFd->pMapRegion==0 ){ + int rc = winMapfile(pFd, -1); + if( rc!=SQLITE_OK ){ + OSTRACE(("FETCH pid=%lu, pFile=%p, rc=%s\n", + osGetCurrentProcessId(), pFd, sqlite3ErrName(rc))); + return rc; + } + } + if( pFd->mmapSize >= iOff+nAmt ){ + *pp = &((u8 *)pFd->pMapRegion)[iOff]; + pFd->nFetchOut++; + } + } +#endif + + OSTRACE(("FETCH pid=%lu, pFile=%p, pp=%p, *pp=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), fd, pp, *pp)); + return SQLITE_OK; +} + +/* +** If the third argument is non-NULL, then this function releases a +** reference obtained by an earlier call to winFetch(). The second +** argument passed to this function must be the same as the corresponding +** argument that was passed to the winFetch() invocation. +** +** Or, if the third argument is NULL, then this function is being called +** to inform the VFS layer that, according to POSIX, any existing mapping +** may now be invalid and should be unmapped. +*/ +static int winUnfetch(sqlite3_file *fd, i64 iOff, void *p){ +#if SQLITE_MAX_MMAP_SIZE>0 + winFile *pFd = (winFile*)fd; /* The underlying database file */ + + /* If p==0 (unmap the entire file) then there must be no outstanding + ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference), + ** then there must be at least one outstanding. */ + assert( (p==0)==(pFd->nFetchOut==0) ); + + /* If p!=0, it must match the iOff value. */ + assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] ); + + OSTRACE(("UNFETCH pid=%lu, pFile=%p, offset=%lld, p=%p\n", + osGetCurrentProcessId(), pFd, iOff, p)); + + if( p ){ + pFd->nFetchOut--; + }else{ + /* FIXME: If Windows truly always prevents truncating or deleting a + ** file while a mapping is held, then the following winUnmapfile() call + ** is unnecessary can be omitted - potentially improving + ** performance. */ + winUnmapfile(pFd); + } + + assert( pFd->nFetchOut>=0 ); +#endif + + OSTRACE(("UNFETCH pid=%lu, pFile=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), fd)); + return SQLITE_OK; +} + +/* +** Here ends the implementation of all sqlite3_file methods. +** +********************** End sqlite3_file Methods ******************************* +******************************************************************************/ + +/* +** This vector defines all the methods that can operate on an +** sqlite3_file for win32. +*/ +static const sqlite3_io_methods winIoMethod = { + 3, /* iVersion */ + winClose, /* xClose */ + winRead, /* xRead */ + winWrite, /* xWrite */ + winTruncate, /* xTruncate */ + winSync, /* xSync */ + winFileSize, /* xFileSize */ + winLock, /* xLock */ + winUnlock, /* xUnlock */ + winCheckReservedLock, /* xCheckReservedLock */ + winFileControl, /* xFileControl */ + winSectorSize, /* xSectorSize */ + winDeviceCharacteristics, /* xDeviceCharacteristics */ + winShmMap, /* xShmMap */ + winShmLock, /* xShmLock */ + winShmBarrier, /* xShmBarrier */ + winShmUnmap, /* xShmUnmap */ + winFetch, /* xFetch */ + winUnfetch /* xUnfetch */ +}; + +/**************************************************************************** +**************************** sqlite3_vfs methods **************************** +** +** This division contains the implementation of methods on the +** sqlite3_vfs object. +*/ + +#if defined(__CYGWIN__) +/* +** Convert a filename from whatever the underlying operating system +** supports for filenames into UTF-8. Space to hold the result is +** obtained from malloc and must be freed by the calling function. +*/ +static char *winConvertToUtf8Filename(const void *zFilename){ + char *zConverted = 0; + if( osIsNT() ){ + zConverted = winUnicodeToUtf8(zFilename); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + zConverted = sqlite3_win32_mbcs_to_utf8(zFilename); + } +#endif + /* caller will handle out of memory */ + return zConverted; +} +#endif + +/* +** Convert a UTF-8 filename into whatever form the underlying +** operating system wants filenames in. Space to hold the result +** is obtained from malloc and must be freed by the calling +** function. +*/ +static void *winConvertFromUtf8Filename(const char *zFilename){ + void *zConverted = 0; + if( osIsNT() ){ + zConverted = winUtf8ToUnicode(zFilename); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + zConverted = sqlite3_win32_utf8_to_mbcs(zFilename); + } +#endif + /* caller will handle out of memory */ + return zConverted; +} + +/* +** This function returns non-zero if the specified UTF-8 string buffer +** ends with a directory separator character or one was successfully +** added to it. +*/ +static int winMakeEndInDirSep(int nBuf, char *zBuf){ + if( zBuf ){ + int nLen = sqlite3Strlen30(zBuf); + if( nLen>0 ){ + if( winIsDirSep(zBuf[nLen-1]) ){ + return 1; + }else if( nLen+1mxPathname; nBuf = nMax + 2; + zBuf = sqlite3MallocZero( nBuf ); + if( !zBuf ){ + OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n")); + return SQLITE_IOERR_NOMEM; + } + + /* Figure out the effective temporary directory. First, check if one + ** has been explicitly set by the application; otherwise, use the one + ** configured by the operating system. + */ + nDir = nMax - (nPre + 15); + assert( nDir>0 ); + if( sqlite3_temp_directory ){ + int nDirLen = sqlite3Strlen30(sqlite3_temp_directory); + if( nDirLen>0 ){ + if( !winIsDirSep(sqlite3_temp_directory[nDirLen-1]) ){ + nDirLen++; + } + if( nDirLen>nDir ){ + sqlite3_free(zBuf); + OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n")); + return winLogError(SQLITE_ERROR, 0, "winGetTempname1", 0); + } + sqlite3_snprintf(nMax, zBuf, "%s", sqlite3_temp_directory); + } + } +#if defined(__CYGWIN__) + else{ + static const char *azDirs[] = { + 0, /* getenv("SQLITE_TMPDIR") */ + 0, /* getenv("TMPDIR") */ + 0, /* getenv("TMP") */ + 0, /* getenv("TEMP") */ + 0, /* getenv("USERPROFILE") */ + "/var/tmp", + "/usr/tmp", + "/tmp", + ".", + 0 /* List terminator */ + }; + unsigned int i; + const char *zDir = 0; + + if( !azDirs[0] ) azDirs[0] = getenv("SQLITE_TMPDIR"); + if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR"); + if( !azDirs[2] ) azDirs[2] = getenv("TMP"); + if( !azDirs[3] ) azDirs[3] = getenv("TEMP"); + if( !azDirs[4] ) azDirs[4] = getenv("USERPROFILE"); + for(i=0; i/etilqs_XXXXXXXXXXXXXXX\0\0" + ** + ** If not, return SQLITE_ERROR. The number 17 is used here in order to + ** account for the space used by the 15 character random suffix and the + ** two trailing NUL characters. The final directory separator character + ** has already added if it was not already present. + */ + nLen = sqlite3Strlen30(zBuf); + if( (nLen + nPre + 17) > nBuf ){ + sqlite3_free(zBuf); + OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n")); + return winLogError(SQLITE_ERROR, 0, "winGetTempname5", 0); + } + + sqlite3_snprintf(nBuf-16-nLen, zBuf+nLen, SQLITE_TEMP_FILE_PREFIX); + + j = sqlite3Strlen30(zBuf); + sqlite3_randomness(15, &zBuf[j]); + for(i=0; i<15; i++, j++){ + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; + } + zBuf[j] = 0; + zBuf[j+1] = 0; + *pzBuf = zBuf; + + OSTRACE(("TEMP-FILENAME name=%s, rc=SQLITE_OK\n", zBuf)); + return SQLITE_OK; +} + +/* +** Return TRUE if the named file is really a directory. Return false if +** it is something other than a directory, or if there is any kind of memory +** allocation failure. +*/ +static int winIsDir(const void *zConverted){ + DWORD attr; + int rc = 0; + DWORD lastErrno; + + if( osIsNT() ){ + int cnt = 0; + WIN32_FILE_ATTRIBUTE_DATA sAttrData; + memset(&sAttrData, 0, sizeof(sAttrData)); + while( !(rc = osGetFileAttributesExW((LPCWSTR)zConverted, + GetFileExInfoStandard, + &sAttrData)) && winRetryIoerr(&cnt, &lastErrno) ){} + if( !rc ){ + return 0; /* Invalid name? */ + } + attr = sAttrData.dwFileAttributes; +#if SQLITE_OS_WINCE==0 + }else{ + attr = osGetFileAttributesA((char*)zConverted); +#endif + } + return (attr!=INVALID_FILE_ATTRIBUTES) && (attr&FILE_ATTRIBUTE_DIRECTORY); +} + +/* +** Open a file. +*/ +static int winOpen( + sqlite3_vfs *pVfs, /* Used to get maximum path name length */ + const char *zName, /* Name of the file (UTF-8) */ + sqlite3_file *id, /* Write the SQLite file handle here */ + int flags, /* Open mode flags */ + int *pOutFlags /* Status return flags */ +){ + HANDLE h; + DWORD lastErrno = 0; + DWORD dwDesiredAccess; + DWORD dwShareMode; + DWORD dwCreationDisposition; + DWORD dwFlagsAndAttributes = 0; +#if SQLITE_OS_WINCE + int isTemp = 0; +#endif + winFile *pFile = (winFile*)id; + void *zConverted; /* Filename in OS encoding */ + const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */ + int cnt = 0; + + /* If argument zPath is a NULL pointer, this function is required to open + ** a temporary file. Use this buffer to store the file name in. + */ + char *zTmpname = 0; /* For temporary filename, if necessary. */ + + int rc = SQLITE_OK; /* Function Return Code */ +#if !defined(NDEBUG) || SQLITE_OS_WINCE + int eType = flags&0xFFFFFF00; /* Type of file to open */ +#endif + + int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE); + int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE); + int isCreate = (flags & SQLITE_OPEN_CREATE); + int isReadonly = (flags & SQLITE_OPEN_READONLY); + int isReadWrite = (flags & SQLITE_OPEN_READWRITE); + +#ifndef NDEBUG + int isOpenJournal = (isCreate && ( + eType==SQLITE_OPEN_MASTER_JOURNAL + || eType==SQLITE_OPEN_MAIN_JOURNAL + || eType==SQLITE_OPEN_WAL + )); +#endif + + OSTRACE(("OPEN name=%s, pFile=%p, flags=%x, pOutFlags=%p\n", + zUtf8Name, id, flags, pOutFlags)); + + /* Check the following statements are true: + ** + ** (a) Exactly one of the READWRITE and READONLY flags must be set, and + ** (b) if CREATE is set, then READWRITE must also be set, and + ** (c) if EXCLUSIVE is set, then CREATE must also be set. + ** (d) if DELETEONCLOSE is set, then CREATE must also be set. + */ + assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly)); + assert(isCreate==0 || isReadWrite); + assert(isExclusive==0 || isCreate); + assert(isDelete==0 || isCreate); + + /* The main DB, main journal, WAL file and master journal are never + ** automatically deleted. Nor are they ever temporary files. */ + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL ); + + /* Assert that the upper layer has set one of the "file-type" flags. */ + assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB + || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL + || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL + || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL + ); + + assert( pFile!=0 ); + memset(pFile, 0, sizeof(winFile)); + pFile->h = INVALID_HANDLE_VALUE; + +#if SQLITE_OS_WINRT + if( !zUtf8Name && !sqlite3_temp_directory ){ + sqlite3_log(SQLITE_ERROR, + "sqlite3_temp_directory variable should be set for WinRT"); + } +#endif + + /* If the second argument to this function is NULL, generate a + ** temporary file name to use + */ + if( !zUtf8Name ){ + assert( isDelete && !isOpenJournal ); + rc = winGetTempname(pVfs, &zTmpname); + if( rc!=SQLITE_OK ){ + OSTRACE(("OPEN name=%s, rc=%s", zUtf8Name, sqlite3ErrName(rc))); + return rc; + } + zUtf8Name = zTmpname; + } + + /* Database filenames are double-zero terminated if they are not + ** URIs with parameters. Hence, they can always be passed into + ** sqlite3_uri_parameter(). + */ + assert( (eType!=SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_URI) || + zUtf8Name[sqlite3Strlen30(zUtf8Name)+1]==0 ); + + /* Convert the filename to the system encoding. */ + zConverted = winConvertFromUtf8Filename(zUtf8Name); + if( zConverted==0 ){ + sqlite3_free(zTmpname); + OSTRACE(("OPEN name=%s, rc=SQLITE_IOERR_NOMEM", zUtf8Name)); + return SQLITE_IOERR_NOMEM; + } + + if( winIsDir(zConverted) ){ + sqlite3_free(zConverted); + sqlite3_free(zTmpname); + OSTRACE(("OPEN name=%s, rc=SQLITE_CANTOPEN_ISDIR", zUtf8Name)); + return SQLITE_CANTOPEN_ISDIR; + } + + if( isReadWrite ){ + dwDesiredAccess = GENERIC_READ | GENERIC_WRITE; + }else{ + dwDesiredAccess = GENERIC_READ; + } + + /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is + ** created. SQLite doesn't use it to indicate "exclusive access" + ** as it is usually understood. + */ + if( isExclusive ){ + /* Creates a new file, only if it does not already exist. */ + /* If the file exists, it fails. */ + dwCreationDisposition = CREATE_NEW; + }else if( isCreate ){ + /* Open existing file, or create if it doesn't exist */ + dwCreationDisposition = OPEN_ALWAYS; + }else{ + /* Opens a file, only if it exists. */ + dwCreationDisposition = OPEN_EXISTING; + } + + dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; + + if( isDelete ){ +#if SQLITE_OS_WINCE + dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN; + isTemp = 1; +#else + dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY + | FILE_ATTRIBUTE_HIDDEN + | FILE_FLAG_DELETE_ON_CLOSE; +#endif + }else{ + dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL; + } + /* Reports from the internet are that performance is always + ** better if FILE_FLAG_RANDOM_ACCESS is used. Ticket #2699. */ +#if SQLITE_OS_WINCE + dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS; +#endif + + if( osIsNT() ){ +#if SQLITE_OS_WINRT + CREATEFILE2_EXTENDED_PARAMETERS extendedParameters; + extendedParameters.dwSize = sizeof(CREATEFILE2_EXTENDED_PARAMETERS); + extendedParameters.dwFileAttributes = + dwFlagsAndAttributes & FILE_ATTRIBUTE_MASK; + extendedParameters.dwFileFlags = dwFlagsAndAttributes & FILE_FLAG_MASK; + extendedParameters.dwSecurityQosFlags = SECURITY_ANONYMOUS; + extendedParameters.lpSecurityAttributes = NULL; + extendedParameters.hTemplateFile = NULL; + while( (h = osCreateFile2((LPCWSTR)zConverted, + dwDesiredAccess, + dwShareMode, + dwCreationDisposition, + &extendedParameters))==INVALID_HANDLE_VALUE && + winRetryIoerr(&cnt, &lastErrno) ){ + /* Noop */ + } +#else + while( (h = osCreateFileW((LPCWSTR)zConverted, + dwDesiredAccess, + dwShareMode, NULL, + dwCreationDisposition, + dwFlagsAndAttributes, + NULL))==INVALID_HANDLE_VALUE && + winRetryIoerr(&cnt, &lastErrno) ){ + /* Noop */ + } +#endif + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + while( (h = osCreateFileA((LPCSTR)zConverted, + dwDesiredAccess, + dwShareMode, NULL, + dwCreationDisposition, + dwFlagsAndAttributes, + NULL))==INVALID_HANDLE_VALUE && + winRetryIoerr(&cnt, &lastErrno) ){ + /* Noop */ + } + } +#endif + winLogIoerr(cnt, __LINE__); + + OSTRACE(("OPEN file=%p, name=%s, access=%lx, rc=%s\n", h, zUtf8Name, + dwDesiredAccess, (h==INVALID_HANDLE_VALUE) ? "failed" : "ok")); + + if( h==INVALID_HANDLE_VALUE ){ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_CANTOPEN, pFile->lastErrno, "winOpen", zUtf8Name); + sqlite3_free(zConverted); + sqlite3_free(zTmpname); + if( isReadWrite && !isExclusive ){ + return winOpen(pVfs, zName, id, + ((flags|SQLITE_OPEN_READONLY) & + ~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE)), + pOutFlags); + }else{ + return SQLITE_CANTOPEN_BKPT; + } + } + + if( pOutFlags ){ + if( isReadWrite ){ + *pOutFlags = SQLITE_OPEN_READWRITE; + }else{ + *pOutFlags = SQLITE_OPEN_READONLY; + } + } + + OSTRACE(("OPEN file=%p, name=%s, access=%lx, pOutFlags=%p, *pOutFlags=%d, " + "rc=%s\n", h, zUtf8Name, dwDesiredAccess, pOutFlags, pOutFlags ? + *pOutFlags : 0, (h==INVALID_HANDLE_VALUE) ? "failed" : "ok")); + +#if SQLITE_OS_WINCE + if( isReadWrite && eType==SQLITE_OPEN_MAIN_DB + && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK + ){ + osCloseHandle(h); + sqlite3_free(zConverted); + sqlite3_free(zTmpname); + OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc))); + return rc; + } + if( isTemp ){ + pFile->zDeleteOnClose = zConverted; + }else +#endif + { + sqlite3_free(zConverted); + } + + sqlite3_free(zTmpname); + pFile->pMethod = &winIoMethod; + pFile->pVfs = pVfs; + pFile->h = h; + if( isReadonly ){ + pFile->ctrlFlags |= WINFILE_RDONLY; + } + if( sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE) ){ + pFile->ctrlFlags |= WINFILE_PSOW; + } + pFile->lastErrno = NO_ERROR; + pFile->zPath = zName; +#if SQLITE_MAX_MMAP_SIZE>0 + pFile->hMap = NULL; + pFile->pMapRegion = 0; + pFile->mmapSize = 0; + pFile->mmapSizeActual = 0; + pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap; +#endif + + OpenCounter(+1); + return rc; +} + +/* +** Delete the named file. +** +** Note that Windows does not allow a file to be deleted if some other +** process has it open. Sometimes a virus scanner or indexing program +** will open a journal file shortly after it is created in order to do +** whatever it does. While this other process is holding the +** file open, we will be unable to delete it. To work around this +** problem, we delay 100 milliseconds and try to delete again. Up +** to MX_DELETION_ATTEMPTs deletion attempts are run before giving +** up and returning an error. +*/ +static int winDelete( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to delete */ + int syncDir /* Not used on win32 */ +){ + int cnt = 0; + int rc; + DWORD attr; + DWORD lastErrno = 0; + void *zConverted; + UNUSED_PARAMETER(pVfs); + UNUSED_PARAMETER(syncDir); + + SimulateIOError(return SQLITE_IOERR_DELETE); + OSTRACE(("DELETE name=%s, syncDir=%d\n", zFilename, syncDir)); + + zConverted = winConvertFromUtf8Filename(zFilename); + if( zConverted==0 ){ + OSTRACE(("DELETE name=%s, rc=SQLITE_IOERR_NOMEM\n", zFilename)); + return SQLITE_IOERR_NOMEM; + } + if( osIsNT() ){ + do { +#if SQLITE_OS_WINRT + WIN32_FILE_ATTRIBUTE_DATA sAttrData; + memset(&sAttrData, 0, sizeof(sAttrData)); + if ( osGetFileAttributesExW(zConverted, GetFileExInfoStandard, + &sAttrData) ){ + attr = sAttrData.dwFileAttributes; + }else{ + lastErrno = osGetLastError(); + if( lastErrno==ERROR_FILE_NOT_FOUND + || lastErrno==ERROR_PATH_NOT_FOUND ){ + rc = SQLITE_IOERR_DELETE_NOENT; /* Already gone? */ + }else{ + rc = SQLITE_ERROR; + } + break; + } +#else + attr = osGetFileAttributesW(zConverted); +#endif + if ( attr==INVALID_FILE_ATTRIBUTES ){ + lastErrno = osGetLastError(); + if( lastErrno==ERROR_FILE_NOT_FOUND + || lastErrno==ERROR_PATH_NOT_FOUND ){ + rc = SQLITE_IOERR_DELETE_NOENT; /* Already gone? */ + }else{ + rc = SQLITE_ERROR; + } + break; + } + if ( attr&FILE_ATTRIBUTE_DIRECTORY ){ + rc = SQLITE_ERROR; /* Files only. */ + break; + } + if ( osDeleteFileW(zConverted) ){ + rc = SQLITE_OK; /* Deleted OK. */ + break; + } + if ( !winRetryIoerr(&cnt, &lastErrno) ){ + rc = SQLITE_ERROR; /* No more retries. */ + break; + } + } while(1); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + do { + attr = osGetFileAttributesA(zConverted); + if ( attr==INVALID_FILE_ATTRIBUTES ){ + lastErrno = osGetLastError(); + if( lastErrno==ERROR_FILE_NOT_FOUND + || lastErrno==ERROR_PATH_NOT_FOUND ){ + rc = SQLITE_IOERR_DELETE_NOENT; /* Already gone? */ + }else{ + rc = SQLITE_ERROR; + } + break; + } + if ( attr&FILE_ATTRIBUTE_DIRECTORY ){ + rc = SQLITE_ERROR; /* Files only. */ + break; + } + if ( osDeleteFileA(zConverted) ){ + rc = SQLITE_OK; /* Deleted OK. */ + break; + } + if ( !winRetryIoerr(&cnt, &lastErrno) ){ + rc = SQLITE_ERROR; /* No more retries. */ + break; + } + } while(1); + } +#endif + if( rc && rc!=SQLITE_IOERR_DELETE_NOENT ){ + rc = winLogError(SQLITE_IOERR_DELETE, lastErrno, "winDelete", zFilename); + }else{ + winLogIoerr(cnt, __LINE__); + } + sqlite3_free(zConverted); + OSTRACE(("DELETE name=%s, rc=%s\n", zFilename, sqlite3ErrName(rc))); + return rc; +} + +/* +** Check the existence and status of a file. +*/ +static int winAccess( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to check */ + int flags, /* Type of test to make on this file */ + int *pResOut /* OUT: Result */ +){ + DWORD attr; + int rc = 0; + DWORD lastErrno = 0; + void *zConverted; + UNUSED_PARAMETER(pVfs); + + SimulateIOError( return SQLITE_IOERR_ACCESS; ); + OSTRACE(("ACCESS name=%s, flags=%x, pResOut=%p\n", + zFilename, flags, pResOut)); + + zConverted = winConvertFromUtf8Filename(zFilename); + if( zConverted==0 ){ + OSTRACE(("ACCESS name=%s, rc=SQLITE_IOERR_NOMEM\n", zFilename)); + return SQLITE_IOERR_NOMEM; + } + if( osIsNT() ){ + int cnt = 0; + WIN32_FILE_ATTRIBUTE_DATA sAttrData; + memset(&sAttrData, 0, sizeof(sAttrData)); + while( !(rc = osGetFileAttributesExW((LPCWSTR)zConverted, + GetFileExInfoStandard, + &sAttrData)) && winRetryIoerr(&cnt, &lastErrno) ){} + if( rc ){ + /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file + ** as if it does not exist. + */ + if( flags==SQLITE_ACCESS_EXISTS + && sAttrData.nFileSizeHigh==0 + && sAttrData.nFileSizeLow==0 ){ + attr = INVALID_FILE_ATTRIBUTES; + }else{ + attr = sAttrData.dwFileAttributes; + } + }else{ + winLogIoerr(cnt, __LINE__); + if( lastErrno!=ERROR_FILE_NOT_FOUND && lastErrno!=ERROR_PATH_NOT_FOUND ){ + sqlite3_free(zConverted); + return winLogError(SQLITE_IOERR_ACCESS, lastErrno, "winAccess", + zFilename); + }else{ + attr = INVALID_FILE_ATTRIBUTES; + } + } + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + attr = osGetFileAttributesA((char*)zConverted); + } +#endif + sqlite3_free(zConverted); + switch( flags ){ + case SQLITE_ACCESS_READ: + case SQLITE_ACCESS_EXISTS: + rc = attr!=INVALID_FILE_ATTRIBUTES; + break; + case SQLITE_ACCESS_READWRITE: + rc = attr!=INVALID_FILE_ATTRIBUTES && + (attr & FILE_ATTRIBUTE_READONLY)==0; + break; + default: + assert(!"Invalid flags argument"); + } + *pResOut = rc; + OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n", + zFilename, pResOut, *pResOut)); + return SQLITE_OK; +} + +/* +** Returns non-zero if the specified path name starts with a drive letter +** followed by a colon character. +*/ +static BOOL winIsDriveLetterAndColon( + const char *zPathname +){ + return ( sqlite3Isalpha(zPathname[0]) && zPathname[1]==':' ); +} + +/* +** Returns non-zero if the specified path name should be used verbatim. If +** non-zero is returned from this function, the calling function must simply +** use the provided path name verbatim -OR- resolve it into a full path name +** using the GetFullPathName Win32 API function (if available). +*/ +static BOOL winIsVerbatimPathname( + const char *zPathname +){ + /* + ** If the path name starts with a forward slash or a backslash, it is either + ** a legal UNC name, a volume relative path, or an absolute path name in the + ** "Unix" format on Windows. There is no easy way to differentiate between + ** the final two cases; therefore, we return the safer return value of TRUE + ** so that callers of this function will simply use it verbatim. + */ + if ( winIsDirSep(zPathname[0]) ){ + return TRUE; + } + + /* + ** If the path name starts with a letter and a colon it is either a volume + ** relative path or an absolute path. Callers of this function must not + ** attempt to treat it as a relative path name (i.e. they should simply use + ** it verbatim). + */ + if ( winIsDriveLetterAndColon(zPathname) ){ + return TRUE; + } + + /* + ** If we get to this point, the path name should almost certainly be a purely + ** relative one (i.e. not a UNC name, not absolute, and not volume relative). + */ + return FALSE; +} + +/* +** Turn a relative pathname into a full pathname. Write the full +** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname +** bytes in size. +*/ +static int winFullPathname( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zRelative, /* Possibly relative input path */ + int nFull, /* Size of output buffer in bytes */ + char *zFull /* Output buffer */ +){ + +#if defined(__CYGWIN__) + SimulateIOError( return SQLITE_ERROR ); + UNUSED_PARAMETER(nFull); + assert( nFull>=pVfs->mxPathname ); + if ( sqlite3_data_directory && !winIsVerbatimPathname(zRelative) ){ + /* + ** NOTE: We are dealing with a relative path name and the data + ** directory has been set. Therefore, use it as the basis + ** for converting the relative path name to an absolute + ** one by prepending the data directory and a slash. + */ + char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 ); + if( !zOut ){ + return SQLITE_IOERR_NOMEM; + } + if( cygwin_conv_path( + (osIsNT() ? CCP_POSIX_TO_WIN_W : CCP_POSIX_TO_WIN_A) | + CCP_RELATIVE, zRelative, zOut, pVfs->mxPathname+1)<0 ){ + sqlite3_free(zOut); + return winLogError(SQLITE_CANTOPEN_CONVPATH, (DWORD)errno, + "winFullPathname1", zRelative); + }else{ + char *zUtf8 = winConvertToUtf8Filename(zOut); + if( !zUtf8 ){ + sqlite3_free(zOut); + return SQLITE_IOERR_NOMEM; + } + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s", + sqlite3_data_directory, winGetDirSep(), zUtf8); + sqlite3_free(zUtf8); + sqlite3_free(zOut); + } + }else{ + char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 ); + if( !zOut ){ + return SQLITE_IOERR_NOMEM; + } + if( cygwin_conv_path( + (osIsNT() ? CCP_POSIX_TO_WIN_W : CCP_POSIX_TO_WIN_A), + zRelative, zOut, pVfs->mxPathname+1)<0 ){ + sqlite3_free(zOut); + return winLogError(SQLITE_CANTOPEN_CONVPATH, (DWORD)errno, + "winFullPathname2", zRelative); + }else{ + char *zUtf8 = winConvertToUtf8Filename(zOut); + if( !zUtf8 ){ + sqlite3_free(zOut); + return SQLITE_IOERR_NOMEM; + } + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zUtf8); + sqlite3_free(zUtf8); + sqlite3_free(zOut); + } + } + return SQLITE_OK; +#endif + +#if (SQLITE_OS_WINCE || SQLITE_OS_WINRT) && !defined(__CYGWIN__) + SimulateIOError( return SQLITE_ERROR ); + /* WinCE has no concept of a relative pathname, or so I am told. */ + /* WinRT has no way to convert a relative path to an absolute one. */ + if ( sqlite3_data_directory && !winIsVerbatimPathname(zRelative) ){ + /* + ** NOTE: We are dealing with a relative path name and the data + ** directory has been set. Therefore, use it as the basis + ** for converting the relative path name to an absolute + ** one by prepending the data directory and a backslash. + */ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s", + sqlite3_data_directory, winGetDirSep(), zRelative); + }else{ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zRelative); + } + return SQLITE_OK; +#endif + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && !defined(__CYGWIN__) + DWORD nByte; + void *zConverted; + char *zOut; + + /* If this path name begins with "/X:", where "X" is any alphabetic + ** character, discard the initial "/" from the pathname. + */ + if( zRelative[0]=='/' && winIsDriveLetterAndColon(zRelative+1) ){ + zRelative++; + } + + /* It's odd to simulate an io-error here, but really this is just + ** using the io-error infrastructure to test that SQLite handles this + ** function failing. This function could fail if, for example, the + ** current working directory has been unlinked. + */ + SimulateIOError( return SQLITE_ERROR ); + if ( sqlite3_data_directory && !winIsVerbatimPathname(zRelative) ){ + /* + ** NOTE: We are dealing with a relative path name and the data + ** directory has been set. Therefore, use it as the basis + ** for converting the relative path name to an absolute + ** one by prepending the data directory and a backslash. + */ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s", + sqlite3_data_directory, winGetDirSep(), zRelative); + return SQLITE_OK; + } + zConverted = winConvertFromUtf8Filename(zRelative); + if( zConverted==0 ){ + return SQLITE_IOERR_NOMEM; + } + if( osIsNT() ){ + LPWSTR zTemp; + nByte = osGetFullPathNameW((LPCWSTR)zConverted, 0, 0, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname1", zRelative); + } + nByte += 3; + zTemp = sqlite3MallocZero( nByte*sizeof(zTemp[0]) ); + if( zTemp==0 ){ + sqlite3_free(zConverted); + return SQLITE_IOERR_NOMEM; + } + nByte = osGetFullPathNameW((LPCWSTR)zConverted, nByte, zTemp, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + sqlite3_free(zTemp); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname2", zRelative); + } + sqlite3_free(zConverted); + zOut = winUnicodeToUtf8(zTemp); + sqlite3_free(zTemp); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + char *zTemp; + nByte = osGetFullPathNameA((char*)zConverted, 0, 0, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname3", zRelative); + } + nByte += 3; + zTemp = sqlite3MallocZero( nByte*sizeof(zTemp[0]) ); + if( zTemp==0 ){ + sqlite3_free(zConverted); + return SQLITE_IOERR_NOMEM; + } + nByte = osGetFullPathNameA((char*)zConverted, nByte, zTemp, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + sqlite3_free(zTemp); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname4", zRelative); + } + sqlite3_free(zConverted); + zOut = sqlite3_win32_mbcs_to_utf8(zTemp); + sqlite3_free(zTemp); + } +#endif + if( zOut ){ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut); + sqlite3_free(zOut); + return SQLITE_OK; + }else{ + return SQLITE_IOERR_NOMEM; + } +#endif +} + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** Interfaces for opening a shared library, finding entry points +** within the shared library, and closing the shared library. +*/ +static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){ + HANDLE h; +#if defined(__CYGWIN__) + int nFull = pVfs->mxPathname+1; + char *zFull = sqlite3MallocZero( nFull ); + void *zConverted = 0; + if( zFull==0 ){ + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0)); + return 0; + } + if( winFullPathname(pVfs, zFilename, nFull, zFull)!=SQLITE_OK ){ + sqlite3_free(zFull); + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0)); + return 0; + } + zConverted = winConvertFromUtf8Filename(zFull); + sqlite3_free(zFull); +#else + void *zConverted = winConvertFromUtf8Filename(zFilename); + UNUSED_PARAMETER(pVfs); +#endif + if( zConverted==0 ){ + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0)); + return 0; + } + if( osIsNT() ){ +#if SQLITE_OS_WINRT + h = osLoadPackagedLibrary((LPCWSTR)zConverted, 0); +#else + h = osLoadLibraryW((LPCWSTR)zConverted); +#endif + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + h = osLoadLibraryA((char*)zConverted); + } +#endif + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)h)); + sqlite3_free(zConverted); + return (void*)h; +} +static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){ + UNUSED_PARAMETER(pVfs); + winGetLastErrorMsg(osGetLastError(), nBuf, zBufOut); +} +static void (*winDlSym(sqlite3_vfs *pVfs,void *pH,const char *zSym))(void){ + FARPROC proc; + UNUSED_PARAMETER(pVfs); + proc = osGetProcAddressA((HANDLE)pH, zSym); + OSTRACE(("DLSYM handle=%p, symbol=%s, address=%p\n", + (void*)pH, zSym, (void*)proc)); + return (void(*)(void))proc; +} +static void winDlClose(sqlite3_vfs *pVfs, void *pHandle){ + UNUSED_PARAMETER(pVfs); + osFreeLibrary((HANDLE)pHandle); + OSTRACE(("DLCLOSE handle=%p\n", (void*)pHandle)); +} +#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */ + #define winDlOpen 0 + #define winDlError 0 + #define winDlSym 0 + #define winDlClose 0 +#endif + + +/* +** Write up to nBuf bytes of randomness into zBuf. +*/ +static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ + int n = 0; + UNUSED_PARAMETER(pVfs); +#if defined(SQLITE_TEST) || defined(SQLITE_OMIT_RANDOMNESS) + n = nBuf; + memset(zBuf, 0, nBuf); +#else + if( sizeof(SYSTEMTIME)<=nBuf-n ){ + SYSTEMTIME x; + osGetSystemTime(&x); + memcpy(&zBuf[n], &x, sizeof(x)); + n += sizeof(x); + } + if( sizeof(DWORD)<=nBuf-n ){ + DWORD pid = osGetCurrentProcessId(); + memcpy(&zBuf[n], &pid, sizeof(pid)); + n += sizeof(pid); + } +#if SQLITE_OS_WINRT + if( sizeof(ULONGLONG)<=nBuf-n ){ + ULONGLONG cnt = osGetTickCount64(); + memcpy(&zBuf[n], &cnt, sizeof(cnt)); + n += sizeof(cnt); + } +#else + if( sizeof(DWORD)<=nBuf-n ){ + DWORD cnt = osGetTickCount(); + memcpy(&zBuf[n], &cnt, sizeof(cnt)); + n += sizeof(cnt); + } +#endif + if( sizeof(LARGE_INTEGER)<=nBuf-n ){ + LARGE_INTEGER i; + osQueryPerformanceCounter(&i); + memcpy(&zBuf[n], &i, sizeof(i)); + n += sizeof(i); + } +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID + if( sizeof(UUID)<=nBuf-n ){ + UUID id; + memset(&id, 0, sizeof(UUID)); + osUuidCreate(&id); + memcpy(&zBuf[n], &id, sizeof(UUID)); + n += sizeof(UUID); + } + if( sizeof(UUID)<=nBuf-n ){ + UUID id; + memset(&id, 0, sizeof(UUID)); + osUuidCreateSequential(&id); + memcpy(&zBuf[n], &id, sizeof(UUID)); + n += sizeof(UUID); + } +#endif +#endif /* defined(SQLITE_TEST) || defined(SQLITE_ZERO_PRNG_SEED) */ + return n; +} + + +/* +** Sleep for a little while. Return the amount of time slept. +*/ +static int winSleep(sqlite3_vfs *pVfs, int microsec){ + sqlite3_win32_sleep((microsec+999)/1000); + UNUSED_PARAMETER(pVfs); + return ((microsec+999)/1000)*1000; +} + +/* +** The following variable, if set to a non-zero value, is interpreted as +** the number of seconds since 1970 and is used to set the result of +** sqlite3OsCurrentTime() during testing. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */ +#endif + +/* +** Find the current time (in Universal Coordinated Time). Write into *piNow +** the current time and date as a Julian Day number times 86_400_000. In +** other words, write into *piNow the number of milliseconds since the Julian +** epoch of noon in Greenwich on November 24, 4714 B.C according to the +** proleptic Gregorian calendar. +** +** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date +** cannot be found. +*/ +static int winCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *piNow){ + /* FILETIME structure is a 64-bit value representing the number of + 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5). + */ + FILETIME ft; + static const sqlite3_int64 winFiletimeEpoch = 23058135*(sqlite3_int64)8640000; +#ifdef SQLITE_TEST + static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000; +#endif + /* 2^32 - to avoid use of LL and warnings in gcc */ + static const sqlite3_int64 max32BitValue = + (sqlite3_int64)2000000000 + (sqlite3_int64)2000000000 + + (sqlite3_int64)294967296; + +#if SQLITE_OS_WINCE + SYSTEMTIME time; + osGetSystemTime(&time); + /* if SystemTimeToFileTime() fails, it returns zero. */ + if (!osSystemTimeToFileTime(&time,&ft)){ + return SQLITE_ERROR; + } +#else + osGetSystemTimeAsFileTime( &ft ); +#endif + + *piNow = winFiletimeEpoch + + ((((sqlite3_int64)ft.dwHighDateTime)*max32BitValue) + + (sqlite3_int64)ft.dwLowDateTime)/(sqlite3_int64)10000; + +#ifdef SQLITE_TEST + if( sqlite3_current_time ){ + *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch; + } +#endif + UNUSED_PARAMETER(pVfs); + return SQLITE_OK; +} + +/* +** Find the current time (in Universal Coordinated Time). Write the +** current time and date as a Julian Day number into *prNow and +** return 0. Return 1 if the time and date cannot be found. +*/ +static int winCurrentTime(sqlite3_vfs *pVfs, double *prNow){ + int rc; + sqlite3_int64 i; + rc = winCurrentTimeInt64(pVfs, &i); + if( !rc ){ + *prNow = i/86400000.0; + } + return rc; +} + +/* +** The idea is that this function works like a combination of +** GetLastError() and FormatMessage() on Windows (or errno and +** strerror_r() on Unix). After an error is returned by an OS +** function, SQLite calls this function with zBuf pointing to +** a buffer of nBuf bytes. The OS layer should populate the +** buffer with a nul-terminated UTF-8 encoded error message +** describing the last IO error to have occurred within the calling +** thread. +** +** If the error message is too large for the supplied buffer, +** it should be truncated. The return value of xGetLastError +** is zero if the error message fits in the buffer, or non-zero +** otherwise (if the message was truncated). If non-zero is returned, +** then it is not necessary to include the nul-terminator character +** in the output buffer. +** +** Not supplying an error message will have no adverse effect +** on SQLite. It is fine to have an implementation that never +** returns an error message: +** +** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ +** assert(zBuf[0]=='\0'); +** return 0; +** } +** +** However if an error message is supplied, it will be incorporated +** by sqlite into the error message available to the user using +** sqlite3_errmsg(), possibly making IO errors easier to debug. +*/ +static int winGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ + UNUSED_PARAMETER(pVfs); + return winGetLastErrorMsg(osGetLastError(), nBuf, zBuf); +} + +/* +** Initialize and deinitialize the operating system interface. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_os_init(void){ + static sqlite3_vfs winVfs = { + 3, /* iVersion */ + sizeof(winFile), /* szOsFile */ + SQLITE_WIN32_MAX_PATH_BYTES, /* mxPathname */ + 0, /* pNext */ + "win32", /* zName */ + 0, /* pAppData */ + winOpen, /* xOpen */ + winDelete, /* xDelete */ + winAccess, /* xAccess */ + winFullPathname, /* xFullPathname */ + winDlOpen, /* xDlOpen */ + winDlError, /* xDlError */ + winDlSym, /* xDlSym */ + winDlClose, /* xDlClose */ + winRandomness, /* xRandomness */ + winSleep, /* xSleep */ + winCurrentTime, /* xCurrentTime */ + winGetLastError, /* xGetLastError */ + winCurrentTimeInt64, /* xCurrentTimeInt64 */ + winSetSystemCall, /* xSetSystemCall */ + winGetSystemCall, /* xGetSystemCall */ + winNextSystemCall, /* xNextSystemCall */ + }; +#if defined(SQLITE_WIN32_HAS_WIDE) + static sqlite3_vfs winLongPathVfs = { + 3, /* iVersion */ + sizeof(winFile), /* szOsFile */ + SQLITE_WINNT_MAX_PATH_BYTES, /* mxPathname */ + 0, /* pNext */ + "win32-longpath", /* zName */ + 0, /* pAppData */ + winOpen, /* xOpen */ + winDelete, /* xDelete */ + winAccess, /* xAccess */ + winFullPathname, /* xFullPathname */ + winDlOpen, /* xDlOpen */ + winDlError, /* xDlError */ + winDlSym, /* xDlSym */ + winDlClose, /* xDlClose */ + winRandomness, /* xRandomness */ + winSleep, /* xSleep */ + winCurrentTime, /* xCurrentTime */ + winGetLastError, /* xGetLastError */ + winCurrentTimeInt64, /* xCurrentTimeInt64 */ + winSetSystemCall, /* xSetSystemCall */ + winGetSystemCall, /* xGetSystemCall */ + winNextSystemCall, /* xNextSystemCall */ + }; +#endif + + /* Double-check that the aSyscall[] array has been constructed + ** correctly. See ticket [bb3a86e890c8e96ab] */ + assert( ArraySize(aSyscall)==80 ); + + /* get memory map allocation granularity */ + memset(&winSysInfo, 0, sizeof(SYSTEM_INFO)); +#if SQLITE_OS_WINRT + osGetNativeSystemInfo(&winSysInfo); +#else + osGetSystemInfo(&winSysInfo); +#endif + assert( winSysInfo.dwAllocationGranularity>0 ); + assert( winSysInfo.dwPageSize>0 ); + + sqlite3_vfs_register(&winVfs, 1); + +#if defined(SQLITE_WIN32_HAS_WIDE) + sqlite3_vfs_register(&winLongPathVfs, 0); +#endif + + return SQLITE_OK; +} + +SQLITE_API int SQLITE_STDCALL sqlite3_os_end(void){ +#if SQLITE_OS_WINRT + if( sleepObj!=NULL ){ + osCloseHandle(sleepObj); + sleepObj = NULL; + } +#endif + return SQLITE_OK; +} + +#endif /* SQLITE_OS_WIN */ + +/************** End of os_win.c **********************************************/ +/************** Begin file bitvec.c ******************************************/ +/* +** 2008 February 16 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file implements an object that represents a fixed-length +** bitmap. Bits are numbered starting with 1. +** +** A bitmap is used to record which pages of a database file have been +** journalled during a transaction, or which pages have the "dont-write" +** property. Usually only a few pages are meet either condition. +** So the bitmap is usually sparse and has low cardinality. +** But sometimes (for example when during a DROP of a large table) most +** or all of the pages in a database can get journalled. In those cases, +** the bitmap becomes dense with high cardinality. The algorithm needs +** to handle both cases well. +** +** The size of the bitmap is fixed when the object is created. +** +** All bits are clear when the bitmap is created. Individual bits +** may be set or cleared one at a time. +** +** Test operations are about 100 times more common that set operations. +** Clear operations are exceedingly rare. There are usually between +** 5 and 500 set operations per Bitvec object, though the number of sets can +** sometimes grow into tens of thousands or larger. The size of the +** Bitvec object is the number of pages in the database file at the +** start of a transaction, and is thus usually less than a few thousand, +** but can be as large as 2 billion for a really big database. +*/ +/* #include "sqliteInt.h" */ + +/* Size of the Bitvec structure in bytes. */ +#define BITVEC_SZ 512 + +/* Round the union size down to the nearest pointer boundary, since that's how +** it will be aligned within the Bitvec struct. */ +#define BITVEC_USIZE (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*)) + +/* Type of the array "element" for the bitmap representation. +** Should be a power of 2, and ideally, evenly divide into BITVEC_USIZE. +** Setting this to the "natural word" size of your CPU may improve +** performance. */ +#define BITVEC_TELEM u8 +/* Size, in bits, of the bitmap element. */ +#define BITVEC_SZELEM 8 +/* Number of elements in a bitmap array. */ +#define BITVEC_NELEM (BITVEC_USIZE/sizeof(BITVEC_TELEM)) +/* Number of bits in the bitmap array. */ +#define BITVEC_NBIT (BITVEC_NELEM*BITVEC_SZELEM) + +/* Number of u32 values in hash table. */ +#define BITVEC_NINT (BITVEC_USIZE/sizeof(u32)) +/* Maximum number of entries in hash table before +** sub-dividing and re-hashing. */ +#define BITVEC_MXHASH (BITVEC_NINT/2) +/* Hashing function for the aHash representation. +** Empirical testing showed that the *37 multiplier +** (an arbitrary prime)in the hash function provided +** no fewer collisions than the no-op *1. */ +#define BITVEC_HASH(X) (((X)*1)%BITVEC_NINT) + +#define BITVEC_NPTR (BITVEC_USIZE/sizeof(Bitvec *)) + + +/* +** A bitmap is an instance of the following structure. +** +** This bitmap records the existence of zero or more bits +** with values between 1 and iSize, inclusive. +** +** There are three possible representations of the bitmap. +** If iSize<=BITVEC_NBIT, then Bitvec.u.aBitmap[] is a straight +** bitmap. The least significant bit is bit 1. +** +** If iSize>BITVEC_NBIT and iDivisor==0 then Bitvec.u.aHash[] is +** a hash table that will hold up to BITVEC_MXHASH distinct values. +** +** Otherwise, the value i is redirected into one of BITVEC_NPTR +** sub-bitmaps pointed to by Bitvec.u.apSub[]. Each subbitmap +** handles up to iDivisor separate values of i. apSub[0] holds +** values between 1 and iDivisor. apSub[1] holds values between +** iDivisor+1 and 2*iDivisor. apSub[N] holds values between +** N*iDivisor+1 and (N+1)*iDivisor. Each subbitmap is normalized +** to hold deal with values between 1 and iDivisor. +*/ +struct Bitvec { + u32 iSize; /* Maximum bit index. Max iSize is 4,294,967,296. */ + u32 nSet; /* Number of bits that are set - only valid for aHash + ** element. Max is BITVEC_NINT. For BITVEC_SZ of 512, + ** this would be 125. */ + u32 iDivisor; /* Number of bits handled by each apSub[] entry. */ + /* Should >=0 for apSub element. */ + /* Max iDivisor is max(u32) / BITVEC_NPTR + 1. */ + /* For a BITVEC_SZ of 512, this would be 34,359,739. */ + union { + BITVEC_TELEM aBitmap[BITVEC_NELEM]; /* Bitmap representation */ + u32 aHash[BITVEC_NINT]; /* Hash table representation */ + Bitvec *apSub[BITVEC_NPTR]; /* Recursive representation */ + } u; +}; + +/* +** Create a new bitmap object able to handle bits between 0 and iSize, +** inclusive. Return a pointer to the new object. Return NULL if +** malloc fails. +*/ +SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32 iSize){ + Bitvec *p; + assert( sizeof(*p)==BITVEC_SZ ); + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ + p->iSize = iSize; + } + return p; +} + +/* +** Check to see if the i-th bit is set. Return true or false. +** If p is NULL (if the bitmap has not been created) or if +** i is out of range, then return false. +*/ +SQLITE_PRIVATE int sqlite3BitvecTestNotNull(Bitvec *p, u32 i){ + assert( p!=0 ); + i--; + if( i>=p->iSize ) return 0; + while( p->iDivisor ){ + u32 bin = i/p->iDivisor; + i = i%p->iDivisor; + p = p->u.apSub[bin]; + if (!p) { + return 0; + } + } + if( p->iSize<=BITVEC_NBIT ){ + return (p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))))!=0; + } else{ + u32 h = BITVEC_HASH(i++); + while( p->u.aHash[h] ){ + if( p->u.aHash[h]==i ) return 1; + h = (h+1) % BITVEC_NINT; + } + return 0; + } +} +SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec *p, u32 i){ + return p!=0 && sqlite3BitvecTestNotNull(p,i); +} + +/* +** Set the i-th bit. Return 0 on success and an error code if +** anything goes wrong. +** +** This routine might cause sub-bitmaps to be allocated. Failing +** to get the memory needed to hold the sub-bitmap is the only +** that can go wrong with an insert, assuming p and i are valid. +** +** The calling function must ensure that p is a valid Bitvec object +** and that the value for "i" is within range of the Bitvec object. +** Otherwise the behavior is undefined. +*/ +SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec *p, u32 i){ + u32 h; + if( p==0 ) return SQLITE_OK; + assert( i>0 ); + assert( i<=p->iSize ); + i--; + while((p->iSize > BITVEC_NBIT) && p->iDivisor) { + u32 bin = i/p->iDivisor; + i = i%p->iDivisor; + if( p->u.apSub[bin]==0 ){ + p->u.apSub[bin] = sqlite3BitvecCreate( p->iDivisor ); + if( p->u.apSub[bin]==0 ) return SQLITE_NOMEM; + } + p = p->u.apSub[bin]; + } + if( p->iSize<=BITVEC_NBIT ){ + p->u.aBitmap[i/BITVEC_SZELEM] |= 1 << (i&(BITVEC_SZELEM-1)); + return SQLITE_OK; + } + h = BITVEC_HASH(i++); + /* if there wasn't a hash collision, and this doesn't */ + /* completely fill the hash, then just add it without */ + /* worring about sub-dividing and re-hashing. */ + if( !p->u.aHash[h] ){ + if (p->nSet<(BITVEC_NINT-1)) { + goto bitvec_set_end; + } else { + goto bitvec_set_rehash; + } + } + /* there was a collision, check to see if it's already */ + /* in hash, if not, try to find a spot for it */ + do { + if( p->u.aHash[h]==i ) return SQLITE_OK; + h++; + if( h>=BITVEC_NINT ) h = 0; + } while( p->u.aHash[h] ); + /* we didn't find it in the hash. h points to the first */ + /* available free spot. check to see if this is going to */ + /* make our hash too "full". */ +bitvec_set_rehash: + if( p->nSet>=BITVEC_MXHASH ){ + unsigned int j; + int rc; + u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash)); + if( aiValues==0 ){ + return SQLITE_NOMEM; + }else{ + memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash)); + memset(p->u.apSub, 0, sizeof(p->u.apSub)); + p->iDivisor = (p->iSize + BITVEC_NPTR - 1)/BITVEC_NPTR; + rc = sqlite3BitvecSet(p, i); + for(j=0; jnSet++; + p->u.aHash[h] = i; + return SQLITE_OK; +} + +/* +** Clear the i-th bit. +** +** pBuf must be a pointer to at least BITVEC_SZ bytes of temporary storage +** that BitvecClear can use to rebuilt its hash table. +*/ +SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){ + if( p==0 ) return; + assert( i>0 ); + i--; + while( p->iDivisor ){ + u32 bin = i/p->iDivisor; + i = i%p->iDivisor; + p = p->u.apSub[bin]; + if (!p) { + return; + } + } + if( p->iSize<=BITVEC_NBIT ){ + p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1))); + }else{ + unsigned int j; + u32 *aiValues = pBuf; + memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash)); + memset(p->u.aHash, 0, sizeof(p->u.aHash)); + p->nSet = 0; + for(j=0; jnSet++; + while( p->u.aHash[h] ){ + h++; + if( h>=BITVEC_NINT ) h = 0; + } + p->u.aHash[h] = aiValues[j]; + } + } + } +} + +/* +** Destroy a bitmap object. Reclaim all memory used. +*/ +SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec *p){ + if( p==0 ) return; + if( p->iDivisor ){ + unsigned int i; + for(i=0; iu.apSub[i]); + } + } + sqlite3_free(p); +} + +/* +** Return the value of the iSize parameter specified when Bitvec *p +** was created. +*/ +SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec *p){ + return p->iSize; +} + +#ifndef SQLITE_OMIT_BUILTIN_TEST +/* +** Let V[] be an array of unsigned characters sufficient to hold +** up to N bits. Let I be an integer between 0 and N. 0<=I>3] |= (1<<(I&7)) +#define CLEARBIT(V,I) V[I>>3] &= ~(1<<(I&7)) +#define TESTBIT(V,I) (V[I>>3]&(1<<(I&7)))!=0 + +/* +** This routine runs an extensive test of the Bitvec code. +** +** The input is an array of integers that acts as a program +** to test the Bitvec. The integers are opcodes followed +** by 0, 1, or 3 operands, depending on the opcode. Another +** opcode follows immediately after the last operand. +** +** There are 6 opcodes numbered from 0 through 5. 0 is the +** "halt" opcode and causes the test to end. +** +** 0 Halt and return the number of errors +** 1 N S X Set N bits beginning with S and incrementing by X +** 2 N S X Clear N bits beginning with S and incrementing by X +** 3 N Set N randomly chosen bits +** 4 N Clear N randomly chosen bits +** 5 N S X Set N bits from S increment X in array only, not in bitvec +** +** The opcodes 1 through 4 perform set and clear operations are performed +** on both a Bitvec object and on a linear array of bits obtained from malloc. +** Opcode 5 works on the linear array only, not on the Bitvec. +** Opcode 5 is used to deliberately induce a fault in order to +** confirm that error detection works. +** +** At the conclusion of the test the linear array is compared +** against the Bitvec object. If there are any differences, +** an error is returned. If they are the same, zero is returned. +** +** If a memory allocation error occurs, return -1. +*/ +SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int sz, int *aOp){ + Bitvec *pBitvec = 0; + unsigned char *pV = 0; + int rc = -1; + int i, nx, pc, op; + void *pTmpSpace; + + /* Allocate the Bitvec to be tested and a linear array of + ** bits to act as the reference */ + pBitvec = sqlite3BitvecCreate( sz ); + pV = sqlite3MallocZero( (sz+7)/8 + 1 ); + pTmpSpace = sqlite3_malloc64(BITVEC_SZ); + if( pBitvec==0 || pV==0 || pTmpSpace==0 ) goto bitvec_end; + + /* NULL pBitvec tests */ + sqlite3BitvecSet(0, 1); + sqlite3BitvecClear(0, 1, pTmpSpace); + + /* Run the program */ + pc = 0; + while( (op = aOp[pc])!=0 ){ + switch( op ){ + case 1: + case 2: + case 5: { + nx = 4; + i = aOp[pc+2] - 1; + aOp[pc+2] += aOp[pc+3]; + break; + } + case 3: + case 4: + default: { + nx = 2; + sqlite3_randomness(sizeof(i), &i); + break; + } + } + if( (--aOp[pc+1]) > 0 ) nx = 0; + pc += nx; + i = (i & 0x7fffffff)%sz; + if( (op & 1)!=0 ){ + SETBIT(pV, (i+1)); + if( op!=5 ){ + if( sqlite3BitvecSet(pBitvec, i+1) ) goto bitvec_end; + } + }else{ + CLEARBIT(pV, (i+1)); + sqlite3BitvecClear(pBitvec, i+1, pTmpSpace); + } + } + + /* Test to make sure the linear array exactly matches the + ** Bitvec object. Start with the assumption that they do + ** match (rc==0). Change rc to non-zero if a discrepancy + ** is found. + */ + rc = sqlite3BitvecTest(0,0) + sqlite3BitvecTest(pBitvec, sz+1) + + sqlite3BitvecTest(pBitvec, 0) + + (sqlite3BitvecSize(pBitvec) - sz); + for(i=1; i<=sz; i++){ + if( (TESTBIT(pV,i))!=sqlite3BitvecTest(pBitvec,i) ){ + rc = i; + break; + } + } + + /* Free allocated structure */ +bitvec_end: + sqlite3_free(pTmpSpace); + sqlite3_free(pV); + sqlite3BitvecDestroy(pBitvec); + return rc; +} +#endif /* SQLITE_OMIT_BUILTIN_TEST */ + +/************** End of bitvec.c **********************************************/ +/************** Begin file pcache.c ******************************************/ +/* +** 2008 August 05 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file implements that page cache. +*/ +/* #include "sqliteInt.h" */ + +/* +** A complete page cache is an instance of this structure. +*/ +struct PCache { + PgHdr *pDirty, *pDirtyTail; /* List of dirty pages in LRU order */ + PgHdr *pSynced; /* Last synced page in dirty page list */ + int nRefSum; /* Sum of ref counts over all pages */ + int szCache; /* Configured cache size */ + int szPage; /* Size of every page in this cache */ + int szExtra; /* Size of extra space for each page */ + u8 bPurgeable; /* True if pages are on backing store */ + u8 eCreate; /* eCreate value for for xFetch() */ + int (*xStress)(void*,PgHdr*); /* Call to try make a page clean */ + void *pStress; /* Argument to xStress */ + sqlite3_pcache *pCache; /* Pluggable cache module */ +}; + +/********************************** Linked List Management ********************/ + +/* Allowed values for second argument to pcacheManageDirtyList() */ +#define PCACHE_DIRTYLIST_REMOVE 1 /* Remove pPage from dirty list */ +#define PCACHE_DIRTYLIST_ADD 2 /* Add pPage to the dirty list */ +#define PCACHE_DIRTYLIST_FRONT 3 /* Move pPage to the front of the list */ + +/* +** Manage pPage's participation on the dirty list. Bits of the addRemove +** argument determines what operation to do. The 0x01 bit means first +** remove pPage from the dirty list. The 0x02 means add pPage back to +** the dirty list. Doing both moves pPage to the front of the dirty list. +*/ +static void pcacheManageDirtyList(PgHdr *pPage, u8 addRemove){ + PCache *p = pPage->pCache; + + if( addRemove & PCACHE_DIRTYLIST_REMOVE ){ + assert( pPage->pDirtyNext || pPage==p->pDirtyTail ); + assert( pPage->pDirtyPrev || pPage==p->pDirty ); + + /* Update the PCache1.pSynced variable if necessary. */ + if( p->pSynced==pPage ){ + PgHdr *pSynced = pPage->pDirtyPrev; + while( pSynced && (pSynced->flags&PGHDR_NEED_SYNC) ){ + pSynced = pSynced->pDirtyPrev; + } + p->pSynced = pSynced; + } + + if( pPage->pDirtyNext ){ + pPage->pDirtyNext->pDirtyPrev = pPage->pDirtyPrev; + }else{ + assert( pPage==p->pDirtyTail ); + p->pDirtyTail = pPage->pDirtyPrev; + } + if( pPage->pDirtyPrev ){ + pPage->pDirtyPrev->pDirtyNext = pPage->pDirtyNext; + }else{ + assert( pPage==p->pDirty ); + p->pDirty = pPage->pDirtyNext; + if( p->pDirty==0 && p->bPurgeable ){ + assert( p->eCreate==1 ); + p->eCreate = 2; + } + } + pPage->pDirtyNext = 0; + pPage->pDirtyPrev = 0; + } + if( addRemove & PCACHE_DIRTYLIST_ADD ){ + assert( pPage->pDirtyNext==0 && pPage->pDirtyPrev==0 && p->pDirty!=pPage ); + + pPage->pDirtyNext = p->pDirty; + if( pPage->pDirtyNext ){ + assert( pPage->pDirtyNext->pDirtyPrev==0 ); + pPage->pDirtyNext->pDirtyPrev = pPage; + }else{ + p->pDirtyTail = pPage; + if( p->bPurgeable ){ + assert( p->eCreate==2 ); + p->eCreate = 1; + } + } + p->pDirty = pPage; + if( !p->pSynced && 0==(pPage->flags&PGHDR_NEED_SYNC) ){ + p->pSynced = pPage; + } + } +} + +/* +** Wrapper around the pluggable caches xUnpin method. If the cache is +** being used for an in-memory database, this function is a no-op. +*/ +static void pcacheUnpin(PgHdr *p){ + if( p->pCache->bPurgeable ){ + sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 0); + } +} + +/* +** Compute the number of pages of cache requested. p->szCache is the +** cache size requested by the "PRAGMA cache_size" statement. +** +** +*/ +static int numberOfCachePages(PCache *p){ + if( p->szCache>=0 ){ + /* IMPLEMENTATION-OF: R-42059-47211 If the argument N is positive then the + ** suggested cache size is set to N. */ + return p->szCache; + }else{ + /* IMPLEMENTATION-OF: R-61436-13639 If the argument N is negative, then + ** the number of cache pages is adjusted to use approximately abs(N*1024) + ** bytes of memory. */ + return (int)((-1024*(i64)p->szCache)/(p->szPage+p->szExtra)); + } +} + +/*************************************************** General Interfaces ****** +** +** Initialize and shutdown the page cache subsystem. Neither of these +** functions are threadsafe. +*/ +SQLITE_PRIVATE int sqlite3PcacheInitialize(void){ + if( sqlite3GlobalConfig.pcache2.xInit==0 ){ + /* IMPLEMENTATION-OF: R-26801-64137 If the xInit() method is NULL, then the + ** built-in default page cache is used instead of the application defined + ** page cache. */ + sqlite3PCacheSetDefault(); + } + return sqlite3GlobalConfig.pcache2.xInit(sqlite3GlobalConfig.pcache2.pArg); +} +SQLITE_PRIVATE void sqlite3PcacheShutdown(void){ + if( sqlite3GlobalConfig.pcache2.xShutdown ){ + /* IMPLEMENTATION-OF: R-26000-56589 The xShutdown() method may be NULL. */ + sqlite3GlobalConfig.pcache2.xShutdown(sqlite3GlobalConfig.pcache2.pArg); + } +} + +/* +** Return the size in bytes of a PCache object. +*/ +SQLITE_PRIVATE int sqlite3PcacheSize(void){ return sizeof(PCache); } + +/* +** Create a new PCache object. Storage space to hold the object +** has already been allocated and is passed in as the p pointer. +** The caller discovers how much space needs to be allocated by +** calling sqlite3PcacheSize(). +*/ +SQLITE_PRIVATE int sqlite3PcacheOpen( + int szPage, /* Size of every page */ + int szExtra, /* Extra space associated with each page */ + int bPurgeable, /* True if pages are on backing store */ + int (*xStress)(void*,PgHdr*),/* Call to try to make pages clean */ + void *pStress, /* Argument to xStress */ + PCache *p /* Preallocated space for the PCache */ +){ + memset(p, 0, sizeof(PCache)); + p->szPage = 1; + p->szExtra = szExtra; + p->bPurgeable = bPurgeable; + p->eCreate = 2; + p->xStress = xStress; + p->pStress = pStress; + p->szCache = 100; + return sqlite3PcacheSetPageSize(p, szPage); +} + +/* +** Change the page size for PCache object. The caller must ensure that there +** are no outstanding page references when this function is called. +*/ +SQLITE_PRIVATE int sqlite3PcacheSetPageSize(PCache *pCache, int szPage){ + assert( pCache->nRefSum==0 && pCache->pDirty==0 ); + if( pCache->szPage ){ + sqlite3_pcache *pNew; + pNew = sqlite3GlobalConfig.pcache2.xCreate( + szPage, pCache->szExtra + ROUND8(sizeof(PgHdr)), + pCache->bPurgeable + ); + if( pNew==0 ) return SQLITE_NOMEM; + sqlite3GlobalConfig.pcache2.xCachesize(pNew, numberOfCachePages(pCache)); + if( pCache->pCache ){ + sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache); + } + pCache->pCache = pNew; + pCache->szPage = szPage; + } + return SQLITE_OK; +} + +/* +** Try to obtain a page from the cache. +** +** This routine returns a pointer to an sqlite3_pcache_page object if +** such an object is already in cache, or if a new one is created. +** This routine returns a NULL pointer if the object was not in cache +** and could not be created. +** +** The createFlags should be 0 to check for existing pages and should +** be 3 (not 1, but 3) to try to create a new page. +** +** If the createFlag is 0, then NULL is always returned if the page +** is not already in the cache. If createFlag is 1, then a new page +** is created only if that can be done without spilling dirty pages +** and without exceeding the cache size limit. +** +** The caller needs to invoke sqlite3PcacheFetchFinish() to properly +** initialize the sqlite3_pcache_page object and convert it into a +** PgHdr object. The sqlite3PcacheFetch() and sqlite3PcacheFetchFinish() +** routines are split this way for performance reasons. When separated +** they can both (usually) operate without having to push values to +** the stack on entry and pop them back off on exit, which saves a +** lot of pushing and popping. +*/ +SQLITE_PRIVATE sqlite3_pcache_page *sqlite3PcacheFetch( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number to obtain */ + int createFlag /* If true, create page if it does not exist already */ +){ + int eCreate; + + assert( pCache!=0 ); + assert( pCache->pCache!=0 ); + assert( createFlag==3 || createFlag==0 ); + assert( pgno>0 ); + + /* eCreate defines what to do if the page does not exist. + ** 0 Do not allocate a new page. (createFlag==0) + ** 1 Allocate a new page if doing so is inexpensive. + ** (createFlag==1 AND bPurgeable AND pDirty) + ** 2 Allocate a new page even it doing so is difficult. + ** (createFlag==1 AND !(bPurgeable AND pDirty) + */ + eCreate = createFlag & pCache->eCreate; + assert( eCreate==0 || eCreate==1 || eCreate==2 ); + assert( createFlag==0 || pCache->eCreate==eCreate ); + assert( createFlag==0 || eCreate==1+(!pCache->bPurgeable||!pCache->pDirty) ); + return sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate); +} + +/* +** If the sqlite3PcacheFetch() routine is unable to allocate a new +** page because new clean pages are available for reuse and the cache +** size limit has been reached, then this routine can be invoked to +** try harder to allocate a page. This routine might invoke the stress +** callback to spill dirty pages to the journal. It will then try to +** allocate the new page and will only fail to allocate a new page on +** an OOM error. +** +** This routine should be invoked only after sqlite3PcacheFetch() fails. +*/ +SQLITE_PRIVATE int sqlite3PcacheFetchStress( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number to obtain */ + sqlite3_pcache_page **ppPage /* Write result here */ +){ + PgHdr *pPg; + if( pCache->eCreate==2 ) return 0; + + + /* Find a dirty page to write-out and recycle. First try to find a + ** page that does not require a journal-sync (one with PGHDR_NEED_SYNC + ** cleared), but if that is not possible settle for any other + ** unreferenced dirty page. + */ + for(pPg=pCache->pSynced; + pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC)); + pPg=pPg->pDirtyPrev + ); + pCache->pSynced = pPg; + if( !pPg ){ + for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pDirtyPrev); + } + if( pPg ){ + int rc; +#ifdef SQLITE_LOG_CACHE_SPILL + sqlite3_log(SQLITE_FULL, + "spill page %d making room for %d - cache used: %d/%d", + pPg->pgno, pgno, + sqlite3GlobalConfig.pcache.xPagecount(pCache->pCache), + numberOfCachePages(pCache)); +#endif + rc = pCache->xStress(pCache->pStress, pPg); + if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){ + return rc; + } + } + *ppPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, 2); + return *ppPage==0 ? SQLITE_NOMEM : SQLITE_OK; +} + +/* +** This is a helper routine for sqlite3PcacheFetchFinish() +** +** In the uncommon case where the page being fetched has not been +** initialized, this routine is invoked to do the initialization. +** This routine is broken out into a separate function since it +** requires extra stack manipulation that can be avoided in the common +** case. +*/ +static SQLITE_NOINLINE PgHdr *pcacheFetchFinishWithInit( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number obtained */ + sqlite3_pcache_page *pPage /* Page obtained by prior PcacheFetch() call */ +){ + PgHdr *pPgHdr; + assert( pPage!=0 ); + pPgHdr = (PgHdr*)pPage->pExtra; + assert( pPgHdr->pPage==0 ); + memset(pPgHdr, 0, sizeof(PgHdr)); + pPgHdr->pPage = pPage; + pPgHdr->pData = pPage->pBuf; + pPgHdr->pExtra = (void *)&pPgHdr[1]; + memset(pPgHdr->pExtra, 0, pCache->szExtra); + pPgHdr->pCache = pCache; + pPgHdr->pgno = pgno; + pPgHdr->flags = PGHDR_CLEAN; + return sqlite3PcacheFetchFinish(pCache,pgno,pPage); +} + +/* +** This routine converts the sqlite3_pcache_page object returned by +** sqlite3PcacheFetch() into an initialized PgHdr object. This routine +** must be called after sqlite3PcacheFetch() in order to get a usable +** result. +*/ +SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number obtained */ + sqlite3_pcache_page *pPage /* Page obtained by prior PcacheFetch() call */ +){ + PgHdr *pPgHdr; + + assert( pPage!=0 ); + pPgHdr = (PgHdr *)pPage->pExtra; + + if( !pPgHdr->pPage ){ + return pcacheFetchFinishWithInit(pCache, pgno, pPage); + } + pCache->nRefSum++; + pPgHdr->nRef++; + return pPgHdr; +} + +/* +** Decrement the reference count on a page. If the page is clean and the +** reference count drops to 0, then it is made eligible for recycling. +*/ +SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3PcacheRelease(PgHdr *p){ + assert( p->nRef>0 ); + p->pCache->nRefSum--; + if( (--p->nRef)==0 ){ + if( p->flags&PGHDR_CLEAN ){ + pcacheUnpin(p); + }else if( p->pDirtyPrev!=0 ){ + /* Move the page to the head of the dirty list. */ + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT); + } + } +} + +/* +** Increase the reference count of a supplied page by 1. +*/ +SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr *p){ + assert(p->nRef>0); + p->nRef++; + p->pCache->nRefSum++; +} + +/* +** Drop a page from the cache. There must be exactly one reference to the +** page. This function deletes that reference, so after it returns the +** page pointed to by p is invalid. +*/ +SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr *p){ + assert( p->nRef==1 ); + if( p->flags&PGHDR_DIRTY ){ + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE); + } + p->pCache->nRefSum--; + sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 1); +} + +/* +** Make sure the page is marked as dirty. If it isn't dirty already, +** make it so. +*/ +SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr *p){ + assert( p->nRef>0 ); + if( p->flags & (PGHDR_CLEAN|PGHDR_DONT_WRITE) ){ + p->flags &= ~PGHDR_DONT_WRITE; + if( p->flags & PGHDR_CLEAN ){ + p->flags ^= (PGHDR_DIRTY|PGHDR_CLEAN); + assert( (p->flags & (PGHDR_DIRTY|PGHDR_CLEAN))==PGHDR_DIRTY ); + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_ADD); + } + } +} + +/* +** Make sure the page is marked as clean. If it isn't clean already, +** make it so. +*/ +SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr *p){ + if( (p->flags & PGHDR_DIRTY) ){ + assert( (p->flags & PGHDR_CLEAN)==0 ); + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE); + p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC|PGHDR_WRITEABLE); + p->flags |= PGHDR_CLEAN; + if( p->nRef==0 ){ + pcacheUnpin(p); + } + } +} + +/* +** Make every page in the cache clean. +*/ +SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache *pCache){ + PgHdr *p; + while( (p = pCache->pDirty)!=0 ){ + sqlite3PcacheMakeClean(p); + } +} + +/* +** Clear the PGHDR_NEED_SYNC flag from all dirty pages. +*/ +SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *pCache){ + PgHdr *p; + for(p=pCache->pDirty; p; p=p->pDirtyNext){ + p->flags &= ~PGHDR_NEED_SYNC; + } + pCache->pSynced = pCache->pDirtyTail; +} + +/* +** Change the page number of page p to newPgno. +*/ +SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){ + PCache *pCache = p->pCache; + assert( p->nRef>0 ); + assert( newPgno>0 ); + sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno); + p->pgno = newPgno; + if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){ + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT); + } +} + +/* +** Drop every cache entry whose page number is greater than "pgno". The +** caller must ensure that there are no outstanding references to any pages +** other than page 1 with a page number greater than pgno. +** +** If there is a reference to page 1 and the pgno parameter passed to this +** function is 0, then the data area associated with page 1 is zeroed, but +** the page object is not dropped. +*/ +SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){ + if( pCache->pCache ){ + PgHdr *p; + PgHdr *pNext; + for(p=pCache->pDirty; p; p=pNext){ + pNext = p->pDirtyNext; + /* This routine never gets call with a positive pgno except right + ** after sqlite3PcacheCleanAll(). So if there are dirty pages, + ** it must be that pgno==0. + */ + assert( p->pgno>0 ); + if( ALWAYS(p->pgno>pgno) ){ + assert( p->flags&PGHDR_DIRTY ); + sqlite3PcacheMakeClean(p); + } + } + if( pgno==0 && pCache->nRefSum ){ + sqlite3_pcache_page *pPage1; + pPage1 = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache,1,0); + if( ALWAYS(pPage1) ){ /* Page 1 is always available in cache, because + ** pCache->nRefSum>0 */ + memset(pPage1->pBuf, 0, pCache->szPage); + pgno = 1; + } + } + sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1); + } +} + +/* +** Close a cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheClose(PCache *pCache){ + assert( pCache->pCache!=0 ); + sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache); +} + +/* +** Discard the contents of the cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheClear(PCache *pCache){ + sqlite3PcacheTruncate(pCache, 0); +} + +/* +** Merge two lists of pages connected by pDirty and in pgno order. +** Do not both fixing the pDirtyPrev pointers. +*/ +static PgHdr *pcacheMergeDirtyList(PgHdr *pA, PgHdr *pB){ + PgHdr result, *pTail; + pTail = &result; + while( pA && pB ){ + if( pA->pgnopgno ){ + pTail->pDirty = pA; + pTail = pA; + pA = pA->pDirty; + }else{ + pTail->pDirty = pB; + pTail = pB; + pB = pB->pDirty; + } + } + if( pA ){ + pTail->pDirty = pA; + }else if( pB ){ + pTail->pDirty = pB; + }else{ + pTail->pDirty = 0; + } + return result.pDirty; +} + +/* +** Sort the list of pages in accending order by pgno. Pages are +** connected by pDirty pointers. The pDirtyPrev pointers are +** corrupted by this sort. +** +** Since there cannot be more than 2^31 distinct pages in a database, +** there cannot be more than 31 buckets required by the merge sorter. +** One extra bucket is added to catch overflow in case something +** ever changes to make the previous sentence incorrect. +*/ +#define N_SORT_BUCKET 32 +static PgHdr *pcacheSortDirtyList(PgHdr *pIn){ + PgHdr *a[N_SORT_BUCKET], *p; + int i; + memset(a, 0, sizeof(a)); + while( pIn ){ + p = pIn; + pIn = p->pDirty; + p->pDirty = 0; + for(i=0; ALWAYS(ipDirty; p; p=p->pDirtyNext){ + p->pDirty = p->pDirtyNext; + } + return pcacheSortDirtyList(pCache->pDirty); +} + +/* +** Return the total number of references to all pages held by the cache. +** +** This is not the total number of pages referenced, but the sum of the +** reference count for all pages. +*/ +SQLITE_PRIVATE int sqlite3PcacheRefCount(PCache *pCache){ + return pCache->nRefSum; +} + +/* +** Return the number of references to the page supplied as an argument. +*/ +SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr *p){ + return p->nRef; +} + +/* +** Return the total number of pages in the cache. +*/ +SQLITE_PRIVATE int sqlite3PcachePagecount(PCache *pCache){ + assert( pCache->pCache!=0 ); + return sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache); +} + +#ifdef SQLITE_TEST +/* +** Get the suggested cache-size value. +*/ +SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *pCache){ + return numberOfCachePages(pCache); +} +#endif + +/* +** Set the suggested cache-size value. +*/ +SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *pCache, int mxPage){ + assert( pCache->pCache!=0 ); + pCache->szCache = mxPage; + sqlite3GlobalConfig.pcache2.xCachesize(pCache->pCache, + numberOfCachePages(pCache)); +} + +/* +** Free up as much memory as possible from the page cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheShrink(PCache *pCache){ + assert( pCache->pCache!=0 ); + sqlite3GlobalConfig.pcache2.xShrink(pCache->pCache); +} + +/* +** Return the size of the header added by this middleware layer +** in the page-cache hierarchy. +*/ +SQLITE_PRIVATE int sqlite3HeaderSizePcache(void){ return ROUND8(sizeof(PgHdr)); } + + +#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG) +/* +** For all dirty pages currently in the cache, invoke the specified +** callback. This is only used if the SQLITE_CHECK_PAGES macro is +** defined. +*/ +SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)){ + PgHdr *pDirty; + for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext){ + xIter(pDirty); + } +} +#endif + +/************** End of pcache.c **********************************************/ +/************** Begin file pcache1.c *****************************************/ +/* +** 2008 November 05 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file implements the default page cache implementation (the +** sqlite3_pcache interface). It also contains part of the implementation +** of the SQLITE_CONFIG_PAGECACHE and sqlite3_release_memory() features. +** If the default page cache implementation is overridden, then neither of +** these two features are available. +** +** A Page cache line looks like this: +** +** ------------------------------------------------------------- +** | database page content | PgHdr1 | MemPage | PgHdr | +** ------------------------------------------------------------- +** +** The database page content is up front (so that buffer overreads tend to +** flow harmlessly into the PgHdr1, MemPage, and PgHdr extensions). MemPage +** is the extension added by the btree.c module containing information such +** as the database page number and how that database page is used. PgHdr +** is added by the pcache.c layer and contains information used to keep track +** of which pages are "dirty". PgHdr1 is an extension added by this +** module (pcache1.c). The PgHdr1 header is a subclass of sqlite3_pcache_page. +** PgHdr1 contains information needed to look up a page by its page number. +** The superclass sqlite3_pcache_page.pBuf points to the start of the +** database page content and sqlite3_pcache_page.pExtra points to PgHdr. +** +** The size of the extension (MemPage+PgHdr+PgHdr1) can be determined at +** runtime using sqlite3_config(SQLITE_CONFIG_PCACHE_HDRSZ, &size). The +** sizes of the extensions sum to 272 bytes on x64 for 3.8.10, but this +** size can vary according to architecture, compile-time options, and +** SQLite library version number. +** +** If SQLITE_PCACHE_SEPARATE_HEADER is defined, then the extension is obtained +** using a separate memory allocation from the database page content. This +** seeks to overcome the "clownshoe" problem (also called "internal +** fragmentation" in academic literature) of allocating a few bytes more +** than a power of two with the memory allocator rounding up to the next +** power of two, and leaving the rounded-up space unused. +** +** This module tracks pointers to PgHdr1 objects. Only pcache.c communicates +** with this module. Information is passed back and forth as PgHdr1 pointers. +** +** The pcache.c and pager.c modules deal pointers to PgHdr objects. +** The btree.c module deals with pointers to MemPage objects. +** +** SOURCE OF PAGE CACHE MEMORY: +** +** Memory for a page might come from any of three sources: +** +** (1) The general-purpose memory allocator - sqlite3Malloc() +** (2) Global page-cache memory provided using sqlite3_config() with +** SQLITE_CONFIG_PAGECACHE. +** (3) PCache-local bulk allocation. +** +** The third case is a chunk of heap memory (defaulting to 100 pages worth) +** that is allocated when the page cache is created. The size of the local +** bulk allocation can be adjusted using +** +** sqlite3_config(SQLITE_CONFIG_PAGECACHE, 0, 0, N). +** +** If N is positive, then N pages worth of memory are allocated using a single +** sqlite3Malloc() call and that memory is used for the first N pages allocated. +** Or if N is negative, then -1024*N bytes of memory are allocated and used +** for as many pages as can be accomodated. +** +** Only one of (2) or (3) can be used. Once the memory available to (2) or +** (3) is exhausted, subsequent allocations fail over to the general-purpose +** memory allocator (1). +** +** Earlier versions of SQLite used only methods (1) and (2). But experiments +** show that method (3) with N==100 provides about a 5% performance boost for +** common workloads. +*/ +/* #include "sqliteInt.h" */ + +typedef struct PCache1 PCache1; +typedef struct PgHdr1 PgHdr1; +typedef struct PgFreeslot PgFreeslot; +typedef struct PGroup PGroup; + +/* +** Each cache entry is represented by an instance of the following +** structure. Unless SQLITE_PCACHE_SEPARATE_HEADER is defined, a buffer of +** PgHdr1.pCache->szPage bytes is allocated directly before this structure +** in memory. +*/ +struct PgHdr1 { + sqlite3_pcache_page page; /* Base class. Must be first. pBuf & pExtra */ + unsigned int iKey; /* Key value (page number) */ + u8 isPinned; /* Page in use, not on the LRU list */ + u8 isBulkLocal; /* This page from bulk local storage */ + u8 isAnchor; /* This is the PGroup.lru element */ + PgHdr1 *pNext; /* Next in hash table chain */ + PCache1 *pCache; /* Cache that currently owns this page */ + PgHdr1 *pLruNext; /* Next in LRU list of unpinned pages */ + PgHdr1 *pLruPrev; /* Previous in LRU list of unpinned pages */ +}; + +/* Each page cache (or PCache) belongs to a PGroup. A PGroup is a set +** of one or more PCaches that are able to recycle each other's unpinned +** pages when they are under memory pressure. A PGroup is an instance of +** the following object. +** +** This page cache implementation works in one of two modes: +** +** (1) Every PCache is the sole member of its own PGroup. There is +** one PGroup per PCache. +** +** (2) There is a single global PGroup that all PCaches are a member +** of. +** +** Mode 1 uses more memory (since PCache instances are not able to rob +** unused pages from other PCaches) but it also operates without a mutex, +** and is therefore often faster. Mode 2 requires a mutex in order to be +** threadsafe, but recycles pages more efficiently. +** +** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single +** PGroup which is the pcache1.grp global variable and its mutex is +** SQLITE_MUTEX_STATIC_LRU. +*/ +struct PGroup { + sqlite3_mutex *mutex; /* MUTEX_STATIC_LRU or NULL */ + unsigned int nMaxPage; /* Sum of nMax for purgeable caches */ + unsigned int nMinPage; /* Sum of nMin for purgeable caches */ + unsigned int mxPinned; /* nMaxpage + 10 - nMinPage */ + unsigned int nCurrentPage; /* Number of purgeable pages allocated */ + PgHdr1 lru; /* The beginning and end of the LRU list */ +}; + +/* Each page cache is an instance of the following object. Every +** open database file (including each in-memory database and each +** temporary or transient database) has a single page cache which +** is an instance of this object. +** +** Pointers to structures of this type are cast and returned as +** opaque sqlite3_pcache* handles. +*/ +struct PCache1 { + /* Cache configuration parameters. Page size (szPage) and the purgeable + ** flag (bPurgeable) are set when the cache is created. nMax may be + ** modified at any time by a call to the pcache1Cachesize() method. + ** The PGroup mutex must be held when accessing nMax. + */ + PGroup *pGroup; /* PGroup this cache belongs to */ + int szPage; /* Size of database content section */ + int szExtra; /* sizeof(MemPage)+sizeof(PgHdr) */ + int szAlloc; /* Total size of one pcache line */ + int bPurgeable; /* True if cache is purgeable */ + unsigned int nMin; /* Minimum number of pages reserved */ + unsigned int nMax; /* Configured "cache_size" value */ + unsigned int n90pct; /* nMax*9/10 */ + unsigned int iMaxKey; /* Largest key seen since xTruncate() */ + + /* Hash table of all pages. The following variables may only be accessed + ** when the accessor is holding the PGroup mutex. + */ + unsigned int nRecyclable; /* Number of pages in the LRU list */ + unsigned int nPage; /* Total number of pages in apHash */ + unsigned int nHash; /* Number of slots in apHash[] */ + PgHdr1 **apHash; /* Hash table for fast lookup by key */ + PgHdr1 *pFree; /* List of unused pcache-local pages */ + void *pBulk; /* Bulk memory used by pcache-local */ +}; + +/* +** Free slots in the allocator used to divide up the global page cache +** buffer provided using the SQLITE_CONFIG_PAGECACHE mechanism. +*/ +struct PgFreeslot { + PgFreeslot *pNext; /* Next free slot */ +}; + +/* +** Global data used by this cache. +*/ +static SQLITE_WSD struct PCacheGlobal { + PGroup grp; /* The global PGroup for mode (2) */ + + /* Variables related to SQLITE_CONFIG_PAGECACHE settings. The + ** szSlot, nSlot, pStart, pEnd, nReserve, and isInit values are all + ** fixed at sqlite3_initialize() time and do not require mutex protection. + ** The nFreeSlot and pFree values do require mutex protection. + */ + int isInit; /* True if initialized */ + int separateCache; /* Use a new PGroup for each PCache */ + int nInitPage; /* Initial bulk allocation size */ + int szSlot; /* Size of each free slot */ + int nSlot; /* The number of pcache slots */ + int nReserve; /* Try to keep nFreeSlot above this */ + void *pStart, *pEnd; /* Bounds of global page cache memory */ + /* Above requires no mutex. Use mutex below for variable that follow. */ + sqlite3_mutex *mutex; /* Mutex for accessing the following: */ + PgFreeslot *pFree; /* Free page blocks */ + int nFreeSlot; /* Number of unused pcache slots */ + /* The following value requires a mutex to change. We skip the mutex on + ** reading because (1) most platforms read a 32-bit integer atomically and + ** (2) even if an incorrect value is read, no great harm is done since this + ** is really just an optimization. */ + int bUnderPressure; /* True if low on PAGECACHE memory */ +} pcache1_g; + +/* +** All code in this file should access the global structure above via the +** alias "pcache1". This ensures that the WSD emulation is used when +** compiling for systems that do not support real WSD. +*/ +#define pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g)) + +/* +** Macros to enter and leave the PCache LRU mutex. +*/ +#if !defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) || SQLITE_THREADSAFE==0 +# define pcache1EnterMutex(X) assert((X)->mutex==0) +# define pcache1LeaveMutex(X) assert((X)->mutex==0) +# define PCACHE1_MIGHT_USE_GROUP_MUTEX 0 +#else +# define pcache1EnterMutex(X) sqlite3_mutex_enter((X)->mutex) +# define pcache1LeaveMutex(X) sqlite3_mutex_leave((X)->mutex) +# define PCACHE1_MIGHT_USE_GROUP_MUTEX 1 +#endif + +/******************************************************************************/ +/******** Page Allocation/SQLITE_CONFIG_PCACHE Related Functions **************/ + + +/* +** This function is called during initialization if a static buffer is +** supplied to use for the page-cache by passing the SQLITE_CONFIG_PAGECACHE +** verb to sqlite3_config(). Parameter pBuf points to an allocation large +** enough to contain 'n' buffers of 'sz' bytes each. +** +** This routine is called from sqlite3_initialize() and so it is guaranteed +** to be serialized already. There is no need for further mutexing. +*/ +SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){ + if( pcache1.isInit ){ + PgFreeslot *p; + if( pBuf==0 ) sz = n = 0; + sz = ROUNDDOWN8(sz); + pcache1.szSlot = sz; + pcache1.nSlot = pcache1.nFreeSlot = n; + pcache1.nReserve = n>90 ? 10 : (n/10 + 1); + pcache1.pStart = pBuf; + pcache1.pFree = 0; + pcache1.bUnderPressure = 0; + while( n-- ){ + p = (PgFreeslot*)pBuf; + p->pNext = pcache1.pFree; + pcache1.pFree = p; + pBuf = (void*)&((char*)pBuf)[sz]; + } + pcache1.pEnd = pBuf; + } +} + +/* +** Try to initialize the pCache->pFree and pCache->pBulk fields. Return +** true if pCache->pFree ends up containing one or more free pages. +*/ +static int pcache1InitBulk(PCache1 *pCache){ + i64 szBulk; + char *zBulk; + if( pcache1.nInitPage==0 ) return 0; + /* Do not bother with a bulk allocation if the cache size very small */ + if( pCache->nMax<3 ) return 0; + sqlite3BeginBenignMalloc(); + if( pcache1.nInitPage>0 ){ + szBulk = pCache->szAlloc * (i64)pcache1.nInitPage; + }else{ + szBulk = -1024 * (i64)pcache1.nInitPage; + } + if( szBulk > pCache->szAlloc*(i64)pCache->nMax ){ + szBulk = pCache->szAlloc*pCache->nMax; + } + zBulk = pCache->pBulk = sqlite3Malloc( szBulk ); + sqlite3EndBenignMalloc(); + if( zBulk ){ + int nBulk = sqlite3MallocSize(zBulk)/pCache->szAlloc; + int i; + for(i=0; iszPage]; + pX->page.pBuf = zBulk; + pX->page.pExtra = &pX[1]; + pX->isBulkLocal = 1; + pX->isAnchor = 0; + pX->pNext = pCache->pFree; + pCache->pFree = pX; + zBulk += pCache->szAlloc; + } + } + return pCache->pFree!=0; +} + +/* +** Malloc function used within this file to allocate space from the buffer +** configured using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no +** such buffer exists or there is no space left in it, this function falls +** back to sqlite3Malloc(). +** +** Multiple threads can run this routine at the same time. Global variables +** in pcache1 need to be protected via mutex. +*/ +static void *pcache1Alloc(int nByte){ + void *p = 0; + assert( sqlite3_mutex_notheld(pcache1.grp.mutex) ); + if( nByte<=pcache1.szSlot ){ + sqlite3_mutex_enter(pcache1.mutex); + p = (PgHdr1 *)pcache1.pFree; + if( p ){ + pcache1.pFree = pcache1.pFree->pNext; + pcache1.nFreeSlot--; + pcache1.bUnderPressure = pcache1.nFreeSlot=0 ); + sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte); + sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_USED, 1); + } + sqlite3_mutex_leave(pcache1.mutex); + } + if( p==0 ){ + /* Memory is not available in the SQLITE_CONFIG_PAGECACHE pool. Get + ** it from sqlite3Malloc instead. + */ + p = sqlite3Malloc(nByte); +#ifndef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS + if( p ){ + int sz = sqlite3MallocSize(p); + sqlite3_mutex_enter(pcache1.mutex); + sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte); + sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_OVERFLOW, sz); + sqlite3_mutex_leave(pcache1.mutex); + } +#endif + sqlite3MemdebugSetType(p, MEMTYPE_PCACHE); + } + return p; +} + +/* +** Free an allocated buffer obtained from pcache1Alloc(). +*/ +static void pcache1Free(void *p){ + int nFreed = 0; + if( p==0 ) return; + if( p>=pcache1.pStart && ppNext = pcache1.pFree; + pcache1.pFree = pSlot; + pcache1.nFreeSlot++; + pcache1.bUnderPressure = pcache1.nFreeSlot=pcache1.pStart && ppGroup->mutex) ); + if( pCache->pFree || (pCache->nPage==0 && pcache1InitBulk(pCache)) ){ + p = pCache->pFree; + pCache->pFree = p->pNext; + p->pNext = 0; + }else{ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + /* The group mutex must be released before pcache1Alloc() is called. This + ** is because it might call sqlite3_release_memory(), which assumes that + ** this mutex is not held. */ + assert( pcache1.separateCache==0 ); + assert( pCache->pGroup==&pcache1.grp ); + pcache1LeaveMutex(pCache->pGroup); +#endif + if( benignMalloc ){ sqlite3BeginBenignMalloc(); } +#ifdef SQLITE_PCACHE_SEPARATE_HEADER + pPg = pcache1Alloc(pCache->szPage); + p = sqlite3Malloc(sizeof(PgHdr1) + pCache->szExtra); + if( !pPg || !p ){ + pcache1Free(pPg); + sqlite3_free(p); + pPg = 0; + } +#else + pPg = pcache1Alloc(pCache->szAlloc); + p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage]; +#endif + if( benignMalloc ){ sqlite3EndBenignMalloc(); } +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + pcache1EnterMutex(pCache->pGroup); +#endif + if( pPg==0 ) return 0; + p->page.pBuf = pPg; + p->page.pExtra = &p[1]; + p->isBulkLocal = 0; + p->isAnchor = 0; + } + if( pCache->bPurgeable ){ + pCache->pGroup->nCurrentPage++; + } + return p; +} + +/* +** Free a page object allocated by pcache1AllocPage(). +*/ +static void pcache1FreePage(PgHdr1 *p){ + PCache1 *pCache; + assert( p!=0 ); + pCache = p->pCache; + assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) ); + if( p->isBulkLocal ){ + p->pNext = pCache->pFree; + pCache->pFree = p; + }else{ + pcache1Free(p->page.pBuf); +#ifdef SQLITE_PCACHE_SEPARATE_HEADER + sqlite3_free(p); +#endif + } + if( pCache->bPurgeable ){ + pCache->pGroup->nCurrentPage--; + } +} + +/* +** Malloc function used by SQLite to obtain space from the buffer configured +** using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no such buffer +** exists, this function falls back to sqlite3Malloc(). +*/ +SQLITE_PRIVATE void *sqlite3PageMalloc(int sz){ + return pcache1Alloc(sz); +} + +/* +** Free an allocated buffer obtained from sqlite3PageMalloc(). +*/ +SQLITE_PRIVATE void sqlite3PageFree(void *p){ + pcache1Free(p); +} + + +/* +** Return true if it desirable to avoid allocating a new page cache +** entry. +** +** If memory was allocated specifically to the page cache using +** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then +** it is desirable to avoid allocating a new page cache entry because +** presumably SQLITE_CONFIG_PAGECACHE was suppose to be sufficient +** for all page cache needs and we should not need to spill the +** allocation onto the heap. +** +** Or, the heap is used for all page cache memory but the heap is +** under memory pressure, then again it is desirable to avoid +** allocating a new page cache entry in order to avoid stressing +** the heap even further. +*/ +static int pcache1UnderMemoryPressure(PCache1 *pCache){ + if( pcache1.nSlot && (pCache->szPage+pCache->szExtra)<=pcache1.szSlot ){ + return pcache1.bUnderPressure; + }else{ + return sqlite3HeapNearlyFull(); + } +} + +/******************************************************************************/ +/******** General Implementation Functions ************************************/ + +/* +** This function is used to resize the hash table used by the cache passed +** as the first argument. +** +** The PCache mutex must be held when this function is called. +*/ +static void pcache1ResizeHash(PCache1 *p){ + PgHdr1 **apNew; + unsigned int nNew; + unsigned int i; + + assert( sqlite3_mutex_held(p->pGroup->mutex) ); + + nNew = p->nHash*2; + if( nNew<256 ){ + nNew = 256; + } + + pcache1LeaveMutex(p->pGroup); + if( p->nHash ){ sqlite3BeginBenignMalloc(); } + apNew = (PgHdr1 **)sqlite3MallocZero(sizeof(PgHdr1 *)*nNew); + if( p->nHash ){ sqlite3EndBenignMalloc(); } + pcache1EnterMutex(p->pGroup); + if( apNew ){ + for(i=0; inHash; i++){ + PgHdr1 *pPage; + PgHdr1 *pNext = p->apHash[i]; + while( (pPage = pNext)!=0 ){ + unsigned int h = pPage->iKey % nNew; + pNext = pPage->pNext; + pPage->pNext = apNew[h]; + apNew[h] = pPage; + } + } + sqlite3_free(p->apHash); + p->apHash = apNew; + p->nHash = nNew; + } +} + +/* +** This function is used internally to remove the page pPage from the +** PGroup LRU list, if is part of it. If pPage is not part of the PGroup +** LRU list, then this function is a no-op. +** +** The PGroup mutex must be held when this function is called. +*/ +static PgHdr1 *pcache1PinPage(PgHdr1 *pPage){ + PCache1 *pCache; + + assert( pPage!=0 ); + assert( pPage->isPinned==0 ); + pCache = pPage->pCache; + assert( pPage->pLruNext ); + assert( pPage->pLruPrev ); + assert( sqlite3_mutex_held(pCache->pGroup->mutex) ); + pPage->pLruPrev->pLruNext = pPage->pLruNext; + pPage->pLruNext->pLruPrev = pPage->pLruPrev; + pPage->pLruNext = 0; + pPage->pLruPrev = 0; + pPage->isPinned = 1; + assert( pPage->isAnchor==0 ); + assert( pCache->pGroup->lru.isAnchor==1 ); + pCache->nRecyclable--; + return pPage; +} + + +/* +** Remove the page supplied as an argument from the hash table +** (PCache1.apHash structure) that it is currently stored in. +** Also free the page if freePage is true. +** +** The PGroup mutex must be held when this function is called. +*/ +static void pcache1RemoveFromHash(PgHdr1 *pPage, int freeFlag){ + unsigned int h; + PCache1 *pCache = pPage->pCache; + PgHdr1 **pp; + + assert( sqlite3_mutex_held(pCache->pGroup->mutex) ); + h = pPage->iKey % pCache->nHash; + for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext); + *pp = (*pp)->pNext; + + pCache->nPage--; + if( freeFlag ) pcache1FreePage(pPage); +} + +/* +** If there are currently more than nMaxPage pages allocated, try +** to recycle pages to reduce the number allocated to nMaxPage. +*/ +static void pcache1EnforceMaxPage(PCache1 *pCache){ + PGroup *pGroup = pCache->pGroup; + PgHdr1 *p; + assert( sqlite3_mutex_held(pGroup->mutex) ); + while( pGroup->nCurrentPage>pGroup->nMaxPage + && (p=pGroup->lru.pLruPrev)->isAnchor==0 + ){ + assert( p->pCache->pGroup==pGroup ); + assert( p->isPinned==0 ); + pcache1PinPage(p); + pcache1RemoveFromHash(p, 1); + } + if( pCache->nPage==0 && pCache->pBulk ){ + sqlite3_free(pCache->pBulk); + pCache->pBulk = pCache->pFree = 0; + } +} + +/* +** Discard all pages from cache pCache with a page number (key value) +** greater than or equal to iLimit. Any pinned pages that meet this +** criteria are unpinned before they are discarded. +** +** The PCache mutex must be held when this function is called. +*/ +static void pcache1TruncateUnsafe( + PCache1 *pCache, /* The cache to truncate */ + unsigned int iLimit /* Drop pages with this pgno or larger */ +){ + TESTONLY( unsigned int nPage = 0; ) /* To assert pCache->nPage is correct */ + unsigned int h; + assert( sqlite3_mutex_held(pCache->pGroup->mutex) ); + for(h=0; hnHash; h++){ + PgHdr1 **pp = &pCache->apHash[h]; + PgHdr1 *pPage; + while( (pPage = *pp)!=0 ){ + if( pPage->iKey>=iLimit ){ + pCache->nPage--; + *pp = pPage->pNext; + if( !pPage->isPinned ) pcache1PinPage(pPage); + pcache1FreePage(pPage); + }else{ + pp = &pPage->pNext; + TESTONLY( nPage++; ) + } + } + } + assert( pCache->nPage==nPage ); +} + +/******************************************************************************/ +/******** sqlite3_pcache Methods **********************************************/ + +/* +** Implementation of the sqlite3_pcache.xInit method. +*/ +static int pcache1Init(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + assert( pcache1.isInit==0 ); + memset(&pcache1, 0, sizeof(pcache1)); + + + /* + ** The pcache1.separateCache variable is true if each PCache has its own + ** private PGroup (mode-1). pcache1.separateCache is false if the single + ** PGroup in pcache1.grp is used for all page caches (mode-2). + ** + ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT + ** + ** * Use a unified cache in single-threaded applications that have + ** configured a start-time buffer for use as page-cache memory using + ** sqlite3_config(SQLITE_CONFIG_PAGECACHE, pBuf, sz, N) with non-NULL + ** pBuf argument. + ** + ** * Otherwise use separate caches (mode-1) + */ +#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) + pcache1.separateCache = 0; +#elif SQLITE_THREADSAFE + pcache1.separateCache = sqlite3GlobalConfig.pPage==0 + || sqlite3GlobalConfig.bCoreMutex>0; +#else + pcache1.separateCache = sqlite3GlobalConfig.pPage==0; +#endif + +#if SQLITE_THREADSAFE + if( sqlite3GlobalConfig.bCoreMutex ){ + pcache1.grp.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU); + pcache1.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PMEM); + } +#endif + if( pcache1.separateCache + && sqlite3GlobalConfig.nPage!=0 + && sqlite3GlobalConfig.pPage==0 + ){ + pcache1.nInitPage = sqlite3GlobalConfig.nPage; + }else{ + pcache1.nInitPage = 0; + } + pcache1.grp.mxPinned = 10; + pcache1.isInit = 1; + return SQLITE_OK; +} + +/* +** Implementation of the sqlite3_pcache.xShutdown method. +** Note that the static mutex allocated in xInit does +** not need to be freed. +*/ +static void pcache1Shutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + assert( pcache1.isInit!=0 ); + memset(&pcache1, 0, sizeof(pcache1)); +} + +/* forward declaration */ +static void pcache1Destroy(sqlite3_pcache *p); + +/* +** Implementation of the sqlite3_pcache.xCreate method. +** +** Allocate a new cache. +*/ +static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){ + PCache1 *pCache; /* The newly created page cache */ + PGroup *pGroup; /* The group the new page cache will belong to */ + int sz; /* Bytes of memory required to allocate the new cache */ + + assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 ); + assert( szExtra < 300 ); + + sz = sizeof(PCache1) + sizeof(PGroup)*pcache1.separateCache; + pCache = (PCache1 *)sqlite3MallocZero(sz); + if( pCache ){ + if( pcache1.separateCache ){ + pGroup = (PGroup*)&pCache[1]; + pGroup->mxPinned = 10; + }else{ + pGroup = &pcache1.grp; + } + if( pGroup->lru.isAnchor==0 ){ + pGroup->lru.isAnchor = 1; + pGroup->lru.pLruPrev = pGroup->lru.pLruNext = &pGroup->lru; + } + pCache->pGroup = pGroup; + pCache->szPage = szPage; + pCache->szExtra = szExtra; + pCache->szAlloc = szPage + szExtra + ROUND8(sizeof(PgHdr1)); + pCache->bPurgeable = (bPurgeable ? 1 : 0); + pcache1EnterMutex(pGroup); + pcache1ResizeHash(pCache); + if( bPurgeable ){ + pCache->nMin = 10; + pGroup->nMinPage += pCache->nMin; + pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage; + } + pcache1LeaveMutex(pGroup); + if( pCache->nHash==0 ){ + pcache1Destroy((sqlite3_pcache*)pCache); + pCache = 0; + } + } + return (sqlite3_pcache *)pCache; +} + +/* +** Implementation of the sqlite3_pcache.xCachesize method. +** +** Configure the cache_size limit for a cache. +*/ +static void pcache1Cachesize(sqlite3_pcache *p, int nMax){ + PCache1 *pCache = (PCache1 *)p; + if( pCache->bPurgeable ){ + PGroup *pGroup = pCache->pGroup; + pcache1EnterMutex(pGroup); + pGroup->nMaxPage += (nMax - pCache->nMax); + pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage; + pCache->nMax = nMax; + pCache->n90pct = pCache->nMax*9/10; + pcache1EnforceMaxPage(pCache); + pcache1LeaveMutex(pGroup); + } +} + +/* +** Implementation of the sqlite3_pcache.xShrink method. +** +** Free up as much memory as possible. +*/ +static void pcache1Shrink(sqlite3_pcache *p){ + PCache1 *pCache = (PCache1*)p; + if( pCache->bPurgeable ){ + PGroup *pGroup = pCache->pGroup; + int savedMaxPage; + pcache1EnterMutex(pGroup); + savedMaxPage = pGroup->nMaxPage; + pGroup->nMaxPage = 0; + pcache1EnforceMaxPage(pCache); + pGroup->nMaxPage = savedMaxPage; + pcache1LeaveMutex(pGroup); + } +} + +/* +** Implementation of the sqlite3_pcache.xPagecount method. +*/ +static int pcache1Pagecount(sqlite3_pcache *p){ + int n; + PCache1 *pCache = (PCache1*)p; + pcache1EnterMutex(pCache->pGroup); + n = pCache->nPage; + pcache1LeaveMutex(pCache->pGroup); + return n; +} + + +/* +** Implement steps 3, 4, and 5 of the pcache1Fetch() algorithm described +** in the header of the pcache1Fetch() procedure. +** +** This steps are broken out into a separate procedure because they are +** usually not needed, and by avoiding the stack initialization required +** for these steps, the main pcache1Fetch() procedure can run faster. +*/ +static SQLITE_NOINLINE PgHdr1 *pcache1FetchStage2( + PCache1 *pCache, + unsigned int iKey, + int createFlag +){ + unsigned int nPinned; + PGroup *pGroup = pCache->pGroup; + PgHdr1 *pPage = 0; + + /* Step 3: Abort if createFlag is 1 but the cache is nearly full */ + assert( pCache->nPage >= pCache->nRecyclable ); + nPinned = pCache->nPage - pCache->nRecyclable; + assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage ); + assert( pCache->n90pct == pCache->nMax*9/10 ); + if( createFlag==1 && ( + nPinned>=pGroup->mxPinned + || nPinned>=pCache->n90pct + || (pcache1UnderMemoryPressure(pCache) && pCache->nRecyclablenPage>=pCache->nHash ) pcache1ResizeHash(pCache); + assert( pCache->nHash>0 && pCache->apHash ); + + /* Step 4. Try to recycle a page. */ + if( pCache->bPurgeable + && !pGroup->lru.pLruPrev->isAnchor + && ((pCache->nPage+1>=pCache->nMax) || pcache1UnderMemoryPressure(pCache)) + ){ + PCache1 *pOther; + pPage = pGroup->lru.pLruPrev; + assert( pPage->isPinned==0 ); + pcache1RemoveFromHash(pPage, 0); + pcache1PinPage(pPage); + pOther = pPage->pCache; + if( pOther->szAlloc != pCache->szAlloc ){ + pcache1FreePage(pPage); + pPage = 0; + }else{ + pGroup->nCurrentPage -= (pOther->bPurgeable - pCache->bPurgeable); + } + } + + /* Step 5. If a usable page buffer has still not been found, + ** attempt to allocate a new one. + */ + if( !pPage ){ + pPage = pcache1AllocPage(pCache, createFlag==1); + } + + if( pPage ){ + unsigned int h = iKey % pCache->nHash; + pCache->nPage++; + pPage->iKey = iKey; + pPage->pNext = pCache->apHash[h]; + pPage->pCache = pCache; + pPage->pLruPrev = 0; + pPage->pLruNext = 0; + pPage->isPinned = 1; + *(void **)pPage->page.pExtra = 0; + pCache->apHash[h] = pPage; + if( iKey>pCache->iMaxKey ){ + pCache->iMaxKey = iKey; + } + } + return pPage; +} + +/* +** Implementation of the sqlite3_pcache.xFetch method. +** +** Fetch a page by key value. +** +** Whether or not a new page may be allocated by this function depends on +** the value of the createFlag argument. 0 means do not allocate a new +** page. 1 means allocate a new page if space is easily available. 2 +** means to try really hard to allocate a new page. +** +** For a non-purgeable cache (a cache used as the storage for an in-memory +** database) there is really no difference between createFlag 1 and 2. So +** the calling function (pcache.c) will never have a createFlag of 1 on +** a non-purgeable cache. +** +** There are three different approaches to obtaining space for a page, +** depending on the value of parameter createFlag (which may be 0, 1 or 2). +** +** 1. Regardless of the value of createFlag, the cache is searched for a +** copy of the requested page. If one is found, it is returned. +** +** 2. If createFlag==0 and the page is not already in the cache, NULL is +** returned. +** +** 3. If createFlag is 1, and the page is not already in the cache, then +** return NULL (do not allocate a new page) if any of the following +** conditions are true: +** +** (a) the number of pages pinned by the cache is greater than +** PCache1.nMax, or +** +** (b) the number of pages pinned by the cache is greater than +** the sum of nMax for all purgeable caches, less the sum of +** nMin for all other purgeable caches, or +** +** 4. If none of the first three conditions apply and the cache is marked +** as purgeable, and if one of the following is true: +** +** (a) The number of pages allocated for the cache is already +** PCache1.nMax, or +** +** (b) The number of pages allocated for all purgeable caches is +** already equal to or greater than the sum of nMax for all +** purgeable caches, +** +** (c) The system is under memory pressure and wants to avoid +** unnecessary pages cache entry allocations +** +** then attempt to recycle a page from the LRU list. If it is the right +** size, return the recycled buffer. Otherwise, free the buffer and +** proceed to step 5. +** +** 5. Otherwise, allocate and return a new page buffer. +** +** There are two versions of this routine. pcache1FetchWithMutex() is +** the general case. pcache1FetchNoMutex() is a faster implementation for +** the common case where pGroup->mutex is NULL. The pcache1Fetch() wrapper +** invokes the appropriate routine. +*/ +static PgHdr1 *pcache1FetchNoMutex( + sqlite3_pcache *p, + unsigned int iKey, + int createFlag +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage = 0; + + /* Step 1: Search the hash table for an existing entry. */ + pPage = pCache->apHash[iKey % pCache->nHash]; + while( pPage && pPage->iKey!=iKey ){ pPage = pPage->pNext; } + + /* Step 2: If the page was found in the hash table, then return it. + ** If the page was not in the hash table and createFlag is 0, abort. + ** Otherwise (page not in hash and createFlag!=0) continue with + ** subsequent steps to try to create the page. */ + if( pPage ){ + if( !pPage->isPinned ){ + return pcache1PinPage(pPage); + }else{ + return pPage; + } + }else if( createFlag ){ + /* Steps 3, 4, and 5 implemented by this subroutine */ + return pcache1FetchStage2(pCache, iKey, createFlag); + }else{ + return 0; + } +} +#if PCACHE1_MIGHT_USE_GROUP_MUTEX +static PgHdr1 *pcache1FetchWithMutex( + sqlite3_pcache *p, + unsigned int iKey, + int createFlag +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage; + + pcache1EnterMutex(pCache->pGroup); + pPage = pcache1FetchNoMutex(p, iKey, createFlag); + assert( pPage==0 || pCache->iMaxKey>=iKey ); + pcache1LeaveMutex(pCache->pGroup); + return pPage; +} +#endif +static sqlite3_pcache_page *pcache1Fetch( + sqlite3_pcache *p, + unsigned int iKey, + int createFlag +){ +#if PCACHE1_MIGHT_USE_GROUP_MUTEX || defined(SQLITE_DEBUG) + PCache1 *pCache = (PCache1 *)p; +#endif + + assert( offsetof(PgHdr1,page)==0 ); + assert( pCache->bPurgeable || createFlag!=1 ); + assert( pCache->bPurgeable || pCache->nMin==0 ); + assert( pCache->bPurgeable==0 || pCache->nMin==10 ); + assert( pCache->nMin==0 || pCache->bPurgeable ); + assert( pCache->nHash>0 ); +#if PCACHE1_MIGHT_USE_GROUP_MUTEX + if( pCache->pGroup->mutex ){ + return (sqlite3_pcache_page*)pcache1FetchWithMutex(p, iKey, createFlag); + }else +#endif + { + return (sqlite3_pcache_page*)pcache1FetchNoMutex(p, iKey, createFlag); + } +} + + +/* +** Implementation of the sqlite3_pcache.xUnpin method. +** +** Mark a page as unpinned (eligible for asynchronous recycling). +*/ +static void pcache1Unpin( + sqlite3_pcache *p, + sqlite3_pcache_page *pPg, + int reuseUnlikely +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage = (PgHdr1 *)pPg; + PGroup *pGroup = pCache->pGroup; + + assert( pPage->pCache==pCache ); + pcache1EnterMutex(pGroup); + + /* It is an error to call this function if the page is already + ** part of the PGroup LRU list. + */ + assert( pPage->pLruPrev==0 && pPage->pLruNext==0 ); + assert( pPage->isPinned==1 ); + + if( reuseUnlikely || pGroup->nCurrentPage>pGroup->nMaxPage ){ + pcache1RemoveFromHash(pPage, 1); + }else{ + /* Add the page to the PGroup LRU list. */ + PgHdr1 **ppFirst = &pGroup->lru.pLruNext; + pPage->pLruPrev = &pGroup->lru; + (pPage->pLruNext = *ppFirst)->pLruPrev = pPage; + *ppFirst = pPage; + pCache->nRecyclable++; + pPage->isPinned = 0; + } + + pcache1LeaveMutex(pCache->pGroup); +} + +/* +** Implementation of the sqlite3_pcache.xRekey method. +*/ +static void pcache1Rekey( + sqlite3_pcache *p, + sqlite3_pcache_page *pPg, + unsigned int iOld, + unsigned int iNew +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage = (PgHdr1 *)pPg; + PgHdr1 **pp; + unsigned int h; + assert( pPage->iKey==iOld ); + assert( pPage->pCache==pCache ); + + pcache1EnterMutex(pCache->pGroup); + + h = iOld%pCache->nHash; + pp = &pCache->apHash[h]; + while( (*pp)!=pPage ){ + pp = &(*pp)->pNext; + } + *pp = pPage->pNext; + + h = iNew%pCache->nHash; + pPage->iKey = iNew; + pPage->pNext = pCache->apHash[h]; + pCache->apHash[h] = pPage; + if( iNew>pCache->iMaxKey ){ + pCache->iMaxKey = iNew; + } + + pcache1LeaveMutex(pCache->pGroup); +} + +/* +** Implementation of the sqlite3_pcache.xTruncate method. +** +** Discard all unpinned pages in the cache with a page number equal to +** or greater than parameter iLimit. Any pinned pages with a page number +** equal to or greater than iLimit are implicitly unpinned. +*/ +static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){ + PCache1 *pCache = (PCache1 *)p; + pcache1EnterMutex(pCache->pGroup); + if( iLimit<=pCache->iMaxKey ){ + pcache1TruncateUnsafe(pCache, iLimit); + pCache->iMaxKey = iLimit-1; + } + pcache1LeaveMutex(pCache->pGroup); +} + +/* +** Implementation of the sqlite3_pcache.xDestroy method. +** +** Destroy a cache allocated using pcache1Create(). +*/ +static void pcache1Destroy(sqlite3_pcache *p){ + PCache1 *pCache = (PCache1 *)p; + PGroup *pGroup = pCache->pGroup; + assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) ); + pcache1EnterMutex(pGroup); + pcache1TruncateUnsafe(pCache, 0); + assert( pGroup->nMaxPage >= pCache->nMax ); + pGroup->nMaxPage -= pCache->nMax; + assert( pGroup->nMinPage >= pCache->nMin ); + pGroup->nMinPage -= pCache->nMin; + pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage; + pcache1EnforceMaxPage(pCache); + pcache1LeaveMutex(pGroup); + sqlite3_free(pCache->pBulk); + sqlite3_free(pCache->apHash); + sqlite3_free(pCache); +} + +/* +** This function is called during initialization (sqlite3_initialize()) to +** install the default pluggable cache module, assuming the user has not +** already provided an alternative. +*/ +SQLITE_PRIVATE void sqlite3PCacheSetDefault(void){ + static const sqlite3_pcache_methods2 defaultMethods = { + 1, /* iVersion */ + 0, /* pArg */ + pcache1Init, /* xInit */ + pcache1Shutdown, /* xShutdown */ + pcache1Create, /* xCreate */ + pcache1Cachesize, /* xCachesize */ + pcache1Pagecount, /* xPagecount */ + pcache1Fetch, /* xFetch */ + pcache1Unpin, /* xUnpin */ + pcache1Rekey, /* xRekey */ + pcache1Truncate, /* xTruncate */ + pcache1Destroy, /* xDestroy */ + pcache1Shrink /* xShrink */ + }; + sqlite3_config(SQLITE_CONFIG_PCACHE2, &defaultMethods); +} + +/* +** Return the size of the header on each page of this PCACHE implementation. +*/ +SQLITE_PRIVATE int sqlite3HeaderSizePcache1(void){ return ROUND8(sizeof(PgHdr1)); } + +/* +** Return the global mutex used by this PCACHE implementation. The +** sqlite3_status() routine needs access to this mutex. +*/ +SQLITE_PRIVATE sqlite3_mutex *sqlite3Pcache1Mutex(void){ + return pcache1.mutex; +} + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT +/* +** This function is called to free superfluous dynamically allocated memory +** held by the pager system. Memory in use by any SQLite pager allocated +** by the current thread may be sqlite3_free()ed. +** +** nReq is the number of bytes of memory required. Once this much has +** been released, the function returns. The return value is the total number +** of bytes of memory released. +*/ +SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int nReq){ + int nFree = 0; + assert( sqlite3_mutex_notheld(pcache1.grp.mutex) ); + assert( sqlite3_mutex_notheld(pcache1.mutex) ); + if( sqlite3GlobalConfig.nPage==0 ){ + PgHdr1 *p; + pcache1EnterMutex(&pcache1.grp); + while( (nReq<0 || nFreeisAnchor==0 + ){ + nFree += pcache1MemSize(p->page.pBuf); +#ifdef SQLITE_PCACHE_SEPARATE_HEADER + nFree += sqlite3MemSize(p); +#endif + assert( p->isPinned==0 ); + pcache1PinPage(p); + pcache1RemoveFromHash(p, 1); + } + pcache1LeaveMutex(&pcache1.grp); + } + return nFree; +} +#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */ + +#ifdef SQLITE_TEST +/* +** This function is used by test procedures to inspect the internal state +** of the global cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheStats( + int *pnCurrent, /* OUT: Total number of pages cached */ + int *pnMax, /* OUT: Global maximum cache size */ + int *pnMin, /* OUT: Sum of PCache1.nMin for purgeable caches */ + int *pnRecyclable /* OUT: Total number of pages available for recycling */ +){ + PgHdr1 *p; + int nRecyclable = 0; + for(p=pcache1.grp.lru.pLruNext; p && !p->isAnchor; p=p->pLruNext){ + assert( p->isPinned==0 ); + nRecyclable++; + } + *pnCurrent = pcache1.grp.nCurrentPage; + *pnMax = (int)pcache1.grp.nMaxPage; + *pnMin = (int)pcache1.grp.nMinPage; + *pnRecyclable = nRecyclable; +} +#endif + +/************** End of pcache1.c *********************************************/ +/************** Begin file rowset.c ******************************************/ +/* +** 2008 December 3 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This module implements an object we call a "RowSet". +** +** The RowSet object is a collection of rowids. Rowids +** are inserted into the RowSet in an arbitrary order. Inserts +** can be intermixed with tests to see if a given rowid has been +** previously inserted into the RowSet. +** +** After all inserts are finished, it is possible to extract the +** elements of the RowSet in sorted order. Once this extraction +** process has started, no new elements may be inserted. +** +** Hence, the primitive operations for a RowSet are: +** +** CREATE +** INSERT +** TEST +** SMALLEST +** DESTROY +** +** The CREATE and DESTROY primitives are the constructor and destructor, +** obviously. The INSERT primitive adds a new element to the RowSet. +** TEST checks to see if an element is already in the RowSet. SMALLEST +** extracts the least value from the RowSet. +** +** The INSERT primitive might allocate additional memory. Memory is +** allocated in chunks so most INSERTs do no allocation. There is an +** upper bound on the size of allocated memory. No memory is freed +** until DESTROY. +** +** The TEST primitive includes a "batch" number. The TEST primitive +** will only see elements that were inserted before the last change +** in the batch number. In other words, if an INSERT occurs between +** two TESTs where the TESTs have the same batch nubmer, then the +** value added by the INSERT will not be visible to the second TEST. +** The initial batch number is zero, so if the very first TEST contains +** a non-zero batch number, it will see all prior INSERTs. +** +** No INSERTs may occurs after a SMALLEST. An assertion will fail if +** that is attempted. +** +** The cost of an INSERT is roughly constant. (Sometimes new memory +** has to be allocated on an INSERT.) The cost of a TEST with a new +** batch number is O(NlogN) where N is the number of elements in the RowSet. +** The cost of a TEST using the same batch number is O(logN). The cost +** of the first SMALLEST is O(NlogN). Second and subsequent SMALLEST +** primitives are constant time. The cost of DESTROY is O(N). +** +** There is an added cost of O(N) when switching between TEST and +** SMALLEST primitives. +*/ +/* #include "sqliteInt.h" */ + + +/* +** Target size for allocation chunks. +*/ +#define ROWSET_ALLOCATION_SIZE 1024 + +/* +** The number of rowset entries per allocation chunk. +*/ +#define ROWSET_ENTRY_PER_CHUNK \ + ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry)) + +/* +** Each entry in a RowSet is an instance of the following object. +** +** This same object is reused to store a linked list of trees of RowSetEntry +** objects. In that alternative use, pRight points to the next entry +** in the list, pLeft points to the tree, and v is unused. The +** RowSet.pForest value points to the head of this forest list. +*/ +struct RowSetEntry { + i64 v; /* ROWID value for this entry */ + struct RowSetEntry *pRight; /* Right subtree (larger entries) or list */ + struct RowSetEntry *pLeft; /* Left subtree (smaller entries) */ +}; + +/* +** RowSetEntry objects are allocated in large chunks (instances of the +** following structure) to reduce memory allocation overhead. The +** chunks are kept on a linked list so that they can be deallocated +** when the RowSet is destroyed. +*/ +struct RowSetChunk { + struct RowSetChunk *pNextChunk; /* Next chunk on list of them all */ + struct RowSetEntry aEntry[ROWSET_ENTRY_PER_CHUNK]; /* Allocated entries */ +}; + +/* +** A RowSet in an instance of the following structure. +** +** A typedef of this structure if found in sqliteInt.h. +*/ +struct RowSet { + struct RowSetChunk *pChunk; /* List of all chunk allocations */ + sqlite3 *db; /* The database connection */ + struct RowSetEntry *pEntry; /* List of entries using pRight */ + struct RowSetEntry *pLast; /* Last entry on the pEntry list */ + struct RowSetEntry *pFresh; /* Source of new entry objects */ + struct RowSetEntry *pForest; /* List of binary trees of entries */ + u16 nFresh; /* Number of objects on pFresh */ + u16 rsFlags; /* Various flags */ + int iBatch; /* Current insert batch */ +}; + +/* +** Allowed values for RowSet.rsFlags +*/ +#define ROWSET_SORTED 0x01 /* True if RowSet.pEntry is sorted */ +#define ROWSET_NEXT 0x02 /* True if sqlite3RowSetNext() has been called */ + +/* +** Turn bulk memory into a RowSet object. N bytes of memory +** are available at pSpace. The db pointer is used as a memory context +** for any subsequent allocations that need to occur. +** Return a pointer to the new RowSet object. +** +** It must be the case that N is sufficient to make a Rowset. If not +** an assertion fault occurs. +** +** If N is larger than the minimum, use the surplus as an initial +** allocation of entries available to be filled. +*/ +SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3 *db, void *pSpace, unsigned int N){ + RowSet *p; + assert( N >= ROUND8(sizeof(*p)) ); + p = pSpace; + p->pChunk = 0; + p->db = db; + p->pEntry = 0; + p->pLast = 0; + p->pForest = 0; + p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p); + p->nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry)); + p->rsFlags = ROWSET_SORTED; + p->iBatch = 0; + return p; +} + +/* +** Deallocate all chunks from a RowSet. This frees all memory that +** the RowSet has allocated over its lifetime. This routine is +** the destructor for the RowSet. +*/ +SQLITE_PRIVATE void sqlite3RowSetClear(RowSet *p){ + struct RowSetChunk *pChunk, *pNextChunk; + for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){ + pNextChunk = pChunk->pNextChunk; + sqlite3DbFree(p->db, pChunk); + } + p->pChunk = 0; + p->nFresh = 0; + p->pEntry = 0; + p->pLast = 0; + p->pForest = 0; + p->rsFlags = ROWSET_SORTED; +} + +/* +** Allocate a new RowSetEntry object that is associated with the +** given RowSet. Return a pointer to the new and completely uninitialized +** objected. +** +** In an OOM situation, the RowSet.db->mallocFailed flag is set and this +** routine returns NULL. +*/ +static struct RowSetEntry *rowSetEntryAlloc(RowSet *p){ + assert( p!=0 ); + if( p->nFresh==0 ){ + struct RowSetChunk *pNew; + pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew)); + if( pNew==0 ){ + return 0; + } + pNew->pNextChunk = p->pChunk; + p->pChunk = pNew; + p->pFresh = pNew->aEntry; + p->nFresh = ROWSET_ENTRY_PER_CHUNK; + } + p->nFresh--; + return p->pFresh++; +} + +/* +** Insert a new value into a RowSet. +** +** The mallocFailed flag of the database connection is set if a +** memory allocation fails. +*/ +SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet *p, i64 rowid){ + struct RowSetEntry *pEntry; /* The new entry */ + struct RowSetEntry *pLast; /* The last prior entry */ + + /* This routine is never called after sqlite3RowSetNext() */ + assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 ); + + pEntry = rowSetEntryAlloc(p); + if( pEntry==0 ) return; + pEntry->v = rowid; + pEntry->pRight = 0; + pLast = p->pLast; + if( pLast ){ + if( (p->rsFlags & ROWSET_SORTED)!=0 && rowid<=pLast->v ){ + p->rsFlags &= ~ROWSET_SORTED; + } + pLast->pRight = pEntry; + }else{ + p->pEntry = pEntry; + } + p->pLast = pEntry; +} + +/* +** Merge two lists of RowSetEntry objects. Remove duplicates. +** +** The input lists are connected via pRight pointers and are +** assumed to each already be in sorted order. +*/ +static struct RowSetEntry *rowSetEntryMerge( + struct RowSetEntry *pA, /* First sorted list to be merged */ + struct RowSetEntry *pB /* Second sorted list to be merged */ +){ + struct RowSetEntry head; + struct RowSetEntry *pTail; + + pTail = &head; + while( pA && pB ){ + assert( pA->pRight==0 || pA->v<=pA->pRight->v ); + assert( pB->pRight==0 || pB->v<=pB->pRight->v ); + if( pA->vv ){ + pTail->pRight = pA; + pA = pA->pRight; + pTail = pTail->pRight; + }else if( pB->vv ){ + pTail->pRight = pB; + pB = pB->pRight; + pTail = pTail->pRight; + }else{ + pA = pA->pRight; + } + } + if( pA ){ + assert( pA->pRight==0 || pA->v<=pA->pRight->v ); + pTail->pRight = pA; + }else{ + assert( pB==0 || pB->pRight==0 || pB->v<=pB->pRight->v ); + pTail->pRight = pB; + } + return head.pRight; +} + +/* +** Sort all elements on the list of RowSetEntry objects into order of +** increasing v. +*/ +static struct RowSetEntry *rowSetEntrySort(struct RowSetEntry *pIn){ + unsigned int i; + struct RowSetEntry *pNext, *aBucket[40]; + + memset(aBucket, 0, sizeof(aBucket)); + while( pIn ){ + pNext = pIn->pRight; + pIn->pRight = 0; + for(i=0; aBucket[i]; i++){ + pIn = rowSetEntryMerge(aBucket[i], pIn); + aBucket[i] = 0; + } + aBucket[i] = pIn; + pIn = pNext; + } + pIn = 0; + for(i=0; ipLeft ){ + struct RowSetEntry *p; + rowSetTreeToList(pIn->pLeft, ppFirst, &p); + p->pRight = pIn; + }else{ + *ppFirst = pIn; + } + if( pIn->pRight ){ + rowSetTreeToList(pIn->pRight, &pIn->pRight, ppLast); + }else{ + *ppLast = pIn; + } + assert( (*ppLast)->pRight==0 ); +} + + +/* +** Convert a sorted list of elements (connected by pRight) into a binary +** tree with depth of iDepth. A depth of 1 means the tree contains a single +** node taken from the head of *ppList. A depth of 2 means a tree with +** three nodes. And so forth. +** +** Use as many entries from the input list as required and update the +** *ppList to point to the unused elements of the list. If the input +** list contains too few elements, then construct an incomplete tree +** and leave *ppList set to NULL. +** +** Return a pointer to the root of the constructed binary tree. +*/ +static struct RowSetEntry *rowSetNDeepTree( + struct RowSetEntry **ppList, + int iDepth +){ + struct RowSetEntry *p; /* Root of the new tree */ + struct RowSetEntry *pLeft; /* Left subtree */ + if( *ppList==0 ){ + return 0; + } + if( iDepth==1 ){ + p = *ppList; + *ppList = p->pRight; + p->pLeft = p->pRight = 0; + return p; + } + pLeft = rowSetNDeepTree(ppList, iDepth-1); + p = *ppList; + if( p==0 ){ + return pLeft; + } + p->pLeft = pLeft; + *ppList = p->pRight; + p->pRight = rowSetNDeepTree(ppList, iDepth-1); + return p; +} + +/* +** Convert a sorted list of elements into a binary tree. Make the tree +** as deep as it needs to be in order to contain the entire list. +*/ +static struct RowSetEntry *rowSetListToTree(struct RowSetEntry *pList){ + int iDepth; /* Depth of the tree so far */ + struct RowSetEntry *p; /* Current tree root */ + struct RowSetEntry *pLeft; /* Left subtree */ + + assert( pList!=0 ); + p = pList; + pList = p->pRight; + p->pLeft = p->pRight = 0; + for(iDepth=1; pList; iDepth++){ + pLeft = p; + p = pList; + pList = p->pRight; + p->pLeft = pLeft; + p->pRight = rowSetNDeepTree(&pList, iDepth); + } + return p; +} + +/* +** Take all the entries on p->pEntry and on the trees in p->pForest and +** sort them all together into one big ordered list on p->pEntry. +** +** This routine should only be called once in the life of a RowSet. +*/ +static void rowSetToList(RowSet *p){ + + /* This routine is called only once */ + assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 ); + + if( (p->rsFlags & ROWSET_SORTED)==0 ){ + p->pEntry = rowSetEntrySort(p->pEntry); + } + + /* While this module could theoretically support it, sqlite3RowSetNext() + ** is never called after sqlite3RowSetText() for the same RowSet. So + ** there is never a forest to deal with. Should this change, simply + ** remove the assert() and the #if 0. */ + assert( p->pForest==0 ); +#if 0 + while( p->pForest ){ + struct RowSetEntry *pTree = p->pForest->pLeft; + if( pTree ){ + struct RowSetEntry *pHead, *pTail; + rowSetTreeToList(pTree, &pHead, &pTail); + p->pEntry = rowSetEntryMerge(p->pEntry, pHead); + } + p->pForest = p->pForest->pRight; + } +#endif + p->rsFlags |= ROWSET_NEXT; /* Verify this routine is never called again */ +} + +/* +** Extract the smallest element from the RowSet. +** Write the element into *pRowid. Return 1 on success. Return +** 0 if the RowSet is already empty. +** +** After this routine has been called, the sqlite3RowSetInsert() +** routine may not be called again. +*/ +SQLITE_PRIVATE int sqlite3RowSetNext(RowSet *p, i64 *pRowid){ + assert( p!=0 ); + + /* Merge the forest into a single sorted list on first call */ + if( (p->rsFlags & ROWSET_NEXT)==0 ) rowSetToList(p); + + /* Return the next entry on the list */ + if( p->pEntry ){ + *pRowid = p->pEntry->v; + p->pEntry = p->pEntry->pRight; + if( p->pEntry==0 ){ + sqlite3RowSetClear(p); + } + return 1; + }else{ + return 0; + } +} + +/* +** Check to see if element iRowid was inserted into the rowset as +** part of any insert batch prior to iBatch. Return 1 or 0. +** +** If this is the first test of a new batch and if there exist entries +** on pRowSet->pEntry, then sort those entries into the forest at +** pRowSet->pForest so that they can be tested. +*/ +SQLITE_PRIVATE int sqlite3RowSetTest(RowSet *pRowSet, int iBatch, sqlite3_int64 iRowid){ + struct RowSetEntry *p, *pTree; + + /* This routine is never called after sqlite3RowSetNext() */ + assert( pRowSet!=0 && (pRowSet->rsFlags & ROWSET_NEXT)==0 ); + + /* Sort entries into the forest on the first test of a new batch + */ + if( iBatch!=pRowSet->iBatch ){ + p = pRowSet->pEntry; + if( p ){ + struct RowSetEntry **ppPrevTree = &pRowSet->pForest; + if( (pRowSet->rsFlags & ROWSET_SORTED)==0 ){ + p = rowSetEntrySort(p); + } + for(pTree = pRowSet->pForest; pTree; pTree=pTree->pRight){ + ppPrevTree = &pTree->pRight; + if( pTree->pLeft==0 ){ + pTree->pLeft = rowSetListToTree(p); + break; + }else{ + struct RowSetEntry *pAux, *pTail; + rowSetTreeToList(pTree->pLeft, &pAux, &pTail); + pTree->pLeft = 0; + p = rowSetEntryMerge(pAux, p); + } + } + if( pTree==0 ){ + *ppPrevTree = pTree = rowSetEntryAlloc(pRowSet); + if( pTree ){ + pTree->v = 0; + pTree->pRight = 0; + pTree->pLeft = rowSetListToTree(p); + } + } + pRowSet->pEntry = 0; + pRowSet->pLast = 0; + pRowSet->rsFlags |= ROWSET_SORTED; + } + pRowSet->iBatch = iBatch; + } + + /* Test to see if the iRowid value appears anywhere in the forest. + ** Return 1 if it does and 0 if not. + */ + for(pTree = pRowSet->pForest; pTree; pTree=pTree->pRight){ + p = pTree->pLeft; + while( p ){ + if( p->vpRight; + }else if( p->v>iRowid ){ + p = p->pLeft; + }else{ + return 1; + } + } + } + return 0; +} + +/************** End of rowset.c **********************************************/ +/************** Begin file pager.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the implementation of the page cache subsystem or "pager". +** +** The pager is used to access a database disk file. It implements +** atomic commit and rollback through the use of a journal file that +** is separate from the database file. The pager also implements file +** locking to prevent two processes from writing the same database +** file simultaneously, or one process from reading the database while +** another is writing. +*/ +#ifndef SQLITE_OMIT_DISKIO +/* #include "sqliteInt.h" */ +/************** Include wal.h in the middle of pager.c ***********************/ +/************** Begin file wal.h *********************************************/ +/* +** 2010 February 1 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface to the write-ahead logging +** system. Refer to the comments below and the header comment attached to +** the implementation of each function in log.c for further details. +*/ + +#ifndef _WAL_H_ +#define _WAL_H_ + +/* #include "sqliteInt.h" */ + +/* Additional values that can be added to the sync_flags argument of +** sqlite3WalFrames(): +*/ +#define WAL_SYNC_TRANSACTIONS 0x20 /* Sync at the end of each transaction */ +#define SQLITE_SYNC_MASK 0x13 /* Mask off the SQLITE_SYNC_* values */ + +#ifdef SQLITE_OMIT_WAL +# define sqlite3WalOpen(x,y,z) 0 +# define sqlite3WalLimit(x,y) +# define sqlite3WalClose(w,x,y,z) 0 +# define sqlite3WalBeginReadTransaction(y,z) 0 +# define sqlite3WalEndReadTransaction(z) +# define sqlite3WalDbsize(y) 0 +# define sqlite3WalBeginWriteTransaction(y) 0 +# define sqlite3WalEndWriteTransaction(x) 0 +# define sqlite3WalUndo(x,y,z) 0 +# define sqlite3WalSavepoint(y,z) +# define sqlite3WalSavepointUndo(y,z) 0 +# define sqlite3WalFrames(u,v,w,x,y,z) 0 +# define sqlite3WalCheckpoint(r,s,t,u,v,w,x,y,z) 0 +# define sqlite3WalCallback(z) 0 +# define sqlite3WalExclusiveMode(y,z) 0 +# define sqlite3WalHeapMemory(z) 0 +# define sqlite3WalFramesize(z) 0 +# define sqlite3WalFindFrame(x,y,z) 0 +#else + +#define WAL_SAVEPOINT_NDATA 4 + +/* Connection to a write-ahead log (WAL) file. +** There is one object of this type for each pager. +*/ +typedef struct Wal Wal; + +/* Open and close a connection to a write-ahead log. */ +SQLITE_PRIVATE int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *, int, i64, Wal**); +SQLITE_PRIVATE int sqlite3WalClose(Wal *pWal, int sync_flags, int, u8 *); + +/* Set the limiting size of a WAL file. */ +SQLITE_PRIVATE void sqlite3WalLimit(Wal*, i64); + +/* Used by readers to open (lock) and close (unlock) a snapshot. A +** snapshot is like a read-transaction. It is the state of the database +** at an instant in time. sqlite3WalOpenSnapshot gets a read lock and +** preserves the current state even if the other threads or processes +** write to or checkpoint the WAL. sqlite3WalCloseSnapshot() closes the +** transaction and releases the lock. +*/ +SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *); +SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal); + +/* Read a page from the write-ahead log, if it is present. */ +SQLITE_PRIVATE int sqlite3WalFindFrame(Wal *, Pgno, u32 *); +SQLITE_PRIVATE int sqlite3WalReadFrame(Wal *, u32, int, u8 *); + +/* If the WAL is not empty, return the size of the database. */ +SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal); + +/* Obtain or release the WRITER lock. */ +SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal); +SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal); + +/* Undo any frames written (but not committed) to the log */ +SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx); + +/* Return an integer that records the current (uncommitted) write +** position in the WAL */ +SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData); + +/* Move the write position of the WAL back to iFrame. Called in +** response to a ROLLBACK TO command. */ +SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData); + +/* Write a frame or frames to the log. */ +SQLITE_PRIVATE int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int); + +/* Copy pages from the log to the database file */ +SQLITE_PRIVATE int sqlite3WalCheckpoint( + Wal *pWal, /* Write-ahead log connection */ + int eMode, /* One of PASSIVE, FULL and RESTART */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int sync_flags, /* Flags to sync db file with (or 0) */ + int nBuf, /* Size of buffer nBuf */ + u8 *zBuf, /* Temporary buffer to use */ + int *pnLog, /* OUT: Number of frames in WAL */ + int *pnCkpt /* OUT: Number of backfilled frames in WAL */ +); + +/* Return the value to pass to a sqlite3_wal_hook callback, the +** number of frames in the WAL at the point of the last commit since +** sqlite3WalCallback() was called. If no commits have occurred since +** the last call, then return 0. +*/ +SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal); + +/* Tell the wal layer that an EXCLUSIVE lock has been obtained (or released) +** by the pager layer on the database file. +*/ +SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op); + +/* Return true if the argument is non-NULL and the WAL module is using +** heap-memory for the wal-index. Otherwise, if the argument is NULL or the +** WAL module is using shared-memory, return false. +*/ +SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal); + +#ifdef SQLITE_ENABLE_ZIPVFS +/* If the WAL file is not empty, return the number of bytes of content +** stored in each frame (i.e. the db page-size when the WAL was created). +*/ +SQLITE_PRIVATE int sqlite3WalFramesize(Wal *pWal); +#endif + +#endif /* ifndef SQLITE_OMIT_WAL */ +#endif /* _WAL_H_ */ + +/************** End of wal.h *************************************************/ +/************** Continuing where we left off in pager.c **********************/ + + +/******************* NOTES ON THE DESIGN OF THE PAGER ************************ +** +** This comment block describes invariants that hold when using a rollback +** journal. These invariants do not apply for journal_mode=WAL, +** journal_mode=MEMORY, or journal_mode=OFF. +** +** Within this comment block, a page is deemed to have been synced +** automatically as soon as it is written when PRAGMA synchronous=OFF. +** Otherwise, the page is not synced until the xSync method of the VFS +** is called successfully on the file containing the page. +** +** Definition: A page of the database file is said to be "overwriteable" if +** one or more of the following are true about the page: +** +** (a) The original content of the page as it was at the beginning of +** the transaction has been written into the rollback journal and +** synced. +** +** (b) The page was a freelist leaf page at the start of the transaction. +** +** (c) The page number is greater than the largest page that existed in +** the database file at the start of the transaction. +** +** (1) A page of the database file is never overwritten unless one of the +** following are true: +** +** (a) The page and all other pages on the same sector are overwriteable. +** +** (b) The atomic page write optimization is enabled, and the entire +** transaction other than the update of the transaction sequence +** number consists of a single page change. +** +** (2) The content of a page written into the rollback journal exactly matches +** both the content in the database when the rollback journal was written +** and the content in the database at the beginning of the current +** transaction. +** +** (3) Writes to the database file are an integer multiple of the page size +** in length and are aligned on a page boundary. +** +** (4) Reads from the database file are either aligned on a page boundary and +** an integer multiple of the page size in length or are taken from the +** first 100 bytes of the database file. +** +** (5) All writes to the database file are synced prior to the rollback journal +** being deleted, truncated, or zeroed. +** +** (6) If a master journal file is used, then all writes to the database file +** are synced prior to the master journal being deleted. +** +** Definition: Two databases (or the same database at two points it time) +** are said to be "logically equivalent" if they give the same answer to +** all queries. Note in particular the content of freelist leaf +** pages can be changed arbitrarily without affecting the logical equivalence +** of the database. +** +** (7) At any time, if any subset, including the empty set and the total set, +** of the unsynced changes to a rollback journal are removed and the +** journal is rolled back, the resulting database file will be logically +** equivalent to the database file at the beginning of the transaction. +** +** (8) When a transaction is rolled back, the xTruncate method of the VFS +** is called to restore the database file to the same size it was at +** the beginning of the transaction. (In some VFSes, the xTruncate +** method is a no-op, but that does not change the fact the SQLite will +** invoke it.) +** +** (9) Whenever the database file is modified, at least one bit in the range +** of bytes from 24 through 39 inclusive will be changed prior to releasing +** the EXCLUSIVE lock, thus signaling other connections on the same +** database to flush their caches. +** +** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less +** than one billion transactions. +** +** (11) A database file is well-formed at the beginning and at the conclusion +** of every transaction. +** +** (12) An EXCLUSIVE lock is held on the database file when writing to +** the database file. +** +** (13) A SHARED lock is held on the database file while reading any +** content out of the database file. +** +******************************************************************************/ + +/* +** Macros for troubleshooting. Normally turned off +*/ +#if 0 +int sqlite3PagerTrace=1; /* True to enable tracing */ +#define sqlite3DebugPrintf printf +#define PAGERTRACE(X) if( sqlite3PagerTrace ){ sqlite3DebugPrintf X; } +#else +#define PAGERTRACE(X) +#endif + +/* +** The following two macros are used within the PAGERTRACE() macros above +** to print out file-descriptors. +** +** PAGERID() takes a pointer to a Pager struct as its argument. The +** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file +** struct as its argument. +*/ +#define PAGERID(p) ((int)(p->fd)) +#define FILEHANDLEID(fd) ((int)fd) + +/* +** The Pager.eState variable stores the current 'state' of a pager. A +** pager may be in any one of the seven states shown in the following +** state diagram. +** +** OPEN <------+------+ +** | | | +** V | | +** +---------> READER-------+ | +** | | | +** | V | +** |<-------WRITER_LOCKED------> ERROR +** | | ^ +** | V | +** |<------WRITER_CACHEMOD-------->| +** | | | +** | V | +** |<-------WRITER_DBMOD---------->| +** | | | +** | V | +** +<------WRITER_FINISHED-------->+ +** +** +** List of state transitions and the C [function] that performs each: +** +** OPEN -> READER [sqlite3PagerSharedLock] +** READER -> OPEN [pager_unlock] +** +** READER -> WRITER_LOCKED [sqlite3PagerBegin] +** WRITER_LOCKED -> WRITER_CACHEMOD [pager_open_journal] +** WRITER_CACHEMOD -> WRITER_DBMOD [syncJournal] +** WRITER_DBMOD -> WRITER_FINISHED [sqlite3PagerCommitPhaseOne] +** WRITER_*** -> READER [pager_end_transaction] +** +** WRITER_*** -> ERROR [pager_error] +** ERROR -> OPEN [pager_unlock] +** +** +** OPEN: +** +** The pager starts up in this state. Nothing is guaranteed in this +** state - the file may or may not be locked and the database size is +** unknown. The database may not be read or written. +** +** * No read or write transaction is active. +** * Any lock, or no lock at all, may be held on the database file. +** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted. +** +** READER: +** +** In this state all the requirements for reading the database in +** rollback (non-WAL) mode are met. Unless the pager is (or recently +** was) in exclusive-locking mode, a user-level read transaction is +** open. The database size is known in this state. +** +** A connection running with locking_mode=normal enters this state when +** it opens a read-transaction on the database and returns to state +** OPEN after the read-transaction is completed. However a connection +** running in locking_mode=exclusive (including temp databases) remains in +** this state even after the read-transaction is closed. The only way +** a locking_mode=exclusive connection can transition from READER to OPEN +** is via the ERROR state (see below). +** +** * A read transaction may be active (but a write-transaction cannot). +** * A SHARED or greater lock is held on the database file. +** * The dbSize variable may be trusted (even if a user-level read +** transaction is not active). The dbOrigSize and dbFileSize variables +** may not be trusted at this point. +** * If the database is a WAL database, then the WAL connection is open. +** * Even if a read-transaction is not open, it is guaranteed that +** there is no hot-journal in the file-system. +** +** WRITER_LOCKED: +** +** The pager moves to this state from READER when a write-transaction +** is first opened on the database. In WRITER_LOCKED state, all locks +** required to start a write-transaction are held, but no actual +** modifications to the cache or database have taken place. +** +** In rollback mode, a RESERVED or (if the transaction was opened with +** BEGIN EXCLUSIVE) EXCLUSIVE lock is obtained on the database file when +** moving to this state, but the journal file is not written to or opened +** to in this state. If the transaction is committed or rolled back while +** in WRITER_LOCKED state, all that is required is to unlock the database +** file. +** +** IN WAL mode, WalBeginWriteTransaction() is called to lock the log file. +** If the connection is running with locking_mode=exclusive, an attempt +** is made to obtain an EXCLUSIVE lock on the database file. +** +** * A write transaction is active. +** * If the connection is open in rollback-mode, a RESERVED or greater +** lock is held on the database file. +** * If the connection is open in WAL-mode, a WAL write transaction +** is open (i.e. sqlite3WalBeginWriteTransaction() has been successfully +** called). +** * The dbSize, dbOrigSize and dbFileSize variables are all valid. +** * The contents of the pager cache have not been modified. +** * The journal file may or may not be open. +** * Nothing (not even the first header) has been written to the journal. +** +** WRITER_CACHEMOD: +** +** A pager moves from WRITER_LOCKED state to this state when a page is +** first modified by the upper layer. In rollback mode the journal file +** is opened (if it is not already open) and a header written to the +** start of it. The database file on disk has not been modified. +** +** * A write transaction is active. +** * A RESERVED or greater lock is held on the database file. +** * The journal file is open and the first header has been written +** to it, but the header has not been synced to disk. +** * The contents of the page cache have been modified. +** +** WRITER_DBMOD: +** +** The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state +** when it modifies the contents of the database file. WAL connections +** never enter this state (since they do not modify the database file, +** just the log file). +** +** * A write transaction is active. +** * An EXCLUSIVE or greater lock is held on the database file. +** * The journal file is open and the first header has been written +** and synced to disk. +** * The contents of the page cache have been modified (and possibly +** written to disk). +** +** WRITER_FINISHED: +** +** It is not possible for a WAL connection to enter this state. +** +** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD +** state after the entire transaction has been successfully written into the +** database file. In this state the transaction may be committed simply +** by finalizing the journal file. Once in WRITER_FINISHED state, it is +** not possible to modify the database further. At this point, the upper +** layer must either commit or rollback the transaction. +** +** * A write transaction is active. +** * An EXCLUSIVE or greater lock is held on the database file. +** * All writing and syncing of journal and database data has finished. +** If no error occurred, all that remains is to finalize the journal to +** commit the transaction. If an error did occur, the caller will need +** to rollback the transaction. +** +** ERROR: +** +** The ERROR state is entered when an IO or disk-full error (including +** SQLITE_IOERR_NOMEM) occurs at a point in the code that makes it +** difficult to be sure that the in-memory pager state (cache contents, +** db size etc.) are consistent with the contents of the file-system. +** +** Temporary pager files may enter the ERROR state, but in-memory pagers +** cannot. +** +** For example, if an IO error occurs while performing a rollback, +** the contents of the page-cache may be left in an inconsistent state. +** At this point it would be dangerous to change back to READER state +** (as usually happens after a rollback). Any subsequent readers might +** report database corruption (due to the inconsistent cache), and if +** they upgrade to writers, they may inadvertently corrupt the database +** file. To avoid this hazard, the pager switches into the ERROR state +** instead of READER following such an error. +** +** Once it has entered the ERROR state, any attempt to use the pager +** to read or write data returns an error. Eventually, once all +** outstanding transactions have been abandoned, the pager is able to +** transition back to OPEN state, discarding the contents of the +** page-cache and any other in-memory state at the same time. Everything +** is reloaded from disk (and, if necessary, hot-journal rollback peformed) +** when a read-transaction is next opened on the pager (transitioning +** the pager into READER state). At that point the system has recovered +** from the error. +** +** Specifically, the pager jumps into the ERROR state if: +** +** 1. An error occurs while attempting a rollback. This happens in +** function sqlite3PagerRollback(). +** +** 2. An error occurs while attempting to finalize a journal file +** following a commit in function sqlite3PagerCommitPhaseTwo(). +** +** 3. An error occurs while attempting to write to the journal or +** database file in function pagerStress() in order to free up +** memory. +** +** In other cases, the error is returned to the b-tree layer. The b-tree +** layer then attempts a rollback operation. If the error condition +** persists, the pager enters the ERROR state via condition (1) above. +** +** Condition (3) is necessary because it can be triggered by a read-only +** statement executed within a transaction. In this case, if the error +** code were simply returned to the user, the b-tree layer would not +** automatically attempt a rollback, as it assumes that an error in a +** read-only statement cannot leave the pager in an internally inconsistent +** state. +** +** * The Pager.errCode variable is set to something other than SQLITE_OK. +** * There are one or more outstanding references to pages (after the +** last reference is dropped the pager should move back to OPEN state). +** * The pager is not an in-memory pager. +** +** +** Notes: +** +** * A pager is never in WRITER_DBMOD or WRITER_FINISHED state if the +** connection is open in WAL mode. A WAL connection is always in one +** of the first four states. +** +** * Normally, a connection open in exclusive mode is never in PAGER_OPEN +** state. There are two exceptions: immediately after exclusive-mode has +** been turned on (and before any read or write transactions are +** executed), and when the pager is leaving the "error state". +** +** * See also: assert_pager_state(). +*/ +#define PAGER_OPEN 0 +#define PAGER_READER 1 +#define PAGER_WRITER_LOCKED 2 +#define PAGER_WRITER_CACHEMOD 3 +#define PAGER_WRITER_DBMOD 4 +#define PAGER_WRITER_FINISHED 5 +#define PAGER_ERROR 6 + +/* +** The Pager.eLock variable is almost always set to one of the +** following locking-states, according to the lock currently held on +** the database file: NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK. +** This variable is kept up to date as locks are taken and released by +** the pagerLockDb() and pagerUnlockDb() wrappers. +** +** If the VFS xLock() or xUnlock() returns an error other than SQLITE_BUSY +** (i.e. one of the SQLITE_IOERR subtypes), it is not clear whether or not +** the operation was successful. In these circumstances pagerLockDb() and +** pagerUnlockDb() take a conservative approach - eLock is always updated +** when unlocking the file, and only updated when locking the file if the +** VFS call is successful. This way, the Pager.eLock variable may be set +** to a less exclusive (lower) value than the lock that is actually held +** at the system level, but it is never set to a more exclusive value. +** +** This is usually safe. If an xUnlock fails or appears to fail, there may +** be a few redundant xLock() calls or a lock may be held for longer than +** required, but nothing really goes wrong. +** +** The exception is when the database file is unlocked as the pager moves +** from ERROR to OPEN state. At this point there may be a hot-journal file +** in the file-system that needs to be rolled back (as part of an OPEN->SHARED +** transition, by the same pager or any other). If the call to xUnlock() +** fails at this point and the pager is left holding an EXCLUSIVE lock, this +** can confuse the call to xCheckReservedLock() call made later as part +** of hot-journal detection. +** +** xCheckReservedLock() is defined as returning true "if there is a RESERVED +** lock held by this process or any others". So xCheckReservedLock may +** return true because the caller itself is holding an EXCLUSIVE lock (but +** doesn't know it because of a previous error in xUnlock). If this happens +** a hot-journal may be mistaken for a journal being created by an active +** transaction in another process, causing SQLite to read from the database +** without rolling it back. +** +** To work around this, if a call to xUnlock() fails when unlocking the +** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It +** is only changed back to a real locking state after a successful call +** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition +** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK +** lock. Instead, it assumes a hot-journal exists and obtains an EXCLUSIVE +** lock on the database file before attempting to roll it back. See function +** PagerSharedLock() for more detail. +** +** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in +** PAGER_OPEN state. +*/ +#define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1) + +/* +** A macro used for invoking the codec if there is one +*/ +#ifdef SQLITE_HAS_CODEC +# define CODEC1(P,D,N,X,E) \ + if( P->xCodec && P->xCodec(P->pCodec,D,N,X)==0 ){ E; } +# define CODEC2(P,D,N,X,E,O) \ + if( P->xCodec==0 ){ O=(char*)D; }else \ + if( (O=(char*)(P->xCodec(P->pCodec,D,N,X)))==0 ){ E; } +#else +# define CODEC1(P,D,N,X,E) /* NO-OP */ +# define CODEC2(P,D,N,X,E,O) O=(char*)D +#endif + +/* +** The maximum allowed sector size. 64KiB. If the xSectorsize() method +** returns a value larger than this, then MAX_SECTOR_SIZE is used instead. +** This could conceivably cause corruption following a power failure on +** such a system. This is currently an undocumented limit. +*/ +#define MAX_SECTOR_SIZE 0x10000 + +/* +** An instance of the following structure is allocated for each active +** savepoint and statement transaction in the system. All such structures +** are stored in the Pager.aSavepoint[] array, which is allocated and +** resized using sqlite3Realloc(). +** +** When a savepoint is created, the PagerSavepoint.iHdrOffset field is +** set to 0. If a journal-header is written into the main journal while +** the savepoint is active, then iHdrOffset is set to the byte offset +** immediately following the last journal record written into the main +** journal before the journal-header. This is required during savepoint +** rollback (see pagerPlaybackSavepoint()). +*/ +typedef struct PagerSavepoint PagerSavepoint; +struct PagerSavepoint { + i64 iOffset; /* Starting offset in main journal */ + i64 iHdrOffset; /* See above */ + Bitvec *pInSavepoint; /* Set of pages in this savepoint */ + Pgno nOrig; /* Original number of pages in file */ + Pgno iSubRec; /* Index of first record in sub-journal */ +#ifndef SQLITE_OMIT_WAL + u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */ +#endif +}; + +/* +** Bits of the Pager.doNotSpill flag. See further description below. +*/ +#define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */ +#define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */ +#define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */ + +/* +** An open page cache is an instance of struct Pager. A description of +** some of the more important member variables follows: +** +** eState +** +** The current 'state' of the pager object. See the comment and state +** diagram above for a description of the pager state. +** +** eLock +** +** For a real on-disk database, the current lock held on the database file - +** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK. +** +** For a temporary or in-memory database (neither of which require any +** locks), this variable is always set to EXCLUSIVE_LOCK. Since such +** databases always have Pager.exclusiveMode==1, this tricks the pager +** logic into thinking that it already has all the locks it will ever +** need (and no reason to release them). +** +** In some (obscure) circumstances, this variable may also be set to +** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for +** details. +** +** changeCountDone +** +** This boolean variable is used to make sure that the change-counter +** (the 4-byte header field at byte offset 24 of the database file) is +** not updated more often than necessary. +** +** It is set to true when the change-counter field is updated, which +** can only happen if an exclusive lock is held on the database file. +** It is cleared (set to false) whenever an exclusive lock is +** relinquished on the database file. Each time a transaction is committed, +** The changeCountDone flag is inspected. If it is true, the work of +** updating the change-counter is omitted for the current transaction. +** +** This mechanism means that when running in exclusive mode, a connection +** need only update the change-counter once, for the first transaction +** committed. +** +** setMaster +** +** When PagerCommitPhaseOne() is called to commit a transaction, it may +** (or may not) specify a master-journal name to be written into the +** journal file before it is synced to disk. +** +** Whether or not a journal file contains a master-journal pointer affects +** the way in which the journal file is finalized after the transaction is +** committed or rolled back when running in "journal_mode=PERSIST" mode. +** If a journal file does not contain a master-journal pointer, it is +** finalized by overwriting the first journal header with zeroes. If +** it does contain a master-journal pointer the journal file is finalized +** by truncating it to zero bytes, just as if the connection were +** running in "journal_mode=truncate" mode. +** +** Journal files that contain master journal pointers cannot be finalized +** simply by overwriting the first journal-header with zeroes, as the +** master journal pointer could interfere with hot-journal rollback of any +** subsequently interrupted transaction that reuses the journal file. +** +** The flag is cleared as soon as the journal file is finalized (either +** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the +** journal file from being successfully finalized, the setMaster flag +** is cleared anyway (and the pager will move to ERROR state). +** +** doNotSpill +** +** This variables control the behavior of cache-spills (calls made by +** the pcache module to the pagerStress() routine to write cached data +** to the file-system in order to free up memory). +** +** When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set, +** writing to the database from pagerStress() is disabled altogether. +** The SPILLFLAG_ROLLBACK case is done in a very obscure case that +** comes up during savepoint rollback that requires the pcache module +** to allocate a new page to prevent the journal file from being written +** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF +** case is a user preference. +** +** If the SPILLFLAG_NOSYNC bit is set, writing to the database from +** pagerStress() is permitted, but syncing the journal file is not. +** This flag is set by sqlite3PagerWrite() when the file-system sector-size +** is larger than the database page-size in order to prevent a journal sync +** from happening in between the journalling of two pages on the same sector. +** +** subjInMemory +** +** This is a boolean variable. If true, then any required sub-journal +** is opened as an in-memory journal file. If false, then in-memory +** sub-journals are only used for in-memory pager files. +** +** This variable is updated by the upper layer each time a new +** write-transaction is opened. +** +** dbSize, dbOrigSize, dbFileSize +** +** Variable dbSize is set to the number of pages in the database file. +** It is valid in PAGER_READER and higher states (all states except for +** OPEN and ERROR). +** +** dbSize is set based on the size of the database file, which may be +** larger than the size of the database (the value stored at offset +** 28 of the database header by the btree). If the size of the file +** is not an integer multiple of the page-size, the value stored in +** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2). +** Except, any file that is greater than 0 bytes in size is considered +** to have at least one page. (i.e. a 1KB file with 2K page-size leads +** to dbSize==1). +** +** During a write-transaction, if pages with page-numbers greater than +** dbSize are modified in the cache, dbSize is updated accordingly. +** Similarly, if the database is truncated using PagerTruncateImage(), +** dbSize is updated. +** +** Variables dbOrigSize and dbFileSize are valid in states +** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize +** variable at the start of the transaction. It is used during rollback, +** and to determine whether or not pages need to be journalled before +** being modified. +** +** Throughout a write-transaction, dbFileSize contains the size of +** the file on disk in pages. It is set to a copy of dbSize when the +** write-transaction is first opened, and updated when VFS calls are made +** to write or truncate the database file on disk. +** +** The only reason the dbFileSize variable is required is to suppress +** unnecessary calls to xTruncate() after committing a transaction. If, +** when a transaction is committed, the dbFileSize variable indicates +** that the database file is larger than the database image (Pager.dbSize), +** pager_truncate() is called. The pager_truncate() call uses xFilesize() +** to measure the database file on disk, and then truncates it if required. +** dbFileSize is not used when rolling back a transaction. In this case +** pager_truncate() is called unconditionally (which means there may be +** a call to xFilesize() that is not strictly required). In either case, +** pager_truncate() may cause the file to become smaller or larger. +** +** dbHintSize +** +** The dbHintSize variable is used to limit the number of calls made to +** the VFS xFileControl(FCNTL_SIZE_HINT) method. +** +** dbHintSize is set to a copy of the dbSize variable when a +** write-transaction is opened (at the same time as dbFileSize and +** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called, +** dbHintSize is increased to the number of pages that correspond to the +** size-hint passed to the method call. See pager_write_pagelist() for +** details. +** +** errCode +** +** The Pager.errCode variable is only ever used in PAGER_ERROR state. It +** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode +** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX +** sub-codes. +*/ +struct Pager { + sqlite3_vfs *pVfs; /* OS functions to use for IO */ + u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */ + u8 journalMode; /* One of the PAGER_JOURNALMODE_* values */ + u8 useJournal; /* Use a rollback journal on this file */ + u8 noSync; /* Do not sync the journal if true */ + u8 fullSync; /* Do extra syncs of the journal for robustness */ + u8 ckptSyncFlags; /* SYNC_NORMAL or SYNC_FULL for checkpoint */ + u8 walSyncFlags; /* SYNC_NORMAL or SYNC_FULL for wal writes */ + u8 syncFlags; /* SYNC_NORMAL or SYNC_FULL otherwise */ + u8 tempFile; /* zFilename is a temporary or immutable file */ + u8 noLock; /* Do not lock (except in WAL mode) */ + u8 readOnly; /* True for a read-only database */ + u8 memDb; /* True to inhibit all file I/O */ + + /************************************************************************** + ** The following block contains those class members that change during + ** routine operation. Class members not in this block are either fixed + ** when the pager is first created or else only change when there is a + ** significant mode change (such as changing the page_size, locking_mode, + ** or the journal_mode). From another view, these class members describe + ** the "state" of the pager, while other class members describe the + ** "configuration" of the pager. + */ + u8 eState; /* Pager state (OPEN, READER, WRITER_LOCKED..) */ + u8 eLock; /* Current lock held on database file */ + u8 changeCountDone; /* Set after incrementing the change-counter */ + u8 setMaster; /* True if a m-j name has been written to jrnl */ + u8 doNotSpill; /* Do not spill the cache when non-zero */ + u8 subjInMemory; /* True to use in-memory sub-journals */ + u8 bUseFetch; /* True to use xFetch() */ + u8 hasHeldSharedLock; /* True if a shared lock has ever been held */ + Pgno dbSize; /* Number of pages in the database */ + Pgno dbOrigSize; /* dbSize before the current transaction */ + Pgno dbFileSize; /* Number of pages in the database file */ + Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */ + int errCode; /* One of several kinds of errors */ + int nRec; /* Pages journalled since last j-header written */ + u32 cksumInit; /* Quasi-random value added to every checksum */ + u32 nSubRec; /* Number of records written to sub-journal */ + Bitvec *pInJournal; /* One bit for each page in the database file */ + sqlite3_file *fd; /* File descriptor for database */ + sqlite3_file *jfd; /* File descriptor for main journal */ + sqlite3_file *sjfd; /* File descriptor for sub-journal */ + i64 journalOff; /* Current write offset in the journal file */ + i64 journalHdr; /* Byte offset to previous journal header */ + sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */ + PagerSavepoint *aSavepoint; /* Array of active savepoints */ + int nSavepoint; /* Number of elements in aSavepoint[] */ + u32 iDataVersion; /* Changes whenever database content changes */ + char dbFileVers[16]; /* Changes whenever database file changes */ + + int nMmapOut; /* Number of mmap pages currently outstanding */ + sqlite3_int64 szMmap; /* Desired maximum mmap size */ + PgHdr *pMmapFreelist; /* List of free mmap page headers (pDirty) */ + /* + ** End of the routinely-changing class members + ***************************************************************************/ + + u16 nExtra; /* Add this many bytes to each in-memory page */ + i16 nReserve; /* Number of unused bytes at end of each page */ + u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */ + u32 sectorSize; /* Assumed sector size during rollback */ + int pageSize; /* Number of bytes in a page */ + Pgno mxPgno; /* Maximum allowed size of the database */ + i64 journalSizeLimit; /* Size limit for persistent journal files */ + char *zFilename; /* Name of the database file */ + char *zJournal; /* Name of the journal file */ + int (*xBusyHandler)(void*); /* Function to call when busy */ + void *pBusyHandlerArg; /* Context argument for xBusyHandler */ + int aStat[3]; /* Total cache hits, misses and writes */ +#ifdef SQLITE_TEST + int nRead; /* Database pages read */ +#endif + void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */ +#ifdef SQLITE_HAS_CODEC + void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */ + void (*xCodecSizeChng)(void*,int,int); /* Notify of page size changes */ + void (*xCodecFree)(void*); /* Destructor for the codec */ + void *pCodec; /* First argument to xCodec... methods */ +#endif + char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */ + PCache *pPCache; /* Pointer to page cache object */ +#ifndef SQLITE_OMIT_WAL + Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */ + char *zWal; /* File name for write-ahead log */ +#endif +}; + +/* +** Indexes for use with Pager.aStat[]. The Pager.aStat[] array contains +** the values accessed by passing SQLITE_DBSTATUS_CACHE_HIT, CACHE_MISS +** or CACHE_WRITE to sqlite3_db_status(). +*/ +#define PAGER_STAT_HIT 0 +#define PAGER_STAT_MISS 1 +#define PAGER_STAT_WRITE 2 + +/* +** The following global variables hold counters used for +** testing purposes only. These variables do not exist in +** a non-testing build. These variables are not thread-safe. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */ +SQLITE_API int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */ +SQLITE_API int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */ +# define PAGER_INCR(v) v++ +#else +# define PAGER_INCR(v) +#endif + + + +/* +** Journal files begin with the following magic string. The data +** was obtained from /dev/random. It is used only as a sanity check. +** +** Since version 2.8.0, the journal format contains additional sanity +** checking information. If the power fails while the journal is being +** written, semi-random garbage data might appear in the journal +** file after power is restored. If an attempt is then made +** to roll the journal back, the database could be corrupted. The additional +** sanity checking data is an attempt to discover the garbage in the +** journal and ignore it. +** +** The sanity checking information for the new journal format consists +** of a 32-bit checksum on each page of data. The checksum covers both +** the page number and the pPager->pageSize bytes of data for the page. +** This cksum is initialized to a 32-bit random value that appears in the +** journal file right after the header. The random initializer is important, +** because garbage data that appears at the end of a journal is likely +** data that was once in other files that have now been deleted. If the +** garbage data came from an obsolete journal file, the checksums might +** be correct. But by initializing the checksum to random value which +** is different for every journal, we minimize that risk. +*/ +static const unsigned char aJournalMagic[] = { + 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7, +}; + +/* +** The size of the of each page record in the journal is given by +** the following macro. +*/ +#define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8) + +/* +** The journal header size for this pager. This is usually the same +** size as a single disk sector. See also setSectorSize(). +*/ +#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize) + +/* +** The macro MEMDB is true if we are dealing with an in-memory database. +** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set, +** the value of MEMDB will be a constant and the compiler will optimize +** out code that would never execute. +*/ +#ifdef SQLITE_OMIT_MEMORYDB +# define MEMDB 0 +#else +# define MEMDB pPager->memDb +#endif + +/* +** The macro USEFETCH is true if we are allowed to use the xFetch and xUnfetch +** interfaces to access the database using memory-mapped I/O. +*/ +#if SQLITE_MAX_MMAP_SIZE>0 +# define USEFETCH(x) ((x)->bUseFetch) +#else +# define USEFETCH(x) 0 +#endif + +/* +** The maximum legal page number is (2^31 - 1). +*/ +#define PAGER_MAX_PGNO 2147483647 + +/* +** The argument to this macro is a file descriptor (type sqlite3_file*). +** Return 0 if it is not open, or non-zero (but not 1) if it is. +** +** This is so that expressions can be written as: +** +** if( isOpen(pPager->jfd) ){ ... +** +** instead of +** +** if( pPager->jfd->pMethods ){ ... +*/ +#define isOpen(pFd) ((pFd)->pMethods!=0) + +/* +** Return true if this pager uses a write-ahead log instead of the usual +** rollback journal. Otherwise false. +*/ +#ifndef SQLITE_OMIT_WAL +static int pagerUseWal(Pager *pPager){ + return (pPager->pWal!=0); +} +#else +# define pagerUseWal(x) 0 +# define pagerRollbackWal(x) 0 +# define pagerWalFrames(v,w,x,y) 0 +# define pagerOpenWalIfPresent(z) SQLITE_OK +# define pagerBeginReadTransaction(z) SQLITE_OK +#endif + +#ifndef NDEBUG +/* +** Usage: +** +** assert( assert_pager_state(pPager) ); +** +** This function runs many asserts to try to find inconsistencies in +** the internal state of the Pager object. +*/ +static int assert_pager_state(Pager *p){ + Pager *pPager = p; + + /* State must be valid. */ + assert( p->eState==PAGER_OPEN + || p->eState==PAGER_READER + || p->eState==PAGER_WRITER_LOCKED + || p->eState==PAGER_WRITER_CACHEMOD + || p->eState==PAGER_WRITER_DBMOD + || p->eState==PAGER_WRITER_FINISHED + || p->eState==PAGER_ERROR + ); + + /* Regardless of the current state, a temp-file connection always behaves + ** as if it has an exclusive lock on the database file. It never updates + ** the change-counter field, so the changeCountDone flag is always set. + */ + assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK ); + assert( p->tempFile==0 || pPager->changeCountDone ); + + /* If the useJournal flag is clear, the journal-mode must be "OFF". + ** And if the journal-mode is "OFF", the journal file must not be open. + */ + assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal ); + assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) ); + + /* Check that MEMDB implies noSync. And an in-memory journal. Since + ** this means an in-memory pager performs no IO at all, it cannot encounter + ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing + ** a journal file. (although the in-memory journal implementation may + ** return SQLITE_IOERR_NOMEM while the journal file is being written). It + ** is therefore not possible for an in-memory pager to enter the ERROR + ** state. + */ + if( MEMDB ){ + assert( p->noSync ); + assert( p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_MEMORY + ); + assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN ); + assert( pagerUseWal(p)==0 ); + } + + /* If changeCountDone is set, a RESERVED lock or greater must be held + ** on the file. + */ + assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK ); + assert( p->eLock!=PENDING_LOCK ); + + switch( p->eState ){ + case PAGER_OPEN: + assert( !MEMDB ); + assert( pPager->errCode==SQLITE_OK ); + assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile ); + break; + + case PAGER_READER: + assert( pPager->errCode==SQLITE_OK ); + assert( p->eLock!=UNKNOWN_LOCK ); + assert( p->eLock>=SHARED_LOCK ); + break; + + case PAGER_WRITER_LOCKED: + assert( p->eLock!=UNKNOWN_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + if( !pagerUseWal(pPager) ){ + assert( p->eLock>=RESERVED_LOCK ); + } + assert( pPager->dbSize==pPager->dbOrigSize ); + assert( pPager->dbOrigSize==pPager->dbFileSize ); + assert( pPager->dbOrigSize==pPager->dbHintSize ); + assert( pPager->setMaster==0 ); + break; + + case PAGER_WRITER_CACHEMOD: + assert( p->eLock!=UNKNOWN_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + if( !pagerUseWal(pPager) ){ + /* It is possible that if journal_mode=wal here that neither the + ** journal file nor the WAL file are open. This happens during + ** a rollback transaction that switches from journal_mode=off + ** to journal_mode=wal. + */ + assert( p->eLock>=RESERVED_LOCK ); + assert( isOpen(p->jfd) + || p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_WAL + ); + } + assert( pPager->dbOrigSize==pPager->dbFileSize ); + assert( pPager->dbOrigSize==pPager->dbHintSize ); + break; + + case PAGER_WRITER_DBMOD: + assert( p->eLock==EXCLUSIVE_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + assert( !pagerUseWal(pPager) ); + assert( p->eLock>=EXCLUSIVE_LOCK ); + assert( isOpen(p->jfd) + || p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_WAL + ); + assert( pPager->dbOrigSize<=pPager->dbHintSize ); + break; + + case PAGER_WRITER_FINISHED: + assert( p->eLock==EXCLUSIVE_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + assert( !pagerUseWal(pPager) ); + assert( isOpen(p->jfd) + || p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_WAL + ); + break; + + case PAGER_ERROR: + /* There must be at least one outstanding reference to the pager if + ** in ERROR state. Otherwise the pager should have already dropped + ** back to OPEN state. + */ + assert( pPager->errCode!=SQLITE_OK ); + assert( sqlite3PcacheRefCount(pPager->pPCache)>0 ); + break; + } + + return 1; +} +#endif /* ifndef NDEBUG */ + +#ifdef SQLITE_DEBUG +/* +** Return a pointer to a human readable string in a static buffer +** containing the state of the Pager object passed as an argument. This +** is intended to be used within debuggers. For example, as an alternative +** to "print *pPager" in gdb: +** +** (gdb) printf "%s", print_pager_state(pPager) +*/ +static char *print_pager_state(Pager *p){ + static char zRet[1024]; + + sqlite3_snprintf(1024, zRet, + "Filename: %s\n" + "State: %s errCode=%d\n" + "Lock: %s\n" + "Locking mode: locking_mode=%s\n" + "Journal mode: journal_mode=%s\n" + "Backing store: tempFile=%d memDb=%d useJournal=%d\n" + "Journal: journalOff=%lld journalHdr=%lld\n" + "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n" + , p->zFilename + , p->eState==PAGER_OPEN ? "OPEN" : + p->eState==PAGER_READER ? "READER" : + p->eState==PAGER_WRITER_LOCKED ? "WRITER_LOCKED" : + p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" : + p->eState==PAGER_WRITER_DBMOD ? "WRITER_DBMOD" : + p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" : + p->eState==PAGER_ERROR ? "ERROR" : "?error?" + , (int)p->errCode + , p->eLock==NO_LOCK ? "NO_LOCK" : + p->eLock==RESERVED_LOCK ? "RESERVED" : + p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" : + p->eLock==SHARED_LOCK ? "SHARED" : + p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?" + , p->exclusiveMode ? "exclusive" : "normal" + , p->journalMode==PAGER_JOURNALMODE_MEMORY ? "memory" : + p->journalMode==PAGER_JOURNALMODE_OFF ? "off" : + p->journalMode==PAGER_JOURNALMODE_DELETE ? "delete" : + p->journalMode==PAGER_JOURNALMODE_PERSIST ? "persist" : + p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" : + p->journalMode==PAGER_JOURNALMODE_WAL ? "wal" : "?error?" + , (int)p->tempFile, (int)p->memDb, (int)p->useJournal + , p->journalOff, p->journalHdr + , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize + ); + + return zRet; +} +#endif + +/* +** Return true if it is necessary to write page *pPg into the sub-journal. +** A page needs to be written into the sub-journal if there exists one +** or more open savepoints for which: +** +** * The page-number is less than or equal to PagerSavepoint.nOrig, and +** * The bit corresponding to the page-number is not set in +** PagerSavepoint.pInSavepoint. +*/ +static int subjRequiresPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + PagerSavepoint *p; + Pgno pgno = pPg->pgno; + int i; + for(i=0; inSavepoint; i++){ + p = &pPager->aSavepoint[i]; + if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){ + return 1; + } + } + return 0; +} + +#ifdef SQLITE_DEBUG +/* +** Return true if the page is already in the journal file. +*/ +static int pageInJournal(Pager *pPager, PgHdr *pPg){ + return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno); +} +#endif + +/* +** Read a 32-bit integer from the given file descriptor. Store the integer +** that is read in *pRes. Return SQLITE_OK if everything worked, or an +** error code is something goes wrong. +** +** All values are stored on disk as big-endian. +*/ +static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){ + unsigned char ac[4]; + int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset); + if( rc==SQLITE_OK ){ + *pRes = sqlite3Get4byte(ac); + } + return rc; +} + +/* +** Write a 32-bit integer into a string buffer in big-endian byte order. +*/ +#define put32bits(A,B) sqlite3Put4byte((u8*)A,B) + + +/* +** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK +** on success or an error code is something goes wrong. +*/ +static int write32bits(sqlite3_file *fd, i64 offset, u32 val){ + char ac[4]; + put32bits(ac, val); + return sqlite3OsWrite(fd, ac, 4, offset); +} + +/* +** Unlock the database file to level eLock, which must be either NO_LOCK +** or SHARED_LOCK. Regardless of whether or not the call to xUnlock() +** succeeds, set the Pager.eLock variable to match the (attempted) new lock. +** +** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is +** called, do not modify it. See the comment above the #define of +** UNKNOWN_LOCK for an explanation of this. +*/ +static int pagerUnlockDb(Pager *pPager, int eLock){ + int rc = SQLITE_OK; + + assert( !pPager->exclusiveMode || pPager->eLock==eLock ); + assert( eLock==NO_LOCK || eLock==SHARED_LOCK ); + assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 ); + if( isOpen(pPager->fd) ){ + assert( pPager->eLock>=eLock ); + rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock); + if( pPager->eLock!=UNKNOWN_LOCK ){ + pPager->eLock = (u8)eLock; + } + IOTRACE(("UNLOCK %p %d\n", pPager, eLock)) + } + return rc; +} + +/* +** Lock the database file to level eLock, which must be either SHARED_LOCK, +** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the +** Pager.eLock variable to the new locking state. +** +** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is +** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK. +** See the comment above the #define of UNKNOWN_LOCK for an explanation +** of this. +*/ +static int pagerLockDb(Pager *pPager, int eLock){ + int rc = SQLITE_OK; + + assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK ); + if( pPager->eLockeLock==UNKNOWN_LOCK ){ + rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock); + if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){ + pPager->eLock = (u8)eLock; + IOTRACE(("LOCK %p %d\n", pPager, eLock)) + } + } + return rc; +} + +/* +** This function determines whether or not the atomic-write optimization +** can be used with this pager. The optimization can be used if: +** +** (a) the value returned by OsDeviceCharacteristics() indicates that +** a database page may be written atomically, and +** (b) the value returned by OsSectorSize() is less than or equal +** to the page size. +** +** The optimization is also always enabled for temporary files. It is +** an error to call this function if pPager is opened on an in-memory +** database. +** +** If the optimization cannot be used, 0 is returned. If it can be used, +** then the value returned is the size of the journal file when it +** contains rollback data for exactly one page. +*/ +#ifdef SQLITE_ENABLE_ATOMIC_WRITE +static int jrnlBufferSize(Pager *pPager){ + assert( !MEMDB ); + if( !pPager->tempFile ){ + int dc; /* Device characteristics */ + int nSector; /* Sector size */ + int szPage; /* Page size */ + + assert( isOpen(pPager->fd) ); + dc = sqlite3OsDeviceCharacteristics(pPager->fd); + nSector = pPager->sectorSize; + szPage = pPager->pageSize; + + assert(SQLITE_IOCAP_ATOMIC512==(512>>8)); + assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8)); + if( 0==(dc&(SQLITE_IOCAP_ATOMIC|(szPage>>8)) || nSector>szPage) ){ + return 0; + } + } + + return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager); +} +#endif + +/* +** If SQLITE_CHECK_PAGES is defined then we do some sanity checking +** on the cache using a hash function. This is used for testing +** and debugging only. +*/ +#ifdef SQLITE_CHECK_PAGES +/* +** Return a 32-bit hash of the page data for pPage. +*/ +static u32 pager_datahash(int nByte, unsigned char *pData){ + u32 hash = 0; + int i; + for(i=0; ipPager->pageSize, (unsigned char *)pPage->pData); +} +static void pager_set_pagehash(PgHdr *pPage){ + pPage->pageHash = pager_pagehash(pPage); +} + +/* +** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES +** is defined, and NDEBUG is not defined, an assert() statement checks +** that the page is either dirty or still matches the calculated page-hash. +*/ +#define CHECK_PAGE(x) checkPage(x) +static void checkPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + assert( pPager->eState!=PAGER_ERROR ); + assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) ); +} + +#else +#define pager_datahash(X,Y) 0 +#define pager_pagehash(X) 0 +#define pager_set_pagehash(X) +#define CHECK_PAGE(x) +#endif /* SQLITE_CHECK_PAGES */ + +/* +** When this is called the journal file for pager pPager must be open. +** This function attempts to read a master journal file name from the +** end of the file and, if successful, copies it into memory supplied +** by the caller. See comments above writeMasterJournal() for the format +** used to store a master journal file name at the end of a journal file. +** +** zMaster must point to a buffer of at least nMaster bytes allocated by +** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is +** enough space to write the master journal name). If the master journal +** name in the journal is longer than nMaster bytes (including a +** nul-terminator), then this is handled as if no master journal name +** were present in the journal. +** +** If a master journal file name is present at the end of the journal +** file, then it is copied into the buffer pointed to by zMaster. A +** nul-terminator byte is appended to the buffer following the master +** journal file name. +** +** If it is determined that no master journal file name is present +** zMaster[0] is set to 0 and SQLITE_OK returned. +** +** If an error occurs while reading from the journal file, an SQLite +** error code is returned. +*/ +static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, u32 nMaster){ + int rc; /* Return code */ + u32 len; /* Length in bytes of master journal name */ + i64 szJ; /* Total size in bytes of journal file pJrnl */ + u32 cksum; /* MJ checksum value read from journal */ + u32 u; /* Unsigned loop counter */ + unsigned char aMagic[8]; /* A buffer to hold the magic header */ + zMaster[0] = '\0'; + + if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ)) + || szJ<16 + || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len)) + || len>=nMaster + || len==0 + || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum)) + || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8)) + || memcmp(aMagic, aJournalMagic, 8) + || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len)) + ){ + return rc; + } + + /* See if the checksum matches the master journal name */ + for(u=0; ujournalOff, assuming a sector +** size of pPager->sectorSize bytes. +** +** i.e for a sector size of 512: +** +** Pager.journalOff Return value +** --------------------------------------- +** 0 0 +** 512 512 +** 100 512 +** 2000 2048 +** +*/ +static i64 journalHdrOffset(Pager *pPager){ + i64 offset = 0; + i64 c = pPager->journalOff; + if( c ){ + offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager); + } + assert( offset%JOURNAL_HDR_SZ(pPager)==0 ); + assert( offset>=c ); + assert( (offset-c)jfd) ); + if( pPager->journalOff ){ + const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */ + + IOTRACE(("JZEROHDR %p\n", pPager)) + if( doTruncate || iLimit==0 ){ + rc = sqlite3OsTruncate(pPager->jfd, 0); + }else{ + static const char zeroHdr[28] = {0}; + rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0); + } + if( rc==SQLITE_OK && !pPager->noSync ){ + rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags); + } + + /* At this point the transaction is committed but the write lock + ** is still held on the file. If there is a size limit configured for + ** the persistent journal and the journal file currently consumes more + ** space than that limit allows for, truncate it now. There is no need + ** to sync the file following this operation. + */ + if( rc==SQLITE_OK && iLimit>0 ){ + i64 sz; + rc = sqlite3OsFileSize(pPager->jfd, &sz); + if( rc==SQLITE_OK && sz>iLimit ){ + rc = sqlite3OsTruncate(pPager->jfd, iLimit); + } + } + } + return rc; +} + +/* +** The journal file must be open when this routine is called. A journal +** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the +** current location. +** +** The format for the journal header is as follows: +** - 8 bytes: Magic identifying journal format. +** - 4 bytes: Number of records in journal, or -1 no-sync mode is on. +** - 4 bytes: Random number used for page hash. +** - 4 bytes: Initial database page count. +** - 4 bytes: Sector size used by the process that wrote this journal. +** - 4 bytes: Database page size. +** +** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space. +*/ +static int writeJournalHdr(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */ + u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */ + u32 nWrite; /* Bytes of header sector written */ + int ii; /* Loop counter */ + + assert( isOpen(pPager->jfd) ); /* Journal file must be open. */ + + if( nHeader>JOURNAL_HDR_SZ(pPager) ){ + nHeader = JOURNAL_HDR_SZ(pPager); + } + + /* If there are active savepoints and any of them were created + ** since the most recent journal header was written, update the + ** PagerSavepoint.iHdrOffset fields now. + */ + for(ii=0; iinSavepoint; ii++){ + if( pPager->aSavepoint[ii].iHdrOffset==0 ){ + pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff; + } + } + + pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager); + + /* + ** Write the nRec Field - the number of page records that follow this + ** journal header. Normally, zero is written to this value at this time. + ** After the records are added to the journal (and the journal synced, + ** if in full-sync mode), the zero is overwritten with the true number + ** of records (see syncJournal()). + ** + ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When + ** reading the journal this value tells SQLite to assume that the + ** rest of the journal file contains valid page records. This assumption + ** is dangerous, as if a failure occurred whilst writing to the journal + ** file it may contain some garbage data. There are two scenarios + ** where this risk can be ignored: + ** + ** * When the pager is in no-sync mode. Corruption can follow a + ** power failure in this case anyway. + ** + ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees + ** that garbage data is never appended to the journal file. + */ + assert( isOpen(pPager->fd) || pPager->noSync ); + if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY) + || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND) + ){ + memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic)); + put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff); + }else{ + memset(zHeader, 0, sizeof(aJournalMagic)+4); + } + + /* The random check-hash initializer */ + sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit); + put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit); + /* The initial database size */ + put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize); + /* The assumed sector size for this process */ + put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize); + + /* The page size */ + put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize); + + /* Initializing the tail of the buffer is not necessary. Everything + ** works find if the following memset() is omitted. But initializing + ** the memory prevents valgrind from complaining, so we are willing to + ** take the performance hit. + */ + memset(&zHeader[sizeof(aJournalMagic)+20], 0, + nHeader-(sizeof(aJournalMagic)+20)); + + /* In theory, it is only necessary to write the 28 bytes that the + ** journal header consumes to the journal file here. Then increment the + ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next + ** record is written to the following sector (leaving a gap in the file + ** that will be implicitly filled in by the OS). + ** + ** However it has been discovered that on some systems this pattern can + ** be significantly slower than contiguously writing data to the file, + ** even if that means explicitly writing data to the block of + ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what + ** is done. + ** + ** The loop is required here in case the sector-size is larger than the + ** database page size. Since the zHeader buffer is only Pager.pageSize + ** bytes in size, more than one call to sqlite3OsWrite() may be required + ** to populate the entire journal header sector. + */ + for(nWrite=0; rc==SQLITE_OK&&nWritejournalHdr, nHeader)) + rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff); + assert( pPager->journalHdr <= pPager->journalOff ); + pPager->journalOff += nHeader; + } + + return rc; +} + +/* +** The journal file must be open when this is called. A journal header file +** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal +** file. The current location in the journal file is given by +** pPager->journalOff. See comments above function writeJournalHdr() for +** a description of the journal header format. +** +** If the header is read successfully, *pNRec is set to the number of +** page records following this header and *pDbSize is set to the size of the +** database before the transaction began, in pages. Also, pPager->cksumInit +** is set to the value read from the journal header. SQLITE_OK is returned +** in this case. +** +** If the journal header file appears to be corrupted, SQLITE_DONE is +** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes +** cannot be read from the journal file an error code is returned. +*/ +static int readJournalHdr( + Pager *pPager, /* Pager object */ + int isHot, + i64 journalSize, /* Size of the open journal file in bytes */ + u32 *pNRec, /* OUT: Value read from the nRec field */ + u32 *pDbSize /* OUT: Value of original database size field */ +){ + int rc; /* Return code */ + unsigned char aMagic[8]; /* A buffer to hold the magic header */ + i64 iHdrOff; /* Offset of journal header being read */ + + assert( isOpen(pPager->jfd) ); /* Journal file must be open. */ + + /* Advance Pager.journalOff to the start of the next sector. If the + ** journal file is too small for there to be a header stored at this + ** point, return SQLITE_DONE. + */ + pPager->journalOff = journalHdrOffset(pPager); + if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){ + return SQLITE_DONE; + } + iHdrOff = pPager->journalOff; + + /* Read in the first 8 bytes of the journal header. If they do not match + ** the magic string found at the start of each journal header, return + ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise, + ** proceed. + */ + if( isHot || iHdrOff!=pPager->journalHdr ){ + rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff); + if( rc ){ + return rc; + } + if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){ + return SQLITE_DONE; + } + } + + /* Read the first three 32-bit fields of the journal header: The nRec + ** field, the checksum-initializer and the database size at the start + ** of the transaction. Return an error code if anything goes wrong. + */ + if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec)) + || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit)) + || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize)) + ){ + return rc; + } + + if( pPager->journalOff==0 ){ + u32 iPageSize; /* Page-size field of journal header */ + u32 iSectorSize; /* Sector-size field of journal header */ + + /* Read the page-size and sector-size journal header fields. */ + if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize)) + || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize)) + ){ + return rc; + } + + /* Versions of SQLite prior to 3.5.8 set the page-size field of the + ** journal header to zero. In this case, assume that the Pager.pageSize + ** variable is already set to the correct page size. + */ + if( iPageSize==0 ){ + iPageSize = pPager->pageSize; + } + + /* Check that the values read from the page-size and sector-size fields + ** are within range. To be 'in range', both values need to be a power + ** of two greater than or equal to 512 or 32, and not greater than their + ** respective compile time maximum limits. + */ + if( iPageSize<512 || iSectorSize<32 + || iPageSize>SQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE + || ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0 + ){ + /* If the either the page-size or sector-size in the journal-header is + ** invalid, then the process that wrote the journal-header must have + ** crashed before the header was synced. In this case stop reading + ** the journal file here. + */ + return SQLITE_DONE; + } + + /* Update the page-size to match the value read from the journal. + ** Use a testcase() macro to make sure that malloc failure within + ** PagerSetPagesize() is tested. + */ + rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1); + testcase( rc!=SQLITE_OK ); + + /* Update the assumed sector-size to match the value used by + ** the process that created this journal. If this journal was + ** created by a process other than this one, then this routine + ** is being called from within pager_playback(). The local value + ** of Pager.sectorSize is restored at the end of that routine. + */ + pPager->sectorSize = iSectorSize; + } + + pPager->journalOff += JOURNAL_HDR_SZ(pPager); + return rc; +} + + +/* +** Write the supplied master journal name into the journal file for pager +** pPager at the current location. The master journal name must be the last +** thing written to a journal file. If the pager is in full-sync mode, the +** journal file descriptor is advanced to the next sector boundary before +** anything is written. The format is: +** +** + 4 bytes: PAGER_MJ_PGNO. +** + N bytes: Master journal filename in utf-8. +** + 4 bytes: N (length of master journal name in bytes, no nul-terminator). +** + 4 bytes: Master journal name checksum. +** + 8 bytes: aJournalMagic[]. +** +** The master journal page checksum is the sum of the bytes in the master +** journal name, where each byte is interpreted as a signed 8-bit integer. +** +** If zMaster is a NULL pointer (occurs for a single database transaction), +** this call is a no-op. +*/ +static int writeMasterJournal(Pager *pPager, const char *zMaster){ + int rc; /* Return code */ + int nMaster; /* Length of string zMaster */ + i64 iHdrOff; /* Offset of header in journal file */ + i64 jrnlSize; /* Size of journal file on disk */ + u32 cksum = 0; /* Checksum of string zMaster */ + + assert( pPager->setMaster==0 ); + assert( !pagerUseWal(pPager) ); + + if( !zMaster + || pPager->journalMode==PAGER_JOURNALMODE_MEMORY + || !isOpen(pPager->jfd) + ){ + return SQLITE_OK; + } + pPager->setMaster = 1; + assert( pPager->journalHdr <= pPager->journalOff ); + + /* Calculate the length in bytes and the checksum of zMaster */ + for(nMaster=0; zMaster[nMaster]; nMaster++){ + cksum += zMaster[nMaster]; + } + + /* If in full-sync mode, advance to the next disk sector before writing + ** the master journal name. This is in case the previous page written to + ** the journal has already been synced. + */ + if( pPager->fullSync ){ + pPager->journalOff = journalHdrOffset(pPager); + } + iHdrOff = pPager->journalOff; + + /* Write the master journal data to the end of the journal file. If + ** an error occurs, return the error code to the caller. + */ + if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager)))) + || (0 != (rc = sqlite3OsWrite(pPager->jfd, zMaster, nMaster, iHdrOff+4))) + || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster, nMaster))) + || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster+4, cksum))) + || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8, + iHdrOff+4+nMaster+8))) + ){ + return rc; + } + pPager->journalOff += (nMaster+20); + + /* If the pager is in peristent-journal mode, then the physical + ** journal-file may extend past the end of the master-journal name + ** and 8 bytes of magic data just written to the file. This is + ** dangerous because the code to rollback a hot-journal file + ** will not be able to find the master-journal name to determine + ** whether or not the journal is hot. + ** + ** Easiest thing to do in this scenario is to truncate the journal + ** file to the required size. + */ + if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize)) + && jrnlSize>pPager->journalOff + ){ + rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff); + } + return rc; +} + +/* +** Discard the entire contents of the in-memory page-cache. +*/ +static void pager_reset(Pager *pPager){ + pPager->iDataVersion++; + sqlite3BackupRestart(pPager->pBackup); + sqlite3PcacheClear(pPager->pPCache); +} + +/* +** Return the pPager->iDataVersion value +*/ +SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager *pPager){ + assert( pPager->eState>PAGER_OPEN ); + return pPager->iDataVersion; +} + +/* +** Free all structures in the Pager.aSavepoint[] array and set both +** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal +** if it is open and the pager is not in exclusive mode. +*/ +static void releaseAllSavepoints(Pager *pPager){ + int ii; /* Iterator for looping through Pager.aSavepoint */ + for(ii=0; iinSavepoint; ii++){ + sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint); + } + if( !pPager->exclusiveMode || sqlite3IsMemJournal(pPager->sjfd) ){ + sqlite3OsClose(pPager->sjfd); + } + sqlite3_free(pPager->aSavepoint); + pPager->aSavepoint = 0; + pPager->nSavepoint = 0; + pPager->nSubRec = 0; +} + +/* +** Set the bit number pgno in the PagerSavepoint.pInSavepoint +** bitvecs of all open savepoints. Return SQLITE_OK if successful +** or SQLITE_NOMEM if a malloc failure occurs. +*/ +static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){ + int ii; /* Loop counter */ + int rc = SQLITE_OK; /* Result code */ + + for(ii=0; iinSavepoint; ii++){ + PagerSavepoint *p = &pPager->aSavepoint[ii]; + if( pgno<=p->nOrig ){ + rc |= sqlite3BitvecSet(p->pInSavepoint, pgno); + testcase( rc==SQLITE_NOMEM ); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + } + } + return rc; +} + +/* +** This function is a no-op if the pager is in exclusive mode and not +** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN +** state. +** +** If the pager is not in exclusive-access mode, the database file is +** completely unlocked. If the file is unlocked and the file-system does +** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is +** closed (if it is open). +** +** If the pager is in ERROR state when this function is called, the +** contents of the pager cache are discarded before switching back to +** the OPEN state. Regardless of whether the pager is in exclusive-mode +** or not, any journal file left in the file-system will be treated +** as a hot-journal and rolled back the next time a read-transaction +** is opened (by this or by any other connection). +*/ +static void pager_unlock(Pager *pPager){ + + assert( pPager->eState==PAGER_READER + || pPager->eState==PAGER_OPEN + || pPager->eState==PAGER_ERROR + ); + + sqlite3BitvecDestroy(pPager->pInJournal); + pPager->pInJournal = 0; + releaseAllSavepoints(pPager); + + if( pagerUseWal(pPager) ){ + assert( !isOpen(pPager->jfd) ); + sqlite3WalEndReadTransaction(pPager->pWal); + pPager->eState = PAGER_OPEN; + }else if( !pPager->exclusiveMode ){ + int rc; /* Error code returned by pagerUnlockDb() */ + int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0; + + /* If the operating system support deletion of open files, then + ** close the journal file when dropping the database lock. Otherwise + ** another connection with journal_mode=delete might delete the file + ** out from under us. + */ + assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 ); + assert( (PAGER_JOURNALMODE_OFF & 5)!=1 ); + assert( (PAGER_JOURNALMODE_WAL & 5)!=1 ); + assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 ); + assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 ); + assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 ); + if( 0==(iDc & SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN) + || 1!=(pPager->journalMode & 5) + ){ + sqlite3OsClose(pPager->jfd); + } + + /* If the pager is in the ERROR state and the call to unlock the database + ** file fails, set the current lock to UNKNOWN_LOCK. See the comment + ** above the #define for UNKNOWN_LOCK for an explanation of why this + ** is necessary. + */ + rc = pagerUnlockDb(pPager, NO_LOCK); + if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){ + pPager->eLock = UNKNOWN_LOCK; + } + + /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here + ** without clearing the error code. This is intentional - the error + ** code is cleared and the cache reset in the block below. + */ + assert( pPager->errCode || pPager->eState!=PAGER_ERROR ); + pPager->changeCountDone = 0; + pPager->eState = PAGER_OPEN; + } + + /* If Pager.errCode is set, the contents of the pager cache cannot be + ** trusted. Now that there are no outstanding references to the pager, + ** it can safely move back to PAGER_OPEN state. This happens in both + ** normal and exclusive-locking mode. + */ + if( pPager->errCode ){ + assert( !MEMDB ); + pager_reset(pPager); + pPager->changeCountDone = pPager->tempFile; + pPager->eState = PAGER_OPEN; + pPager->errCode = SQLITE_OK; + if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0); + } + + pPager->journalOff = 0; + pPager->journalHdr = 0; + pPager->setMaster = 0; +} + +/* +** This function is called whenever an IOERR or FULL error that requires +** the pager to transition into the ERROR state may ahve occurred. +** The first argument is a pointer to the pager structure, the second +** the error-code about to be returned by a pager API function. The +** value returned is a copy of the second argument to this function. +** +** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the +** IOERR sub-codes, the pager enters the ERROR state and the error code +** is stored in Pager.errCode. While the pager remains in the ERROR state, +** all major API calls on the Pager will immediately return Pager.errCode. +** +** The ERROR state indicates that the contents of the pager-cache +** cannot be trusted. This state can be cleared by completely discarding +** the contents of the pager-cache. If a transaction was active when +** the persistent error occurred, then the rollback journal may need +** to be replayed to restore the contents of the database file (as if +** it were a hot-journal). +*/ +static int pager_error(Pager *pPager, int rc){ + int rc2 = rc & 0xff; + assert( rc==SQLITE_OK || !MEMDB ); + assert( + pPager->errCode==SQLITE_FULL || + pPager->errCode==SQLITE_OK || + (pPager->errCode & 0xff)==SQLITE_IOERR + ); + if( rc2==SQLITE_FULL || rc2==SQLITE_IOERR ){ + pPager->errCode = rc; + pPager->eState = PAGER_ERROR; + } + return rc; +} + +static int pager_truncate(Pager *pPager, Pgno nPage); + +/* +** This routine ends a transaction. A transaction is usually ended by +** either a COMMIT or a ROLLBACK operation. This routine may be called +** after rollback of a hot-journal, or if an error occurs while opening +** the journal file or writing the very first journal-header of a +** database transaction. +** +** This routine is never called in PAGER_ERROR state. If it is called +** in PAGER_NONE or PAGER_SHARED state and the lock held is less +** exclusive than a RESERVED lock, it is a no-op. +** +** Otherwise, any active savepoints are released. +** +** If the journal file is open, then it is "finalized". Once a journal +** file has been finalized it is not possible to use it to roll back a +** transaction. Nor will it be considered to be a hot-journal by this +** or any other database connection. Exactly how a journal is finalized +** depends on whether or not the pager is running in exclusive mode and +** the current journal-mode (Pager.journalMode value), as follows: +** +** journalMode==MEMORY +** Journal file descriptor is simply closed. This destroys an +** in-memory journal. +** +** journalMode==TRUNCATE +** Journal file is truncated to zero bytes in size. +** +** journalMode==PERSIST +** The first 28 bytes of the journal file are zeroed. This invalidates +** the first journal header in the file, and hence the entire journal +** file. An invalid journal file cannot be rolled back. +** +** journalMode==DELETE +** The journal file is closed and deleted using sqlite3OsDelete(). +** +** If the pager is running in exclusive mode, this method of finalizing +** the journal file is never used. Instead, if the journalMode is +** DELETE and the pager is in exclusive mode, the method described under +** journalMode==PERSIST is used instead. +** +** After the journal is finalized, the pager moves to PAGER_READER state. +** If running in non-exclusive rollback mode, the lock on the file is +** downgraded to a SHARED_LOCK. +** +** SQLITE_OK is returned if no error occurs. If an error occurs during +** any of the IO operations to finalize the journal file or unlock the +** database then the IO error code is returned to the user. If the +** operation to finalize the journal file fails, then the code still +** tries to unlock the database file if not in exclusive mode. If the +** unlock operation fails as well, then the first error code related +** to the first error encountered (the journal finalization one) is +** returned. +*/ +static int pager_end_transaction(Pager *pPager, int hasMaster, int bCommit){ + int rc = SQLITE_OK; /* Error code from journal finalization operation */ + int rc2 = SQLITE_OK; /* Error code from db file unlock operation */ + + /* Do nothing if the pager does not have an open write transaction + ** or at least a RESERVED lock. This function may be called when there + ** is no write-transaction active but a RESERVED or greater lock is + ** held under two circumstances: + ** + ** 1. After a successful hot-journal rollback, it is called with + ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK. + ** + ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE + ** lock switches back to locking_mode=normal and then executes a + ** read-transaction, this function is called with eState==PAGER_READER + ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed. + */ + assert( assert_pager_state(pPager) ); + assert( pPager->eState!=PAGER_ERROR ); + if( pPager->eStateeLockjfd) || pPager->pInJournal==0 ); + if( isOpen(pPager->jfd) ){ + assert( !pagerUseWal(pPager) ); + + /* Finalize the journal file. */ + if( sqlite3IsMemJournal(pPager->jfd) ){ + assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); + sqlite3OsClose(pPager->jfd); + }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){ + if( pPager->journalOff==0 ){ + rc = SQLITE_OK; + }else{ + rc = sqlite3OsTruncate(pPager->jfd, 0); + if( rc==SQLITE_OK && pPager->fullSync ){ + /* Make sure the new file size is written into the inode right away. + ** Otherwise the journal might resurrect following a power loss and + ** cause the last transaction to roll back. See + ** https://bugzilla.mozilla.org/show_bug.cgi?id=1072773 + */ + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags); + } + } + pPager->journalOff = 0; + }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST + || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL) + ){ + rc = zeroJournalHdr(pPager, hasMaster); + pPager->journalOff = 0; + }else{ + /* This branch may be executed with Pager.journalMode==MEMORY if + ** a hot-journal was just rolled back. In this case the journal + ** file should be closed and deleted. If this connection writes to + ** the database file, it will do so using an in-memory journal. + */ + int bDelete = (!pPager->tempFile && sqlite3JournalExists(pPager->jfd)); + assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE + || pPager->journalMode==PAGER_JOURNALMODE_MEMORY + || pPager->journalMode==PAGER_JOURNALMODE_WAL + ); + sqlite3OsClose(pPager->jfd); + if( bDelete ){ + rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0); + } + } + } + +#ifdef SQLITE_CHECK_PAGES + sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash); + if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){ + PgHdr *p = sqlite3PagerLookup(pPager, 1); + if( p ){ + p->pageHash = 0; + sqlite3PagerUnrefNotNull(p); + } + } +#endif + + sqlite3BitvecDestroy(pPager->pInJournal); + pPager->pInJournal = 0; + pPager->nRec = 0; + sqlite3PcacheCleanAll(pPager->pPCache); + sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize); + + if( pagerUseWal(pPager) ){ + /* Drop the WAL write-lock, if any. Also, if the connection was in + ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE + ** lock held on the database file. + */ + rc2 = sqlite3WalEndWriteTransaction(pPager->pWal); + assert( rc2==SQLITE_OK ); + }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){ + /* This branch is taken when committing a transaction in rollback-journal + ** mode if the database file on disk is larger than the database image. + ** At this point the journal has been finalized and the transaction + ** successfully committed, but the EXCLUSIVE lock is still held on the + ** file. So it is safe to truncate the database file to its minimum + ** required size. */ + assert( pPager->eLock==EXCLUSIVE_LOCK ); + rc = pager_truncate(pPager, pPager->dbSize); + } + + if( rc==SQLITE_OK && bCommit && isOpen(pPager->fd) ){ + rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0); + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + } + + if( !pPager->exclusiveMode + && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0)) + ){ + rc2 = pagerUnlockDb(pPager, SHARED_LOCK); + pPager->changeCountDone = 0; + } + pPager->eState = PAGER_READER; + pPager->setMaster = 0; + + return (rc==SQLITE_OK?rc2:rc); +} + +/* +** Execute a rollback if a transaction is active and unlock the +** database file. +** +** If the pager has already entered the ERROR state, do not attempt +** the rollback at this time. Instead, pager_unlock() is called. The +** call to pager_unlock() will discard all in-memory pages, unlock +** the database file and move the pager back to OPEN state. If this +** means that there is a hot-journal left in the file-system, the next +** connection to obtain a shared lock on the pager (which may be this one) +** will roll it back. +** +** If the pager has not already entered the ERROR state, but an IO or +** malloc error occurs during a rollback, then this will itself cause +** the pager to enter the ERROR state. Which will be cleared by the +** call to pager_unlock(), as described above. +*/ +static void pagerUnlockAndRollback(Pager *pPager){ + if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){ + assert( assert_pager_state(pPager) ); + if( pPager->eState>=PAGER_WRITER_LOCKED ){ + sqlite3BeginBenignMalloc(); + sqlite3PagerRollback(pPager); + sqlite3EndBenignMalloc(); + }else if( !pPager->exclusiveMode ){ + assert( pPager->eState==PAGER_READER ); + pager_end_transaction(pPager, 0, 0); + } + } + pager_unlock(pPager); +} + +/* +** Parameter aData must point to a buffer of pPager->pageSize bytes +** of data. Compute and return a checksum based ont the contents of the +** page of data and the current value of pPager->cksumInit. +** +** This is not a real checksum. It is really just the sum of the +** random initial value (pPager->cksumInit) and every 200th byte +** of the page data, starting with byte offset (pPager->pageSize%200). +** Each byte is interpreted as an 8-bit unsigned integer. +** +** Changing the formula used to compute this checksum results in an +** incompatible journal file format. +** +** If journal corruption occurs due to a power failure, the most likely +** scenario is that one end or the other of the record will be changed. +** It is much less likely that the two ends of the journal record will be +** correct and the middle be corrupt. Thus, this "checksum" scheme, +** though fast and simple, catches the mostly likely kind of corruption. +*/ +static u32 pager_cksum(Pager *pPager, const u8 *aData){ + u32 cksum = pPager->cksumInit; /* Checksum value to return */ + int i = pPager->pageSize-200; /* Loop counter */ + while( i>0 ){ + cksum += aData[i]; + i -= 200; + } + return cksum; +} + +/* +** Report the current page size and number of reserved bytes back +** to the codec. +*/ +#ifdef SQLITE_HAS_CODEC +static void pagerReportSize(Pager *pPager){ + if( pPager->xCodecSizeChng ){ + pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize, + (int)pPager->nReserve); + } +} +#else +# define pagerReportSize(X) /* No-op if we do not support a codec */ +#endif + +#ifdef SQLITE_HAS_CODEC +/* +** Make sure the number of reserved bits is the same in the destination +** pager as it is in the source. This comes up when a VACUUM changes the +** number of reserved bits to the "optimal" amount. +*/ +SQLITE_PRIVATE void sqlite3PagerAlignReserve(Pager *pDest, Pager *pSrc){ + if( pDest->nReserve!=pSrc->nReserve ){ + pDest->nReserve = pSrc->nReserve; + pagerReportSize(pDest); + } +} +#endif + +/* +** Read a single page from either the journal file (if isMainJrnl==1) or +** from the sub-journal (if isMainJrnl==0) and playback that page. +** The page begins at offset *pOffset into the file. The *pOffset +** value is increased to the start of the next page in the journal. +** +** The main rollback journal uses checksums - the statement journal does +** not. +** +** If the page number of the page record read from the (sub-)journal file +** is greater than the current value of Pager.dbSize, then playback is +** skipped and SQLITE_OK is returned. +** +** If pDone is not NULL, then it is a record of pages that have already +** been played back. If the page at *pOffset has already been played back +** (if the corresponding pDone bit is set) then skip the playback. +** Make sure the pDone bit corresponding to the *pOffset page is set +** prior to returning. +** +** If the page record is successfully read from the (sub-)journal file +** and played back, then SQLITE_OK is returned. If an IO error occurs +** while reading the record from the (sub-)journal file or while writing +** to the database file, then the IO error code is returned. If data +** is successfully read from the (sub-)journal file but appears to be +** corrupted, SQLITE_DONE is returned. Data is considered corrupted in +** two circumstances: +** +** * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or +** * If the record is being rolled back from the main journal file +** and the checksum field does not match the record content. +** +** Neither of these two scenarios are possible during a savepoint rollback. +** +** If this is a savepoint rollback, then memory may have to be dynamically +** allocated by this function. If this is the case and an allocation fails, +** SQLITE_NOMEM is returned. +*/ +static int pager_playback_one_page( + Pager *pPager, /* The pager being played back */ + i64 *pOffset, /* Offset of record to playback */ + Bitvec *pDone, /* Bitvec of pages already played back */ + int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */ + int isSavepnt /* True for a savepoint rollback */ +){ + int rc; + PgHdr *pPg; /* An existing page in the cache */ + Pgno pgno; /* The page number of a page in journal */ + u32 cksum; /* Checksum used for sanity checking */ + char *aData; /* Temporary storage for the page */ + sqlite3_file *jfd; /* The file descriptor for the journal file */ + int isSynced; /* True if journal page is synced */ + + assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */ + assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */ + assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */ + assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */ + + aData = pPager->pTmpSpace; + assert( aData ); /* Temp storage must have already been allocated */ + assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) ); + + /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction + ** or savepoint rollback done at the request of the caller) or this is + ** a hot-journal rollback. If it is a hot-journal rollback, the pager + ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback + ** only reads from the main journal, not the sub-journal. + */ + assert( pPager->eState>=PAGER_WRITER_CACHEMOD + || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK) + ); + assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl ); + + /* Read the page number and page data from the journal or sub-journal + ** file. Return an error code to the caller if an IO error occurs. + */ + jfd = isMainJrnl ? pPager->jfd : pPager->sjfd; + rc = read32bits(jfd, *pOffset, &pgno); + if( rc!=SQLITE_OK ) return rc; + rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4); + if( rc!=SQLITE_OK ) return rc; + *pOffset += pPager->pageSize + 4 + isMainJrnl*4; + + /* Sanity checking on the page. This is more important that I originally + ** thought. If a power failure occurs while the journal is being written, + ** it could cause invalid data to be written into the journal. We need to + ** detect this invalid data (with high probability) and ignore it. + */ + if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){ + assert( !isSavepnt ); + return SQLITE_DONE; + } + if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){ + return SQLITE_OK; + } + if( isMainJrnl ){ + rc = read32bits(jfd, (*pOffset)-4, &cksum); + if( rc ) return rc; + if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){ + return SQLITE_DONE; + } + } + + /* If this page has already been played back before during the current + ** rollback, then don't bother to play it back again. + */ + if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){ + return rc; + } + + /* When playing back page 1, restore the nReserve setting + */ + if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){ + pPager->nReserve = ((u8*)aData)[20]; + pagerReportSize(pPager); + } + + /* If the pager is in CACHEMOD state, then there must be a copy of this + ** page in the pager cache. In this case just update the pager cache, + ** not the database file. The page is left marked dirty in this case. + ** + ** An exception to the above rule: If the database is in no-sync mode + ** and a page is moved during an incremental vacuum then the page may + ** not be in the pager cache. Later: if a malloc() or IO error occurs + ** during a Movepage() call, then the page may not be in the cache + ** either. So the condition described in the above paragraph is not + ** assert()able. + ** + ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the + ** pager cache if it exists and the main file. The page is then marked + ** not dirty. Since this code is only executed in PAGER_OPEN state for + ** a hot-journal rollback, it is guaranteed that the page-cache is empty + ** if the pager is in OPEN state. + ** + ** Ticket #1171: The statement journal might contain page content that is + ** different from the page content at the start of the transaction. + ** This occurs when a page is changed prior to the start of a statement + ** then changed again within the statement. When rolling back such a + ** statement we must not write to the original database unless we know + ** for certain that original page contents are synced into the main rollback + ** journal. Otherwise, a power loss might leave modified data in the + ** database file without an entry in the rollback journal that can + ** restore the database to its original form. Two conditions must be + ** met before writing to the database files. (1) the database must be + ** locked. (2) we know that the original page content is fully synced + ** in the main journal either because the page is not in cache or else + ** the page is marked as needSync==0. + ** + ** 2008-04-14: When attempting to vacuum a corrupt database file, it + ** is possible to fail a statement on a database that does not yet exist. + ** Do not attempt to write if database file has never been opened. + */ + if( pagerUseWal(pPager) ){ + pPg = 0; + }else{ + pPg = sqlite3PagerLookup(pPager, pgno); + } + assert( pPg || !MEMDB ); + assert( pPager->eState!=PAGER_OPEN || pPg==0 ); + PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n", + PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData), + (isMainJrnl?"main-journal":"sub-journal") + )); + if( isMainJrnl ){ + isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr); + }else{ + isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC)); + } + if( isOpen(pPager->fd) + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN) + && isSynced + ){ + i64 ofst = (pgno-1)*(i64)pPager->pageSize; + testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 ); + assert( !pagerUseWal(pPager) ); + rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst); + if( pgno>pPager->dbFileSize ){ + pPager->dbFileSize = pgno; + } + if( pPager->pBackup ){ + CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM); + sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData); + CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData); + } + }else if( !isMainJrnl && pPg==0 ){ + /* If this is a rollback of a savepoint and data was not written to + ** the database and the page is not in-memory, there is a potential + ** problem. When the page is next fetched by the b-tree layer, it + ** will be read from the database file, which may or may not be + ** current. + ** + ** There are a couple of different ways this can happen. All are quite + ** obscure. When running in synchronous mode, this can only happen + ** if the page is on the free-list at the start of the transaction, then + ** populated, then moved using sqlite3PagerMovepage(). + ** + ** The solution is to add an in-memory page to the cache containing + ** the data just read from the sub-journal. Mark the page as dirty + ** and if the pager requires a journal-sync, then mark the page as + ** requiring a journal-sync before it is written. + */ + assert( isSavepnt ); + assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 ); + pPager->doNotSpill |= SPILLFLAG_ROLLBACK; + rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1); + assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 ); + pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK; + if( rc!=SQLITE_OK ) return rc; + pPg->flags &= ~PGHDR_NEED_READ; + sqlite3PcacheMakeDirty(pPg); + } + if( pPg ){ + /* No page should ever be explicitly rolled back that is in use, except + ** for page 1 which is held in use in order to keep the lock on the + ** database active. However such a page may be rolled back as a result + ** of an internal error resulting in an automatic call to + ** sqlite3PagerRollback(). + */ + void *pData; + pData = pPg->pData; + memcpy(pData, (u8*)aData, pPager->pageSize); + pPager->xReiniter(pPg); + if( isMainJrnl && (!isSavepnt || *pOffset<=pPager->journalHdr) ){ + /* If the contents of this page were just restored from the main + ** journal file, then its content must be as they were when the + ** transaction was first opened. In this case we can mark the page + ** as clean, since there will be no need to write it out to the + ** database. + ** + ** There is one exception to this rule. If the page is being rolled + ** back as part of a savepoint (or statement) rollback from an + ** unsynced portion of the main journal file, then it is not safe + ** to mark the page as clean. This is because marking the page as + ** clean will clear the PGHDR_NEED_SYNC flag. Since the page is + ** already in the journal file (recorded in Pager.pInJournal) and + ** the PGHDR_NEED_SYNC flag is cleared, if the page is written to + ** again within this transaction, it will be marked as dirty but + ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially + ** be written out into the database file before its journal file + ** segment is synced. If a crash occurs during or following this, + ** database corruption may ensue. + */ + assert( !pagerUseWal(pPager) ); + sqlite3PcacheMakeClean(pPg); + } + pager_set_pagehash(pPg); + + /* If this was page 1, then restore the value of Pager.dbFileVers. + ** Do this before any decoding. */ + if( pgno==1 ){ + memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers)); + } + + /* Decode the page just read from disk */ + CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM); + sqlite3PcacheRelease(pPg); + } + return rc; +} + +/* +** Parameter zMaster is the name of a master journal file. A single journal +** file that referred to the master journal file has just been rolled back. +** This routine checks if it is possible to delete the master journal file, +** and does so if it is. +** +** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not +** available for use within this function. +** +** When a master journal file is created, it is populated with the names +** of all of its child journals, one after another, formatted as utf-8 +** encoded text. The end of each child journal file is marked with a +** nul-terminator byte (0x00). i.e. the entire contents of a master journal +** file for a transaction involving two databases might be: +** +** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00" +** +** A master journal file may only be deleted once all of its child +** journals have been rolled back. +** +** This function reads the contents of the master-journal file into +** memory and loops through each of the child journal names. For +** each child journal, it checks if: +** +** * if the child journal exists, and if so +** * if the child journal contains a reference to master journal +** file zMaster +** +** If a child journal can be found that matches both of the criteria +** above, this function returns without doing anything. Otherwise, if +** no such child journal can be found, file zMaster is deleted from +** the file-system using sqlite3OsDelete(). +** +** If an IO error within this function, an error code is returned. This +** function allocates memory by calling sqlite3Malloc(). If an allocation +** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors +** occur, SQLITE_OK is returned. +** +** TODO: This function allocates a single block of memory to load +** the entire contents of the master journal file. This could be +** a couple of kilobytes or so - potentially larger than the page +** size. +*/ +static int pager_delmaster(Pager *pPager, const char *zMaster){ + sqlite3_vfs *pVfs = pPager->pVfs; + int rc; /* Return code */ + sqlite3_file *pMaster; /* Malloc'd master-journal file descriptor */ + sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */ + char *zMasterJournal = 0; /* Contents of master journal file */ + i64 nMasterJournal; /* Size of master journal file */ + char *zJournal; /* Pointer to one journal within MJ file */ + char *zMasterPtr; /* Space to hold MJ filename from a journal file */ + int nMasterPtr; /* Amount of space allocated to zMasterPtr[] */ + + /* Allocate space for both the pJournal and pMaster file descriptors. + ** If successful, open the master journal file for reading. + */ + pMaster = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2); + pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile); + if( !pMaster ){ + rc = SQLITE_NOMEM; + }else{ + const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL); + rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0); + } + if( rc!=SQLITE_OK ) goto delmaster_out; + + /* Load the entire master journal file into space obtained from + ** sqlite3_malloc() and pointed to by zMasterJournal. Also obtain + ** sufficient space (in zMasterPtr) to hold the names of master + ** journal files extracted from regular rollback-journals. + */ + rc = sqlite3OsFileSize(pMaster, &nMasterJournal); + if( rc!=SQLITE_OK ) goto delmaster_out; + nMasterPtr = pVfs->mxPathname+1; + zMasterJournal = sqlite3Malloc(nMasterJournal + nMasterPtr + 1); + if( !zMasterJournal ){ + rc = SQLITE_NOMEM; + goto delmaster_out; + } + zMasterPtr = &zMasterJournal[nMasterJournal+1]; + rc = sqlite3OsRead(pMaster, zMasterJournal, (int)nMasterJournal, 0); + if( rc!=SQLITE_OK ) goto delmaster_out; + zMasterJournal[nMasterJournal] = 0; + + zJournal = zMasterJournal; + while( (zJournal-zMasterJournal)pageSize bytes). +** If the file on disk is currently larger than nPage pages, then use the VFS +** xTruncate() method to truncate it. +** +** Or, it might be the case that the file on disk is smaller than +** nPage pages. Some operating system implementations can get confused if +** you try to truncate a file to some size that is larger than it +** currently is, so detect this case and write a single zero byte to +** the end of the new file instead. +** +** If successful, return SQLITE_OK. If an IO error occurs while modifying +** the database file, return the error code to the caller. +*/ +static int pager_truncate(Pager *pPager, Pgno nPage){ + int rc = SQLITE_OK; + assert( pPager->eState!=PAGER_ERROR ); + assert( pPager->eState!=PAGER_READER ); + + if( isOpen(pPager->fd) + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN) + ){ + i64 currentSize, newSize; + int szPage = pPager->pageSize; + assert( pPager->eLock==EXCLUSIVE_LOCK ); + /* TODO: Is it safe to use Pager.dbFileSize here? */ + rc = sqlite3OsFileSize(pPager->fd, ¤tSize); + newSize = szPage*(i64)nPage; + if( rc==SQLITE_OK && currentSize!=newSize ){ + if( currentSize>newSize ){ + rc = sqlite3OsTruncate(pPager->fd, newSize); + }else if( (currentSize+szPage)<=newSize ){ + char *pTmp = pPager->pTmpSpace; + memset(pTmp, 0, szPage); + testcase( (newSize-szPage) == currentSize ); + testcase( (newSize-szPage) > currentSize ); + rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage); + } + if( rc==SQLITE_OK ){ + pPager->dbFileSize = nPage; + } + } + } + return rc; +} + +/* +** Return a sanitized version of the sector-size of OS file pFile. The +** return value is guaranteed to lie between 32 and MAX_SECTOR_SIZE. +*/ +SQLITE_PRIVATE int sqlite3SectorSize(sqlite3_file *pFile){ + int iRet = sqlite3OsSectorSize(pFile); + if( iRet<32 ){ + iRet = 512; + }else if( iRet>MAX_SECTOR_SIZE ){ + assert( MAX_SECTOR_SIZE>=512 ); + iRet = MAX_SECTOR_SIZE; + } + return iRet; +} + +/* +** Set the value of the Pager.sectorSize variable for the given +** pager based on the value returned by the xSectorSize method +** of the open database file. The sector size will be used +** to determine the size and alignment of journal header and +** master journal pointers within created journal files. +** +** For temporary files the effective sector size is always 512 bytes. +** +** Otherwise, for non-temporary files, the effective sector size is +** the value returned by the xSectorSize() method rounded up to 32 if +** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it +** is greater than MAX_SECTOR_SIZE. +** +** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set +** the effective sector size to its minimum value (512). The purpose of +** pPager->sectorSize is to define the "blast radius" of bytes that +** might change if a crash occurs while writing to a single byte in +** that range. But with POWERSAFE_OVERWRITE, the blast radius is zero +** (that is what POWERSAFE_OVERWRITE means), so we minimize the sector +** size. For backwards compatibility of the rollback journal file format, +** we cannot reduce the effective sector size below 512. +*/ +static void setSectorSize(Pager *pPager){ + assert( isOpen(pPager->fd) || pPager->tempFile ); + + if( pPager->tempFile + || (sqlite3OsDeviceCharacteristics(pPager->fd) & + SQLITE_IOCAP_POWERSAFE_OVERWRITE)!=0 + ){ + /* Sector size doesn't matter for temporary files. Also, the file + ** may not have been opened yet, in which case the OsSectorSize() + ** call will segfault. */ + pPager->sectorSize = 512; + }else{ + pPager->sectorSize = sqlite3SectorSize(pPager->fd); + } +} + +/* +** Playback the journal and thus restore the database file to +** the state it was in before we started making changes. +** +** The journal file format is as follows: +** +** (1) 8 byte prefix. A copy of aJournalMagic[]. +** (2) 4 byte big-endian integer which is the number of valid page records +** in the journal. If this value is 0xffffffff, then compute the +** number of page records from the journal size. +** (3) 4 byte big-endian integer which is the initial value for the +** sanity checksum. +** (4) 4 byte integer which is the number of pages to truncate the +** database to during a rollback. +** (5) 4 byte big-endian integer which is the sector size. The header +** is this many bytes in size. +** (6) 4 byte big-endian integer which is the page size. +** (7) zero padding out to the next sector size. +** (8) Zero or more pages instances, each as follows: +** + 4 byte page number. +** + pPager->pageSize bytes of data. +** + 4 byte checksum +** +** When we speak of the journal header, we mean the first 7 items above. +** Each entry in the journal is an instance of the 8th item. +** +** Call the value from the second bullet "nRec". nRec is the number of +** valid page entries in the journal. In most cases, you can compute the +** value of nRec from the size of the journal file. But if a power +** failure occurred while the journal was being written, it could be the +** case that the size of the journal file had already been increased but +** the extra entries had not yet made it safely to disk. In such a case, +** the value of nRec computed from the file size would be too large. For +** that reason, we always use the nRec value in the header. +** +** If the nRec value is 0xffffffff it means that nRec should be computed +** from the file size. This value is used when the user selects the +** no-sync option for the journal. A power failure could lead to corruption +** in this case. But for things like temporary table (which will be +** deleted when the power is restored) we don't care. +** +** If the file opened as the journal file is not a well-formed +** journal file then all pages up to the first corrupted page are rolled +** back (or no pages if the journal header is corrupted). The journal file +** is then deleted and SQLITE_OK returned, just as if no corruption had +** been encountered. +** +** If an I/O or malloc() error occurs, the journal-file is not deleted +** and an error code is returned. +** +** The isHot parameter indicates that we are trying to rollback a journal +** that might be a hot journal. Or, it could be that the journal is +** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE. +** If the journal really is hot, reset the pager cache prior rolling +** back any content. If the journal is merely persistent, no reset is +** needed. +*/ +static int pager_playback(Pager *pPager, int isHot){ + sqlite3_vfs *pVfs = pPager->pVfs; + i64 szJ; /* Size of the journal file in bytes */ + u32 nRec; /* Number of Records in the journal */ + u32 u; /* Unsigned loop counter */ + Pgno mxPg = 0; /* Size of the original file in pages */ + int rc; /* Result code of a subroutine */ + int res = 1; /* Value returned by sqlite3OsAccess() */ + char *zMaster = 0; /* Name of master journal file if any */ + int needPagerReset; /* True to reset page prior to first page rollback */ + int nPlayback = 0; /* Total number of pages restored from journal */ + + /* Figure out how many records are in the journal. Abort early if + ** the journal is empty. + */ + assert( isOpen(pPager->jfd) ); + rc = sqlite3OsFileSize(pPager->jfd, &szJ); + if( rc!=SQLITE_OK ){ + goto end_playback; + } + + /* Read the master journal name from the journal, if it is present. + ** If a master journal file name is specified, but the file is not + ** present on disk, then the journal is not hot and does not need to be + ** played back. + ** + ** TODO: Technically the following is an error because it assumes that + ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that + ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c, + ** mxPathname is 512, which is the same as the minimum allowable value + ** for pageSize. + */ + zMaster = pPager->pTmpSpace; + rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1); + if( rc==SQLITE_OK && zMaster[0] ){ + rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res); + } + zMaster = 0; + if( rc!=SQLITE_OK || !res ){ + goto end_playback; + } + pPager->journalOff = 0; + needPagerReset = isHot; + + /* This loop terminates either when a readJournalHdr() or + ** pager_playback_one_page() call returns SQLITE_DONE or an IO error + ** occurs. + */ + while( 1 ){ + /* Read the next journal header from the journal file. If there are + ** not enough bytes left in the journal file for a complete header, or + ** it is corrupted, then a process must have failed while writing it. + ** This indicates nothing more needs to be rolled back. + */ + rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + goto end_playback; + } + + /* If nRec is 0xffffffff, then this journal was created by a process + ** working in no-sync mode. This means that the rest of the journal + ** file consists of pages, there are no more journal headers. Compute + ** the value of nRec based on this assumption. + */ + if( nRec==0xffffffff ){ + assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ); + nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager)); + } + + /* If nRec is 0 and this rollback is of a transaction created by this + ** process and if this is the final header in the journal, then it means + ** that this part of the journal was being filled but has not yet been + ** synced to disk. Compute the number of pages based on the remaining + ** size of the file. + ** + ** The third term of the test was added to fix ticket #2565. + ** When rolling back a hot journal, nRec==0 always means that the next + ** chunk of the journal contains zero pages to be rolled back. But + ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in + ** the journal, it means that the journal might contain additional + ** pages that need to be rolled back and that the number of pages + ** should be computed based on the journal file size. + */ + if( nRec==0 && !isHot && + pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){ + nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager)); + } + + /* If this is the first header read from the journal, truncate the + ** database file back to its original size. + */ + if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){ + rc = pager_truncate(pPager, mxPg); + if( rc!=SQLITE_OK ){ + goto end_playback; + } + pPager->dbSize = mxPg; + } + + /* Copy original pages out of the journal and back into the + ** database file and/or page cache. + */ + for(u=0; ujournalOff,0,1,0); + if( rc==SQLITE_OK ){ + nPlayback++; + }else{ + if( rc==SQLITE_DONE ){ + pPager->journalOff = szJ; + break; + }else if( rc==SQLITE_IOERR_SHORT_READ ){ + /* If the journal has been truncated, simply stop reading and + ** processing the journal. This might happen if the journal was + ** not completely written and synced prior to a crash. In that + ** case, the database should have never been written in the + ** first place so it is OK to simply abandon the rollback. */ + rc = SQLITE_OK; + goto end_playback; + }else{ + /* If we are unable to rollback, quit and return the error + ** code. This will cause the pager to enter the error state + ** so that no further harm will be done. Perhaps the next + ** process to come along will be able to rollback the database. + */ + goto end_playback; + } + } + } + } + /*NOTREACHED*/ + assert( 0 ); + +end_playback: + /* Following a rollback, the database file should be back in its original + ** state prior to the start of the transaction, so invoke the + ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the + ** assertion that the transaction counter was modified. + */ +#ifdef SQLITE_DEBUG + if( pPager->fd->pMethods ){ + sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0); + } +#endif + + /* If this playback is happening automatically as a result of an IO or + ** malloc error that occurred after the change-counter was updated but + ** before the transaction was committed, then the change-counter + ** modification may just have been reverted. If this happens in exclusive + ** mode, then subsequent transactions performed by the connection will not + ** update the change-counter at all. This may lead to cache inconsistency + ** problems for other processes at some point in the future. So, just + ** in case this has happened, clear the changeCountDone flag now. + */ + pPager->changeCountDone = pPager->tempFile; + + if( rc==SQLITE_OK ){ + zMaster = pPager->pTmpSpace; + rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1); + testcase( rc!=SQLITE_OK ); + } + if( rc==SQLITE_OK + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN) + ){ + rc = sqlite3PagerSync(pPager, 0); + } + if( rc==SQLITE_OK ){ + rc = pager_end_transaction(pPager, zMaster[0]!='\0', 0); + testcase( rc!=SQLITE_OK ); + } + if( rc==SQLITE_OK && zMaster[0] && res ){ + /* If there was a master journal and this routine will return success, + ** see if it is possible to delete the master journal. + */ + rc = pager_delmaster(pPager, zMaster); + testcase( rc!=SQLITE_OK ); + } + if( isHot && nPlayback ){ + sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK, "recovered %d pages from %s", + nPlayback, pPager->zJournal); + } + + /* The Pager.sectorSize variable may have been updated while rolling + ** back a journal created by a process with a different sector size + ** value. Reset it to the correct value for this process. + */ + setSectorSize(pPager); + return rc; +} + + +/* +** Read the content for page pPg out of the database file and into +** pPg->pData. A shared lock or greater must be held on the database +** file before this function is called. +** +** If page 1 is read, then the value of Pager.dbFileVers[] is set to +** the value read from the database file. +** +** If an IO error occurs, then the IO error is returned to the caller. +** Otherwise, SQLITE_OK is returned. +*/ +static int readDbPage(PgHdr *pPg, u32 iFrame){ + Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */ + Pgno pgno = pPg->pgno; /* Page number to read */ + int rc = SQLITE_OK; /* Return code */ + int pgsz = pPager->pageSize; /* Number of bytes to read */ + + assert( pPager->eState>=PAGER_READER && !MEMDB ); + assert( isOpen(pPager->fd) ); + +#ifndef SQLITE_OMIT_WAL + if( iFrame ){ + /* Try to pull the page from the write-ahead log. */ + rc = sqlite3WalReadFrame(pPager->pWal, iFrame, pgsz, pPg->pData); + }else +#endif + { + i64 iOffset = (pgno-1)*(i64)pPager->pageSize; + rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset); + if( rc==SQLITE_IOERR_SHORT_READ ){ + rc = SQLITE_OK; + } + } + + if( pgno==1 ){ + if( rc ){ + /* If the read is unsuccessful, set the dbFileVers[] to something + ** that will never be a valid file version. dbFileVers[] is a copy + ** of bytes 24..39 of the database. Bytes 28..31 should always be + ** zero or the size of the database in page. Bytes 32..35 and 35..39 + ** should be page numbers which are never 0xffffffff. So filling + ** pPager->dbFileVers[] with all 0xff bytes should suffice. + ** + ** For an encrypted database, the situation is more complex: bytes + ** 24..39 of the database are white noise. But the probability of + ** white noise equaling 16 bytes of 0xff is vanishingly small so + ** we should still be ok. + */ + memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers)); + }else{ + u8 *dbFileVers = &((u8*)pPg->pData)[24]; + memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers)); + } + } + CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM); + + PAGER_INCR(sqlite3_pager_readdb_count); + PAGER_INCR(pPager->nRead); + IOTRACE(("PGIN %p %d\n", pPager, pgno)); + PAGERTRACE(("FETCH %d page %d hash(%08x)\n", + PAGERID(pPager), pgno, pager_pagehash(pPg))); + + return rc; +} + +/* +** Update the value of the change-counter at offsets 24 and 92 in +** the header and the sqlite version number at offset 96. +** +** This is an unconditional update. See also the pager_incr_changecounter() +** routine which only updates the change-counter if the update is actually +** needed, as determined by the pPager->changeCountDone state variable. +*/ +static void pager_write_changecounter(PgHdr *pPg){ + u32 change_counter; + + /* Increment the value just read and write it back to byte 24. */ + change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1; + put32bits(((char*)pPg->pData)+24, change_counter); + + /* Also store the SQLite version number in bytes 96..99 and in + ** bytes 92..95 store the change counter for which the version number + ** is valid. */ + put32bits(((char*)pPg->pData)+92, change_counter); + put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER); +} + +#ifndef SQLITE_OMIT_WAL +/* +** This function is invoked once for each page that has already been +** written into the log file when a WAL transaction is rolled back. +** Parameter iPg is the page number of said page. The pCtx argument +** is actually a pointer to the Pager structure. +** +** If page iPg is present in the cache, and has no outstanding references, +** it is discarded. Otherwise, if there are one or more outstanding +** references, the page content is reloaded from the database. If the +** attempt to reload content from the database is required and fails, +** return an SQLite error code. Otherwise, SQLITE_OK. +*/ +static int pagerUndoCallback(void *pCtx, Pgno iPg){ + int rc = SQLITE_OK; + Pager *pPager = (Pager *)pCtx; + PgHdr *pPg; + + assert( pagerUseWal(pPager) ); + pPg = sqlite3PagerLookup(pPager, iPg); + if( pPg ){ + if( sqlite3PcachePageRefcount(pPg)==1 ){ + sqlite3PcacheDrop(pPg); + }else{ + u32 iFrame = 0; + rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame); + if( rc==SQLITE_OK ){ + rc = readDbPage(pPg, iFrame); + } + if( rc==SQLITE_OK ){ + pPager->xReiniter(pPg); + } + sqlite3PagerUnrefNotNull(pPg); + } + } + + /* Normally, if a transaction is rolled back, any backup processes are + ** updated as data is copied out of the rollback journal and into the + ** database. This is not generally possible with a WAL database, as + ** rollback involves simply truncating the log file. Therefore, if one + ** or more frames have already been written to the log (and therefore + ** also copied into the backup databases) as part of this transaction, + ** the backups must be restarted. + */ + sqlite3BackupRestart(pPager->pBackup); + + return rc; +} + +/* +** This function is called to rollback a transaction on a WAL database. +*/ +static int pagerRollbackWal(Pager *pPager){ + int rc; /* Return Code */ + PgHdr *pList; /* List of dirty pages to revert */ + + /* For all pages in the cache that are currently dirty or have already + ** been written (but not committed) to the log file, do one of the + ** following: + ** + ** + Discard the cached page (if refcount==0), or + ** + Reload page content from the database (if refcount>0). + */ + pPager->dbSize = pPager->dbOrigSize; + rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager); + pList = sqlite3PcacheDirtyList(pPager->pPCache); + while( pList && rc==SQLITE_OK ){ + PgHdr *pNext = pList->pDirty; + rc = pagerUndoCallback((void *)pPager, pList->pgno); + pList = pNext; + } + + return rc; +} + +/* +** This function is a wrapper around sqlite3WalFrames(). As well as logging +** the contents of the list of pages headed by pList (connected by pDirty), +** this function notifies any active backup processes that the pages have +** changed. +** +** The list of pages passed into this routine is always sorted by page number. +** Hence, if page 1 appears anywhere on the list, it will be the first page. +*/ +static int pagerWalFrames( + Pager *pPager, /* Pager object */ + PgHdr *pList, /* List of frames to log */ + Pgno nTruncate, /* Database size after this commit */ + int isCommit /* True if this is a commit */ +){ + int rc; /* Return code */ + int nList; /* Number of pages in pList */ + PgHdr *p; /* For looping over pages */ + + assert( pPager->pWal ); + assert( pList ); +#ifdef SQLITE_DEBUG + /* Verify that the page list is in accending order */ + for(p=pList; p && p->pDirty; p=p->pDirty){ + assert( p->pgno < p->pDirty->pgno ); + } +#endif + + assert( pList->pDirty==0 || isCommit ); + if( isCommit ){ + /* If a WAL transaction is being committed, there is no point in writing + ** any pages with page numbers greater than nTruncate into the WAL file. + ** They will never be read by any client. So remove them from the pDirty + ** list here. */ + PgHdr **ppNext = &pList; + nList = 0; + for(p=pList; (*ppNext = p)!=0; p=p->pDirty){ + if( p->pgno<=nTruncate ){ + ppNext = &p->pDirty; + nList++; + } + } + assert( pList ); + }else{ + nList = 1; + } + pPager->aStat[PAGER_STAT_WRITE] += nList; + + if( pList->pgno==1 ) pager_write_changecounter(pList); + rc = sqlite3WalFrames(pPager->pWal, + pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags + ); + if( rc==SQLITE_OK && pPager->pBackup ){ + for(p=pList; p; p=p->pDirty){ + sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData); + } + } + +#ifdef SQLITE_CHECK_PAGES + pList = sqlite3PcacheDirtyList(pPager->pPCache); + for(p=pList; p; p=p->pDirty){ + pager_set_pagehash(p); + } +#endif + + return rc; +} + +/* +** Begin a read transaction on the WAL. +** +** This routine used to be called "pagerOpenSnapshot()" because it essentially +** makes a snapshot of the database at the current point in time and preserves +** that snapshot for use by the reader in spite of concurrently changes by +** other writers or checkpointers. +*/ +static int pagerBeginReadTransaction(Pager *pPager){ + int rc; /* Return code */ + int changed = 0; /* True if cache must be reset */ + + assert( pagerUseWal(pPager) ); + assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER ); + + /* sqlite3WalEndReadTransaction() was not called for the previous + ** transaction in locking_mode=EXCLUSIVE. So call it now. If we + ** are in locking_mode=NORMAL and EndRead() was previously called, + ** the duplicate call is harmless. + */ + sqlite3WalEndReadTransaction(pPager->pWal); + + rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed); + if( rc!=SQLITE_OK || changed ){ + pager_reset(pPager); + if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0); + } + + return rc; +} +#endif + +/* +** This function is called as part of the transition from PAGER_OPEN +** to PAGER_READER state to determine the size of the database file +** in pages (assuming the page size currently stored in Pager.pageSize). +** +** If no error occurs, SQLITE_OK is returned and the size of the database +** in pages is stored in *pnPage. Otherwise, an error code (perhaps +** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified. +*/ +static int pagerPagecount(Pager *pPager, Pgno *pnPage){ + Pgno nPage; /* Value to return via *pnPage */ + + /* Query the WAL sub-system for the database size. The WalDbsize() + ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or + ** if the database size is not available. The database size is not + ** available from the WAL sub-system if the log file is empty or + ** contains no valid committed transactions. + */ + assert( pPager->eState==PAGER_OPEN ); + assert( pPager->eLock>=SHARED_LOCK ); + nPage = sqlite3WalDbsize(pPager->pWal); + + /* If the number of pages in the database is not available from the + ** WAL sub-system, determine the page counte based on the size of + ** the database file. If the size of the database file is not an + ** integer multiple of the page-size, round up the result. + */ + if( nPage==0 ){ + i64 n = 0; /* Size of db file in bytes */ + assert( isOpen(pPager->fd) || pPager->tempFile ); + if( isOpen(pPager->fd) ){ + int rc = sqlite3OsFileSize(pPager->fd, &n); + if( rc!=SQLITE_OK ){ + return rc; + } + } + nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize); + } + + /* If the current number of pages in the file is greater than the + ** configured maximum pager number, increase the allowed limit so + ** that the file can be read. + */ + if( nPage>pPager->mxPgno ){ + pPager->mxPgno = (Pgno)nPage; + } + + *pnPage = nPage; + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_WAL +/* +** Check if the *-wal file that corresponds to the database opened by pPager +** exists if the database is not empy, or verify that the *-wal file does +** not exist (by deleting it) if the database file is empty. +** +** If the database is not empty and the *-wal file exists, open the pager +** in WAL mode. If the database is empty or if no *-wal file exists and +** if no error occurs, make sure Pager.journalMode is not set to +** PAGER_JOURNALMODE_WAL. +** +** Return SQLITE_OK or an error code. +** +** The caller must hold a SHARED lock on the database file to call this +** function. Because an EXCLUSIVE lock on the db file is required to delete +** a WAL on a none-empty database, this ensures there is no race condition +** between the xAccess() below and an xDelete() being executed by some +** other connection. +*/ +static int pagerOpenWalIfPresent(Pager *pPager){ + int rc = SQLITE_OK; + assert( pPager->eState==PAGER_OPEN ); + assert( pPager->eLock>=SHARED_LOCK ); + + if( !pPager->tempFile ){ + int isWal; /* True if WAL file exists */ + Pgno nPage; /* Size of the database file */ + + rc = pagerPagecount(pPager, &nPage); + if( rc ) return rc; + if( nPage==0 ){ + rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0); + if( rc==SQLITE_IOERR_DELETE_NOENT ) rc = SQLITE_OK; + isWal = 0; + }else{ + rc = sqlite3OsAccess( + pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal + ); + } + if( rc==SQLITE_OK ){ + if( isWal ){ + testcase( sqlite3PcachePagecount(pPager->pPCache)==0 ); + rc = sqlite3PagerOpenWal(pPager, 0); + }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){ + pPager->journalMode = PAGER_JOURNALMODE_DELETE; + } + } + } + return rc; +} +#endif + +/* +** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback +** the entire master journal file. The case pSavepoint==NULL occurs when +** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction +** savepoint. +** +** When pSavepoint is not NULL (meaning a non-transaction savepoint is +** being rolled back), then the rollback consists of up to three stages, +** performed in the order specified: +** +** * Pages are played back from the main journal starting at byte +** offset PagerSavepoint.iOffset and continuing to +** PagerSavepoint.iHdrOffset, or to the end of the main journal +** file if PagerSavepoint.iHdrOffset is zero. +** +** * If PagerSavepoint.iHdrOffset is not zero, then pages are played +** back starting from the journal header immediately following +** PagerSavepoint.iHdrOffset to the end of the main journal file. +** +** * Pages are then played back from the sub-journal file, starting +** with the PagerSavepoint.iSubRec and continuing to the end of +** the journal file. +** +** Throughout the rollback process, each time a page is rolled back, the +** corresponding bit is set in a bitvec structure (variable pDone in the +** implementation below). This is used to ensure that a page is only +** rolled back the first time it is encountered in either journal. +** +** If pSavepoint is NULL, then pages are only played back from the main +** journal file. There is no need for a bitvec in this case. +** +** In either case, before playback commences the Pager.dbSize variable +** is reset to the value that it held at the start of the savepoint +** (or transaction). No page with a page-number greater than this value +** is played back. If one is encountered it is simply skipped. +*/ +static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){ + i64 szJ; /* Effective size of the main journal */ + i64 iHdrOff; /* End of first segment of main-journal records */ + int rc = SQLITE_OK; /* Return code */ + Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */ + + assert( pPager->eState!=PAGER_ERROR ); + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + + /* Allocate a bitvec to use to store the set of pages rolled back */ + if( pSavepoint ){ + pDone = sqlite3BitvecCreate(pSavepoint->nOrig); + if( !pDone ){ + return SQLITE_NOMEM; + } + } + + /* Set the database size back to the value it was before the savepoint + ** being reverted was opened. + */ + pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize; + pPager->changeCountDone = pPager->tempFile; + + if( !pSavepoint && pagerUseWal(pPager) ){ + return pagerRollbackWal(pPager); + } + + /* Use pPager->journalOff as the effective size of the main rollback + ** journal. The actual file might be larger than this in + ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything + ** past pPager->journalOff is off-limits to us. + */ + szJ = pPager->journalOff; + assert( pagerUseWal(pPager)==0 || szJ==0 ); + + /* Begin by rolling back records from the main journal starting at + ** PagerSavepoint.iOffset and continuing to the next journal header. + ** There might be records in the main journal that have a page number + ** greater than the current database size (pPager->dbSize) but those + ** will be skipped automatically. Pages are added to pDone as they + ** are played back. + */ + if( pSavepoint && !pagerUseWal(pPager) ){ + iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ; + pPager->journalOff = pSavepoint->iOffset; + while( rc==SQLITE_OK && pPager->journalOffjournalOff, pDone, 1, 1); + } + assert( rc!=SQLITE_DONE ); + }else{ + pPager->journalOff = 0; + } + + /* Continue rolling back records out of the main journal starting at + ** the first journal header seen and continuing until the effective end + ** of the main journal file. Continue to skip out-of-range pages and + ** continue adding pages rolled back to pDone. + */ + while( rc==SQLITE_OK && pPager->journalOffjournalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff" + ** test is related to ticket #2565. See the discussion in the + ** pager_playback() function for additional information. + */ + if( nJRec==0 + && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff + ){ + nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager)); + } + for(ii=0; rc==SQLITE_OK && iijournalOffjournalOff, pDone, 1, 1); + } + assert( rc!=SQLITE_DONE ); + } + assert( rc!=SQLITE_OK || pPager->journalOff>=szJ ); + + /* Finally, rollback pages from the sub-journal. Page that were + ** previously rolled back out of the main journal (and are hence in pDone) + ** will be skipped. Out-of-range pages are also skipped. + */ + if( pSavepoint ){ + u32 ii; /* Loop counter */ + i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize); + + if( pagerUseWal(pPager) ){ + rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData); + } + for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && iinSubRec; ii++){ + assert( offset==(i64)ii*(4+pPager->pageSize) ); + rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1); + } + assert( rc!=SQLITE_DONE ); + } + + sqlite3BitvecDestroy(pDone); + if( rc==SQLITE_OK ){ + pPager->journalOff = szJ; + } + + return rc; +} + +/* +** Change the maximum number of in-memory pages that are allowed. +*/ +SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){ + sqlite3PcacheSetCachesize(pPager->pPCache, mxPage); +} + +/* +** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap. +*/ +static void pagerFixMaplimit(Pager *pPager){ +#if SQLITE_MAX_MMAP_SIZE>0 + sqlite3_file *fd = pPager->fd; + if( isOpen(fd) && fd->pMethods->iVersion>=3 ){ + sqlite3_int64 sz; + sz = pPager->szMmap; + pPager->bUseFetch = (sz>0); + sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz); + } +#endif +} + +/* +** Change the maximum size of any memory mapping made of the database file. +*/ +SQLITE_PRIVATE void sqlite3PagerSetMmapLimit(Pager *pPager, sqlite3_int64 szMmap){ + pPager->szMmap = szMmap; + pagerFixMaplimit(pPager); +} + +/* +** Free as much memory as possible from the pager. +*/ +SQLITE_PRIVATE void sqlite3PagerShrink(Pager *pPager){ + sqlite3PcacheShrink(pPager->pPCache); +} + +/* +** Adjust settings of the pager to those specified in the pgFlags parameter. +** +** The "level" in pgFlags & PAGER_SYNCHRONOUS_MASK sets the robustness +** of the database to damage due to OS crashes or power failures by +** changing the number of syncs()s when writing the journals. +** There are three levels: +** +** OFF sqlite3OsSync() is never called. This is the default +** for temporary and transient files. +** +** NORMAL The journal is synced once before writes begin on the +** database. This is normally adequate protection, but +** it is theoretically possible, though very unlikely, +** that an inopertune power failure could leave the journal +** in a state which would cause damage to the database +** when it is rolled back. +** +** FULL The journal is synced twice before writes begin on the +** database (with some additional information - the nRec field +** of the journal header - being written in between the two +** syncs). If we assume that writing a +** single disk sector is atomic, then this mode provides +** assurance that the journal will not be corrupted to the +** point of causing damage to the database during rollback. +** +** The above is for a rollback-journal mode. For WAL mode, OFF continues +** to mean that no syncs ever occur. NORMAL means that the WAL is synced +** prior to the start of checkpoint and that the database file is synced +** at the conclusion of the checkpoint if the entire content of the WAL +** was written back into the database. But no sync operations occur for +** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL +** file is synced following each commit operation, in addition to the +** syncs associated with NORMAL. +** +** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The +** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync +** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an +** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL +** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the +** synchronous=FULL versus synchronous=NORMAL setting determines when +** the xSync primitive is called and is relevant to all platforms. +** +** Numeric values associated with these states are OFF==1, NORMAL=2, +** and FULL=3. +*/ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +SQLITE_PRIVATE void sqlite3PagerSetFlags( + Pager *pPager, /* The pager to set safety level for */ + unsigned pgFlags /* Various flags */ +){ + unsigned level = pgFlags & PAGER_SYNCHRONOUS_MASK; + assert( level>=1 && level<=3 ); + pPager->noSync = (level==1 || pPager->tempFile) ?1:0; + pPager->fullSync = (level==3 && !pPager->tempFile) ?1:0; + if( pPager->noSync ){ + pPager->syncFlags = 0; + pPager->ckptSyncFlags = 0; + }else if( pgFlags & PAGER_FULLFSYNC ){ + pPager->syncFlags = SQLITE_SYNC_FULL; + pPager->ckptSyncFlags = SQLITE_SYNC_FULL; + }else if( pgFlags & PAGER_CKPT_FULLFSYNC ){ + pPager->syncFlags = SQLITE_SYNC_NORMAL; + pPager->ckptSyncFlags = SQLITE_SYNC_FULL; + }else{ + pPager->syncFlags = SQLITE_SYNC_NORMAL; + pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL; + } + pPager->walSyncFlags = pPager->syncFlags; + if( pPager->fullSync ){ + pPager->walSyncFlags |= WAL_SYNC_TRANSACTIONS; + } + if( pgFlags & PAGER_CACHESPILL ){ + pPager->doNotSpill &= ~SPILLFLAG_OFF; + }else{ + pPager->doNotSpill |= SPILLFLAG_OFF; + } +} +#endif + +/* +** The following global variable is incremented whenever the library +** attempts to open a temporary file. This information is used for +** testing and analysis only. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_opentemp_count = 0; +#endif + +/* +** Open a temporary file. +** +** Write the file descriptor into *pFile. Return SQLITE_OK on success +** or some other error code if we fail. The OS will automatically +** delete the temporary file when it is closed. +** +** The flags passed to the VFS layer xOpen() call are those specified +** by parameter vfsFlags ORed with the following: +** +** SQLITE_OPEN_READWRITE +** SQLITE_OPEN_CREATE +** SQLITE_OPEN_EXCLUSIVE +** SQLITE_OPEN_DELETEONCLOSE +*/ +static int pagerOpentemp( + Pager *pPager, /* The pager object */ + sqlite3_file *pFile, /* Write the file descriptor here */ + int vfsFlags /* Flags passed through to the VFS */ +){ + int rc; /* Return code */ + +#ifdef SQLITE_TEST + sqlite3_opentemp_count++; /* Used for testing and analysis only */ +#endif + + vfsFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE; + rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0); + assert( rc!=SQLITE_OK || isOpen(pFile) ); + return rc; +} + +/* +** Set the busy handler function. +** +** The pager invokes the busy-handler if sqlite3OsLock() returns +** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock, +** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE +** lock. It does *not* invoke the busy handler when upgrading from +** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE +** (which occurs during hot-journal rollback). Summary: +** +** Transition | Invokes xBusyHandler +** -------------------------------------------------------- +** NO_LOCK -> SHARED_LOCK | Yes +** SHARED_LOCK -> RESERVED_LOCK | No +** SHARED_LOCK -> EXCLUSIVE_LOCK | No +** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes +** +** If the busy-handler callback returns non-zero, the lock is +** retried. If it returns zero, then the SQLITE_BUSY error is +** returned to the caller of the pager API function. +*/ +SQLITE_PRIVATE void sqlite3PagerSetBusyhandler( + Pager *pPager, /* Pager object */ + int (*xBusyHandler)(void *), /* Pointer to busy-handler function */ + void *pBusyHandlerArg /* Argument to pass to xBusyHandler */ +){ + pPager->xBusyHandler = xBusyHandler; + pPager->pBusyHandlerArg = pBusyHandlerArg; + + if( isOpen(pPager->fd) ){ + void **ap = (void **)&pPager->xBusyHandler; + assert( ((int(*)(void *))(ap[0]))==xBusyHandler ); + assert( ap[1]==pBusyHandlerArg ); + sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap); + } +} + +/* +** Change the page size used by the Pager object. The new page size +** is passed in *pPageSize. +** +** If the pager is in the error state when this function is called, it +** is a no-op. The value returned is the error state error code (i.e. +** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL). +** +** Otherwise, if all of the following are true: +** +** * the new page size (value of *pPageSize) is valid (a power +** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and +** +** * there are no outstanding page references, and +** +** * the database is either not an in-memory database or it is +** an in-memory database that currently consists of zero pages. +** +** then the pager object page size is set to *pPageSize. +** +** If the page size is changed, then this function uses sqlite3PagerMalloc() +** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt +** fails, SQLITE_NOMEM is returned and the page size remains unchanged. +** In all other cases, SQLITE_OK is returned. +** +** If the page size is not changed, either because one of the enumerated +** conditions above is not true, the pager was in error state when this +** function was called, or because the memory allocation attempt failed, +** then *pPageSize is set to the old, retained page size before returning. +*/ +SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){ + int rc = SQLITE_OK; + + /* It is not possible to do a full assert_pager_state() here, as this + ** function may be called from within PagerOpen(), before the state + ** of the Pager object is internally consistent. + ** + ** At one point this function returned an error if the pager was in + ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that + ** there is at least one outstanding page reference, this function + ** is a no-op for that case anyhow. + */ + + u32 pageSize = *pPageSize; + assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) ); + if( (pPager->memDb==0 || pPager->dbSize==0) + && sqlite3PcacheRefCount(pPager->pPCache)==0 + && pageSize && pageSize!=(u32)pPager->pageSize + ){ + char *pNew = NULL; /* New temp space */ + i64 nByte = 0; + + if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){ + rc = sqlite3OsFileSize(pPager->fd, &nByte); + } + if( rc==SQLITE_OK ){ + pNew = (char *)sqlite3PageMalloc(pageSize); + if( !pNew ) rc = SQLITE_NOMEM; + } + + if( rc==SQLITE_OK ){ + pager_reset(pPager); + rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize); + } + if( rc==SQLITE_OK ){ + sqlite3PageFree(pPager->pTmpSpace); + pPager->pTmpSpace = pNew; + pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize); + pPager->pageSize = pageSize; + }else{ + sqlite3PageFree(pNew); + } + } + + *pPageSize = pPager->pageSize; + if( rc==SQLITE_OK ){ + if( nReserve<0 ) nReserve = pPager->nReserve; + assert( nReserve>=0 && nReserve<1000 ); + pPager->nReserve = (i16)nReserve; + pagerReportSize(pPager); + pagerFixMaplimit(pPager); + } + return rc; +} + +/* +** Return a pointer to the "temporary page" buffer held internally +** by the pager. This is a buffer that is big enough to hold the +** entire content of a database page. This buffer is used internally +** during rollback and will be overwritten whenever a rollback +** occurs. But other modules are free to use it too, as long as +** no rollbacks are happening. +*/ +SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){ + return pPager->pTmpSpace; +} + +/* +** Attempt to set the maximum database page count if mxPage is positive. +** Make no changes if mxPage is zero or negative. And never reduce the +** maximum page count below the current size of the database. +** +** Regardless of mxPage, return the current maximum page count. +*/ +SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){ + if( mxPage>0 ){ + pPager->mxPgno = mxPage; + } + assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */ + assert( pPager->mxPgno>=pPager->dbSize ); /* OP_MaxPgcnt enforces this */ + return pPager->mxPgno; +} + +/* +** The following set of routines are used to disable the simulated +** I/O error mechanism. These routines are used to avoid simulated +** errors in places where we do not care about errors. +** +** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops +** and generate no code. +*/ +#ifdef SQLITE_TEST +SQLITE_API extern int sqlite3_io_error_pending; +SQLITE_API extern int sqlite3_io_error_hit; +static int saved_cnt; +void disable_simulated_io_errors(void){ + saved_cnt = sqlite3_io_error_pending; + sqlite3_io_error_pending = -1; +} +void enable_simulated_io_errors(void){ + sqlite3_io_error_pending = saved_cnt; +} +#else +# define disable_simulated_io_errors() +# define enable_simulated_io_errors() +#endif + +/* +** Read the first N bytes from the beginning of the file into memory +** that pDest points to. +** +** If the pager was opened on a transient file (zFilename==""), or +** opened on a file less than N bytes in size, the output buffer is +** zeroed and SQLITE_OK returned. The rationale for this is that this +** function is used to read database headers, and a new transient or +** zero sized database has a header than consists entirely of zeroes. +** +** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered, +** the error code is returned to the caller and the contents of the +** output buffer undefined. +*/ +SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){ + int rc = SQLITE_OK; + memset(pDest, 0, N); + assert( isOpen(pPager->fd) || pPager->tempFile ); + + /* This routine is only called by btree immediately after creating + ** the Pager object. There has not been an opportunity to transition + ** to WAL mode yet. + */ + assert( !pagerUseWal(pPager) ); + + if( isOpen(pPager->fd) ){ + IOTRACE(("DBHDR %p 0 %d\n", pPager, N)) + rc = sqlite3OsRead(pPager->fd, pDest, N, 0); + if( rc==SQLITE_IOERR_SHORT_READ ){ + rc = SQLITE_OK; + } + } + return rc; +} + +/* +** This function may only be called when a read-transaction is open on +** the pager. It returns the total number of pages in the database. +** +** However, if the file is between 1 and bytes in size, then +** this is considered a 1 page file. +*/ +SQLITE_PRIVATE void sqlite3PagerPagecount(Pager *pPager, int *pnPage){ + assert( pPager->eState>=PAGER_READER ); + assert( pPager->eState!=PAGER_WRITER_FINISHED ); + *pnPage = (int)pPager->dbSize; +} + + +/* +** Try to obtain a lock of type locktype on the database file. If +** a similar or greater lock is already held, this function is a no-op +** (returning SQLITE_OK immediately). +** +** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke +** the busy callback if the lock is currently not available. Repeat +** until the busy callback returns false or until the attempt to +** obtain the lock succeeds. +** +** Return SQLITE_OK on success and an error code if we cannot obtain +** the lock. If the lock is obtained successfully, set the Pager.state +** variable to locktype before returning. +*/ +static int pager_wait_on_lock(Pager *pPager, int locktype){ + int rc; /* Return code */ + + /* Check that this is either a no-op (because the requested lock is + ** already held), or one of the transitions that the busy-handler + ** may be invoked during, according to the comment above + ** sqlite3PagerSetBusyhandler(). + */ + assert( (pPager->eLock>=locktype) + || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK) + || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK) + ); + + do { + rc = pagerLockDb(pPager, locktype); + }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) ); + return rc; +} + +/* +** Function assertTruncateConstraint(pPager) checks that one of the +** following is true for all dirty pages currently in the page-cache: +** +** a) The page number is less than or equal to the size of the +** current database image, in pages, OR +** +** b) if the page content were written at this time, it would not +** be necessary to write the current content out to the sub-journal +** (as determined by function subjRequiresPage()). +** +** If the condition asserted by this function were not true, and the +** dirty page were to be discarded from the cache via the pagerStress() +** routine, pagerStress() would not write the current page content to +** the database file. If a savepoint transaction were rolled back after +** this happened, the correct behavior would be to restore the current +** content of the page. However, since this content is not present in either +** the database file or the portion of the rollback journal and +** sub-journal rolled back the content could not be restored and the +** database image would become corrupt. It is therefore fortunate that +** this circumstance cannot arise. +*/ +#if defined(SQLITE_DEBUG) +static void assertTruncateConstraintCb(PgHdr *pPg){ + assert( pPg->flags&PGHDR_DIRTY ); + assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize ); +} +static void assertTruncateConstraint(Pager *pPager){ + sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb); +} +#else +# define assertTruncateConstraint(pPager) +#endif + +/* +** Truncate the in-memory database file image to nPage pages. This +** function does not actually modify the database file on disk. It +** just sets the internal state of the pager object so that the +** truncation will be done when the current transaction is committed. +** +** This function is only called right before committing a transaction. +** Once this function has been called, the transaction must either be +** rolled back or committed. It is not safe to call this function and +** then continue writing to the database. +*/ +SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){ + assert( pPager->dbSize>=nPage ); + assert( pPager->eState>=PAGER_WRITER_CACHEMOD ); + pPager->dbSize = nPage; + + /* At one point the code here called assertTruncateConstraint() to + ** ensure that all pages being truncated away by this operation are, + ** if one or more savepoints are open, present in the savepoint + ** journal so that they can be restored if the savepoint is rolled + ** back. This is no longer necessary as this function is now only + ** called right before committing a transaction. So although the + ** Pager object may still have open savepoints (Pager.nSavepoint!=0), + ** they cannot be rolled back. So the assertTruncateConstraint() call + ** is no longer correct. */ +} + + +/* +** This function is called before attempting a hot-journal rollback. It +** syncs the journal file to disk, then sets pPager->journalHdr to the +** size of the journal file so that the pager_playback() routine knows +** that the entire journal file has been synced. +** +** Syncing a hot-journal to disk before attempting to roll it back ensures +** that if a power-failure occurs during the rollback, the process that +** attempts rollback following system recovery sees the same journal +** content as this process. +** +** If everything goes as planned, SQLITE_OK is returned. Otherwise, +** an SQLite error code. +*/ +static int pagerSyncHotJournal(Pager *pPager){ + int rc = SQLITE_OK; + if( !pPager->noSync ){ + rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL); + } + if( rc==SQLITE_OK ){ + rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr); + } + return rc; +} + +/* +** Obtain a reference to a memory mapped page object for page number pgno. +** The new object will use the pointer pData, obtained from xFetch(). +** If successful, set *ppPage to point to the new page reference +** and return SQLITE_OK. Otherwise, return an SQLite error code and set +** *ppPage to zero. +** +** Page references obtained by calling this function should be released +** by calling pagerReleaseMapPage(). +*/ +static int pagerAcquireMapPage( + Pager *pPager, /* Pager object */ + Pgno pgno, /* Page number */ + void *pData, /* xFetch()'d data for this page */ + PgHdr **ppPage /* OUT: Acquired page object */ +){ + PgHdr *p; /* Memory mapped page to return */ + + if( pPager->pMmapFreelist ){ + *ppPage = p = pPager->pMmapFreelist; + pPager->pMmapFreelist = p->pDirty; + p->pDirty = 0; + memset(p->pExtra, 0, pPager->nExtra); + }else{ + *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra); + if( p==0 ){ + sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData); + return SQLITE_NOMEM; + } + p->pExtra = (void *)&p[1]; + p->flags = PGHDR_MMAP; + p->nRef = 1; + p->pPager = pPager; + } + + assert( p->pExtra==(void *)&p[1] ); + assert( p->pPage==0 ); + assert( p->flags==PGHDR_MMAP ); + assert( p->pPager==pPager ); + assert( p->nRef==1 ); + + p->pgno = pgno; + p->pData = pData; + pPager->nMmapOut++; + + return SQLITE_OK; +} + +/* +** Release a reference to page pPg. pPg must have been returned by an +** earlier call to pagerAcquireMapPage(). +*/ +static void pagerReleaseMapPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + pPager->nMmapOut--; + pPg->pDirty = pPager->pMmapFreelist; + pPager->pMmapFreelist = pPg; + + assert( pPager->fd->pMethods->iVersion>=3 ); + sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData); +} + +/* +** Free all PgHdr objects stored in the Pager.pMmapFreelist list. +*/ +static void pagerFreeMapHdrs(Pager *pPager){ + PgHdr *p; + PgHdr *pNext; + for(p=pPager->pMmapFreelist; p; p=pNext){ + pNext = p->pDirty; + sqlite3_free(p); + } +} + + +/* +** Shutdown the page cache. Free all memory and close all files. +** +** If a transaction was in progress when this routine is called, that +** transaction is rolled back. All outstanding pages are invalidated +** and their memory is freed. Any attempt to use a page associated +** with this page cache after this function returns will likely +** result in a coredump. +** +** This function always succeeds. If a transaction is active an attempt +** is made to roll it back. If an error occurs during the rollback +** a hot journal may be left in the filesystem but no error is returned +** to the caller. +*/ +SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager){ + u8 *pTmp = (u8 *)pPager->pTmpSpace; + + assert( assert_pager_state(pPager) ); + disable_simulated_io_errors(); + sqlite3BeginBenignMalloc(); + pagerFreeMapHdrs(pPager); + /* pPager->errCode = 0; */ + pPager->exclusiveMode = 0; +#ifndef SQLITE_OMIT_WAL + sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags, pPager->pageSize, pTmp); + pPager->pWal = 0; +#endif + pager_reset(pPager); + if( MEMDB ){ + pager_unlock(pPager); + }else{ + /* If it is open, sync the journal file before calling UnlockAndRollback. + ** If this is not done, then an unsynced portion of the open journal + ** file may be played back into the database. If a power failure occurs + ** while this is happening, the database could become corrupt. + ** + ** If an error occurs while trying to sync the journal, shift the pager + ** into the ERROR state. This causes UnlockAndRollback to unlock the + ** database and close the journal file without attempting to roll it + ** back or finalize it. The next database user will have to do hot-journal + ** rollback before accessing the database file. + */ + if( isOpen(pPager->jfd) ){ + pager_error(pPager, pagerSyncHotJournal(pPager)); + } + pagerUnlockAndRollback(pPager); + } + sqlite3EndBenignMalloc(); + enable_simulated_io_errors(); + PAGERTRACE(("CLOSE %d\n", PAGERID(pPager))); + IOTRACE(("CLOSE %p\n", pPager)) + sqlite3OsClose(pPager->jfd); + sqlite3OsClose(pPager->fd); + sqlite3PageFree(pTmp); + sqlite3PcacheClose(pPager->pPCache); + +#ifdef SQLITE_HAS_CODEC + if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec); +#endif + + assert( !pPager->aSavepoint && !pPager->pInJournal ); + assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) ); + + sqlite3_free(pPager); + return SQLITE_OK; +} + +#if !defined(NDEBUG) || defined(SQLITE_TEST) +/* +** Return the page number for page pPg. +*/ +SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage *pPg){ + return pPg->pgno; +} +#endif + +/* +** Increment the reference count for page pPg. +*/ +SQLITE_PRIVATE void sqlite3PagerRef(DbPage *pPg){ + sqlite3PcacheRef(pPg); +} + +/* +** Sync the journal. In other words, make sure all the pages that have +** been written to the journal have actually reached the surface of the +** disk and can be restored in the event of a hot-journal rollback. +** +** If the Pager.noSync flag is set, then this function is a no-op. +** Otherwise, the actions required depend on the journal-mode and the +** device characteristics of the file-system, as follows: +** +** * If the journal file is an in-memory journal file, no action need +** be taken. +** +** * Otherwise, if the device does not support the SAFE_APPEND property, +** then the nRec field of the most recently written journal header +** is updated to contain the number of journal records that have +** been written following it. If the pager is operating in full-sync +** mode, then the journal file is synced before this field is updated. +** +** * If the device does not support the SEQUENTIAL property, then +** journal file is synced. +** +** Or, in pseudo-code: +** +** if( NOT ){ +** if( NOT SAFE_APPEND ){ +** if( ) xSync(); +** +** } +** if( NOT SEQUENTIAL ) xSync(); +** } +** +** If successful, this routine clears the PGHDR_NEED_SYNC flag of every +** page currently held in memory before returning SQLITE_OK. If an IO +** error is encountered, then the IO error code is returned to the caller. +*/ +static int syncJournal(Pager *pPager, int newHdr){ + int rc; /* Return code */ + + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + assert( !pagerUseWal(pPager) ); + + rc = sqlite3PagerExclusiveLock(pPager); + if( rc!=SQLITE_OK ) return rc; + + if( !pPager->noSync ){ + assert( !pPager->tempFile ); + if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){ + const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd); + assert( isOpen(pPager->jfd) ); + + if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){ + /* This block deals with an obscure problem. If the last connection + ** that wrote to this database was operating in persistent-journal + ** mode, then the journal file may at this point actually be larger + ** than Pager.journalOff bytes. If the next thing in the journal + ** file happens to be a journal-header (written as part of the + ** previous connection's transaction), and a crash or power-failure + ** occurs after nRec is updated but before this connection writes + ** anything else to the journal file (or commits/rolls back its + ** transaction), then SQLite may become confused when doing the + ** hot-journal rollback following recovery. It may roll back all + ** of this connections data, then proceed to rolling back the old, + ** out-of-date data that follows it. Database corruption. + ** + ** To work around this, if the journal file does appear to contain + ** a valid header following Pager.journalOff, then write a 0x00 + ** byte to the start of it to prevent it from being recognized. + ** + ** Variable iNextHdrOffset is set to the offset at which this + ** problematic header will occur, if it exists. aMagic is used + ** as a temporary buffer to inspect the first couple of bytes of + ** the potential journal header. + */ + i64 iNextHdrOffset; + u8 aMagic[8]; + u8 zHeader[sizeof(aJournalMagic)+4]; + + memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic)); + put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec); + + iNextHdrOffset = journalHdrOffset(pPager); + rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset); + if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){ + static const u8 zerobyte = 0; + rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset); + } + if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){ + return rc; + } + + /* Write the nRec value into the journal file header. If in + ** full-synchronous mode, sync the journal first. This ensures that + ** all data has really hit the disk before nRec is updated to mark + ** it as a candidate for rollback. + ** + ** This is not required if the persistent media supports the + ** SAFE_APPEND property. Because in this case it is not possible + ** for garbage data to be appended to the file, the nRec field + ** is populated with 0xFFFFFFFF when the journal header is written + ** and never needs to be updated. + */ + if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){ + PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager))); + IOTRACE(("JSYNC %p\n", pPager)) + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags); + if( rc!=SQLITE_OK ) return rc; + } + IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr)); + rc = sqlite3OsWrite( + pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr + ); + if( rc!=SQLITE_OK ) return rc; + } + if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){ + PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager))); + IOTRACE(("JSYNC %p\n", pPager)) + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags| + (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0) + ); + if( rc!=SQLITE_OK ) return rc; + } + + pPager->journalHdr = pPager->journalOff; + if( newHdr && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){ + pPager->nRec = 0; + rc = writeJournalHdr(pPager); + if( rc!=SQLITE_OK ) return rc; + } + }else{ + pPager->journalHdr = pPager->journalOff; + } + } + + /* Unless the pager is in noSync mode, the journal file was just + ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on + ** all pages. + */ + sqlite3PcacheClearSyncFlags(pPager->pPCache); + pPager->eState = PAGER_WRITER_DBMOD; + assert( assert_pager_state(pPager) ); + return SQLITE_OK; +} + +/* +** The argument is the first in a linked list of dirty pages connected +** by the PgHdr.pDirty pointer. This function writes each one of the +** in-memory pages in the list to the database file. The argument may +** be NULL, representing an empty list. In this case this function is +** a no-op. +** +** The pager must hold at least a RESERVED lock when this function +** is called. Before writing anything to the database file, this lock +** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained, +** SQLITE_BUSY is returned and no data is written to the database file. +** +** If the pager is a temp-file pager and the actual file-system file +** is not yet open, it is created and opened before any data is +** written out. +** +** Once the lock has been upgraded and, if necessary, the file opened, +** the pages are written out to the database file in list order. Writing +** a page is skipped if it meets either of the following criteria: +** +** * The page number is greater than Pager.dbSize, or +** * The PGHDR_DONT_WRITE flag is set on the page. +** +** If writing out a page causes the database file to grow, Pager.dbFileSize +** is updated accordingly. If page 1 is written out, then the value cached +** in Pager.dbFileVers[] is updated to match the new value stored in +** the database file. +** +** If everything is successful, SQLITE_OK is returned. If an IO error +** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot +** be obtained, SQLITE_BUSY is returned. +*/ +static int pager_write_pagelist(Pager *pPager, PgHdr *pList){ + int rc = SQLITE_OK; /* Return code */ + + /* This function is only called for rollback pagers in WRITER_DBMOD state. */ + assert( !pagerUseWal(pPager) ); + assert( pPager->eState==PAGER_WRITER_DBMOD ); + assert( pPager->eLock==EXCLUSIVE_LOCK ); + + /* If the file is a temp-file has not yet been opened, open it now. It + ** is not possible for rc to be other than SQLITE_OK if this branch + ** is taken, as pager_wait_on_lock() is a no-op for temp-files. + */ + if( !isOpen(pPager->fd) ){ + assert( pPager->tempFile && rc==SQLITE_OK ); + rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags); + } + + /* Before the first write, give the VFS a hint of what the final + ** file size will be. + */ + assert( rc!=SQLITE_OK || isOpen(pPager->fd) ); + if( rc==SQLITE_OK + && pPager->dbHintSizedbSize + && (pList->pDirty || pList->pgno>pPager->dbHintSize) + ){ + sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize; + sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile); + pPager->dbHintSize = pPager->dbSize; + } + + while( rc==SQLITE_OK && pList ){ + Pgno pgno = pList->pgno; + + /* If there are dirty pages in the page cache with page numbers greater + ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to + ** make the file smaller (presumably by auto-vacuum code). Do not write + ** any such pages to the file. + ** + ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag + ** set (set by sqlite3PagerDontWrite()). + */ + if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){ + i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */ + char *pData; /* Data to write */ + + assert( (pList->flags&PGHDR_NEED_SYNC)==0 ); + if( pList->pgno==1 ) pager_write_changecounter(pList); + + /* Encode the database */ + CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData); + + /* Write out the page data. */ + rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset); + + /* If page 1 was just written, update Pager.dbFileVers to match + ** the value now stored in the database file. If writing this + ** page caused the database file to grow, update dbFileSize. + */ + if( pgno==1 ){ + memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers)); + } + if( pgno>pPager->dbFileSize ){ + pPager->dbFileSize = pgno; + } + pPager->aStat[PAGER_STAT_WRITE]++; + + /* Update any backup objects copying the contents of this pager. */ + sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData); + + PAGERTRACE(("STORE %d page %d hash(%08x)\n", + PAGERID(pPager), pgno, pager_pagehash(pList))); + IOTRACE(("PGOUT %p %d\n", pPager, pgno)); + PAGER_INCR(sqlite3_pager_writedb_count); + }else{ + PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno)); + } + pager_set_pagehash(pList); + pList = pList->pDirty; + } + + return rc; +} + +/* +** Ensure that the sub-journal file is open. If it is already open, this +** function is a no-op. +** +** SQLITE_OK is returned if everything goes according to plan. An +** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen() +** fails. +*/ +static int openSubJournal(Pager *pPager){ + int rc = SQLITE_OK; + if( !isOpen(pPager->sjfd) ){ + if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){ + sqlite3MemJournalOpen(pPager->sjfd); + }else{ + rc = pagerOpentemp(pPager, pPager->sjfd, SQLITE_OPEN_SUBJOURNAL); + } + } + return rc; +} + +/* +** Append a record of the current state of page pPg to the sub-journal. +** +** If successful, set the bit corresponding to pPg->pgno in the bitvecs +** for all open savepoints before returning. +** +** This function returns SQLITE_OK if everything is successful, an IO +** error code if the attempt to write to the sub-journal fails, or +** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint +** bitvec. +*/ +static int subjournalPage(PgHdr *pPg){ + int rc = SQLITE_OK; + Pager *pPager = pPg->pPager; + if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ + + /* Open the sub-journal, if it has not already been opened */ + assert( pPager->useJournal ); + assert( isOpen(pPager->jfd) || pagerUseWal(pPager) ); + assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 ); + assert( pagerUseWal(pPager) + || pageInJournal(pPager, pPg) + || pPg->pgno>pPager->dbOrigSize + ); + rc = openSubJournal(pPager); + + /* If the sub-journal was opened successfully (or was already open), + ** write the journal record into the file. */ + if( rc==SQLITE_OK ){ + void *pData = pPg->pData; + i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize); + char *pData2; + + CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2); + PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno)); + rc = write32bits(pPager->sjfd, offset, pPg->pgno); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4); + } + } + } + if( rc==SQLITE_OK ){ + pPager->nSubRec++; + assert( pPager->nSavepoint>0 ); + rc = addToSavepointBitvecs(pPager, pPg->pgno); + } + return rc; +} +static int subjournalPageIfRequired(PgHdr *pPg){ + if( subjRequiresPage(pPg) ){ + return subjournalPage(pPg); + }else{ + return SQLITE_OK; + } +} + +/* +** This function is called by the pcache layer when it has reached some +** soft memory limit. The first argument is a pointer to a Pager object +** (cast as a void*). The pager is always 'purgeable' (not an in-memory +** database). The second argument is a reference to a page that is +** currently dirty but has no outstanding references. The page +** is always associated with the Pager object passed as the first +** argument. +** +** The job of this function is to make pPg clean by writing its contents +** out to the database file, if possible. This may involve syncing the +** journal file. +** +** If successful, sqlite3PcacheMakeClean() is called on the page and +** SQLITE_OK returned. If an IO error occurs while trying to make the +** page clean, the IO error code is returned. If the page cannot be +** made clean for some other reason, but no error occurs, then SQLITE_OK +** is returned by sqlite3PcacheMakeClean() is not called. +*/ +static int pagerStress(void *p, PgHdr *pPg){ + Pager *pPager = (Pager *)p; + int rc = SQLITE_OK; + + assert( pPg->pPager==pPager ); + assert( pPg->flags&PGHDR_DIRTY ); + + /* The doNotSpill NOSYNC bit is set during times when doing a sync of + ** journal (and adding a new header) is not allowed. This occurs + ** during calls to sqlite3PagerWrite() while trying to journal multiple + ** pages belonging to the same sector. + ** + ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling + ** regardless of whether or not a sync is required. This is set during + ** a rollback or by user request, respectively. + ** + ** Spilling is also prohibited when in an error state since that could + ** lead to database corruption. In the current implementation it + ** is impossible for sqlite3PcacheFetch() to be called with createFlag==3 + ** while in the error state, hence it is impossible for this routine to + ** be called in the error state. Nevertheless, we include a NEVER() + ** test for the error state as a safeguard against future changes. + */ + if( NEVER(pPager->errCode) ) return SQLITE_OK; + testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK ); + testcase( pPager->doNotSpill & SPILLFLAG_OFF ); + testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC ); + if( pPager->doNotSpill + && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0 + || (pPg->flags & PGHDR_NEED_SYNC)!=0) + ){ + return SQLITE_OK; + } + + pPg->pDirty = 0; + if( pagerUseWal(pPager) ){ + /* Write a single frame for this page to the log. */ + rc = subjournalPageIfRequired(pPg); + if( rc==SQLITE_OK ){ + rc = pagerWalFrames(pPager, pPg, 0, 0); + } + }else{ + + /* Sync the journal file if required. */ + if( pPg->flags&PGHDR_NEED_SYNC + || pPager->eState==PAGER_WRITER_CACHEMOD + ){ + rc = syncJournal(pPager, 1); + } + + /* Write the contents of the page out to the database file. */ + if( rc==SQLITE_OK ){ + assert( (pPg->flags&PGHDR_NEED_SYNC)==0 ); + rc = pager_write_pagelist(pPager, pPg); + } + } + + /* Mark the page as clean. */ + if( rc==SQLITE_OK ){ + PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno)); + sqlite3PcacheMakeClean(pPg); + } + + return pager_error(pPager, rc); +} + + +/* +** Allocate and initialize a new Pager object and put a pointer to it +** in *ppPager. The pager should eventually be freed by passing it +** to sqlite3PagerClose(). +** +** The zFilename argument is the path to the database file to open. +** If zFilename is NULL then a randomly-named temporary file is created +** and used as the file to be cached. Temporary files are be deleted +** automatically when they are closed. If zFilename is ":memory:" then +** all information is held in cache. It is never written to disk. +** This can be used to implement an in-memory database. +** +** The nExtra parameter specifies the number of bytes of space allocated +** along with each page reference. This space is available to the user +** via the sqlite3PagerGetExtra() API. +** +** The flags argument is used to specify properties that affect the +** operation of the pager. It should be passed some bitwise combination +** of the PAGER_* flags. +** +** The vfsFlags parameter is a bitmask to pass to the flags parameter +** of the xOpen() method of the supplied VFS when opening files. +** +** If the pager object is allocated and the specified file opened +** successfully, SQLITE_OK is returned and *ppPager set to point to +** the new pager object. If an error occurs, *ppPager is set to NULL +** and error code returned. This function may return SQLITE_NOMEM +** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or +** various SQLITE_IO_XXX errors. +*/ +SQLITE_PRIVATE int sqlite3PagerOpen( + sqlite3_vfs *pVfs, /* The virtual file system to use */ + Pager **ppPager, /* OUT: Return the Pager structure here */ + const char *zFilename, /* Name of the database file to open */ + int nExtra, /* Extra bytes append to each in-memory page */ + int flags, /* flags controlling this file */ + int vfsFlags, /* flags passed through to sqlite3_vfs.xOpen() */ + void (*xReinit)(DbPage*) /* Function to reinitialize pages */ +){ + u8 *pPtr; + Pager *pPager = 0; /* Pager object to allocate and return */ + int rc = SQLITE_OK; /* Return code */ + int tempFile = 0; /* True for temp files (incl. in-memory files) */ + int memDb = 0; /* True if this is an in-memory file */ + int readOnly = 0; /* True if this is a read-only file */ + int journalFileSize; /* Bytes to allocate for each journal fd */ + char *zPathname = 0; /* Full path to database file */ + int nPathname = 0; /* Number of bytes in zPathname */ + int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */ + int pcacheSize = sqlite3PcacheSize(); /* Bytes to allocate for PCache */ + u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */ + const char *zUri = 0; /* URI args to copy */ + int nUri = 0; /* Number of bytes of URI args at *zUri */ + + /* Figure out how much space is required for each journal file-handle + ** (there are two of them, the main journal and the sub-journal). This + ** is the maximum space required for an in-memory journal file handle + ** and a regular journal file-handle. Note that a "regular journal-handle" + ** may be a wrapper capable of caching the first portion of the journal + ** file in memory to implement the atomic-write optimization (see + ** source file journal.c). + */ + if( sqlite3JournalSize(pVfs)>sqlite3MemJournalSize() ){ + journalFileSize = ROUND8(sqlite3JournalSize(pVfs)); + }else{ + journalFileSize = ROUND8(sqlite3MemJournalSize()); + } + + /* Set the output variable to NULL in case an error occurs. */ + *ppPager = 0; + +#ifndef SQLITE_OMIT_MEMORYDB + if( flags & PAGER_MEMORY ){ + memDb = 1; + if( zFilename && zFilename[0] ){ + zPathname = sqlite3DbStrDup(0, zFilename); + if( zPathname==0 ) return SQLITE_NOMEM; + nPathname = sqlite3Strlen30(zPathname); + zFilename = 0; + } + } +#endif + + /* Compute and store the full pathname in an allocated buffer pointed + ** to by zPathname, length nPathname. Or, if this is a temporary file, + ** leave both nPathname and zPathname set to 0. + */ + if( zFilename && zFilename[0] ){ + const char *z; + nPathname = pVfs->mxPathname+1; + zPathname = sqlite3DbMallocRaw(0, nPathname*2); + if( zPathname==0 ){ + return SQLITE_NOMEM; + } + zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */ + rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname); + nPathname = sqlite3Strlen30(zPathname); + z = zUri = &zFilename[sqlite3Strlen30(zFilename)+1]; + while( *z ){ + z += sqlite3Strlen30(z)+1; + z += sqlite3Strlen30(z)+1; + } + nUri = (int)(&z[1] - zUri); + assert( nUri>=0 ); + if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){ + /* This branch is taken when the journal path required by + ** the database being opened will be more than pVfs->mxPathname + ** bytes in length. This means the database cannot be opened, + ** as it will not be possible to open the journal file or even + ** check for a hot-journal before reading. + */ + rc = SQLITE_CANTOPEN_BKPT; + } + if( rc!=SQLITE_OK ){ + sqlite3DbFree(0, zPathname); + return rc; + } + } + + /* Allocate memory for the Pager structure, PCache object, the + ** three file descriptors, the database file name and the journal + ** file name. The layout in memory is as follows: + ** + ** Pager object (sizeof(Pager) bytes) + ** PCache object (sqlite3PcacheSize() bytes) + ** Database file handle (pVfs->szOsFile bytes) + ** Sub-journal file handle (journalFileSize bytes) + ** Main journal file handle (journalFileSize bytes) + ** Database file name (nPathname+1 bytes) + ** Journal file name (nPathname+8+1 bytes) + */ + pPtr = (u8 *)sqlite3MallocZero( + ROUND8(sizeof(*pPager)) + /* Pager structure */ + ROUND8(pcacheSize) + /* PCache object */ + ROUND8(pVfs->szOsFile) + /* The main db file */ + journalFileSize * 2 + /* The two journal files */ + nPathname + 1 + nUri + /* zFilename */ + nPathname + 8 + 2 /* zJournal */ +#ifndef SQLITE_OMIT_WAL + + nPathname + 4 + 2 /* zWal */ +#endif + ); + assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) ); + if( !pPtr ){ + sqlite3DbFree(0, zPathname); + return SQLITE_NOMEM; + } + pPager = (Pager*)(pPtr); + pPager->pPCache = (PCache*)(pPtr += ROUND8(sizeof(*pPager))); + pPager->fd = (sqlite3_file*)(pPtr += ROUND8(pcacheSize)); + pPager->sjfd = (sqlite3_file*)(pPtr += ROUND8(pVfs->szOsFile)); + pPager->jfd = (sqlite3_file*)(pPtr += journalFileSize); + pPager->zFilename = (char*)(pPtr += journalFileSize); + assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) ); + + /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */ + if( zPathname ){ + assert( nPathname>0 ); + pPager->zJournal = (char*)(pPtr += nPathname + 1 + nUri); + memcpy(pPager->zFilename, zPathname, nPathname); + if( nUri ) memcpy(&pPager->zFilename[nPathname+1], zUri, nUri); + memcpy(pPager->zJournal, zPathname, nPathname); + memcpy(&pPager->zJournal[nPathname], "-journal\000", 8+2); + sqlite3FileSuffix3(pPager->zFilename, pPager->zJournal); +#ifndef SQLITE_OMIT_WAL + pPager->zWal = &pPager->zJournal[nPathname+8+1]; + memcpy(pPager->zWal, zPathname, nPathname); + memcpy(&pPager->zWal[nPathname], "-wal\000", 4+1); + sqlite3FileSuffix3(pPager->zFilename, pPager->zWal); +#endif + sqlite3DbFree(0, zPathname); + } + pPager->pVfs = pVfs; + pPager->vfsFlags = vfsFlags; + + /* Open the pager file. + */ + if( zFilename && zFilename[0] ){ + int fout = 0; /* VFS flags returned by xOpen() */ + rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout); + assert( !memDb ); + readOnly = (fout&SQLITE_OPEN_READONLY); + + /* If the file was successfully opened for read/write access, + ** choose a default page size in case we have to create the + ** database file. The default page size is the maximum of: + ** + ** + SQLITE_DEFAULT_PAGE_SIZE, + ** + The value returned by sqlite3OsSectorSize() + ** + The largest page size that can be written atomically. + */ + if( rc==SQLITE_OK ){ + int iDc = sqlite3OsDeviceCharacteristics(pPager->fd); + if( !readOnly ){ + setSectorSize(pPager); + assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE); + if( szPageDfltsectorSize ){ + if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){ + szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE; + }else{ + szPageDflt = (u32)pPager->sectorSize; + } + } +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + { + int ii; + assert(SQLITE_IOCAP_ATOMIC512==(512>>8)); + assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8)); + assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536); + for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){ + if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ){ + szPageDflt = ii; + } + } + } +#endif + } + pPager->noLock = sqlite3_uri_boolean(zFilename, "nolock", 0); + if( (iDc & SQLITE_IOCAP_IMMUTABLE)!=0 + || sqlite3_uri_boolean(zFilename, "immutable", 0) ){ + vfsFlags |= SQLITE_OPEN_READONLY; + goto act_like_temp_file; + } + } + }else{ + /* If a temporary file is requested, it is not opened immediately. + ** In this case we accept the default page size and delay actually + ** opening the file until the first call to OsWrite(). + ** + ** This branch is also run for an in-memory database. An in-memory + ** database is the same as a temp-file that is never written out to + ** disk and uses an in-memory rollback journal. + ** + ** This branch also runs for files marked as immutable. + */ +act_like_temp_file: + tempFile = 1; + pPager->eState = PAGER_READER; /* Pretend we already have a lock */ + pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */ + pPager->noLock = 1; /* Do no locking */ + readOnly = (vfsFlags&SQLITE_OPEN_READONLY); + } + + /* The following call to PagerSetPagesize() serves to set the value of + ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer. + */ + if( rc==SQLITE_OK ){ + assert( pPager->memDb==0 ); + rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1); + testcase( rc!=SQLITE_OK ); + } + + /* Initialize the PCache object. */ + if( rc==SQLITE_OK ){ + assert( nExtra<1000 ); + nExtra = ROUND8(nExtra); + rc = sqlite3PcacheOpen(szPageDflt, nExtra, !memDb, + !memDb?pagerStress:0, (void *)pPager, pPager->pPCache); + } + + /* If an error occurred above, free the Pager structure and close the file. + */ + if( rc!=SQLITE_OK ){ + sqlite3OsClose(pPager->fd); + sqlite3PageFree(pPager->pTmpSpace); + sqlite3_free(pPager); + return rc; + } + + PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename)); + IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename)) + + pPager->useJournal = (u8)useJournal; + /* pPager->stmtOpen = 0; */ + /* pPager->stmtInUse = 0; */ + /* pPager->nRef = 0; */ + /* pPager->stmtSize = 0; */ + /* pPager->stmtJSize = 0; */ + /* pPager->nPage = 0; */ + pPager->mxPgno = SQLITE_MAX_PAGE_COUNT; + /* pPager->state = PAGER_UNLOCK; */ + /* pPager->errMask = 0; */ + pPager->tempFile = (u8)tempFile; + assert( tempFile==PAGER_LOCKINGMODE_NORMAL + || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE ); + assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 ); + pPager->exclusiveMode = (u8)tempFile; + pPager->changeCountDone = pPager->tempFile; + pPager->memDb = (u8)memDb; + pPager->readOnly = (u8)readOnly; + assert( useJournal || pPager->tempFile ); + pPager->noSync = pPager->tempFile; + if( pPager->noSync ){ + assert( pPager->fullSync==0 ); + assert( pPager->syncFlags==0 ); + assert( pPager->walSyncFlags==0 ); + assert( pPager->ckptSyncFlags==0 ); + }else{ + pPager->fullSync = 1; + pPager->syncFlags = SQLITE_SYNC_NORMAL; + pPager->walSyncFlags = SQLITE_SYNC_NORMAL | WAL_SYNC_TRANSACTIONS; + pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL; + } + /* pPager->pFirst = 0; */ + /* pPager->pFirstSynced = 0; */ + /* pPager->pLast = 0; */ + pPager->nExtra = (u16)nExtra; + pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT; + assert( isOpen(pPager->fd) || tempFile ); + setSectorSize(pPager); + if( !useJournal ){ + pPager->journalMode = PAGER_JOURNALMODE_OFF; + }else if( memDb ){ + pPager->journalMode = PAGER_JOURNALMODE_MEMORY; + } + /* pPager->xBusyHandler = 0; */ + /* pPager->pBusyHandlerArg = 0; */ + pPager->xReiniter = xReinit; + /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */ + /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */ + + *ppPager = pPager; + return SQLITE_OK; +} + + +/* Verify that the database file has not be deleted or renamed out from +** under the pager. Return SQLITE_OK if the database is still were it ought +** to be on disk. Return non-zero (SQLITE_READONLY_DBMOVED or some other error +** code from sqlite3OsAccess()) if the database has gone missing. +*/ +static int databaseIsUnmoved(Pager *pPager){ + int bHasMoved = 0; + int rc; + + if( pPager->tempFile ) return SQLITE_OK; + if( pPager->dbSize==0 ) return SQLITE_OK; + assert( pPager->zFilename && pPager->zFilename[0] ); + rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved); + if( rc==SQLITE_NOTFOUND ){ + /* If the HAS_MOVED file-control is unimplemented, assume that the file + ** has not been moved. That is the historical behavior of SQLite: prior to + ** version 3.8.3, it never checked */ + rc = SQLITE_OK; + }else if( rc==SQLITE_OK && bHasMoved ){ + rc = SQLITE_READONLY_DBMOVED; + } + return rc; +} + + +/* +** This function is called after transitioning from PAGER_UNLOCK to +** PAGER_SHARED state. It tests if there is a hot journal present in +** the file-system for the given pager. A hot journal is one that +** needs to be played back. According to this function, a hot-journal +** file exists if the following criteria are met: +** +** * The journal file exists in the file system, and +** * No process holds a RESERVED or greater lock on the database file, and +** * The database file itself is greater than 0 bytes in size, and +** * The first byte of the journal file exists and is not 0x00. +** +** If the current size of the database file is 0 but a journal file +** exists, that is probably an old journal left over from a prior +** database with the same name. In this case the journal file is +** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK +** is returned. +** +** This routine does not check if there is a master journal filename +** at the end of the file. If there is, and that master journal file +** does not exist, then the journal file is not really hot. In this +** case this routine will return a false-positive. The pager_playback() +** routine will discover that the journal file is not really hot and +** will not roll it back. +** +** If a hot-journal file is found to exist, *pExists is set to 1 and +** SQLITE_OK returned. If no hot-journal file is present, *pExists is +** set to 0 and SQLITE_OK returned. If an IO error occurs while trying +** to determine whether or not a hot-journal file exists, the IO error +** code is returned and the value of *pExists is undefined. +*/ +static int hasHotJournal(Pager *pPager, int *pExists){ + sqlite3_vfs * const pVfs = pPager->pVfs; + int rc = SQLITE_OK; /* Return code */ + int exists = 1; /* True if a journal file is present */ + int jrnlOpen = !!isOpen(pPager->jfd); + + assert( pPager->useJournal ); + assert( isOpen(pPager->fd) ); + assert( pPager->eState==PAGER_OPEN ); + + assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) & + SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN + )); + + *pExists = 0; + if( !jrnlOpen ){ + rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists); + } + if( rc==SQLITE_OK && exists ){ + int locked = 0; /* True if some process holds a RESERVED lock */ + + /* Race condition here: Another process might have been holding the + ** the RESERVED lock and have a journal open at the sqlite3OsAccess() + ** call above, but then delete the journal and drop the lock before + ** we get to the following sqlite3OsCheckReservedLock() call. If that + ** is the case, this routine might think there is a hot journal when + ** in fact there is none. This results in a false-positive which will + ** be dealt with by the playback routine. Ticket #3883. + */ + rc = sqlite3OsCheckReservedLock(pPager->fd, &locked); + if( rc==SQLITE_OK && !locked ){ + Pgno nPage; /* Number of pages in database file */ + + rc = pagerPagecount(pPager, &nPage); + if( rc==SQLITE_OK ){ + /* If the database is zero pages in size, that means that either (1) the + ** journal is a remnant from a prior database with the same name where + ** the database file but not the journal was deleted, or (2) the initial + ** transaction that populates a new database is being rolled back. + ** In either case, the journal file can be deleted. However, take care + ** not to delete the journal file if it is already open due to + ** journal_mode=PERSIST. + */ + if( nPage==0 && !jrnlOpen ){ + sqlite3BeginBenignMalloc(); + if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){ + sqlite3OsDelete(pVfs, pPager->zJournal, 0); + if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK); + } + sqlite3EndBenignMalloc(); + }else{ + /* The journal file exists and no other connection has a reserved + ** or greater lock on the database file. Now check that there is + ** at least one non-zero bytes at the start of the journal file. + ** If there is, then we consider this journal to be hot. If not, + ** it can be ignored. + */ + if( !jrnlOpen ){ + int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL; + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f); + } + if( rc==SQLITE_OK ){ + u8 first = 0; + rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0); + if( rc==SQLITE_IOERR_SHORT_READ ){ + rc = SQLITE_OK; + } + if( !jrnlOpen ){ + sqlite3OsClose(pPager->jfd); + } + *pExists = (first!=0); + }else if( rc==SQLITE_CANTOPEN ){ + /* If we cannot open the rollback journal file in order to see if + ** it has a zero header, that might be due to an I/O error, or + ** it might be due to the race condition described above and in + ** ticket #3883. Either way, assume that the journal is hot. + ** This might be a false positive. But if it is, then the + ** automatic journal playback and recovery mechanism will deal + ** with it under an EXCLUSIVE lock where we do not need to + ** worry so much with race conditions. + */ + *pExists = 1; + rc = SQLITE_OK; + } + } + } + } + } + + return rc; +} + +/* +** This function is called to obtain a shared lock on the database file. +** It is illegal to call sqlite3PagerAcquire() until after this function +** has been successfully called. If a shared-lock is already held when +** this function is called, it is a no-op. +** +** The following operations are also performed by this function. +** +** 1) If the pager is currently in PAGER_OPEN state (no lock held +** on the database file), then an attempt is made to obtain a +** SHARED lock on the database file. Immediately after obtaining +** the SHARED lock, the file-system is checked for a hot-journal, +** which is played back if present. Following any hot-journal +** rollback, the contents of the cache are validated by checking +** the 'change-counter' field of the database file header and +** discarded if they are found to be invalid. +** +** 2) If the pager is running in exclusive-mode, and there are currently +** no outstanding references to any pages, and is in the error state, +** then an attempt is made to clear the error state by discarding +** the contents of the page cache and rolling back any open journal +** file. +** +** If everything is successful, SQLITE_OK is returned. If an IO error +** occurs while locking the database, checking for a hot-journal file or +** rolling back a journal file, the IO error code is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + + /* This routine is only called from b-tree and only when there are no + ** outstanding pages. This implies that the pager state should either + ** be OPEN or READER. READER is only possible if the pager is or was in + ** exclusive access mode. + */ + assert( sqlite3PcacheRefCount(pPager->pPCache)==0 ); + assert( assert_pager_state(pPager) ); + assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER ); + if( NEVER(MEMDB && pPager->errCode) ){ return pPager->errCode; } + + if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){ + int bHotJournal = 1; /* True if there exists a hot journal-file */ + + assert( !MEMDB ); + + rc = pager_wait_on_lock(pPager, SHARED_LOCK); + if( rc!=SQLITE_OK ){ + assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK ); + goto failed; + } + + /* If a journal file exists, and there is no RESERVED lock on the + ** database file, then it either needs to be played back or deleted. + */ + if( pPager->eLock<=SHARED_LOCK ){ + rc = hasHotJournal(pPager, &bHotJournal); + } + if( rc!=SQLITE_OK ){ + goto failed; + } + if( bHotJournal ){ + if( pPager->readOnly ){ + rc = SQLITE_READONLY_ROLLBACK; + goto failed; + } + + /* Get an EXCLUSIVE lock on the database file. At this point it is + ** important that a RESERVED lock is not obtained on the way to the + ** EXCLUSIVE lock. If it were, another process might open the + ** database file, detect the RESERVED lock, and conclude that the + ** database is safe to read while this process is still rolling the + ** hot-journal back. + ** + ** Because the intermediate RESERVED lock is not requested, any + ** other process attempting to access the database file will get to + ** this point in the code and fail to obtain its own EXCLUSIVE lock + ** on the database file. + ** + ** Unless the pager is in locking_mode=exclusive mode, the lock is + ** downgraded to SHARED_LOCK before this function returns. + */ + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + goto failed; + } + + /* If it is not already open and the file exists on disk, open the + ** journal for read/write access. Write access is required because + ** in exclusive-access mode the file descriptor will be kept open + ** and possibly used for a transaction later on. Also, write-access + ** is usually required to finalize the journal in journal_mode=persist + ** mode (and also for journal_mode=truncate on some systems). + ** + ** If the journal does not exist, it usually means that some + ** other connection managed to get in and roll it back before + ** this connection obtained the exclusive lock above. Or, it + ** may mean that the pager was in the error-state when this + ** function was called and the journal file does not exist. + */ + if( !isOpen(pPager->jfd) ){ + sqlite3_vfs * const pVfs = pPager->pVfs; + int bExists; /* True if journal file exists */ + rc = sqlite3OsAccess( + pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists); + if( rc==SQLITE_OK && bExists ){ + int fout = 0; + int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL; + assert( !pPager->tempFile ); + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout); + assert( rc!=SQLITE_OK || isOpen(pPager->jfd) ); + if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){ + rc = SQLITE_CANTOPEN_BKPT; + sqlite3OsClose(pPager->jfd); + } + } + } + + /* Playback and delete the journal. Drop the database write + ** lock and reacquire the read lock. Purge the cache before + ** playing back the hot-journal so that we don't end up with + ** an inconsistent cache. Sync the hot journal before playing + ** it back since the process that crashed and left the hot journal + ** probably did not sync it and we are required to always sync + ** the journal before playing it back. + */ + if( isOpen(pPager->jfd) ){ + assert( rc==SQLITE_OK ); + rc = pagerSyncHotJournal(pPager); + if( rc==SQLITE_OK ){ + rc = pager_playback(pPager, 1); + pPager->eState = PAGER_OPEN; + } + }else if( !pPager->exclusiveMode ){ + pagerUnlockDb(pPager, SHARED_LOCK); + } + + if( rc!=SQLITE_OK ){ + /* This branch is taken if an error occurs while trying to open + ** or roll back a hot-journal while holding an EXCLUSIVE lock. The + ** pager_unlock() routine will be called before returning to unlock + ** the file. If the unlock attempt fails, then Pager.eLock must be + ** set to UNKNOWN_LOCK (see the comment above the #define for + ** UNKNOWN_LOCK above for an explanation). + ** + ** In order to get pager_unlock() to do this, set Pager.eState to + ** PAGER_ERROR now. This is not actually counted as a transition + ** to ERROR state in the state diagram at the top of this file, + ** since we know that the same call to pager_unlock() will very + ** shortly transition the pager object to the OPEN state. Calling + ** assert_pager_state() would fail now, as it should not be possible + ** to be in ERROR state when there are zero outstanding page + ** references. + */ + pager_error(pPager, rc); + goto failed; + } + + assert( pPager->eState==PAGER_OPEN ); + assert( (pPager->eLock==SHARED_LOCK) + || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK) + ); + } + + if( !pPager->tempFile && pPager->hasHeldSharedLock ){ + /* The shared-lock has just been acquired then check to + ** see if the database has been modified. If the database has changed, + ** flush the cache. The hasHeldSharedLock flag prevents this from + ** occurring on the very first access to a file, in order to save a + ** single unnecessary sqlite3OsRead() call at the start-up. + ** + ** Database changes are detected by looking at 15 bytes beginning + ** at offset 24 into the file. The first 4 of these 16 bytes are + ** a 32-bit counter that is incremented with each change. The + ** other bytes change randomly with each file change when + ** a codec is in use. + ** + ** There is a vanishingly small chance that a change will not be + ** detected. The chance of an undetected change is so small that + ** it can be neglected. + */ + Pgno nPage = 0; + char dbFileVers[sizeof(pPager->dbFileVers)]; + + rc = pagerPagecount(pPager, &nPage); + if( rc ) goto failed; + + if( nPage>0 ){ + IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers))); + rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24); + if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){ + goto failed; + } + }else{ + memset(dbFileVers, 0, sizeof(dbFileVers)); + } + + if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){ + pager_reset(pPager); + + /* Unmap the database file. It is possible that external processes + ** may have truncated the database file and then extended it back + ** to its original size while this process was not holding a lock. + ** In this case there may exist a Pager.pMap mapping that appears + ** to be the right size but is not actually valid. Avoid this + ** possibility by unmapping the db here. */ + if( USEFETCH(pPager) ){ + sqlite3OsUnfetch(pPager->fd, 0, 0); + } + } + } + + /* If there is a WAL file in the file-system, open this database in WAL + ** mode. Otherwise, the following function call is a no-op. + */ + rc = pagerOpenWalIfPresent(pPager); +#ifndef SQLITE_OMIT_WAL + assert( pPager->pWal==0 || rc==SQLITE_OK ); +#endif + } + + if( pagerUseWal(pPager) ){ + assert( rc==SQLITE_OK ); + rc = pagerBeginReadTransaction(pPager); + } + + if( pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){ + rc = pagerPagecount(pPager, &pPager->dbSize); + } + + failed: + if( rc!=SQLITE_OK ){ + assert( !MEMDB ); + pager_unlock(pPager); + assert( pPager->eState==PAGER_OPEN ); + }else{ + pPager->eState = PAGER_READER; + pPager->hasHeldSharedLock = 1; + } + return rc; +} + +/* +** If the reference count has reached zero, rollback any active +** transaction and unlock the pager. +** +** Except, in locking_mode=EXCLUSIVE when there is nothing to in +** the rollback journal, the unlock is not performed and there is +** nothing to rollback, so this routine is a no-op. +*/ +static void pagerUnlockIfUnused(Pager *pPager){ + if( pPager->nMmapOut==0 && (sqlite3PcacheRefCount(pPager->pPCache)==0) ){ + pagerUnlockAndRollback(pPager); + } +} + +/* +** Acquire a reference to page number pgno in pager pPager (a page +** reference has type DbPage*). If the requested reference is +** successfully obtained, it is copied to *ppPage and SQLITE_OK returned. +** +** If the requested page is already in the cache, it is returned. +** Otherwise, a new page object is allocated and populated with data +** read from the database file. In some cases, the pcache module may +** choose not to allocate a new page object and may reuse an existing +** object with no outstanding references. +** +** The extra data appended to a page is always initialized to zeros the +** first time a page is loaded into memory. If the page requested is +** already in the cache when this function is called, then the extra +** data is left as it was when the page object was last used. +** +** If the database image is smaller than the requested page or if a +** non-zero value is passed as the noContent parameter and the +** requested page is not already stored in the cache, then no +** actual disk read occurs. In this case the memory image of the +** page is initialized to all zeros. +** +** If noContent is true, it means that we do not care about the contents +** of the page. This occurs in two scenarios: +** +** a) When reading a free-list leaf page from the database, and +** +** b) When a savepoint is being rolled back and we need to load +** a new page into the cache to be filled with the data read +** from the savepoint journal. +** +** If noContent is true, then the data returned is zeroed instead of +** being read from the database. Additionally, the bits corresponding +** to pgno in Pager.pInJournal (bitvec of pages already written to the +** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open +** savepoints are set. This means if the page is made writable at any +** point in the future, using a call to sqlite3PagerWrite(), its contents +** will not be journaled. This saves IO. +** +** The acquisition might fail for several reasons. In all cases, +** an appropriate error code is returned and *ppPage is set to NULL. +** +** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt +** to find a page in the in-memory cache first. If the page is not already +** in memory, this routine goes to disk to read it in whereas Lookup() +** just returns 0. This routine acquires a read-lock the first time it +** has to go to disk, and could also playback an old journal if necessary. +** Since Lookup() never goes to disk, it never has to deal with locks +** or journal files. +*/ +SQLITE_PRIVATE int sqlite3PagerAcquire( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int flags /* PAGER_GET_XXX flags */ +){ + int rc = SQLITE_OK; + PgHdr *pPg = 0; + u32 iFrame = 0; /* Frame to read from WAL file */ + const int noContent = (flags & PAGER_GET_NOCONTENT); + + /* It is acceptable to use a read-only (mmap) page for any page except + ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY + ** flag was specified by the caller. And so long as the db is not a + ** temporary or in-memory database. */ + const int bMmapOk = (pgno>1 && USEFETCH(pPager) + && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY)) +#ifdef SQLITE_HAS_CODEC + && pPager->xCodec==0 +#endif + ); + + /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here + ** allows the compiler optimizer to reuse the results of the "pgno>1" + ** test in the previous statement, and avoid testing pgno==0 in the + ** common case where pgno is large. */ + if( pgno<=1 && pgno==0 ){ + return SQLITE_CORRUPT_BKPT; + } + assert( pPager->eState>=PAGER_READER ); + assert( assert_pager_state(pPager) ); + assert( noContent==0 || bMmapOk==0 ); + + assert( pPager->hasHeldSharedLock==1 ); + + /* If the pager is in the error state, return an error immediately. + ** Otherwise, request the page from the PCache layer. */ + if( pPager->errCode!=SQLITE_OK ){ + rc = pPager->errCode; + }else{ + if( bMmapOk && pagerUseWal(pPager) ){ + rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame); + if( rc!=SQLITE_OK ) goto pager_acquire_err; + } + + if( bMmapOk && iFrame==0 ){ + void *pData = 0; + + rc = sqlite3OsFetch(pPager->fd, + (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData + ); + + if( rc==SQLITE_OK && pData ){ + if( pPager->eState>PAGER_READER ){ + pPg = sqlite3PagerLookup(pPager, pgno); + } + if( pPg==0 ){ + rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg); + }else{ + sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData); + } + if( pPg ){ + assert( rc==SQLITE_OK ); + *ppPage = pPg; + return SQLITE_OK; + } + } + if( rc!=SQLITE_OK ){ + goto pager_acquire_err; + } + } + + { + sqlite3_pcache_page *pBase; + pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3); + if( pBase==0 ){ + rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase); + if( rc!=SQLITE_OK ) goto pager_acquire_err; + if( pBase==0 ){ + pPg = *ppPage = 0; + rc = SQLITE_NOMEM; + goto pager_acquire_err; + } + } + pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase); + assert( pPg!=0 ); + } + } + + if( rc!=SQLITE_OK ){ + /* Either the call to sqlite3PcacheFetch() returned an error or the + ** pager was already in the error-state when this function was called. + ** Set pPg to 0 and jump to the exception handler. */ + pPg = 0; + goto pager_acquire_err; + } + assert( pPg==(*ppPage) ); + assert( pPg->pgno==pgno ); + assert( pPg->pPager==pPager || pPg->pPager==0 ); + + if( pPg->pPager && !noContent ){ + /* In this case the pcache already contains an initialized copy of + ** the page. Return without further ado. */ + assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) ); + pPager->aStat[PAGER_STAT_HIT]++; + return SQLITE_OK; + + }else{ + /* The pager cache has created a new page. Its content needs to + ** be initialized. */ + + pPg->pPager = pPager; + + /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page + ** number greater than this, or the unused locking-page, is requested. */ + if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){ + rc = SQLITE_CORRUPT_BKPT; + goto pager_acquire_err; + } + + if( MEMDB || pPager->dbSizefd) ){ + if( pgno>pPager->mxPgno ){ + rc = SQLITE_FULL; + goto pager_acquire_err; + } + if( noContent ){ + /* Failure to set the bits in the InJournal bit-vectors is benign. + ** It merely means that we might do some extra work to journal a + ** page that does not need to be journaled. Nevertheless, be sure + ** to test the case where a malloc error occurs while trying to set + ** a bit in a bit vector. + */ + sqlite3BeginBenignMalloc(); + if( pgno<=pPager->dbOrigSize ){ + TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno); + testcase( rc==SQLITE_NOMEM ); + } + TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno); + testcase( rc==SQLITE_NOMEM ); + sqlite3EndBenignMalloc(); + } + memset(pPg->pData, 0, pPager->pageSize); + IOTRACE(("ZERO %p %d\n", pPager, pgno)); + }else{ + if( pagerUseWal(pPager) && bMmapOk==0 ){ + rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame); + if( rc!=SQLITE_OK ) goto pager_acquire_err; + } + assert( pPg->pPager==pPager ); + pPager->aStat[PAGER_STAT_MISS]++; + rc = readDbPage(pPg, iFrame); + if( rc!=SQLITE_OK ){ + goto pager_acquire_err; + } + } + pager_set_pagehash(pPg); + } + + return SQLITE_OK; + +pager_acquire_err: + assert( rc!=SQLITE_OK ); + if( pPg ){ + sqlite3PcacheDrop(pPg); + } + pagerUnlockIfUnused(pPager); + + *ppPage = 0; + return rc; +} + +/* +** Acquire a page if it is already in the in-memory cache. Do +** not read the page from disk. Return a pointer to the page, +** or 0 if the page is not in cache. +** +** See also sqlite3PagerGet(). The difference between this routine +** and sqlite3PagerGet() is that _get() will go to the disk and read +** in the page if the page is not already in cache. This routine +** returns NULL if the page is not in cache or if a disk I/O error +** has ever happened. +*/ +SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){ + sqlite3_pcache_page *pPage; + assert( pPager!=0 ); + assert( pgno!=0 ); + assert( pPager->pPCache!=0 ); + pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0); + assert( pPage==0 || pPager->hasHeldSharedLock ); + if( pPage==0 ) return 0; + return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage); +} + +/* +** Release a page reference. +** +** If the number of references to the page drop to zero, then the +** page is added to the LRU list. When all references to all pages +** are released, a rollback occurs and the lock on the database is +** removed. +*/ +SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage *pPg){ + Pager *pPager; + assert( pPg!=0 ); + pPager = pPg->pPager; + if( pPg->flags & PGHDR_MMAP ){ + pagerReleaseMapPage(pPg); + }else{ + sqlite3PcacheRelease(pPg); + } + pagerUnlockIfUnused(pPager); +} +SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){ + if( pPg ) sqlite3PagerUnrefNotNull(pPg); +} + +/* +** This function is called at the start of every write transaction. +** There must already be a RESERVED or EXCLUSIVE lock on the database +** file when this routine is called. +** +** Open the journal file for pager pPager and write a journal header +** to the start of it. If there are active savepoints, open the sub-journal +** as well. This function is only used when the journal file is being +** opened to write a rollback log for a transaction. It is not used +** when opening a hot journal file to roll it back. +** +** If the journal file is already open (as it may be in exclusive mode), +** then this function just writes a journal header to the start of the +** already open file. +** +** Whether or not the journal file is opened by this function, the +** Pager.pInJournal bitvec structure is allocated. +** +** Return SQLITE_OK if everything is successful. Otherwise, return +** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or +** an IO error code if opening or writing the journal file fails. +*/ +static int pager_open_journal(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */ + + assert( pPager->eState==PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + assert( pPager->pInJournal==0 ); + + /* If already in the error state, this function is a no-op. But on + ** the other hand, this routine is never called if we are already in + ** an error state. */ + if( NEVER(pPager->errCode) ) return pPager->errCode; + + if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ + pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize); + if( pPager->pInJournal==0 ){ + return SQLITE_NOMEM; + } + + /* Open the journal file if it is not already open. */ + if( !isOpen(pPager->jfd) ){ + if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){ + sqlite3MemJournalOpen(pPager->jfd); + }else{ + const int flags = /* VFS flags to open journal file */ + SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE| + (pPager->tempFile ? + (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL): + (SQLITE_OPEN_MAIN_JOURNAL) + ); + + /* Verify that the database still has the same name as it did when + ** it was originally opened. */ + rc = databaseIsUnmoved(pPager); + if( rc==SQLITE_OK ){ +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + rc = sqlite3JournalOpen( + pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager) + ); +#else + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0); +#endif + } + } + assert( rc!=SQLITE_OK || isOpen(pPager->jfd) ); + } + + + /* Write the first journal header to the journal file and open + ** the sub-journal if necessary. + */ + if( rc==SQLITE_OK ){ + /* TODO: Check if all of these are really required. */ + pPager->nRec = 0; + pPager->journalOff = 0; + pPager->setMaster = 0; + pPager->journalHdr = 0; + rc = writeJournalHdr(pPager); + } + } + + if( rc!=SQLITE_OK ){ + sqlite3BitvecDestroy(pPager->pInJournal); + pPager->pInJournal = 0; + }else{ + assert( pPager->eState==PAGER_WRITER_LOCKED ); + pPager->eState = PAGER_WRITER_CACHEMOD; + } + + return rc; +} + +/* +** Begin a write-transaction on the specified pager object. If a +** write-transaction has already been opened, this function is a no-op. +** +** If the exFlag argument is false, then acquire at least a RESERVED +** lock on the database file. If exFlag is true, then acquire at least +** an EXCLUSIVE lock. If such a lock is already held, no locking +** functions need be called. +** +** If the subjInMemory argument is non-zero, then any sub-journal opened +** within this transaction will be opened as an in-memory file. This +** has no effect if the sub-journal is already opened (as it may be when +** running in exclusive mode) or if the transaction does not require a +** sub-journal. If the subjInMemory argument is zero, then any required +** sub-journal is implemented in-memory if pPager is an in-memory database, +** or using a temporary file otherwise. +*/ +SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){ + int rc = SQLITE_OK; + + if( pPager->errCode ) return pPager->errCode; + assert( pPager->eState>=PAGER_READER && pPager->eStatesubjInMemory = (u8)subjInMemory; + + if( ALWAYS(pPager->eState==PAGER_READER) ){ + assert( pPager->pInJournal==0 ); + + if( pagerUseWal(pPager) ){ + /* If the pager is configured to use locking_mode=exclusive, and an + ** exclusive lock on the database is not already held, obtain it now. + */ + if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){ + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + return rc; + } + sqlite3WalExclusiveMode(pPager->pWal, 1); + } + + /* Grab the write lock on the log file. If successful, upgrade to + ** PAGER_RESERVED state. Otherwise, return an error code to the caller. + ** The busy-handler is not invoked if another connection already + ** holds the write-lock. If possible, the upper layer will call it. + */ + rc = sqlite3WalBeginWriteTransaction(pPager->pWal); + }else{ + /* Obtain a RESERVED lock on the database file. If the exFlag parameter + ** is true, then immediately upgrade this to an EXCLUSIVE lock. The + ** busy-handler callback can be used when upgrading to the EXCLUSIVE + ** lock, but not when obtaining the RESERVED lock. + */ + rc = pagerLockDb(pPager, RESERVED_LOCK); + if( rc==SQLITE_OK && exFlag ){ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + } + } + + if( rc==SQLITE_OK ){ + /* Change to WRITER_LOCKED state. + ** + ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD + ** when it has an open transaction, but never to DBMOD or FINISHED. + ** This is because in those states the code to roll back savepoint + ** transactions may copy data from the sub-journal into the database + ** file as well as into the page cache. Which would be incorrect in + ** WAL mode. + */ + pPager->eState = PAGER_WRITER_LOCKED; + pPager->dbHintSize = pPager->dbSize; + pPager->dbFileSize = pPager->dbSize; + pPager->dbOrigSize = pPager->dbSize; + pPager->journalOff = 0; + } + + assert( rc==SQLITE_OK || pPager->eState==PAGER_READER ); + assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + } + + PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager))); + return rc; +} + +/* +** Write page pPg onto the end of the rollback journal. +*/ +static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + int rc; + u32 cksum; + char *pData2; + i64 iOff = pPager->journalOff; + + /* We should never write to the journal file the page that + ** contains the database locks. The following assert verifies + ** that we do not. */ + assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) ); + + assert( pPager->journalHdr<=pPager->journalOff ); + CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2); + cksum = pager_cksum(pPager, (u8*)pData2); + + /* Even if an IO or diskfull error occurs while journalling the + ** page in the block above, set the need-sync flag for the page. + ** Otherwise, when the transaction is rolled back, the logic in + ** playback_one_page() will think that the page needs to be restored + ** in the database file. And if an IO error occurs while doing so, + ** then corruption may follow. + */ + pPg->flags |= PGHDR_NEED_SYNC; + + rc = write32bits(pPager->jfd, iOff, pPg->pgno); + if( rc!=SQLITE_OK ) return rc; + rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4); + if( rc!=SQLITE_OK ) return rc; + rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum); + if( rc!=SQLITE_OK ) return rc; + + IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno, + pPager->journalOff, pPager->pageSize)); + PAGER_INCR(sqlite3_pager_writej_count); + PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n", + PAGERID(pPager), pPg->pgno, + ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg))); + + pPager->journalOff += 8 + pPager->pageSize; + pPager->nRec++; + assert( pPager->pInJournal!=0 ); + rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno); + testcase( rc==SQLITE_NOMEM ); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + rc |= addToSavepointBitvecs(pPager, pPg->pgno); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + return rc; +} + +/* +** Mark a single data page as writeable. The page is written into the +** main journal or sub-journal as required. If the page is written into +** one of the journals, the corresponding bit is set in the +** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs +** of any open savepoints as appropriate. +*/ +static int pager_write(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + int rc = SQLITE_OK; + + /* This routine is not called unless a write-transaction has already + ** been started. The journal file may or may not be open at this point. + ** It is never called in the ERROR state. + */ + assert( pPager->eState==PAGER_WRITER_LOCKED + || pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + assert( pPager->errCode==0 ); + assert( pPager->readOnly==0 ); + CHECK_PAGE(pPg); + + /* The journal file needs to be opened. Higher level routines have already + ** obtained the necessary locks to begin the write-transaction, but the + ** rollback journal might not yet be open. Open it now if this is the case. + ** + ** This is done before calling sqlite3PcacheMakeDirty() on the page. + ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then + ** an error might occur and the pager would end up in WRITER_LOCKED state + ** with pages marked as dirty in the cache. + */ + if( pPager->eState==PAGER_WRITER_LOCKED ){ + rc = pager_open_journal(pPager); + if( rc!=SQLITE_OK ) return rc; + } + assert( pPager->eState>=PAGER_WRITER_CACHEMOD ); + assert( assert_pager_state(pPager) ); + + /* Mark the page that is about to be modified as dirty. */ + sqlite3PcacheMakeDirty(pPg); + + /* If a rollback journal is in use, them make sure the page that is about + ** to change is in the rollback journal, or if the page is a new page off + ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC. + */ + assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) ); + if( pPager->pInJournal!=0 + && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0 + ){ + assert( pagerUseWal(pPager)==0 ); + if( pPg->pgno<=pPager->dbOrigSize ){ + rc = pagerAddPageToRollbackJournal(pPg); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + if( pPager->eState!=PAGER_WRITER_DBMOD ){ + pPg->flags |= PGHDR_NEED_SYNC; + } + PAGERTRACE(("APPEND %d page %d needSync=%d\n", + PAGERID(pPager), pPg->pgno, + ((pPg->flags&PGHDR_NEED_SYNC)?1:0))); + } + } + + /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list + ** and before writing the page into the rollback journal. Wait until now, + ** after the page has been successfully journalled, before setting the + ** PGHDR_WRITEABLE bit that indicates that the page can be safely modified. + */ + pPg->flags |= PGHDR_WRITEABLE; + + /* If the statement journal is open and the page is not in it, + ** then write the page into the statement journal. + */ + if( pPager->nSavepoint>0 ){ + rc = subjournalPageIfRequired(pPg); + } + + /* Update the database size and return. */ + if( pPager->dbSizepgno ){ + pPager->dbSize = pPg->pgno; + } + return rc; +} + +/* +** This is a variant of sqlite3PagerWrite() that runs when the sector size +** is larger than the page size. SQLite makes the (reasonable) assumption that +** all bytes of a sector are written together by hardware. Hence, all bytes of +** a sector need to be journalled in case of a power loss in the middle of +** a write. +** +** Usually, the sector size is less than or equal to the page size, in which +** case pages can be individually written. This routine only runs in the +** exceptional case where the page size is smaller than the sector size. +*/ +static SQLITE_NOINLINE int pagerWriteLargeSector(PgHdr *pPg){ + int rc = SQLITE_OK; /* Return code */ + Pgno nPageCount; /* Total number of pages in database file */ + Pgno pg1; /* First page of the sector pPg is located on. */ + int nPage = 0; /* Number of pages starting at pg1 to journal */ + int ii; /* Loop counter */ + int needSync = 0; /* True if any page has PGHDR_NEED_SYNC */ + Pager *pPager = pPg->pPager; /* The pager that owns pPg */ + Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize); + + /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow + ** a journal header to be written between the pages journaled by + ** this function. + */ + assert( !MEMDB ); + assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 ); + pPager->doNotSpill |= SPILLFLAG_NOSYNC; + + /* This trick assumes that both the page-size and sector-size are + ** an integer power of 2. It sets variable pg1 to the identifier + ** of the first page of the sector pPg is located on. + */ + pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1; + + nPageCount = pPager->dbSize; + if( pPg->pgno>nPageCount ){ + nPage = (pPg->pgno - pg1)+1; + }else if( (pg1+nPagePerSector-1)>nPageCount ){ + nPage = nPageCount+1-pg1; + }else{ + nPage = nPagePerSector; + } + assert(nPage>0); + assert(pg1<=pPg->pgno); + assert((pg1+nPage)>pPg->pgno); + + for(ii=0; iipgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){ + if( pg!=PAGER_MJ_PGNO(pPager) ){ + rc = sqlite3PagerGet(pPager, pg, &pPage); + if( rc==SQLITE_OK ){ + rc = pager_write(pPage); + if( pPage->flags&PGHDR_NEED_SYNC ){ + needSync = 1; + } + sqlite3PagerUnrefNotNull(pPage); + } + } + }else if( (pPage = sqlite3PagerLookup(pPager, pg))!=0 ){ + if( pPage->flags&PGHDR_NEED_SYNC ){ + needSync = 1; + } + sqlite3PagerUnrefNotNull(pPage); + } + } + + /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages + ** starting at pg1, then it needs to be set for all of them. Because + ** writing to any of these nPage pages may damage the others, the + ** journal file must contain sync()ed copies of all of them + ** before any of them can be written out to the database file. + */ + if( rc==SQLITE_OK && needSync ){ + assert( !MEMDB ); + for(ii=0; iiflags |= PGHDR_NEED_SYNC; + sqlite3PagerUnrefNotNull(pPage); + } + } + } + + assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 ); + pPager->doNotSpill &= ~SPILLFLAG_NOSYNC; + return rc; +} + +/* +** Mark a data page as writeable. This routine must be called before +** making changes to a page. The caller must check the return value +** of this function and be careful not to change any page data unless +** this routine returns SQLITE_OK. +** +** The difference between this function and pager_write() is that this +** function also deals with the special case where 2 or more pages +** fit on a single disk sector. In this case all co-resident pages +** must have been written to the journal file before returning. +** +** If an error occurs, SQLITE_NOMEM or an IO error code is returned +** as appropriate. Otherwise, SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3PagerWrite(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + assert( (pPg->flags & PGHDR_MMAP)==0 ); + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + assert( pPager->eState!=PAGER_ERROR ); + assert( assert_pager_state(pPager) ); + if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){ + if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg); + return SQLITE_OK; + }else if( pPager->sectorSize > (u32)pPager->pageSize ){ + return pagerWriteLargeSector(pPg); + }else{ + return pager_write(pPg); + } +} + +/* +** Return TRUE if the page given in the argument was previously passed +** to sqlite3PagerWrite(). In other words, return TRUE if it is ok +** to change the content of the page. +*/ +#ifndef NDEBUG +SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage *pPg){ + return pPg->flags & PGHDR_WRITEABLE; +} +#endif + +/* +** A call to this routine tells the pager that it is not necessary to +** write the information on page pPg back to the disk, even though +** that page might be marked as dirty. This happens, for example, when +** the page has been added as a leaf of the freelist and so its +** content no longer matters. +** +** The overlying software layer calls this routine when all of the data +** on the given page is unused. The pager marks the page as clean so +** that it does not get written to disk. +** +** Tests show that this optimization can quadruple the speed of large +** DELETE operations. +*/ +SQLITE_PRIVATE void sqlite3PagerDontWrite(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + if( (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){ + PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager))); + IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno)) + pPg->flags |= PGHDR_DONT_WRITE; + pPg->flags &= ~PGHDR_WRITEABLE; + pager_set_pagehash(pPg); + } +} + +/* +** This routine is called to increment the value of the database file +** change-counter, stored as a 4-byte big-endian integer starting at +** byte offset 24 of the pager file. The secondary change counter at +** 92 is also updated, as is the SQLite version number at offset 96. +** +** But this only happens if the pPager->changeCountDone flag is false. +** To avoid excess churning of page 1, the update only happens once. +** See also the pager_write_changecounter() routine that does an +** unconditional update of the change counters. +** +** If the isDirectMode flag is zero, then this is done by calling +** sqlite3PagerWrite() on page 1, then modifying the contents of the +** page data. In this case the file will be updated when the current +** transaction is committed. +** +** The isDirectMode flag may only be non-zero if the library was compiled +** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case, +** if isDirect is non-zero, then the database file is updated directly +** by writing an updated version of page 1 using a call to the +** sqlite3OsWrite() function. +*/ +static int pager_incr_changecounter(Pager *pPager, int isDirectMode){ + int rc = SQLITE_OK; + + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + + /* Declare and initialize constant integer 'isDirect'. If the + ** atomic-write optimization is enabled in this build, then isDirect + ** is initialized to the value passed as the isDirectMode parameter + ** to this function. Otherwise, it is always set to zero. + ** + ** The idea is that if the atomic-write optimization is not + ** enabled at compile time, the compiler can omit the tests of + ** 'isDirect' below, as well as the block enclosed in the + ** "if( isDirect )" condition. + */ +#ifndef SQLITE_ENABLE_ATOMIC_WRITE +# define DIRECT_MODE 0 + assert( isDirectMode==0 ); + UNUSED_PARAMETER(isDirectMode); +#else +# define DIRECT_MODE isDirectMode +#endif + + if( !pPager->changeCountDone && ALWAYS(pPager->dbSize>0) ){ + PgHdr *pPgHdr; /* Reference to page 1 */ + + assert( !pPager->tempFile && isOpen(pPager->fd) ); + + /* Open page 1 of the file for writing. */ + rc = sqlite3PagerGet(pPager, 1, &pPgHdr); + assert( pPgHdr==0 || rc==SQLITE_OK ); + + /* If page one was fetched successfully, and this function is not + ** operating in direct-mode, make page 1 writable. When not in + ** direct mode, page 1 is always held in cache and hence the PagerGet() + ** above is always successful - hence the ALWAYS on rc==SQLITE_OK. + */ + if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){ + rc = sqlite3PagerWrite(pPgHdr); + } + + if( rc==SQLITE_OK ){ + /* Actually do the update of the change counter */ + pager_write_changecounter(pPgHdr); + + /* If running in direct mode, write the contents of page 1 to the file. */ + if( DIRECT_MODE ){ + const void *zBuf; + assert( pPager->dbFileSize>0 ); + CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM, zBuf); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0); + pPager->aStat[PAGER_STAT_WRITE]++; + } + if( rc==SQLITE_OK ){ + /* Update the pager's copy of the change-counter. Otherwise, the + ** next time a read transaction is opened the cache will be + ** flushed (as the change-counter values will not match). */ + const void *pCopy = (const void *)&((const char *)zBuf)[24]; + memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers)); + pPager->changeCountDone = 1; + } + }else{ + pPager->changeCountDone = 1; + } + } + + /* Release the page reference. */ + sqlite3PagerUnref(pPgHdr); + } + return rc; +} + +/* +** Sync the database file to disk. This is a no-op for in-memory databases +** or pages with the Pager.noSync flag set. +** +** If successful, or if called on a pager for which it is a no-op, this +** function returns SQLITE_OK. Otherwise, an IO error code is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zMaster){ + int rc = SQLITE_OK; + + if( isOpen(pPager->fd) ){ + void *pArg = (void*)zMaster; + rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg); + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + } + if( rc==SQLITE_OK && !pPager->noSync ){ + assert( !MEMDB ); + rc = sqlite3OsSync(pPager->fd, pPager->syncFlags); + } + return rc; +} + +/* +** This function may only be called while a write-transaction is active in +** rollback. If the connection is in WAL mode, this call is a no-op. +** Otherwise, if the connection does not already have an EXCLUSIVE lock on +** the database file, an attempt is made to obtain one. +** +** If the EXCLUSIVE lock is already held or the attempt to obtain it is +** successful, or the connection is in WAL mode, SQLITE_OK is returned. +** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is +** returned. +*/ +SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager *pPager){ + int rc = SQLITE_OK; + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + || pPager->eState==PAGER_WRITER_LOCKED + ); + assert( assert_pager_state(pPager) ); + if( 0==pagerUseWal(pPager) ){ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + } + return rc; +} + +/* +** Sync the database file for the pager pPager. zMaster points to the name +** of a master journal file that should be written into the individual +** journal file. zMaster may be NULL, which is interpreted as no master +** journal (a single database transaction). +** +** This routine ensures that: +** +** * The database file change-counter is updated, +** * the journal is synced (unless the atomic-write optimization is used), +** * all dirty pages are written to the database file, +** * the database file is truncated (if required), and +** * the database file synced. +** +** The only thing that remains to commit the transaction is to finalize +** (delete, truncate or zero the first part of) the journal file (or +** delete the master journal file if specified). +** +** Note that if zMaster==NULL, this does not overwrite a previous value +** passed to an sqlite3PagerCommitPhaseOne() call. +** +** If the final parameter - noSync - is true, then the database file itself +** is not synced. The caller must call sqlite3PagerSync() directly to +** sync the database file before calling CommitPhaseTwo() to delete the +** journal file in this case. +*/ +SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne( + Pager *pPager, /* Pager object */ + const char *zMaster, /* If not NULL, the master journal name */ + int noSync /* True to omit the xSync on the db file */ +){ + int rc = SQLITE_OK; /* Return code */ + + assert( pPager->eState==PAGER_WRITER_LOCKED + || pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + || pPager->eState==PAGER_ERROR + ); + assert( assert_pager_state(pPager) ); + + /* If a prior error occurred, report that error again. */ + if( NEVER(pPager->errCode) ) return pPager->errCode; + + PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n", + pPager->zFilename, zMaster, pPager->dbSize)); + + /* If no database changes have been made, return early. */ + if( pPager->eStatepBackup); + }else{ + if( pagerUseWal(pPager) ){ + PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache); + PgHdr *pPageOne = 0; + if( pList==0 ){ + /* Must have at least one page for the WAL commit flag. + ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */ + rc = sqlite3PagerGet(pPager, 1, &pPageOne); + pList = pPageOne; + pList->pDirty = 0; + } + assert( rc==SQLITE_OK ); + if( ALWAYS(pList) ){ + rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1); + } + sqlite3PagerUnref(pPageOne); + if( rc==SQLITE_OK ){ + sqlite3PcacheCleanAll(pPager->pPCache); + } + }else{ + /* The following block updates the change-counter. Exactly how it + ** does this depends on whether or not the atomic-update optimization + ** was enabled at compile time, and if this transaction meets the + ** runtime criteria to use the operation: + ** + ** * The file-system supports the atomic-write property for + ** blocks of size page-size, and + ** * This commit is not part of a multi-file transaction, and + ** * Exactly one page has been modified and store in the journal file. + ** + ** If the optimization was not enabled at compile time, then the + ** pager_incr_changecounter() function is called to update the change + ** counter in 'indirect-mode'. If the optimization is compiled in but + ** is not applicable to this transaction, call sqlite3JournalCreate() + ** to make sure the journal file has actually been created, then call + ** pager_incr_changecounter() to update the change-counter in indirect + ** mode. + ** + ** Otherwise, if the optimization is both enabled and applicable, + ** then call pager_incr_changecounter() to update the change-counter + ** in 'direct' mode. In this case the journal file will never be + ** created for this transaction. + */ + #ifdef SQLITE_ENABLE_ATOMIC_WRITE + PgHdr *pPg; + assert( isOpen(pPager->jfd) + || pPager->journalMode==PAGER_JOURNALMODE_OFF + || pPager->journalMode==PAGER_JOURNALMODE_WAL + ); + if( !zMaster && isOpen(pPager->jfd) + && pPager->journalOff==jrnlBufferSize(pPager) + && pPager->dbSize>=pPager->dbOrigSize + && (0==(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty) + ){ + /* Update the db file change counter via the direct-write method. The + ** following call will modify the in-memory representation of page 1 + ** to include the updated change counter and then write page 1 + ** directly to the database file. Because of the atomic-write + ** property of the host file-system, this is safe. + */ + rc = pager_incr_changecounter(pPager, 1); + }else{ + rc = sqlite3JournalCreate(pPager->jfd); + if( rc==SQLITE_OK ){ + rc = pager_incr_changecounter(pPager, 0); + } + } + #else + rc = pager_incr_changecounter(pPager, 0); + #endif + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + + /* Write the master journal name into the journal file. If a master + ** journal file name has already been written to the journal file, + ** or if zMaster is NULL (no master journal), then this call is a no-op. + */ + rc = writeMasterJournal(pPager, zMaster); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + + /* Sync the journal file and write all dirty pages to the database. + ** If the atomic-update optimization is being used, this sync will not + ** create the journal file or perform any real IO. + ** + ** Because the change-counter page was just modified, unless the + ** atomic-update optimization is used it is almost certain that the + ** journal requires a sync here. However, in locking_mode=exclusive + ** on a system under memory pressure it is just possible that this is + ** not the case. In this case it is likely enough that the redundant + ** xSync() call will be changed to a no-op by the OS anyhow. + */ + rc = syncJournal(pPager, 0); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + + rc = pager_write_pagelist(pPager,sqlite3PcacheDirtyList(pPager->pPCache)); + if( rc!=SQLITE_OK ){ + assert( rc!=SQLITE_IOERR_BLOCKED ); + goto commit_phase_one_exit; + } + sqlite3PcacheCleanAll(pPager->pPCache); + + /* If the file on disk is smaller than the database image, use + ** pager_truncate to grow the file here. This can happen if the database + ** image was extended as part of the current transaction and then the + ** last page in the db image moved to the free-list. In this case the + ** last page is never written out to disk, leaving the database file + ** undersized. Fix this now if it is the case. */ + if( pPager->dbSize>pPager->dbFileSize ){ + Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager)); + assert( pPager->eState==PAGER_WRITER_DBMOD ); + rc = pager_truncate(pPager, nNew); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + } + + /* Finally, sync the database file. */ + if( !noSync ){ + rc = sqlite3PagerSync(pPager, zMaster); + } + IOTRACE(("DBSYNC %p\n", pPager)) + } + } + +commit_phase_one_exit: + if( rc==SQLITE_OK && !pagerUseWal(pPager) ){ + pPager->eState = PAGER_WRITER_FINISHED; + } + return rc; +} + + +/* +** When this function is called, the database file has been completely +** updated to reflect the changes made by the current transaction and +** synced to disk. The journal file still exists in the file-system +** though, and if a failure occurs at this point it will eventually +** be used as a hot-journal and the current transaction rolled back. +** +** This function finalizes the journal file, either by deleting, +** truncating or partially zeroing it, so that it cannot be used +** for hot-journal rollback. Once this is done the transaction is +** irrevocably committed. +** +** If an error occurs, an IO error code is returned and the pager +** moves into the error state. Otherwise, SQLITE_OK is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + + /* This routine should not be called if a prior error has occurred. + ** But if (due to a coding error elsewhere in the system) it does get + ** called, just return the same error code without doing anything. */ + if( NEVER(pPager->errCode) ) return pPager->errCode; + + assert( pPager->eState==PAGER_WRITER_LOCKED + || pPager->eState==PAGER_WRITER_FINISHED + || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD) + ); + assert( assert_pager_state(pPager) ); + + /* An optimization. If the database was not actually modified during + ** this transaction, the pager is running in exclusive-mode and is + ** using persistent journals, then this function is a no-op. + ** + ** The start of the journal file currently contains a single journal + ** header with the nRec field set to 0. If such a journal is used as + ** a hot-journal during hot-journal rollback, 0 changes will be made + ** to the database file. So there is no need to zero the journal + ** header. Since the pager is in exclusive mode, there is no need + ** to drop any locks either. + */ + if( pPager->eState==PAGER_WRITER_LOCKED + && pPager->exclusiveMode + && pPager->journalMode==PAGER_JOURNALMODE_PERSIST + ){ + assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff ); + pPager->eState = PAGER_READER; + return SQLITE_OK; + } + + PAGERTRACE(("COMMIT %d\n", PAGERID(pPager))); + pPager->iDataVersion++; + rc = pager_end_transaction(pPager, pPager->setMaster, 1); + return pager_error(pPager, rc); +} + +/* +** If a write transaction is open, then all changes made within the +** transaction are reverted and the current write-transaction is closed. +** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR +** state if an error occurs. +** +** If the pager is already in PAGER_ERROR state when this function is called, +** it returns Pager.errCode immediately. No work is performed in this case. +** +** Otherwise, in rollback mode, this function performs two functions: +** +** 1) It rolls back the journal file, restoring all database file and +** in-memory cache pages to the state they were in when the transaction +** was opened, and +** +** 2) It finalizes the journal file, so that it is not used for hot +** rollback at any point in the future. +** +** Finalization of the journal file (task 2) is only performed if the +** rollback is successful. +** +** In WAL mode, all cache-entries containing data modified within the +** current transaction are either expelled from the cache or reverted to +** their pre-transaction state by re-reading data from the database or +** WAL files. The WAL transaction is then closed. +*/ +SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager))); + + /* PagerRollback() is a no-op if called in READER or OPEN state. If + ** the pager is already in the ERROR state, the rollback is not + ** attempted here. Instead, the error code is returned to the caller. + */ + assert( assert_pager_state(pPager) ); + if( pPager->eState==PAGER_ERROR ) return pPager->errCode; + if( pPager->eState<=PAGER_READER ) return SQLITE_OK; + + if( pagerUseWal(pPager) ){ + int rc2; + rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1); + rc2 = pager_end_transaction(pPager, pPager->setMaster, 0); + if( rc==SQLITE_OK ) rc = rc2; + }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){ + int eState = pPager->eState; + rc = pager_end_transaction(pPager, 0, 0); + if( !MEMDB && eState>PAGER_WRITER_LOCKED ){ + /* This can happen using journal_mode=off. Move the pager to the error + ** state to indicate that the contents of the cache may not be trusted. + ** Any active readers will get SQLITE_ABORT. + */ + pPager->errCode = SQLITE_ABORT; + pPager->eState = PAGER_ERROR; + return rc; + } + }else{ + rc = pager_playback(pPager, 0); + } + + assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK ); + assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT + || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR + || rc==SQLITE_CANTOPEN + ); + + /* If an error occurs during a ROLLBACK, we can no longer trust the pager + ** cache. So call pager_error() on the way out to make any error persistent. + */ + return pager_error(pPager, rc); +} + +/* +** Return TRUE if the database file is opened read-only. Return FALSE +** if the database is (in theory) writable. +*/ +SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){ + return pPager->readOnly; +} + +#ifdef SQLITE_DEBUG +/* +** Return the sum of the reference counts for all pages held by pPager. +*/ +SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){ + return sqlite3PcacheRefCount(pPager->pPCache); +} +#endif + +/* +** Return the approximate number of bytes of memory currently +** used by the pager and its associated cache. +*/ +SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){ + int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr) + + 5*sizeof(void*); + return perPageSize*sqlite3PcachePagecount(pPager->pPCache) + + sqlite3MallocSize(pPager) + + pPager->pageSize; +} + +/* +** Return the number of references to the specified page. +*/ +SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage *pPage){ + return sqlite3PcachePageRefcount(pPage); +} + +#ifdef SQLITE_TEST +/* +** This routine is used for testing and analysis only. +*/ +SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){ + static int a[11]; + a[0] = sqlite3PcacheRefCount(pPager->pPCache); + a[1] = sqlite3PcachePagecount(pPager->pPCache); + a[2] = sqlite3PcacheGetCachesize(pPager->pPCache); + a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize; + a[4] = pPager->eState; + a[5] = pPager->errCode; + a[6] = pPager->aStat[PAGER_STAT_HIT]; + a[7] = pPager->aStat[PAGER_STAT_MISS]; + a[8] = 0; /* Used to be pPager->nOvfl */ + a[9] = pPager->nRead; + a[10] = pPager->aStat[PAGER_STAT_WRITE]; + return a; +} +#endif + +/* +** Parameter eStat must be either SQLITE_DBSTATUS_CACHE_HIT or +** SQLITE_DBSTATUS_CACHE_MISS. Before returning, *pnVal is incremented by the +** current cache hit or miss count, according to the value of eStat. If the +** reset parameter is non-zero, the cache hit or miss count is zeroed before +** returning. +*/ +SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){ + + assert( eStat==SQLITE_DBSTATUS_CACHE_HIT + || eStat==SQLITE_DBSTATUS_CACHE_MISS + || eStat==SQLITE_DBSTATUS_CACHE_WRITE + ); + + assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS ); + assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE ); + assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1 && PAGER_STAT_WRITE==2 ); + + *pnVal += pPager->aStat[eStat - SQLITE_DBSTATUS_CACHE_HIT]; + if( reset ){ + pPager->aStat[eStat - SQLITE_DBSTATUS_CACHE_HIT] = 0; + } +} + +/* +** Return true if this is an in-memory pager. +*/ +SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){ + return MEMDB; +} + +/* +** Check that there are at least nSavepoint savepoints open. If there are +** currently less than nSavepoints open, then open one or more savepoints +** to make up the difference. If the number of savepoints is already +** equal to nSavepoint, then this function is a no-op. +** +** If a memory allocation fails, SQLITE_NOMEM is returned. If an error +** occurs while opening the sub-journal file, then an IO error code is +** returned. Otherwise, SQLITE_OK. +*/ +static SQLITE_NOINLINE int pagerOpenSavepoint(Pager *pPager, int nSavepoint){ + int rc = SQLITE_OK; /* Return code */ + int nCurrent = pPager->nSavepoint; /* Current number of savepoints */ + int ii; /* Iterator variable */ + PagerSavepoint *aNew; /* New Pager.aSavepoint array */ + + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + assert( nSavepoint>nCurrent && pPager->useJournal ); + + /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM + ** if the allocation fails. Otherwise, zero the new portion in case a + ** malloc failure occurs while populating it in the for(...) loop below. + */ + aNew = (PagerSavepoint *)sqlite3Realloc( + pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint + ); + if( !aNew ){ + return SQLITE_NOMEM; + } + memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint)); + pPager->aSavepoint = aNew; + + /* Populate the PagerSavepoint structures just allocated. */ + for(ii=nCurrent; iidbSize; + if( isOpen(pPager->jfd) && pPager->journalOff>0 ){ + aNew[ii].iOffset = pPager->journalOff; + }else{ + aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager); + } + aNew[ii].iSubRec = pPager->nSubRec; + aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize); + if( !aNew[ii].pInSavepoint ){ + return SQLITE_NOMEM; + } + if( pagerUseWal(pPager) ){ + sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData); + } + pPager->nSavepoint = ii+1; + } + assert( pPager->nSavepoint==nSavepoint ); + assertTruncateConstraint(pPager); + return rc; +} +SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){ + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + + if( nSavepoint>pPager->nSavepoint && pPager->useJournal ){ + return pagerOpenSavepoint(pPager, nSavepoint); + }else{ + return SQLITE_OK; + } +} + + +/* +** This function is called to rollback or release (commit) a savepoint. +** The savepoint to release or rollback need not be the most recently +** created savepoint. +** +** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE. +** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with +** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes +** that have occurred since the specified savepoint was created. +** +** The savepoint to rollback or release is identified by parameter +** iSavepoint. A value of 0 means to operate on the outermost savepoint +** (the first created). A value of (Pager.nSavepoint-1) means operate +** on the most recently created savepoint. If iSavepoint is greater than +** (Pager.nSavepoint-1), then this function is a no-op. +** +** If a negative value is passed to this function, then the current +** transaction is rolled back. This is different to calling +** sqlite3PagerRollback() because this function does not terminate +** the transaction or unlock the database, it just restores the +** contents of the database to its original state. +** +** In any case, all savepoints with an index greater than iSavepoint +** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE), +** then savepoint iSavepoint is also destroyed. +** +** This function may return SQLITE_NOMEM if a memory allocation fails, +** or an IO error code if an IO error occurs while rolling back a +** savepoint. If no errors occur, SQLITE_OK is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){ + int rc = pPager->errCode; /* Return code */ + + assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK ); + assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK ); + + if( rc==SQLITE_OK && iSavepointnSavepoint ){ + int ii; /* Iterator variable */ + int nNew; /* Number of remaining savepoints after this op. */ + + /* Figure out how many savepoints will still be active after this + ** operation. Store this value in nNew. Then free resources associated + ** with any savepoints that are destroyed by this operation. + */ + nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1); + for(ii=nNew; iinSavepoint; ii++){ + sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint); + } + pPager->nSavepoint = nNew; + + /* If this is a release of the outermost savepoint, truncate + ** the sub-journal to zero bytes in size. */ + if( op==SAVEPOINT_RELEASE ){ + if( nNew==0 && isOpen(pPager->sjfd) ){ + /* Only truncate if it is an in-memory sub-journal. */ + if( sqlite3IsMemJournal(pPager->sjfd) ){ + rc = sqlite3OsTruncate(pPager->sjfd, 0); + assert( rc==SQLITE_OK ); + } + pPager->nSubRec = 0; + } + } + /* Else this is a rollback operation, playback the specified savepoint. + ** If this is a temp-file, it is possible that the journal file has + ** not yet been opened. In this case there have been no changes to + ** the database file, so the playback operation can be skipped. + */ + else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){ + PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1]; + rc = pagerPlaybackSavepoint(pPager, pSavepoint); + assert(rc!=SQLITE_DONE); + } + } + + return rc; +} + +/* +** Return the full pathname of the database file. +** +** Except, if the pager is in-memory only, then return an empty string if +** nullIfMemDb is true. This routine is called with nullIfMemDb==1 when +** used to report the filename to the user, for compatibility with legacy +** behavior. But when the Btree needs to know the filename for matching to +** shared cache, it uses nullIfMemDb==0 so that in-memory databases can +** participate in shared-cache. +*/ +SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager *pPager, int nullIfMemDb){ + return (nullIfMemDb && pPager->memDb) ? "" : pPager->zFilename; +} + +/* +** Return the VFS structure for the pager. +*/ +SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){ + return pPager->pVfs; +} + +/* +** Return the file handle for the database file associated +** with the pager. This might return NULL if the file has +** not yet been opened. +*/ +SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){ + return pPager->fd; +} + +/* +** Return the full pathname of the journal file. +*/ +SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){ + return pPager->zJournal; +} + +/* +** Return true if fsync() calls are disabled for this pager. Return FALSE +** if fsync()s are executed normally. +*/ +SQLITE_PRIVATE int sqlite3PagerNosync(Pager *pPager){ + return pPager->noSync; +} + +#ifdef SQLITE_HAS_CODEC +/* +** Set or retrieve the codec for this pager +*/ +SQLITE_PRIVATE void sqlite3PagerSetCodec( + Pager *pPager, + void *(*xCodec)(void*,void*,Pgno,int), + void (*xCodecSizeChng)(void*,int,int), + void (*xCodecFree)(void*), + void *pCodec +){ + if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec); + pPager->xCodec = pPager->memDb ? 0 : xCodec; + pPager->xCodecSizeChng = xCodecSizeChng; + pPager->xCodecFree = xCodecFree; + pPager->pCodec = pCodec; + pagerReportSize(pPager); +} +SQLITE_PRIVATE void *sqlite3PagerGetCodec(Pager *pPager){ + return pPager->pCodec; +} + +/* +** This function is called by the wal module when writing page content +** into the log file. +** +** This function returns a pointer to a buffer containing the encrypted +** page content. If a malloc fails, this function may return NULL. +*/ +SQLITE_PRIVATE void *sqlite3PagerCodec(PgHdr *pPg){ + void *aData = 0; + CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData); + return aData; +} + +/* +** Return the current pager state +*/ +SQLITE_PRIVATE int sqlite3PagerState(Pager *pPager){ + return pPager->eState; +} +#endif /* SQLITE_HAS_CODEC */ + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Move the page pPg to location pgno in the file. +** +** There must be no references to the page previously located at +** pgno (which we call pPgOld) though that page is allowed to be +** in cache. If the page previously located at pgno is not already +** in the rollback journal, it is not put there by by this routine. +** +** References to the page pPg remain valid. Updating any +** meta-data associated with pPg (i.e. data stored in the nExtra bytes +** allocated along with the page) is the responsibility of the caller. +** +** A transaction must be active when this routine is called. It used to be +** required that a statement transaction was not active, but this restriction +** has been removed (CREATE INDEX needs to move a page when a statement +** transaction is active). +** +** If the fourth argument, isCommit, is non-zero, then this page is being +** moved as part of a database reorganization just before the transaction +** is being committed. In this case, it is guaranteed that the database page +** pPg refers to will not be written to again within this transaction. +** +** This function may return SQLITE_NOMEM or an IO error code if an error +** occurs. Otherwise, it returns SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){ + PgHdr *pPgOld; /* The page being overwritten. */ + Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */ + int rc; /* Return code */ + Pgno origPgno; /* The original page number */ + + assert( pPg->nRef>0 ); + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + + /* In order to be able to rollback, an in-memory database must journal + ** the page we are moving from. + */ + if( MEMDB ){ + rc = sqlite3PagerWrite(pPg); + if( rc ) return rc; + } + + /* If the page being moved is dirty and has not been saved by the latest + ** savepoint, then save the current contents of the page into the + ** sub-journal now. This is required to handle the following scenario: + ** + ** BEGIN; + ** + ** SAVEPOINT one; + ** + ** ROLLBACK TO one; + ** + ** If page X were not written to the sub-journal here, it would not + ** be possible to restore its contents when the "ROLLBACK TO one" + ** statement were is processed. + ** + ** subjournalPage() may need to allocate space to store pPg->pgno into + ** one or more savepoint bitvecs. This is the reason this function + ** may return SQLITE_NOMEM. + */ + if( (pPg->flags & PGHDR_DIRTY)!=0 + && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg)) + ){ + return rc; + } + + PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n", + PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno)); + IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno)) + + /* If the journal needs to be sync()ed before page pPg->pgno can + ** be written to, store pPg->pgno in local variable needSyncPgno. + ** + ** If the isCommit flag is set, there is no need to remember that + ** the journal needs to be sync()ed before database page pPg->pgno + ** can be written to. The caller has already promised not to write to it. + */ + if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){ + needSyncPgno = pPg->pgno; + assert( pPager->journalMode==PAGER_JOURNALMODE_OFF || + pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize ); + assert( pPg->flags&PGHDR_DIRTY ); + } + + /* If the cache contains a page with page-number pgno, remove it + ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for + ** page pgno before the 'move' operation, it needs to be retained + ** for the page moved there. + */ + pPg->flags &= ~PGHDR_NEED_SYNC; + pPgOld = sqlite3PagerLookup(pPager, pgno); + assert( !pPgOld || pPgOld->nRef==1 ); + if( pPgOld ){ + pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC); + if( MEMDB ){ + /* Do not discard pages from an in-memory database since we might + ** need to rollback later. Just move the page out of the way. */ + sqlite3PcacheMove(pPgOld, pPager->dbSize+1); + }else{ + sqlite3PcacheDrop(pPgOld); + } + } + + origPgno = pPg->pgno; + sqlite3PcacheMove(pPg, pgno); + sqlite3PcacheMakeDirty(pPg); + + /* For an in-memory database, make sure the original page continues + ** to exist, in case the transaction needs to roll back. Use pPgOld + ** as the original page since it has already been allocated. + */ + if( MEMDB ){ + assert( pPgOld ); + sqlite3PcacheMove(pPgOld, origPgno); + sqlite3PagerUnrefNotNull(pPgOld); + } + + if( needSyncPgno ){ + /* If needSyncPgno is non-zero, then the journal file needs to be + ** sync()ed before any data is written to database file page needSyncPgno. + ** Currently, no such page exists in the page-cache and the + ** "is journaled" bitvec flag has been set. This needs to be remedied by + ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC + ** flag. + ** + ** If the attempt to load the page into the page-cache fails, (due + ** to a malloc() or IO failure), clear the bit in the pInJournal[] + ** array. Otherwise, if the page is loaded and written again in + ** this transaction, it may be written to the database file before + ** it is synced into the journal file. This way, it may end up in + ** the journal file twice, but that is not a problem. + */ + PgHdr *pPgHdr; + rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr); + if( rc!=SQLITE_OK ){ + if( needSyncPgno<=pPager->dbOrigSize ){ + assert( pPager->pTmpSpace!=0 ); + sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace); + } + return rc; + } + pPgHdr->flags |= PGHDR_NEED_SYNC; + sqlite3PcacheMakeDirty(pPgHdr); + sqlite3PagerUnrefNotNull(pPgHdr); + } + + return SQLITE_OK; +} +#endif + +/* +** The page handle passed as the first argument refers to a dirty page +** with a page number other than iNew. This function changes the page's +** page number to iNew and sets the value of the PgHdr.flags field to +** the value passed as the third parameter. +*/ +SQLITE_PRIVATE void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){ + assert( pPg->pgno!=iNew ); + pPg->flags = flags; + sqlite3PcacheMove(pPg, iNew); +} + +/* +** Return a pointer to the data for the specified page. +*/ +SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *pPg){ + assert( pPg->nRef>0 || pPg->pPager->memDb ); + return pPg->pData; +} + +/* +** Return a pointer to the Pager.nExtra bytes of "extra" space +** allocated along with the specified page. +*/ +SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *pPg){ + return pPg->pExtra; +} + +/* +** Get/set the locking-mode for this pager. Parameter eMode must be one +** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or +** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then +** the locking-mode is set to the value specified. +** +** The returned value is either PAGER_LOCKINGMODE_NORMAL or +** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated) +** locking-mode. +*/ +SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){ + assert( eMode==PAGER_LOCKINGMODE_QUERY + || eMode==PAGER_LOCKINGMODE_NORMAL + || eMode==PAGER_LOCKINGMODE_EXCLUSIVE ); + assert( PAGER_LOCKINGMODE_QUERY<0 ); + assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 ); + assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) ); + if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){ + pPager->exclusiveMode = (u8)eMode; + } + return (int)pPager->exclusiveMode; +} + +/* +** Set the journal-mode for this pager. Parameter eMode must be one of: +** +** PAGER_JOURNALMODE_DELETE +** PAGER_JOURNALMODE_TRUNCATE +** PAGER_JOURNALMODE_PERSIST +** PAGER_JOURNALMODE_OFF +** PAGER_JOURNALMODE_MEMORY +** PAGER_JOURNALMODE_WAL +** +** The journalmode is set to the value specified if the change is allowed. +** The change may be disallowed for the following reasons: +** +** * An in-memory database can only have its journal_mode set to _OFF +** or _MEMORY. +** +** * Temporary databases cannot have _WAL journalmode. +** +** The returned indicate the current (possibly updated) journal-mode. +*/ +SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){ + u8 eOld = pPager->journalMode; /* Prior journalmode */ + +#ifdef SQLITE_DEBUG + /* The print_pager_state() routine is intended to be used by the debugger + ** only. We invoke it once here to suppress a compiler warning. */ + print_pager_state(pPager); +#endif + + + /* The eMode parameter is always valid */ + assert( eMode==PAGER_JOURNALMODE_DELETE + || eMode==PAGER_JOURNALMODE_TRUNCATE + || eMode==PAGER_JOURNALMODE_PERSIST + || eMode==PAGER_JOURNALMODE_OFF + || eMode==PAGER_JOURNALMODE_WAL + || eMode==PAGER_JOURNALMODE_MEMORY ); + + /* This routine is only called from the OP_JournalMode opcode, and + ** the logic there will never allow a temporary file to be changed + ** to WAL mode. + */ + assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL ); + + /* Do allow the journalmode of an in-memory database to be set to + ** anything other than MEMORY or OFF + */ + if( MEMDB ){ + assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF ); + if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){ + eMode = eOld; + } + } + + if( eMode!=eOld ){ + + /* Change the journal mode. */ + assert( pPager->eState!=PAGER_ERROR ); + pPager->journalMode = (u8)eMode; + + /* When transistioning from TRUNCATE or PERSIST to any other journal + ** mode except WAL, unless the pager is in locking_mode=exclusive mode, + ** delete the journal file. + */ + assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 ); + assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 ); + assert( (PAGER_JOURNALMODE_DELETE & 5)==0 ); + assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 ); + assert( (PAGER_JOURNALMODE_OFF & 5)==0 ); + assert( (PAGER_JOURNALMODE_WAL & 5)==5 ); + + assert( isOpen(pPager->fd) || pPager->exclusiveMode ); + if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){ + + /* In this case we would like to delete the journal file. If it is + ** not possible, then that is not a problem. Deleting the journal file + ** here is an optimization only. + ** + ** Before deleting the journal file, obtain a RESERVED lock on the + ** database file. This ensures that the journal file is not deleted + ** while it is in use by some other client. + */ + sqlite3OsClose(pPager->jfd); + if( pPager->eLock>=RESERVED_LOCK ){ + sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0); + }else{ + int rc = SQLITE_OK; + int state = pPager->eState; + assert( state==PAGER_OPEN || state==PAGER_READER ); + if( state==PAGER_OPEN ){ + rc = sqlite3PagerSharedLock(pPager); + } + if( pPager->eState==PAGER_READER ){ + assert( rc==SQLITE_OK ); + rc = pagerLockDb(pPager, RESERVED_LOCK); + } + if( rc==SQLITE_OK ){ + sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0); + } + if( rc==SQLITE_OK && state==PAGER_READER ){ + pagerUnlockDb(pPager, SHARED_LOCK); + }else if( state==PAGER_OPEN ){ + pager_unlock(pPager); + } + assert( state==pPager->eState ); + } + }else if( eMode==PAGER_JOURNALMODE_OFF ){ + sqlite3OsClose(pPager->jfd); + } + } + + /* Return the new journal mode */ + return (int)pPager->journalMode; +} + +/* +** Return the current journal mode. +*/ +SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager *pPager){ + return (int)pPager->journalMode; +} + +/* +** Return TRUE if the pager is in a state where it is OK to change the +** journalmode. Journalmode changes can only happen when the database +** is unmodified. +*/ +SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){ + assert( assert_pager_state(pPager) ); + if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0; + if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0; + return 1; +} + +/* +** Get/set the size-limit used for persistent journal files. +** +** Setting the size limit to -1 means no limit is enforced. +** An attempt to set a limit smaller than -1 is a no-op. +*/ +SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){ + if( iLimit>=-1 ){ + pPager->journalSizeLimit = iLimit; + sqlite3WalLimit(pPager->pWal, iLimit); + } + return pPager->journalSizeLimit; +} + +/* +** Return a pointer to the pPager->pBackup variable. The backup module +** in backup.c maintains the content of this variable. This module +** uses it opaquely as an argument to sqlite3BackupRestart() and +** sqlite3BackupUpdate() only. +*/ +SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){ + return &pPager->pBackup; +} + +#ifndef SQLITE_OMIT_VACUUM +/* +** Unless this is an in-memory or temporary database, clear the pager cache. +*/ +SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *pPager){ + if( !MEMDB && pPager->tempFile==0 ) pager_reset(pPager); +} +#endif + +#ifndef SQLITE_OMIT_WAL +/* +** This function is called when the user invokes "PRAGMA wal_checkpoint", +** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint() +** or wal_blocking_checkpoint() API functions. +** +** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART. +*/ +SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int eMode, int *pnLog, int *pnCkpt){ + int rc = SQLITE_OK; + if( pPager->pWal ){ + rc = sqlite3WalCheckpoint(pPager->pWal, eMode, + (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler), + pPager->pBusyHandlerArg, + pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace, + pnLog, pnCkpt + ); + } + return rc; +} + +SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager){ + return sqlite3WalCallback(pPager->pWal); +} + +/* +** Return true if the underlying VFS for the given pager supports the +** primitives necessary for write-ahead logging. +*/ +SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){ + const sqlite3_io_methods *pMethods = pPager->fd->pMethods; + return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap); +} + +/* +** Attempt to take an exclusive lock on the database file. If a PENDING lock +** is obtained instead, immediately release it. +*/ +static int pagerExclusiveLock(Pager *pPager){ + int rc; /* Return code */ + + assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK ); + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + /* If the attempt to grab the exclusive lock failed, release the + ** pending lock that may have been obtained instead. */ + pagerUnlockDb(pPager, SHARED_LOCK); + } + + return rc; +} + +/* +** Call sqlite3WalOpen() to open the WAL handle. If the pager is in +** exclusive-locking mode when this function is called, take an EXCLUSIVE +** lock on the database file and use heap-memory to store the wal-index +** in. Otherwise, use the normal shared-memory. +*/ +static int pagerOpenWal(Pager *pPager){ + int rc = SQLITE_OK; + + assert( pPager->pWal==0 && pPager->tempFile==0 ); + assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK ); + + /* If the pager is already in exclusive-mode, the WAL module will use + ** heap-memory for the wal-index instead of the VFS shared-memory + ** implementation. Take the exclusive lock now, before opening the WAL + ** file, to make sure this is safe. + */ + if( pPager->exclusiveMode ){ + rc = pagerExclusiveLock(pPager); + } + + /* Open the connection to the log file. If this operation fails, + ** (e.g. due to malloc() failure), return an error code. + */ + if( rc==SQLITE_OK ){ + rc = sqlite3WalOpen(pPager->pVfs, + pPager->fd, pPager->zWal, pPager->exclusiveMode, + pPager->journalSizeLimit, &pPager->pWal + ); + } + pagerFixMaplimit(pPager); + + return rc; +} + + +/* +** The caller must be holding a SHARED lock on the database file to call +** this function. +** +** If the pager passed as the first argument is open on a real database +** file (not a temp file or an in-memory database), and the WAL file +** is not already open, make an attempt to open it now. If successful, +** return SQLITE_OK. If an error occurs or the VFS used by the pager does +** not support the xShmXXX() methods, return an error code. *pbOpen is +** not modified in either case. +** +** If the pager is open on a temp-file (or in-memory database), or if +** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK +** without doing anything. +*/ +SQLITE_PRIVATE int sqlite3PagerOpenWal( + Pager *pPager, /* Pager object */ + int *pbOpen /* OUT: Set to true if call is a no-op */ +){ + int rc = SQLITE_OK; /* Return code */ + + assert( assert_pager_state(pPager) ); + assert( pPager->eState==PAGER_OPEN || pbOpen ); + assert( pPager->eState==PAGER_READER || !pbOpen ); + assert( pbOpen==0 || *pbOpen==0 ); + assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) ); + + if( !pPager->tempFile && !pPager->pWal ){ + if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN; + + /* Close any rollback journal previously open */ + sqlite3OsClose(pPager->jfd); + + rc = pagerOpenWal(pPager); + if( rc==SQLITE_OK ){ + pPager->journalMode = PAGER_JOURNALMODE_WAL; + pPager->eState = PAGER_OPEN; + } + }else{ + *pbOpen = 1; + } + + return rc; +} + +/* +** This function is called to close the connection to the log file prior +** to switching from WAL to rollback mode. +** +** Before closing the log file, this function attempts to take an +** EXCLUSIVE lock on the database file. If this cannot be obtained, an +** error (SQLITE_BUSY) is returned and the log connection is not closed. +** If successful, the EXCLUSIVE lock is not released before returning. +*/ +SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager){ + int rc = SQLITE_OK; + + assert( pPager->journalMode==PAGER_JOURNALMODE_WAL ); + + /* If the log file is not already open, but does exist in the file-system, + ** it may need to be checkpointed before the connection can switch to + ** rollback mode. Open it now so this can happen. + */ + if( !pPager->pWal ){ + int logexists = 0; + rc = pagerLockDb(pPager, SHARED_LOCK); + if( rc==SQLITE_OK ){ + rc = sqlite3OsAccess( + pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists + ); + } + if( rc==SQLITE_OK && logexists ){ + rc = pagerOpenWal(pPager); + } + } + + /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on + ** the database file, the log and log-summary files will be deleted. + */ + if( rc==SQLITE_OK && pPager->pWal ){ + rc = pagerExclusiveLock(pPager); + if( rc==SQLITE_OK ){ + rc = sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags, + pPager->pageSize, (u8*)pPager->pTmpSpace); + pPager->pWal = 0; + pagerFixMaplimit(pPager); + } + } + return rc; +} + +#endif /* !SQLITE_OMIT_WAL */ + +#ifdef SQLITE_ENABLE_ZIPVFS +/* +** A read-lock must be held on the pager when this function is called. If +** the pager is in WAL mode and the WAL file currently contains one or more +** frames, return the size in bytes of the page images stored within the +** WAL frames. Otherwise, if this is not a WAL database or the WAL file +** is empty, return 0. +*/ +SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager){ + assert( pPager->eState>=PAGER_READER ); + return sqlite3WalFramesize(pPager->pWal); +} +#endif + + +#endif /* SQLITE_OMIT_DISKIO */ + +/************** End of pager.c ***********************************************/ +/************** Begin file wal.c *********************************************/ +/* +** 2010 February 1 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the implementation of a write-ahead log (WAL) used in +** "journal_mode=WAL" mode. +** +** WRITE-AHEAD LOG (WAL) FILE FORMAT +** +** A WAL file consists of a header followed by zero or more "frames". +** Each frame records the revised content of a single page from the +** database file. All changes to the database are recorded by writing +** frames into the WAL. Transactions commit when a frame is written that +** contains a commit marker. A single WAL can and usually does record +** multiple transactions. Periodically, the content of the WAL is +** transferred back into the database file in an operation called a +** "checkpoint". +** +** A single WAL file can be used multiple times. In other words, the +** WAL can fill up with frames and then be checkpointed and then new +** frames can overwrite the old ones. A WAL always grows from beginning +** toward the end. Checksums and counters attached to each frame are +** used to determine which frames within the WAL are valid and which +** are leftovers from prior checkpoints. +** +** The WAL header is 32 bytes in size and consists of the following eight +** big-endian 32-bit unsigned integer values: +** +** 0: Magic number. 0x377f0682 or 0x377f0683 +** 4: File format version. Currently 3007000 +** 8: Database page size. Example: 1024 +** 12: Checkpoint sequence number +** 16: Salt-1, random integer incremented with each checkpoint +** 20: Salt-2, a different random integer changing with each ckpt +** 24: Checksum-1 (first part of checksum for first 24 bytes of header). +** 28: Checksum-2 (second part of checksum for first 24 bytes of header). +** +** Immediately following the wal-header are zero or more frames. Each +** frame consists of a 24-byte frame-header followed by a bytes +** of page data. The frame-header is six big-endian 32-bit unsigned +** integer values, as follows: +** +** 0: Page number. +** 4: For commit records, the size of the database image in pages +** after the commit. For all other records, zero. +** 8: Salt-1 (copied from the header) +** 12: Salt-2 (copied from the header) +** 16: Checksum-1. +** 20: Checksum-2. +** +** A frame is considered valid if and only if the following conditions are +** true: +** +** (1) The salt-1 and salt-2 values in the frame-header match +** salt values in the wal-header +** +** (2) The checksum values in the final 8 bytes of the frame-header +** exactly match the checksum computed consecutively on the +** WAL header and the first 8 bytes and the content of all frames +** up to and including the current frame. +** +** The checksum is computed using 32-bit big-endian integers if the +** magic number in the first 4 bytes of the WAL is 0x377f0683 and it +** is computed using little-endian if the magic number is 0x377f0682. +** The checksum values are always stored in the frame header in a +** big-endian format regardless of which byte order is used to compute +** the checksum. The checksum is computed by interpreting the input as +** an even number of unsigned 32-bit integers: x[0] through x[N]. The +** algorithm used for the checksum is as follows: +** +** for i from 0 to n-1 step 2: +** s0 += x[i] + s1; +** s1 += x[i+1] + s0; +** endfor +** +** Note that s0 and s1 are both weighted checksums using fibonacci weights +** in reverse order (the largest fibonacci weight occurs on the first element +** of the sequence being summed.) The s1 value spans all 32-bit +** terms of the sequence whereas s0 omits the final term. +** +** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the +** WAL is transferred into the database, then the database is VFS.xSync-ed. +** The VFS.xSync operations serve as write barriers - all writes launched +** before the xSync must complete before any write that launches after the +** xSync begins. +** +** After each checkpoint, the salt-1 value is incremented and the salt-2 +** value is randomized. This prevents old and new frames in the WAL from +** being considered valid at the same time and being checkpointing together +** following a crash. +** +** READER ALGORITHM +** +** To read a page from the database (call it page number P), a reader +** first checks the WAL to see if it contains page P. If so, then the +** last valid instance of page P that is a followed by a commit frame +** or is a commit frame itself becomes the value read. If the WAL +** contains no copies of page P that are valid and which are a commit +** frame or are followed by a commit frame, then page P is read from +** the database file. +** +** To start a read transaction, the reader records the index of the last +** valid frame in the WAL. The reader uses this recorded "mxFrame" value +** for all subsequent read operations. New transactions can be appended +** to the WAL, but as long as the reader uses its original mxFrame value +** and ignores the newly appended content, it will see a consistent snapshot +** of the database from a single point in time. This technique allows +** multiple concurrent readers to view different versions of the database +** content simultaneously. +** +** The reader algorithm in the previous paragraphs works correctly, but +** because frames for page P can appear anywhere within the WAL, the +** reader has to scan the entire WAL looking for page P frames. If the +** WAL is large (multiple megabytes is typical) that scan can be slow, +** and read performance suffers. To overcome this problem, a separate +** data structure called the wal-index is maintained to expedite the +** search for frames of a particular page. +** +** WAL-INDEX FORMAT +** +** Conceptually, the wal-index is shared memory, though VFS implementations +** might choose to implement the wal-index using a mmapped file. Because +** the wal-index is shared memory, SQLite does not support journal_mode=WAL +** on a network filesystem. All users of the database must be able to +** share memory. +** +** The wal-index is transient. After a crash, the wal-index can (and should +** be) reconstructed from the original WAL file. In fact, the VFS is required +** to either truncate or zero the header of the wal-index when the last +** connection to it closes. Because the wal-index is transient, it can +** use an architecture-specific format; it does not have to be cross-platform. +** Hence, unlike the database and WAL file formats which store all values +** as big endian, the wal-index can store multi-byte values in the native +** byte order of the host computer. +** +** The purpose of the wal-index is to answer this question quickly: Given +** a page number P and a maximum frame index M, return the index of the +** last frame in the wal before frame M for page P in the WAL, or return +** NULL if there are no frames for page P in the WAL prior to M. +** +** The wal-index consists of a header region, followed by an one or +** more index blocks. +** +** The wal-index header contains the total number of frames within the WAL +** in the mxFrame field. +** +** Each index block except for the first contains information on +** HASHTABLE_NPAGE frames. The first index block contains information on +** HASHTABLE_NPAGE_ONE frames. The values of HASHTABLE_NPAGE_ONE and +** HASHTABLE_NPAGE are selected so that together the wal-index header and +** first index block are the same size as all other index blocks in the +** wal-index. +** +** Each index block contains two sections, a page-mapping that contains the +** database page number associated with each wal frame, and a hash-table +** that allows readers to query an index block for a specific page number. +** The page-mapping is an array of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE +** for the first index block) 32-bit page numbers. The first entry in the +** first index-block contains the database page number corresponding to the +** first frame in the WAL file. The first entry in the second index block +** in the WAL file corresponds to the (HASHTABLE_NPAGE_ONE+1)th frame in +** the log, and so on. +** +** The last index block in a wal-index usually contains less than the full +** complement of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE) page-numbers, +** depending on the contents of the WAL file. This does not change the +** allocated size of the page-mapping array - the page-mapping array merely +** contains unused entries. +** +** Even without using the hash table, the last frame for page P +** can be found by scanning the page-mapping sections of each index block +** starting with the last index block and moving toward the first, and +** within each index block, starting at the end and moving toward the +** beginning. The first entry that equals P corresponds to the frame +** holding the content for that page. +** +** The hash table consists of HASHTABLE_NSLOT 16-bit unsigned integers. +** HASHTABLE_NSLOT = 2*HASHTABLE_NPAGE, and there is one entry in the +** hash table for each page number in the mapping section, so the hash +** table is never more than half full. The expected number of collisions +** prior to finding a match is 1. Each entry of the hash table is an +** 1-based index of an entry in the mapping section of the same +** index block. Let K be the 1-based index of the largest entry in +** the mapping section. (For index blocks other than the last, K will +** always be exactly HASHTABLE_NPAGE (4096) and for the last index block +** K will be (mxFrame%HASHTABLE_NPAGE).) Unused slots of the hash table +** contain a value of 0. +** +** To look for page P in the hash table, first compute a hash iKey on +** P as follows: +** +** iKey = (P * 383) % HASHTABLE_NSLOT +** +** Then start scanning entries of the hash table, starting with iKey +** (wrapping around to the beginning when the end of the hash table is +** reached) until an unused hash slot is found. Let the first unused slot +** be at index iUnused. (iUnused might be less than iKey if there was +** wrap-around.) Because the hash table is never more than half full, +** the search is guaranteed to eventually hit an unused entry. Let +** iMax be the value between iKey and iUnused, closest to iUnused, +** where aHash[iMax]==P. If there is no iMax entry (if there exists +** no hash slot such that aHash[i]==p) then page P is not in the +** current index block. Otherwise the iMax-th mapping entry of the +** current index block corresponds to the last entry that references +** page P. +** +** A hash search begins with the last index block and moves toward the +** first index block, looking for entries corresponding to page P. On +** average, only two or three slots in each index block need to be +** examined in order to either find the last entry for page P, or to +** establish that no such entry exists in the block. Each index block +** holds over 4000 entries. So two or three index blocks are sufficient +** to cover a typical 10 megabyte WAL file, assuming 1K pages. 8 or 10 +** comparisons (on average) suffice to either locate a frame in the +** WAL or to establish that the frame does not exist in the WAL. This +** is much faster than scanning the entire 10MB WAL. +** +** Note that entries are added in order of increasing K. Hence, one +** reader might be using some value K0 and a second reader that started +** at a later time (after additional transactions were added to the WAL +** and to the wal-index) might be using a different value K1, where K1>K0. +** Both readers can use the same hash table and mapping section to get +** the correct result. There may be entries in the hash table with +** K>K0 but to the first reader, those entries will appear to be unused +** slots in the hash table and so the first reader will get an answer as +** if no values greater than K0 had ever been inserted into the hash table +** in the first place - which is what reader one wants. Meanwhile, the +** second reader using K1 will see additional values that were inserted +** later, which is exactly what reader two wants. +** +** When a rollback occurs, the value of K is decreased. Hash table entries +** that correspond to frames greater than the new K value are removed +** from the hash table at this point. +*/ +#ifndef SQLITE_OMIT_WAL + +/* #include "wal.h" */ + +/* +** Trace output macros +*/ +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) +SQLITE_PRIVATE int sqlite3WalTrace = 0; +# define WALTRACE(X) if(sqlite3WalTrace) sqlite3DebugPrintf X +#else +# define WALTRACE(X) +#endif + +/* +** The maximum (and only) versions of the wal and wal-index formats +** that may be interpreted by this version of SQLite. +** +** If a client begins recovering a WAL file and finds that (a) the checksum +** values in the wal-header are correct and (b) the version field is not +** WAL_MAX_VERSION, recovery fails and SQLite returns SQLITE_CANTOPEN. +** +** Similarly, if a client successfully reads a wal-index header (i.e. the +** checksum test is successful) and finds that the version field is not +** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite +** returns SQLITE_CANTOPEN. +*/ +#define WAL_MAX_VERSION 3007000 +#define WALINDEX_MAX_VERSION 3007000 + +/* +** Indices of various locking bytes. WAL_NREADER is the number +** of available reader locks and should be at least 3. +*/ +#define WAL_WRITE_LOCK 0 +#define WAL_ALL_BUT_WRITE 1 +#define WAL_CKPT_LOCK 1 +#define WAL_RECOVER_LOCK 2 +#define WAL_READ_LOCK(I) (3+(I)) +#define WAL_NREADER (SQLITE_SHM_NLOCK-3) + + +/* Object declarations */ +typedef struct WalIndexHdr WalIndexHdr; +typedef struct WalIterator WalIterator; +typedef struct WalCkptInfo WalCkptInfo; + + +/* +** The following object holds a copy of the wal-index header content. +** +** The actual header in the wal-index consists of two copies of this +** object. +** +** The szPage value can be any power of 2 between 512 and 32768, inclusive. +** Or it can be 1 to represent a 65536-byte page. The latter case was +** added in 3.7.1 when support for 64K pages was added. +*/ +struct WalIndexHdr { + u32 iVersion; /* Wal-index version */ + u32 unused; /* Unused (padding) field */ + u32 iChange; /* Counter incremented each transaction */ + u8 isInit; /* 1 when initialized */ + u8 bigEndCksum; /* True if checksums in WAL are big-endian */ + u16 szPage; /* Database page size in bytes. 1==64K */ + u32 mxFrame; /* Index of last valid frame in the WAL */ + u32 nPage; /* Size of database in pages */ + u32 aFrameCksum[2]; /* Checksum of last frame in log */ + u32 aSalt[2]; /* Two salt values copied from WAL header */ + u32 aCksum[2]; /* Checksum over all prior fields */ +}; + +/* +** A copy of the following object occurs in the wal-index immediately +** following the second copy of the WalIndexHdr. This object stores +** information used by checkpoint. +** +** nBackfill is the number of frames in the WAL that have been written +** back into the database. (We call the act of moving content from WAL to +** database "backfilling".) The nBackfill number is never greater than +** WalIndexHdr.mxFrame. nBackfill can only be increased by threads +** holding the WAL_CKPT_LOCK lock (which includes a recovery thread). +** However, a WAL_WRITE_LOCK thread can move the value of nBackfill from +** mxFrame back to zero when the WAL is reset. +** +** There is one entry in aReadMark[] for each reader lock. If a reader +** holds read-lock K, then the value in aReadMark[K] is no greater than +** the mxFrame for that reader. The value READMARK_NOT_USED (0xffffffff) +** for any aReadMark[] means that entry is unused. aReadMark[0] is +** a special case; its value is never used and it exists as a place-holder +** to avoid having to offset aReadMark[] indexs by one. Readers holding +** WAL_READ_LOCK(0) always ignore the entire WAL and read all content +** directly from the database. +** +** The value of aReadMark[K] may only be changed by a thread that +** is holding an exclusive lock on WAL_READ_LOCK(K). Thus, the value of +** aReadMark[K] cannot changed while there is a reader is using that mark +** since the reader will be holding a shared lock on WAL_READ_LOCK(K). +** +** The checkpointer may only transfer frames from WAL to database where +** the frame numbers are less than or equal to every aReadMark[] that is +** in use (that is, every aReadMark[j] for which there is a corresponding +** WAL_READ_LOCK(j)). New readers (usually) pick the aReadMark[] with the +** largest value and will increase an unused aReadMark[] to mxFrame if there +** is not already an aReadMark[] equal to mxFrame. The exception to the +** previous sentence is when nBackfill equals mxFrame (meaning that everything +** in the WAL has been backfilled into the database) then new readers +** will choose aReadMark[0] which has value 0 and hence such reader will +** get all their all content directly from the database file and ignore +** the WAL. +** +** Writers normally append new frames to the end of the WAL. However, +** if nBackfill equals mxFrame (meaning that all WAL content has been +** written back into the database) and if no readers are using the WAL +** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then +** the writer will first "reset" the WAL back to the beginning and start +** writing new content beginning at frame 1. +** +** We assume that 32-bit loads are atomic and so no locks are needed in +** order to read from any aReadMark[] entries. +*/ +struct WalCkptInfo { + u32 nBackfill; /* Number of WAL frames backfilled into DB */ + u32 aReadMark[WAL_NREADER]; /* Reader marks */ +}; +#define READMARK_NOT_USED 0xffffffff + + +/* A block of WALINDEX_LOCK_RESERVED bytes beginning at +** WALINDEX_LOCK_OFFSET is reserved for locks. Since some systems +** only support mandatory file-locks, we do not read or write data +** from the region of the file on which locks are applied. +*/ +#define WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2 + sizeof(WalCkptInfo)) +#define WALINDEX_LOCK_RESERVED 16 +#define WALINDEX_HDR_SIZE (WALINDEX_LOCK_OFFSET+WALINDEX_LOCK_RESERVED) + +/* Size of header before each frame in wal */ +#define WAL_FRAME_HDRSIZE 24 + +/* Size of write ahead log header, including checksum. */ +/* #define WAL_HDRSIZE 24 */ +#define WAL_HDRSIZE 32 + +/* WAL magic value. Either this value, or the same value with the least +** significant bit also set (WAL_MAGIC | 0x00000001) is stored in 32-bit +** big-endian format in the first 4 bytes of a WAL file. +** +** If the LSB is set, then the checksums for each frame within the WAL +** file are calculated by treating all data as an array of 32-bit +** big-endian words. Otherwise, they are calculated by interpreting +** all data as 32-bit little-endian words. +*/ +#define WAL_MAGIC 0x377f0682 + +/* +** Return the offset of frame iFrame in the write-ahead log file, +** assuming a database page size of szPage bytes. The offset returned +** is to the start of the write-ahead log frame-header. +*/ +#define walFrameOffset(iFrame, szPage) ( \ + WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE) \ +) + +/* +** An open write-ahead log file is represented by an instance of the +** following object. +*/ +struct Wal { + sqlite3_vfs *pVfs; /* The VFS used to create pDbFd */ + sqlite3_file *pDbFd; /* File handle for the database file */ + sqlite3_file *pWalFd; /* File handle for WAL file */ + u32 iCallback; /* Value to pass to log callback (or 0) */ + i64 mxWalSize; /* Truncate WAL to this size upon reset */ + int nWiData; /* Size of array apWiData */ + int szFirstBlock; /* Size of first block written to WAL file */ + volatile u32 **apWiData; /* Pointer to wal-index content in memory */ + u32 szPage; /* Database page size */ + i16 readLock; /* Which read lock is being held. -1 for none */ + u8 syncFlags; /* Flags to use to sync header writes */ + u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */ + u8 writeLock; /* True if in a write transaction */ + u8 ckptLock; /* True if holding a checkpoint lock */ + u8 readOnly; /* WAL_RDWR, WAL_RDONLY, or WAL_SHM_RDONLY */ + u8 truncateOnCommit; /* True to truncate WAL file on commit */ + u8 syncHeader; /* Fsync the WAL header if true */ + u8 padToSectorBoundary; /* Pad transactions out to the next sector */ + WalIndexHdr hdr; /* Wal-index header for current transaction */ + u32 minFrame; /* Ignore wal frames before this one */ + const char *zWalName; /* Name of WAL file */ + u32 nCkpt; /* Checkpoint sequence counter in the wal-header */ +#ifdef SQLITE_DEBUG + u8 lockError; /* True if a locking error has occurred */ +#endif +}; + +/* +** Candidate values for Wal.exclusiveMode. +*/ +#define WAL_NORMAL_MODE 0 +#define WAL_EXCLUSIVE_MODE 1 +#define WAL_HEAPMEMORY_MODE 2 + +/* +** Possible values for WAL.readOnly +*/ +#define WAL_RDWR 0 /* Normal read/write connection */ +#define WAL_RDONLY 1 /* The WAL file is readonly */ +#define WAL_SHM_RDONLY 2 /* The SHM file is readonly */ + +/* +** Each page of the wal-index mapping contains a hash-table made up of +** an array of HASHTABLE_NSLOT elements of the following type. +*/ +typedef u16 ht_slot; + +/* +** This structure is used to implement an iterator that loops through +** all frames in the WAL in database page order. Where two or more frames +** correspond to the same database page, the iterator visits only the +** frame most recently written to the WAL (in other words, the frame with +** the largest index). +** +** The internals of this structure are only accessed by: +** +** walIteratorInit() - Create a new iterator, +** walIteratorNext() - Step an iterator, +** walIteratorFree() - Free an iterator. +** +** This functionality is used by the checkpoint code (see walCheckpoint()). +*/ +struct WalIterator { + int iPrior; /* Last result returned from the iterator */ + int nSegment; /* Number of entries in aSegment[] */ + struct WalSegment { + int iNext; /* Next slot in aIndex[] not yet returned */ + ht_slot *aIndex; /* i0, i1, i2... such that aPgno[iN] ascend */ + u32 *aPgno; /* Array of page numbers. */ + int nEntry; /* Nr. of entries in aPgno[] and aIndex[] */ + int iZero; /* Frame number associated with aPgno[0] */ + } aSegment[1]; /* One for every 32KB page in the wal-index */ +}; + +/* +** Define the parameters of the hash tables in the wal-index file. There +** is a hash-table following every HASHTABLE_NPAGE page numbers in the +** wal-index. +** +** Changing any of these constants will alter the wal-index format and +** create incompatibilities. +*/ +#define HASHTABLE_NPAGE 4096 /* Must be power of 2 */ +#define HASHTABLE_HASH_1 383 /* Should be prime */ +#define HASHTABLE_NSLOT (HASHTABLE_NPAGE*2) /* Must be a power of 2 */ + +/* +** The block of page numbers associated with the first hash-table in a +** wal-index is smaller than usual. This is so that there is a complete +** hash-table on each aligned 32KB page of the wal-index. +*/ +#define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32))) + +/* The wal-index is divided into pages of WALINDEX_PGSZ bytes each. */ +#define WALINDEX_PGSZ ( \ + sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \ +) + +/* +** Obtain a pointer to the iPage'th page of the wal-index. The wal-index +** is broken into pages of WALINDEX_PGSZ bytes. Wal-index pages are +** numbered from zero. +** +** If this call is successful, *ppPage is set to point to the wal-index +** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs, +** then an SQLite error code is returned and *ppPage is set to 0. +*/ +static int walIndexPage(Wal *pWal, int iPage, volatile u32 **ppPage){ + int rc = SQLITE_OK; + + /* Enlarge the pWal->apWiData[] array if required */ + if( pWal->nWiData<=iPage ){ + int nByte = sizeof(u32*)*(iPage+1); + volatile u32 **apNew; + apNew = (volatile u32 **)sqlite3_realloc64((void *)pWal->apWiData, nByte); + if( !apNew ){ + *ppPage = 0; + return SQLITE_NOMEM; + } + memset((void*)&apNew[pWal->nWiData], 0, + sizeof(u32*)*(iPage+1-pWal->nWiData)); + pWal->apWiData = apNew; + pWal->nWiData = iPage+1; + } + + /* Request a pointer to the required page from the VFS */ + if( pWal->apWiData[iPage]==0 ){ + if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){ + pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ); + if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM; + }else{ + rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ, + pWal->writeLock, (void volatile **)&pWal->apWiData[iPage] + ); + if( rc==SQLITE_READONLY ){ + pWal->readOnly |= WAL_SHM_RDONLY; + rc = SQLITE_OK; + } + } + } + + *ppPage = pWal->apWiData[iPage]; + assert( iPage==0 || *ppPage || rc!=SQLITE_OK ); + return rc; +} + +/* +** Return a pointer to the WalCkptInfo structure in the wal-index. +*/ +static volatile WalCkptInfo *walCkptInfo(Wal *pWal){ + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]); +} + +/* +** Return a pointer to the WalIndexHdr structure in the wal-index. +*/ +static volatile WalIndexHdr *walIndexHdr(Wal *pWal){ + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + return (volatile WalIndexHdr*)pWal->apWiData[0]; +} + +/* +** The argument to this macro must be of type u32. On a little-endian +** architecture, it returns the u32 value that results from interpreting +** the 4 bytes as a big-endian value. On a big-endian architecture, it +** returns the value that would be produced by interpreting the 4 bytes +** of the input value as a little-endian integer. +*/ +#define BYTESWAP32(x) ( \ + (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8) \ + + (((x)&0x00FF0000)>>8) + (((x)&0xFF000000)>>24) \ +) + +/* +** Generate or extend an 8 byte checksum based on the data in +** array aByte[] and the initial values of aIn[0] and aIn[1] (or +** initial values of 0 and 0 if aIn==NULL). +** +** The checksum is written back into aOut[] before returning. +** +** nByte must be a positive multiple of 8. +*/ +static void walChecksumBytes( + int nativeCksum, /* True for native byte-order, false for non-native */ + u8 *a, /* Content to be checksummed */ + int nByte, /* Bytes of content in a[]. Must be a multiple of 8. */ + const u32 *aIn, /* Initial checksum value input */ + u32 *aOut /* OUT: Final checksum value output */ +){ + u32 s1, s2; + u32 *aData = (u32 *)a; + u32 *aEnd = (u32 *)&a[nByte]; + + if( aIn ){ + s1 = aIn[0]; + s2 = aIn[1]; + }else{ + s1 = s2 = 0; + } + + assert( nByte>=8 ); + assert( (nByte&0x00000007)==0 ); + + if( nativeCksum ){ + do { + s1 += *aData++ + s2; + s2 += *aData++ + s1; + }while( aDataexclusiveMode!=WAL_HEAPMEMORY_MODE ){ + sqlite3OsShmBarrier(pWal->pDbFd); + } +} + +/* +** Write the header information in pWal->hdr into the wal-index. +** +** The checksum on pWal->hdr is updated before it is written. +*/ +static void walIndexWriteHdr(Wal *pWal){ + volatile WalIndexHdr *aHdr = walIndexHdr(pWal); + const int nCksum = offsetof(WalIndexHdr, aCksum); + + assert( pWal->writeLock ); + pWal->hdr.isInit = 1; + pWal->hdr.iVersion = WALINDEX_MAX_VERSION; + walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum); + memcpy((void*)&aHdr[1], (const void*)&pWal->hdr, sizeof(WalIndexHdr)); + walShmBarrier(pWal); + memcpy((void*)&aHdr[0], (const void*)&pWal->hdr, sizeof(WalIndexHdr)); +} + +/* +** This function encodes a single frame header and writes it to a buffer +** supplied by the caller. A frame-header is made up of a series of +** 4-byte big-endian integers, as follows: +** +** 0: Page number. +** 4: For commit records, the size of the database image in pages +** after the commit. For all other records, zero. +** 8: Salt-1 (copied from the wal-header) +** 12: Salt-2 (copied from the wal-header) +** 16: Checksum-1. +** 20: Checksum-2. +*/ +static void walEncodeFrame( + Wal *pWal, /* The write-ahead log */ + u32 iPage, /* Database page number for frame */ + u32 nTruncate, /* New db size (or 0 for non-commit frames) */ + u8 *aData, /* Pointer to page data */ + u8 *aFrame /* OUT: Write encoded frame here */ +){ + int nativeCksum; /* True for native byte-order checksums */ + u32 *aCksum = pWal->hdr.aFrameCksum; + assert( WAL_FRAME_HDRSIZE==24 ); + sqlite3Put4byte(&aFrame[0], iPage); + sqlite3Put4byte(&aFrame[4], nTruncate); + memcpy(&aFrame[8], pWal->hdr.aSalt, 8); + + nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN); + walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum); + walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum); + + sqlite3Put4byte(&aFrame[16], aCksum[0]); + sqlite3Put4byte(&aFrame[20], aCksum[1]); +} + +/* +** Check to see if the frame with header in aFrame[] and content +** in aData[] is valid. If it is a valid frame, fill *piPage and +** *pnTruncate and return true. Return if the frame is not valid. +*/ +static int walDecodeFrame( + Wal *pWal, /* The write-ahead log */ + u32 *piPage, /* OUT: Database page number for frame */ + u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */ + u8 *aData, /* Pointer to page data (for checksum) */ + u8 *aFrame /* Frame data */ +){ + int nativeCksum; /* True for native byte-order checksums */ + u32 *aCksum = pWal->hdr.aFrameCksum; + u32 pgno; /* Page number of the frame */ + assert( WAL_FRAME_HDRSIZE==24 ); + + /* A frame is only valid if the salt values in the frame-header + ** match the salt values in the wal-header. + */ + if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){ + return 0; + } + + /* A frame is only valid if the page number is creater than zero. + */ + pgno = sqlite3Get4byte(&aFrame[0]); + if( pgno==0 ){ + return 0; + } + + /* A frame is only valid if a checksum of the WAL header, + ** all prior frams, the first 16 bytes of this frame-header, + ** and the frame-data matches the checksum in the last 8 + ** bytes of this frame-header. + */ + nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN); + walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum); + walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum); + if( aCksum[0]!=sqlite3Get4byte(&aFrame[16]) + || aCksum[1]!=sqlite3Get4byte(&aFrame[20]) + ){ + /* Checksum failed. */ + return 0; + } + + /* If we reach this point, the frame is valid. Return the page number + ** and the new database size. + */ + *piPage = pgno; + *pnTruncate = sqlite3Get4byte(&aFrame[4]); + return 1; +} + + +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) +/* +** Names of locks. This routine is used to provide debugging output and is not +** a part of an ordinary build. +*/ +static const char *walLockName(int lockIdx){ + if( lockIdx==WAL_WRITE_LOCK ){ + return "WRITE-LOCK"; + }else if( lockIdx==WAL_CKPT_LOCK ){ + return "CKPT-LOCK"; + }else if( lockIdx==WAL_RECOVER_LOCK ){ + return "RECOVER-LOCK"; + }else{ + static char zName[15]; + sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]", + lockIdx-WAL_READ_LOCK(0)); + return zName; + } +} +#endif /*defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */ + + +/* +** Set or release locks on the WAL. Locks are either shared or exclusive. +** A lock cannot be moved directly between shared and exclusive - it must go +** through the unlocked state first. +** +** In locking_mode=EXCLUSIVE, all of these routines become no-ops. +*/ +static int walLockShared(Wal *pWal, int lockIdx){ + int rc; + if( pWal->exclusiveMode ) return SQLITE_OK; + rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1, + SQLITE_SHM_LOCK | SQLITE_SHM_SHARED); + WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal, + walLockName(lockIdx), rc ? "failed" : "ok")); + VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); ) + return rc; +} +static void walUnlockShared(Wal *pWal, int lockIdx){ + if( pWal->exclusiveMode ) return; + (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1, + SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED); + WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx))); +} +static int walLockExclusive(Wal *pWal, int lockIdx, int n, int fBlock){ + int rc; + if( pWal->exclusiveMode ) return SQLITE_OK; + if( fBlock ) sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_WAL_BLOCK, 0); + rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n, + SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE); + WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal, + walLockName(lockIdx), n, rc ? "failed" : "ok")); + VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); ) + return rc; +} +static void walUnlockExclusive(Wal *pWal, int lockIdx, int n){ + if( pWal->exclusiveMode ) return; + (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, n, + SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE); + WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal, + walLockName(lockIdx), n)); +} + +/* +** Compute a hash on a page number. The resulting hash value must land +** between 0 and (HASHTABLE_NSLOT-1). The walHashNext() function advances +** the hash to the next value in the event of a collision. +*/ +static int walHash(u32 iPage){ + assert( iPage>0 ); + assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 ); + return (iPage*HASHTABLE_HASH_1) & (HASHTABLE_NSLOT-1); +} +static int walNextHash(int iPriorHash){ + return (iPriorHash+1)&(HASHTABLE_NSLOT-1); +} + +/* +** Return pointers to the hash table and page number array stored on +** page iHash of the wal-index. The wal-index is broken into 32KB pages +** numbered starting from 0. +** +** Set output variable *paHash to point to the start of the hash table +** in the wal-index file. Set *piZero to one less than the frame +** number of the first frame indexed by this hash table. If a +** slot in the hash table is set to N, it refers to frame number +** (*piZero+N) in the log. +** +** Finally, set *paPgno so that *paPgno[1] is the page number of the +** first frame indexed by the hash table, frame (*piZero+1). +*/ +static int walHashGet( + Wal *pWal, /* WAL handle */ + int iHash, /* Find the iHash'th table */ + volatile ht_slot **paHash, /* OUT: Pointer to hash index */ + volatile u32 **paPgno, /* OUT: Pointer to page number array */ + u32 *piZero /* OUT: Frame associated with *paPgno[0] */ +){ + int rc; /* Return code */ + volatile u32 *aPgno; + + rc = walIndexPage(pWal, iHash, &aPgno); + assert( rc==SQLITE_OK || iHash>0 ); + + if( rc==SQLITE_OK ){ + u32 iZero; + volatile ht_slot *aHash; + + aHash = (volatile ht_slot *)&aPgno[HASHTABLE_NPAGE]; + if( iHash==0 ){ + aPgno = &aPgno[WALINDEX_HDR_SIZE/sizeof(u32)]; + iZero = 0; + }else{ + iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE; + } + + *paPgno = &aPgno[-1]; + *paHash = aHash; + *piZero = iZero; + } + return rc; +} + +/* +** Return the number of the wal-index page that contains the hash-table +** and page-number array that contain entries corresponding to WAL frame +** iFrame. The wal-index is broken up into 32KB pages. Wal-index pages +** are numbered starting from 0. +*/ +static int walFramePage(u32 iFrame){ + int iHash = (iFrame+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1) / HASHTABLE_NPAGE; + assert( (iHash==0 || iFrame>HASHTABLE_NPAGE_ONE) + && (iHash>=1 || iFrame<=HASHTABLE_NPAGE_ONE) + && (iHash<=1 || iFrame>(HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE)) + && (iHash>=2 || iFrame<=HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE) + && (iHash<=2 || iFrame>(HASHTABLE_NPAGE_ONE+2*HASHTABLE_NPAGE)) + ); + return iHash; +} + +/* +** Return the page number associated with frame iFrame in this WAL. +*/ +static u32 walFramePgno(Wal *pWal, u32 iFrame){ + int iHash = walFramePage(iFrame); + if( iHash==0 ){ + return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1]; + } + return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE]; +} + +/* +** Remove entries from the hash table that point to WAL slots greater +** than pWal->hdr.mxFrame. +** +** This function is called whenever pWal->hdr.mxFrame is decreased due +** to a rollback or savepoint. +** +** At most only the hash table containing pWal->hdr.mxFrame needs to be +** updated. Any later hash tables will be automatically cleared when +** pWal->hdr.mxFrame advances to the point where those hash tables are +** actually needed. +*/ +static void walCleanupHash(Wal *pWal){ + volatile ht_slot *aHash = 0; /* Pointer to hash table to clear */ + volatile u32 *aPgno = 0; /* Page number array for hash table */ + u32 iZero = 0; /* frame == (aHash[x]+iZero) */ + int iLimit = 0; /* Zero values greater than this */ + int nByte; /* Number of bytes to zero in aPgno[] */ + int i; /* Used to iterate through aHash[] */ + + assert( pWal->writeLock ); + testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 ); + testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE ); + testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 ); + + if( pWal->hdr.mxFrame==0 ) return; + + /* Obtain pointers to the hash-table and page-number array containing + ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed + ** that the page said hash-table and array reside on is already mapped. + */ + assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) ); + assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] ); + walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &aHash, &aPgno, &iZero); + + /* Zero all hash-table entries that correspond to frame numbers greater + ** than pWal->hdr.mxFrame. + */ + iLimit = pWal->hdr.mxFrame - iZero; + assert( iLimit>0 ); + for(i=0; iiLimit ){ + aHash[i] = 0; + } + } + + /* Zero the entries in the aPgno array that correspond to frames with + ** frame numbers greater than pWal->hdr.mxFrame. + */ + nByte = (int)((char *)aHash - (char *)&aPgno[iLimit+1]); + memset((void *)&aPgno[iLimit+1], 0, nByte); + +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + /* Verify that the every entry in the mapping region is still reachable + ** via the hash table even after the cleanup. + */ + if( iLimit ){ + int j; /* Loop counter */ + int iKey; /* Hash key */ + for(j=1; j<=iLimit; j++){ + for(iKey=walHash(aPgno[j]); aHash[iKey]; iKey=walNextHash(iKey)){ + if( aHash[iKey]==j ) break; + } + assert( aHash[iKey]==j ); + } + } +#endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */ +} + + +/* +** Set an entry in the wal-index that will map database page number +** pPage into WAL frame iFrame. +*/ +static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){ + int rc; /* Return code */ + u32 iZero = 0; /* One less than frame number of aPgno[1] */ + volatile u32 *aPgno = 0; /* Page number array */ + volatile ht_slot *aHash = 0; /* Hash table */ + + rc = walHashGet(pWal, walFramePage(iFrame), &aHash, &aPgno, &iZero); + + /* Assuming the wal-index file was successfully mapped, populate the + ** page number array and hash table entry. + */ + if( rc==SQLITE_OK ){ + int iKey; /* Hash table key */ + int idx; /* Value to write to hash-table slot */ + int nCollide; /* Number of hash collisions */ + + idx = iFrame - iZero; + assert( idx <= HASHTABLE_NSLOT/2 + 1 ); + + /* If this is the first entry to be added to this hash-table, zero the + ** entire hash table and aPgno[] array before proceeding. + */ + if( idx==1 ){ + int nByte = (int)((u8 *)&aHash[HASHTABLE_NSLOT] - (u8 *)&aPgno[1]); + memset((void*)&aPgno[1], 0, nByte); + } + + /* If the entry in aPgno[] is already set, then the previous writer + ** must have exited unexpectedly in the middle of a transaction (after + ** writing one or more dirty pages to the WAL to free up memory). + ** Remove the remnants of that writers uncommitted transaction from + ** the hash-table before writing any new entries. + */ + if( aPgno[idx] ){ + walCleanupHash(pWal); + assert( !aPgno[idx] ); + } + + /* Write the aPgno[] array entry and the hash-table slot. */ + nCollide = idx; + for(iKey=walHash(iPage); aHash[iKey]; iKey=walNextHash(iKey)){ + if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT; + } + aPgno[idx] = iPage; + aHash[iKey] = (ht_slot)idx; + +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + /* Verify that the number of entries in the hash table exactly equals + ** the number of entries in the mapping region. + */ + { + int i; /* Loop counter */ + int nEntry = 0; /* Number of entries in the hash table */ + for(i=0; ickptLock==1 || pWal->ckptLock==0 ); + assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 ); + assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE ); + assert( pWal->writeLock ); + iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock; + nLock = SQLITE_SHM_NLOCK - iLock; + rc = walLockExclusive(pWal, iLock, nLock, 0); + if( rc ){ + return rc; + } + WALTRACE(("WAL%p: recovery begin...\n", pWal)); + + memset(&pWal->hdr, 0, sizeof(WalIndexHdr)); + + rc = sqlite3OsFileSize(pWal->pWalFd, &nSize); + if( rc!=SQLITE_OK ){ + goto recovery_error; + } + + if( nSize>WAL_HDRSIZE ){ + u8 aBuf[WAL_HDRSIZE]; /* Buffer to load WAL header into */ + u8 *aFrame = 0; /* Malloc'd buffer to load entire frame */ + int szFrame; /* Number of bytes in buffer aFrame[] */ + u8 *aData; /* Pointer to data part of aFrame buffer */ + int iFrame; /* Index of last frame read */ + i64 iOffset; /* Next offset to read from log file */ + int szPage; /* Page size according to the log */ + u32 magic; /* Magic value read from WAL header */ + u32 version; /* Magic value read from WAL header */ + int isValid; /* True if this frame is valid */ + + /* Read in the WAL header. */ + rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0); + if( rc!=SQLITE_OK ){ + goto recovery_error; + } + + /* If the database page size is not a power of two, or is greater than + ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid + ** data. Similarly, if the 'magic' value is invalid, ignore the whole + ** WAL file. + */ + magic = sqlite3Get4byte(&aBuf[0]); + szPage = sqlite3Get4byte(&aBuf[8]); + if( (magic&0xFFFFFFFE)!=WAL_MAGIC + || szPage&(szPage-1) + || szPage>SQLITE_MAX_PAGE_SIZE + || szPage<512 + ){ + goto finished; + } + pWal->hdr.bigEndCksum = (u8)(magic&0x00000001); + pWal->szPage = szPage; + pWal->nCkpt = sqlite3Get4byte(&aBuf[12]); + memcpy(&pWal->hdr.aSalt, &aBuf[16], 8); + + /* Verify that the WAL header checksum is correct */ + walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN, + aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum + ); + if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24]) + || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28]) + ){ + goto finished; + } + + /* Verify that the version number on the WAL format is one that + ** are able to understand */ + version = sqlite3Get4byte(&aBuf[4]); + if( version!=WAL_MAX_VERSION ){ + rc = SQLITE_CANTOPEN_BKPT; + goto finished; + } + + /* Malloc a buffer to read frames into. */ + szFrame = szPage + WAL_FRAME_HDRSIZE; + aFrame = (u8 *)sqlite3_malloc64(szFrame); + if( !aFrame ){ + rc = SQLITE_NOMEM; + goto recovery_error; + } + aData = &aFrame[WAL_FRAME_HDRSIZE]; + + /* Read all frames from the log file. */ + iFrame = 0; + for(iOffset=WAL_HDRSIZE; (iOffset+szFrame)<=nSize; iOffset+=szFrame){ + u32 pgno; /* Database page number for frame */ + u32 nTruncate; /* dbsize field from frame header */ + + /* Read and decode the next log frame. */ + iFrame++; + rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset); + if( rc!=SQLITE_OK ) break; + isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame); + if( !isValid ) break; + rc = walIndexAppend(pWal, iFrame, pgno); + if( rc!=SQLITE_OK ) break; + + /* If nTruncate is non-zero, this is a commit record. */ + if( nTruncate ){ + pWal->hdr.mxFrame = iFrame; + pWal->hdr.nPage = nTruncate; + pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16)); + testcase( szPage<=32768 ); + testcase( szPage>=65536 ); + aFrameCksum[0] = pWal->hdr.aFrameCksum[0]; + aFrameCksum[1] = pWal->hdr.aFrameCksum[1]; + } + } + + sqlite3_free(aFrame); + } + +finished: + if( rc==SQLITE_OK ){ + volatile WalCkptInfo *pInfo; + int i; + pWal->hdr.aFrameCksum[0] = aFrameCksum[0]; + pWal->hdr.aFrameCksum[1] = aFrameCksum[1]; + walIndexWriteHdr(pWal); + + /* Reset the checkpoint-header. This is safe because this thread is + ** currently holding locks that exclude all other readers, writers and + ** checkpointers. + */ + pInfo = walCkptInfo(pWal); + pInfo->nBackfill = 0; + pInfo->aReadMark[0] = 0; + for(i=1; iaReadMark[i] = READMARK_NOT_USED; + if( pWal->hdr.mxFrame ) pInfo->aReadMark[1] = pWal->hdr.mxFrame; + + /* If more than one frame was recovered from the log file, report an + ** event via sqlite3_log(). This is to help with identifying performance + ** problems caused by applications routinely shutting down without + ** checkpointing the log file. + */ + if( pWal->hdr.nPage ){ + sqlite3_log(SQLITE_NOTICE_RECOVER_WAL, + "recovered %d frames from WAL file %s", + pWal->hdr.mxFrame, pWal->zWalName + ); + } + } + +recovery_error: + WALTRACE(("WAL%p: recovery %s\n", pWal, rc ? "failed" : "ok")); + walUnlockExclusive(pWal, iLock, nLock); + return rc; +} + +/* +** Close an open wal-index. +*/ +static void walIndexClose(Wal *pWal, int isDelete){ + if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){ + int i; + for(i=0; inWiData; i++){ + sqlite3_free((void *)pWal->apWiData[i]); + pWal->apWiData[i] = 0; + } + }else{ + sqlite3OsShmUnmap(pWal->pDbFd, isDelete); + } +} + +/* +** Open a connection to the WAL file zWalName. The database file must +** already be opened on connection pDbFd. The buffer that zWalName points +** to must remain valid for the lifetime of the returned Wal* handle. +** +** A SHARED lock should be held on the database file when this function +** is called. The purpose of this SHARED lock is to prevent any other +** client from unlinking the WAL or wal-index file. If another process +** were to do this just after this client opened one of these files, the +** system would be badly broken. +** +** If the log file is successfully opened, SQLITE_OK is returned and +** *ppWal is set to point to a new WAL handle. If an error occurs, +** an SQLite error code is returned and *ppWal is left unmodified. +*/ +SQLITE_PRIVATE int sqlite3WalOpen( + sqlite3_vfs *pVfs, /* vfs module to open wal and wal-index */ + sqlite3_file *pDbFd, /* The open database file */ + const char *zWalName, /* Name of the WAL file */ + int bNoShm, /* True to run in heap-memory mode */ + i64 mxWalSize, /* Truncate WAL to this size on reset */ + Wal **ppWal /* OUT: Allocated Wal handle */ +){ + int rc; /* Return Code */ + Wal *pRet; /* Object to allocate and return */ + int flags; /* Flags passed to OsOpen() */ + + assert( zWalName && zWalName[0] ); + assert( pDbFd ); + + /* In the amalgamation, the os_unix.c and os_win.c source files come before + ** this source file. Verify that the #defines of the locking byte offsets + ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value. + */ +#ifdef WIN_SHM_BASE + assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET ); +#endif +#ifdef UNIX_SHM_BASE + assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET ); +#endif + + + /* Allocate an instance of struct Wal to return. */ + *ppWal = 0; + pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile); + if( !pRet ){ + return SQLITE_NOMEM; + } + + pRet->pVfs = pVfs; + pRet->pWalFd = (sqlite3_file *)&pRet[1]; + pRet->pDbFd = pDbFd; + pRet->readLock = -1; + pRet->mxWalSize = mxWalSize; + pRet->zWalName = zWalName; + pRet->syncHeader = 1; + pRet->padToSectorBoundary = 1; + pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE); + + /* Open file handle on the write-ahead log file. */ + flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL); + rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags); + if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){ + pRet->readOnly = WAL_RDONLY; + } + + if( rc!=SQLITE_OK ){ + walIndexClose(pRet, 0); + sqlite3OsClose(pRet->pWalFd); + sqlite3_free(pRet); + }else{ + int iDC = sqlite3OsDeviceCharacteristics(pDbFd); + if( iDC & SQLITE_IOCAP_SEQUENTIAL ){ pRet->syncHeader = 0; } + if( iDC & SQLITE_IOCAP_POWERSAFE_OVERWRITE ){ + pRet->padToSectorBoundary = 0; + } + *ppWal = pRet; + WALTRACE(("WAL%d: opened\n", pRet)); + } + return rc; +} + +/* +** Change the size to which the WAL file is trucated on each reset. +*/ +SQLITE_PRIVATE void sqlite3WalLimit(Wal *pWal, i64 iLimit){ + if( pWal ) pWal->mxWalSize = iLimit; +} + +/* +** Find the smallest page number out of all pages held in the WAL that +** has not been returned by any prior invocation of this method on the +** same WalIterator object. Write into *piFrame the frame index where +** that page was last written into the WAL. Write into *piPage the page +** number. +** +** Return 0 on success. If there are no pages in the WAL with a page +** number larger than *piPage, then return 1. +*/ +static int walIteratorNext( + WalIterator *p, /* Iterator */ + u32 *piPage, /* OUT: The page number of the next page */ + u32 *piFrame /* OUT: Wal frame index of next page */ +){ + u32 iMin; /* Result pgno must be greater than iMin */ + u32 iRet = 0xFFFFFFFF; /* 0xffffffff is never a valid page number */ + int i; /* For looping through segments */ + + iMin = p->iPrior; + assert( iMin<0xffffffff ); + for(i=p->nSegment-1; i>=0; i--){ + struct WalSegment *pSegment = &p->aSegment[i]; + while( pSegment->iNextnEntry ){ + u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]]; + if( iPg>iMin ){ + if( iPgiZero + pSegment->aIndex[pSegment->iNext]; + } + break; + } + pSegment->iNext++; + } + } + + *piPage = p->iPrior = iRet; + return (iRet==0xFFFFFFFF); +} + +/* +** This function merges two sorted lists into a single sorted list. +** +** aLeft[] and aRight[] are arrays of indices. The sort key is +** aContent[aLeft[]] and aContent[aRight[]]. Upon entry, the following +** is guaranteed for all J0 && nRight>0 ); + while( iRight=nRight || aContent[aLeft[iLeft]]=nLeft || aContent[aLeft[iLeft]]>dbpage ); + assert( iRight>=nRight || aContent[aRight[iRight]]>dbpage ); + } + + *paRight = aLeft; + *pnRight = iOut; + memcpy(aLeft, aTmp, sizeof(aTmp[0])*iOut); +} + +/* +** Sort the elements in list aList using aContent[] as the sort key. +** Remove elements with duplicate keys, preferring to keep the +** larger aList[] values. +** +** The aList[] entries are indices into aContent[]. The values in +** aList[] are to be sorted so that for all J0 ); + assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) ); + + for(iList=0; iListaList && p->nList<=(1<aList==&aList[iList&~((2<aList, p->nList, &aMerge, &nMerge, aBuffer); + } + aSub[iSub].aList = aMerge; + aSub[iSub].nList = nMerge; + } + + for(iSub++; iSubnList<=(1<aList==&aList[nList&~((2<aList, p->nList, &aMerge, &nMerge, aBuffer); + } + } + assert( aMerge==aList ); + *pnList = nMerge; + +#ifdef SQLITE_DEBUG + { + int i; + for(i=1; i<*pnList; i++){ + assert( aContent[aList[i]] > aContent[aList[i-1]] ); + } + } +#endif +} + +/* +** Free an iterator allocated by walIteratorInit(). +*/ +static void walIteratorFree(WalIterator *p){ + sqlite3_free(p); +} + +/* +** Construct a WalInterator object that can be used to loop over all +** pages in the WAL in ascending order. The caller must hold the checkpoint +** lock. +** +** On success, make *pp point to the newly allocated WalInterator object +** return SQLITE_OK. Otherwise, return an error code. If this routine +** returns an error, the value of *pp is undefined. +** +** The calling routine should invoke walIteratorFree() to destroy the +** WalIterator object when it has finished with it. +*/ +static int walIteratorInit(Wal *pWal, WalIterator **pp){ + WalIterator *p; /* Return value */ + int nSegment; /* Number of segments to merge */ + u32 iLast; /* Last frame in log */ + int nByte; /* Number of bytes to allocate */ + int i; /* Iterator variable */ + ht_slot *aTmp; /* Temp space used by merge-sort */ + int rc = SQLITE_OK; /* Return Code */ + + /* This routine only runs while holding the checkpoint lock. And + ** it only runs if there is actually content in the log (mxFrame>0). + */ + assert( pWal->ckptLock && pWal->hdr.mxFrame>0 ); + iLast = pWal->hdr.mxFrame; + + /* Allocate space for the WalIterator object. */ + nSegment = walFramePage(iLast) + 1; + nByte = sizeof(WalIterator) + + (nSegment-1)*sizeof(struct WalSegment) + + iLast*sizeof(ht_slot); + p = (WalIterator *)sqlite3_malloc64(nByte); + if( !p ){ + return SQLITE_NOMEM; + } + memset(p, 0, nByte); + p->nSegment = nSegment; + + /* Allocate temporary space used by the merge-sort routine. This block + ** of memory will be freed before this function returns. + */ + aTmp = (ht_slot *)sqlite3_malloc64( + sizeof(ht_slot) * (iLast>HASHTABLE_NPAGE?HASHTABLE_NPAGE:iLast) + ); + if( !aTmp ){ + rc = SQLITE_NOMEM; + } + + for(i=0; rc==SQLITE_OK && iaSegment[p->nSegment])[iZero]; + iZero++; + + for(j=0; jaSegment[i].iZero = iZero; + p->aSegment[i].nEntry = nEntry; + p->aSegment[i].aIndex = aIndex; + p->aSegment[i].aPgno = (u32 *)aPgno; + } + } + sqlite3_free(aTmp); + + if( rc!=SQLITE_OK ){ + walIteratorFree(p); + } + *pp = p; + return rc; +} + +/* +** Attempt to obtain the exclusive WAL lock defined by parameters lockIdx and +** n. If the attempt fails and parameter xBusy is not NULL, then it is a +** busy-handler function. Invoke it and retry the lock until either the +** lock is successfully obtained or the busy-handler returns 0. +*/ +static int walBusyLock( + Wal *pWal, /* WAL connection */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int lockIdx, /* Offset of first byte to lock */ + int n /* Number of bytes to lock */ +){ + int rc; + do { + rc = walLockExclusive(pWal, lockIdx, n, 0); + }while( xBusy && rc==SQLITE_BUSY && xBusy(pBusyArg) ); + return rc; +} + +/* +** The cache of the wal-index header must be valid to call this function. +** Return the page-size in bytes used by the database. +*/ +static int walPagesize(Wal *pWal){ + return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16); +} + +/* +** The following is guaranteed when this function is called: +** +** a) the WRITER lock is held, +** b) the entire log file has been checkpointed, and +** c) any existing readers are reading exclusively from the database +** file - there are no readers that may attempt to read a frame from +** the log file. +** +** This function updates the shared-memory structures so that the next +** client to write to the database (which may be this one) does so by +** writing frames into the start of the log file. +** +** The value of parameter salt1 is used as the aSalt[1] value in the +** new wal-index header. It should be passed a pseudo-random value (i.e. +** one obtained from sqlite3_randomness()). +*/ +static void walRestartHdr(Wal *pWal, u32 salt1){ + volatile WalCkptInfo *pInfo = walCkptInfo(pWal); + int i; /* Loop counter */ + u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */ + pWal->nCkpt++; + pWal->hdr.mxFrame = 0; + sqlite3Put4byte((u8*)&aSalt[0], 1 + sqlite3Get4byte((u8*)&aSalt[0])); + memcpy(&pWal->hdr.aSalt[1], &salt1, 4); + walIndexWriteHdr(pWal); + pInfo->nBackfill = 0; + pInfo->aReadMark[1] = 0; + for(i=2; iaReadMark[i] = READMARK_NOT_USED; + assert( pInfo->aReadMark[0]==0 ); +} + +/* +** Copy as much content as we can from the WAL back into the database file +** in response to an sqlite3_wal_checkpoint() request or the equivalent. +** +** The amount of information copies from WAL to database might be limited +** by active readers. This routine will never overwrite a database page +** that a concurrent reader might be using. +** +** All I/O barrier operations (a.k.a fsyncs) occur in this routine when +** SQLite is in WAL-mode in synchronous=NORMAL. That means that if +** checkpoints are always run by a background thread or background +** process, foreground threads will never block on a lengthy fsync call. +** +** Fsync is called on the WAL before writing content out of the WAL and +** into the database. This ensures that if the new content is persistent +** in the WAL and can be recovered following a power-loss or hard reset. +** +** Fsync is also called on the database file if (and only if) the entire +** WAL content is copied into the database file. This second fsync makes +** it safe to delete the WAL since the new content will persist in the +** database file. +** +** This routine uses and updates the nBackfill field of the wal-index header. +** This is the only routine that will increase the value of nBackfill. +** (A WAL reset or recovery will revert nBackfill to zero, but not increase +** its value.) +** +** The caller must be holding sufficient locks to ensure that no other +** checkpoint is running (in any other thread or process) at the same +** time. +*/ +static int walCheckpoint( + Wal *pWal, /* Wal connection */ + int eMode, /* One of PASSIVE, FULL or RESTART */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int sync_flags, /* Flags for OsSync() (or 0) */ + u8 *zBuf /* Temporary buffer to use */ +){ + int rc = SQLITE_OK; /* Return code */ + int szPage; /* Database page-size */ + WalIterator *pIter = 0; /* Wal iterator context */ + u32 iDbpage = 0; /* Next database page to write */ + u32 iFrame = 0; /* Wal frame containing data for iDbpage */ + u32 mxSafeFrame; /* Max frame that can be backfilled */ + u32 mxPage; /* Max database page to write */ + int i; /* Loop counter */ + volatile WalCkptInfo *pInfo; /* The checkpoint status information */ + + szPage = walPagesize(pWal); + testcase( szPage<=32768 ); + testcase( szPage>=65536 ); + pInfo = walCkptInfo(pWal); + if( pInfo->nBackfillhdr.mxFrame ){ + + /* Allocate the iterator */ + rc = walIteratorInit(pWal, &pIter); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( pIter ); + + /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked + ** in the SQLITE_CHECKPOINT_PASSIVE mode. */ + assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 ); + + /* Compute in mxSafeFrame the index of the last frame of the WAL that is + ** safe to write into the database. Frames beyond mxSafeFrame might + ** overwrite database pages that are in use by active readers and thus + ** cannot be backfilled from the WAL. + */ + mxSafeFrame = pWal->hdr.mxFrame; + mxPage = pWal->hdr.nPage; + for(i=1; iaReadMark[i]; + if( mxSafeFrame>y ){ + assert( y<=pWal->hdr.mxFrame ); + rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1); + if( rc==SQLITE_OK ){ + pInfo->aReadMark[i] = (i==1 ? mxSafeFrame : READMARK_NOT_USED); + walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1); + }else if( rc==SQLITE_BUSY ){ + mxSafeFrame = y; + xBusy = 0; + }else{ + goto walcheckpoint_out; + } + } + } + + if( pInfo->nBackfillnBackfill; + + /* Sync the WAL to disk */ + if( sync_flags ){ + rc = sqlite3OsSync(pWal->pWalFd, sync_flags); + } + + /* If the database may grow as a result of this checkpoint, hint + ** about the eventual size of the db file to the VFS layer. + */ + if( rc==SQLITE_OK ){ + i64 nReq = ((i64)mxPage * szPage); + rc = sqlite3OsFileSize(pWal->pDbFd, &nSize); + if( rc==SQLITE_OK && nSizepDbFd, SQLITE_FCNTL_SIZE_HINT, &nReq); + } + } + + + /* Iterate through the contents of the WAL, copying data to the db file */ + while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){ + i64 iOffset; + assert( walFramePgno(pWal, iFrame)==iDbpage ); + if( iFrame<=nBackfill || iFrame>mxSafeFrame || iDbpage>mxPage ){ + continue; + } + iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE; + /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */ + rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset); + if( rc!=SQLITE_OK ) break; + iOffset = (iDbpage-1)*(i64)szPage; + testcase( IS_BIG_INT(iOffset) ); + rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset); + if( rc!=SQLITE_OK ) break; + } + + /* If work was actually accomplished... */ + if( rc==SQLITE_OK ){ + if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){ + i64 szDb = pWal->hdr.nPage*(i64)szPage; + testcase( IS_BIG_INT(szDb) ); + rc = sqlite3OsTruncate(pWal->pDbFd, szDb); + if( rc==SQLITE_OK && sync_flags ){ + rc = sqlite3OsSync(pWal->pDbFd, sync_flags); + } + } + if( rc==SQLITE_OK ){ + pInfo->nBackfill = mxSafeFrame; + } + } + + /* Release the reader lock held while backfilling */ + walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1); + } + + if( rc==SQLITE_BUSY ){ + /* Reset the return code so as not to report a checkpoint failure + ** just because there are active readers. */ + rc = SQLITE_OK; + } + } + + /* If this is an SQLITE_CHECKPOINT_RESTART or TRUNCATE operation, and the + ** entire wal file has been copied into the database file, then block + ** until all readers have finished using the wal file. This ensures that + ** the next process to write to the database restarts the wal file. + */ + if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){ + assert( pWal->writeLock ); + if( pInfo->nBackfillhdr.mxFrame ){ + rc = SQLITE_BUSY; + }else if( eMode>=SQLITE_CHECKPOINT_RESTART ){ + u32 salt1; + sqlite3_randomness(4, &salt1); + assert( pInfo->nBackfill==pWal->hdr.mxFrame ); + rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1); + if( rc==SQLITE_OK ){ + if( eMode==SQLITE_CHECKPOINT_TRUNCATE ){ + /* IMPLEMENTATION-OF: R-44699-57140 This mode works the same way as + ** SQLITE_CHECKPOINT_RESTART with the addition that it also + ** truncates the log file to zero bytes just prior to a + ** successful return. + ** + ** In theory, it might be safe to do this without updating the + ** wal-index header in shared memory, as all subsequent reader or + ** writer clients should see that the entire log file has been + ** checkpointed and behave accordingly. This seems unsafe though, + ** as it would leave the system in a state where the contents of + ** the wal-index header do not match the contents of the + ** file-system. To avoid this, update the wal-index header to + ** indicate that the log file contains zero valid frames. */ + walRestartHdr(pWal, salt1); + rc = sqlite3OsTruncate(pWal->pWalFd, 0); + } + walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1); + } + } + } + + walcheckpoint_out: + walIteratorFree(pIter); + return rc; +} + +/* +** If the WAL file is currently larger than nMax bytes in size, truncate +** it to exactly nMax bytes. If an error occurs while doing so, ignore it. +*/ +static void walLimitSize(Wal *pWal, i64 nMax){ + i64 sz; + int rx; + sqlite3BeginBenignMalloc(); + rx = sqlite3OsFileSize(pWal->pWalFd, &sz); + if( rx==SQLITE_OK && (sz > nMax ) ){ + rx = sqlite3OsTruncate(pWal->pWalFd, nMax); + } + sqlite3EndBenignMalloc(); + if( rx ){ + sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName); + } +} + +/* +** Close a connection to a log file. +*/ +SQLITE_PRIVATE int sqlite3WalClose( + Wal *pWal, /* Wal to close */ + int sync_flags, /* Flags to pass to OsSync() (or 0) */ + int nBuf, + u8 *zBuf /* Buffer of at least nBuf bytes */ +){ + int rc = SQLITE_OK; + if( pWal ){ + int isDelete = 0; /* True to unlink wal and wal-index files */ + + /* If an EXCLUSIVE lock can be obtained on the database file (using the + ** ordinary, rollback-mode locking methods, this guarantees that the + ** connection associated with this log file is the only connection to + ** the database. In this case checkpoint the database and unlink both + ** the wal and wal-index files. + ** + ** The EXCLUSIVE lock is not released before returning. + */ + rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE); + if( rc==SQLITE_OK ){ + if( pWal->exclusiveMode==WAL_NORMAL_MODE ){ + pWal->exclusiveMode = WAL_EXCLUSIVE_MODE; + } + rc = sqlite3WalCheckpoint( + pWal, SQLITE_CHECKPOINT_PASSIVE, 0, 0, sync_flags, nBuf, zBuf, 0, 0 + ); + if( rc==SQLITE_OK ){ + int bPersist = -1; + sqlite3OsFileControlHint( + pWal->pDbFd, SQLITE_FCNTL_PERSIST_WAL, &bPersist + ); + if( bPersist!=1 ){ + /* Try to delete the WAL file if the checkpoint completed and + ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal + ** mode (!bPersist) */ + isDelete = 1; + }else if( pWal->mxWalSize>=0 ){ + /* Try to truncate the WAL file to zero bytes if the checkpoint + ** completed and fsynced (rc==SQLITE_OK) and we are in persistent + ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a + ** non-negative value (pWal->mxWalSize>=0). Note that we truncate + ** to zero bytes as truncating to the journal_size_limit might + ** leave a corrupt WAL file on disk. */ + walLimitSize(pWal, 0); + } + } + } + + walIndexClose(pWal, isDelete); + sqlite3OsClose(pWal->pWalFd); + if( isDelete ){ + sqlite3BeginBenignMalloc(); + sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0); + sqlite3EndBenignMalloc(); + } + WALTRACE(("WAL%p: closed\n", pWal)); + sqlite3_free((void *)pWal->apWiData); + sqlite3_free(pWal); + } + return rc; +} + +/* +** Try to read the wal-index header. Return 0 on success and 1 if +** there is a problem. +** +** The wal-index is in shared memory. Another thread or process might +** be writing the header at the same time this procedure is trying to +** read it, which might result in inconsistency. A dirty read is detected +** by verifying that both copies of the header are the same and also by +** a checksum on the header. +** +** If and only if the read is consistent and the header is different from +** pWal->hdr, then pWal->hdr is updated to the content of the new header +** and *pChanged is set to 1. +** +** If the checksum cannot be verified return non-zero. If the header +** is read successfully and the checksum verified, return zero. +*/ +static int walIndexTryHdr(Wal *pWal, int *pChanged){ + u32 aCksum[2]; /* Checksum on the header content */ + WalIndexHdr h1, h2; /* Two copies of the header content */ + WalIndexHdr volatile *aHdr; /* Header in shared memory */ + + /* The first page of the wal-index must be mapped at this point. */ + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + + /* Read the header. This might happen concurrently with a write to the + ** same area of shared memory on a different CPU in a SMP, + ** meaning it is possible that an inconsistent snapshot is read + ** from the file. If this happens, return non-zero. + ** + ** There are two copies of the header at the beginning of the wal-index. + ** When reading, read [0] first then [1]. Writes are in the reverse order. + ** Memory barriers are used to prevent the compiler or the hardware from + ** reordering the reads and writes. + */ + aHdr = walIndexHdr(pWal); + memcpy(&h1, (void *)&aHdr[0], sizeof(h1)); + walShmBarrier(pWal); + memcpy(&h2, (void *)&aHdr[1], sizeof(h2)); + + if( memcmp(&h1, &h2, sizeof(h1))!=0 ){ + return 1; /* Dirty read */ + } + if( h1.isInit==0 ){ + return 1; /* Malformed header - probably all zeros */ + } + walChecksumBytes(1, (u8*)&h1, sizeof(h1)-sizeof(h1.aCksum), 0, aCksum); + if( aCksum[0]!=h1.aCksum[0] || aCksum[1]!=h1.aCksum[1] ){ + return 1; /* Checksum does not match */ + } + + if( memcmp(&pWal->hdr, &h1, sizeof(WalIndexHdr)) ){ + *pChanged = 1; + memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr)); + pWal->szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16); + testcase( pWal->szPage<=32768 ); + testcase( pWal->szPage>=65536 ); + } + + /* The header was successfully read. Return zero. */ + return 0; +} + +/* +** Read the wal-index header from the wal-index and into pWal->hdr. +** If the wal-header appears to be corrupt, try to reconstruct the +** wal-index from the WAL before returning. +** +** Set *pChanged to 1 if the wal-index header value in pWal->hdr is +** changed by this operation. If pWal->hdr is unchanged, set *pChanged +** to 0. +** +** If the wal-index header is successfully read, return SQLITE_OK. +** Otherwise an SQLite error code. +*/ +static int walIndexReadHdr(Wal *pWal, int *pChanged){ + int rc; /* Return code */ + int badHdr; /* True if a header read failed */ + volatile u32 *page0; /* Chunk of wal-index containing header */ + + /* Ensure that page 0 of the wal-index (the page that contains the + ** wal-index header) is mapped. Return early if an error occurs here. + */ + assert( pChanged ); + rc = walIndexPage(pWal, 0, &page0); + if( rc!=SQLITE_OK ){ + return rc; + }; + assert( page0 || pWal->writeLock==0 ); + + /* If the first page of the wal-index has been mapped, try to read the + ** wal-index header immediately, without holding any lock. This usually + ** works, but may fail if the wal-index header is corrupt or currently + ** being modified by another thread or process. + */ + badHdr = (page0 ? walIndexTryHdr(pWal, pChanged) : 1); + + /* If the first attempt failed, it might have been due to a race + ** with a writer. So get a WRITE lock and try again. + */ + assert( badHdr==0 || pWal->writeLock==0 ); + if( badHdr ){ + if( pWal->readOnly & WAL_SHM_RDONLY ){ + if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){ + walUnlockShared(pWal, WAL_WRITE_LOCK); + rc = SQLITE_READONLY_RECOVERY; + } + }else if( SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1, 1)) ){ + pWal->writeLock = 1; + if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){ + badHdr = walIndexTryHdr(pWal, pChanged); + if( badHdr ){ + /* If the wal-index header is still malformed even while holding + ** a WRITE lock, it can only mean that the header is corrupted and + ** needs to be reconstructed. So run recovery to do exactly that. + */ + rc = walIndexRecover(pWal); + *pChanged = 1; + } + } + pWal->writeLock = 0; + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + } + } + + /* If the header is read successfully, check the version number to make + ** sure the wal-index was not constructed with some future format that + ** this version of SQLite cannot understand. + */ + if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){ + rc = SQLITE_CANTOPEN_BKPT; + } + + return rc; +} + +/* +** This is the value that walTryBeginRead returns when it needs to +** be retried. +*/ +#define WAL_RETRY (-1) + +/* +** Attempt to start a read transaction. This might fail due to a race or +** other transient condition. When that happens, it returns WAL_RETRY to +** indicate to the caller that it is safe to retry immediately. +** +** On success return SQLITE_OK. On a permanent failure (such an +** I/O error or an SQLITE_BUSY because another process is running +** recovery) return a positive error code. +** +** The useWal parameter is true to force the use of the WAL and disable +** the case where the WAL is bypassed because it has been completely +** checkpointed. If useWal==0 then this routine calls walIndexReadHdr() +** to make a copy of the wal-index header into pWal->hdr. If the +** wal-index header has changed, *pChanged is set to 1 (as an indication +** to the caller that the local paget cache is obsolete and needs to be +** flushed.) When useWal==1, the wal-index header is assumed to already +** be loaded and the pChanged parameter is unused. +** +** The caller must set the cnt parameter to the number of prior calls to +** this routine during the current read attempt that returned WAL_RETRY. +** This routine will start taking more aggressive measures to clear the +** race conditions after multiple WAL_RETRY returns, and after an excessive +** number of errors will ultimately return SQLITE_PROTOCOL. The +** SQLITE_PROTOCOL return indicates that some other process has gone rogue +** and is not honoring the locking protocol. There is a vanishingly small +** chance that SQLITE_PROTOCOL could be returned because of a run of really +** bad luck when there is lots of contention for the wal-index, but that +** possibility is so small that it can be safely neglected, we believe. +** +** On success, this routine obtains a read lock on +** WAL_READ_LOCK(pWal->readLock). The pWal->readLock integer is +** in the range 0 <= pWal->readLock < WAL_NREADER. If pWal->readLock==(-1) +** that means the Wal does not hold any read lock. The reader must not +** access any database page that is modified by a WAL frame up to and +** including frame number aReadMark[pWal->readLock]. The reader will +** use WAL frames up to and including pWal->hdr.mxFrame if pWal->readLock>0 +** Or if pWal->readLock==0, then the reader will ignore the WAL +** completely and get all content directly from the database file. +** If the useWal parameter is 1 then the WAL will never be ignored and +** this routine will always set pWal->readLock>0 on success. +** When the read transaction is completed, the caller must release the +** lock on WAL_READ_LOCK(pWal->readLock) and set pWal->readLock to -1. +** +** This routine uses the nBackfill and aReadMark[] fields of the header +** to select a particular WAL_READ_LOCK() that strives to let the +** checkpoint process do as much work as possible. This routine might +** update values of the aReadMark[] array in the header, but if it does +** so it takes care to hold an exclusive lock on the corresponding +** WAL_READ_LOCK() while changing values. +*/ +static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int cnt){ + volatile WalCkptInfo *pInfo; /* Checkpoint information in wal-index */ + u32 mxReadMark; /* Largest aReadMark[] value */ + int mxI; /* Index of largest aReadMark[] value */ + int i; /* Loop counter */ + int rc = SQLITE_OK; /* Return code */ + + assert( pWal->readLock<0 ); /* Not currently locked */ + + /* Take steps to avoid spinning forever if there is a protocol error. + ** + ** Circumstances that cause a RETRY should only last for the briefest + ** instances of time. No I/O or other system calls are done while the + ** locks are held, so the locks should not be held for very long. But + ** if we are unlucky, another process that is holding a lock might get + ** paged out or take a page-fault that is time-consuming to resolve, + ** during the few nanoseconds that it is holding the lock. In that case, + ** it might take longer than normal for the lock to free. + ** + ** After 5 RETRYs, we begin calling sqlite3OsSleep(). The first few + ** calls to sqlite3OsSleep() have a delay of 1 microsecond. Really this + ** is more of a scheduler yield than an actual delay. But on the 10th + ** an subsequent retries, the delays start becoming longer and longer, + ** so that on the 100th (and last) RETRY we delay for 323 milliseconds. + ** The total delay time before giving up is less than 10 seconds. + */ + if( cnt>5 ){ + int nDelay = 1; /* Pause time in microseconds */ + if( cnt>100 ){ + VVA_ONLY( pWal->lockError = 1; ) + return SQLITE_PROTOCOL; + } + if( cnt>=10 ) nDelay = (cnt-9)*(cnt-9)*39; + sqlite3OsSleep(pWal->pVfs, nDelay); + } + + if( !useWal ){ + rc = walIndexReadHdr(pWal, pChanged); + if( rc==SQLITE_BUSY ){ + /* If there is not a recovery running in another thread or process + ** then convert BUSY errors to WAL_RETRY. If recovery is known to + ** be running, convert BUSY to BUSY_RECOVERY. There is a race here + ** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY + ** would be technically correct. But the race is benign since with + ** WAL_RETRY this routine will be called again and will probably be + ** right on the second iteration. + */ + if( pWal->apWiData[0]==0 ){ + /* This branch is taken when the xShmMap() method returns SQLITE_BUSY. + ** We assume this is a transient condition, so return WAL_RETRY. The + ** xShmMap() implementation used by the default unix and win32 VFS + ** modules may return SQLITE_BUSY due to a race condition in the + ** code that determines whether or not the shared-memory region + ** must be zeroed before the requested page is returned. + */ + rc = WAL_RETRY; + }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){ + walUnlockShared(pWal, WAL_RECOVER_LOCK); + rc = WAL_RETRY; + }else if( rc==SQLITE_BUSY ){ + rc = SQLITE_BUSY_RECOVERY; + } + } + if( rc!=SQLITE_OK ){ + return rc; + } + } + + pInfo = walCkptInfo(pWal); + if( !useWal && pInfo->nBackfill==pWal->hdr.mxFrame ){ + /* The WAL has been completely backfilled (or it is empty). + ** and can be safely ignored. + */ + rc = walLockShared(pWal, WAL_READ_LOCK(0)); + walShmBarrier(pWal); + if( rc==SQLITE_OK ){ + if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) ){ + /* It is not safe to allow the reader to continue here if frames + ** may have been appended to the log before READ_LOCK(0) was obtained. + ** When holding READ_LOCK(0), the reader ignores the entire log file, + ** which implies that the database file contains a trustworthy + ** snapshot. Since holding READ_LOCK(0) prevents a checkpoint from + ** happening, this is usually correct. + ** + ** However, if frames have been appended to the log (or if the log + ** is wrapped and written for that matter) before the READ_LOCK(0) + ** is obtained, that is not necessarily true. A checkpointer may + ** have started to backfill the appended frames but crashed before + ** it finished. Leaving a corrupt image in the database file. + */ + walUnlockShared(pWal, WAL_READ_LOCK(0)); + return WAL_RETRY; + } + pWal->readLock = 0; + return SQLITE_OK; + }else if( rc!=SQLITE_BUSY ){ + return rc; + } + } + + /* If we get this far, it means that the reader will want to use + ** the WAL to get at content from recent commits. The job now is + ** to select one of the aReadMark[] entries that is closest to + ** but not exceeding pWal->hdr.mxFrame and lock that entry. + */ + mxReadMark = 0; + mxI = 0; + for(i=1; iaReadMark[i]; + if( mxReadMark<=thisMark && thisMark<=pWal->hdr.mxFrame ){ + assert( thisMark!=READMARK_NOT_USED ); + mxReadMark = thisMark; + mxI = i; + } + } + /* There was once an "if" here. The extra "{" is to preserve indentation. */ + { + if( (pWal->readOnly & WAL_SHM_RDONLY)==0 + && (mxReadMarkhdr.mxFrame || mxI==0) + ){ + for(i=1; iaReadMark[i] = pWal->hdr.mxFrame; + mxI = i; + walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1); + break; + }else if( rc!=SQLITE_BUSY ){ + return rc; + } + } + } + if( mxI==0 ){ + assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 ); + return rc==SQLITE_BUSY ? WAL_RETRY : SQLITE_READONLY_CANTLOCK; + } + + rc = walLockShared(pWal, WAL_READ_LOCK(mxI)); + if( rc ){ + return rc==SQLITE_BUSY ? WAL_RETRY : rc; + } + /* Now that the read-lock has been obtained, check that neither the + ** value in the aReadMark[] array or the contents of the wal-index + ** header have changed. + ** + ** It is necessary to check that the wal-index header did not change + ** between the time it was read and when the shared-lock was obtained + ** on WAL_READ_LOCK(mxI) was obtained to account for the possibility + ** that the log file may have been wrapped by a writer, or that frames + ** that occur later in the log than pWal->hdr.mxFrame may have been + ** copied into the database by a checkpointer. If either of these things + ** happened, then reading the database with the current value of + ** pWal->hdr.mxFrame risks reading a corrupted snapshot. So, retry + ** instead. + ** + ** Before checking that the live wal-index header has not changed + ** since it was read, set Wal.minFrame to the first frame in the wal + ** file that has not yet been checkpointed. This client will not need + ** to read any frames earlier than minFrame from the wal file - they + ** can be safely read directly from the database file. + ** + ** Because a ShmBarrier() call is made between taking the copy of + ** nBackfill and checking that the wal-header in shared-memory still + ** matches the one cached in pWal->hdr, it is guaranteed that the + ** checkpointer that set nBackfill was not working with a wal-index + ** header newer than that cached in pWal->hdr. If it were, that could + ** cause a problem. The checkpointer could omit to checkpoint + ** a version of page X that lies before pWal->minFrame (call that version + ** A) on the basis that there is a newer version (version B) of the same + ** page later in the wal file. But if version B happens to like past + ** frame pWal->hdr.mxFrame - then the client would incorrectly assume + ** that it can read version A from the database file. However, since + ** we can guarantee that the checkpointer that set nBackfill could not + ** see any pages past pWal->hdr.mxFrame, this problem does not come up. + */ + pWal->minFrame = pInfo->nBackfill+1; + walShmBarrier(pWal); + if( pInfo->aReadMark[mxI]!=mxReadMark + || memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) + ){ + walUnlockShared(pWal, WAL_READ_LOCK(mxI)); + return WAL_RETRY; + }else{ + assert( mxReadMark<=pWal->hdr.mxFrame ); + pWal->readLock = (i16)mxI; + } + } + return rc; +} + +/* +** Begin a read transaction on the database. +** +** This routine used to be called sqlite3OpenSnapshot() and with good reason: +** it takes a snapshot of the state of the WAL and wal-index for the current +** instant in time. The current thread will continue to use this snapshot. +** Other threads might append new content to the WAL and wal-index but +** that extra content is ignored by the current thread. +** +** If the database contents have changes since the previous read +** transaction, then *pChanged is set to 1 before returning. The +** Pager layer will use this to know that is cache is stale and +** needs to be flushed. +*/ +SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *pChanged){ + int rc; /* Return code */ + int cnt = 0; /* Number of TryBeginRead attempts */ + + do{ + rc = walTryBeginRead(pWal, pChanged, 0, ++cnt); + }while( rc==WAL_RETRY ); + testcase( (rc&0xff)==SQLITE_BUSY ); + testcase( (rc&0xff)==SQLITE_IOERR ); + testcase( rc==SQLITE_PROTOCOL ); + testcase( rc==SQLITE_OK ); + return rc; +} + +/* +** Finish with a read transaction. All this does is release the +** read-lock. +*/ +SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal){ + sqlite3WalEndWriteTransaction(pWal); + if( pWal->readLock>=0 ){ + walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock)); + pWal->readLock = -1; + } +} + +/* +** Search the wal file for page pgno. If found, set *piRead to the frame that +** contains the page. Otherwise, if pgno is not in the wal file, set *piRead +** to zero. +** +** Return SQLITE_OK if successful, or an error code if an error occurs. If an +** error does occur, the final value of *piRead is undefined. +*/ +SQLITE_PRIVATE int sqlite3WalFindFrame( + Wal *pWal, /* WAL handle */ + Pgno pgno, /* Database page number to read data for */ + u32 *piRead /* OUT: Frame number (or zero) */ +){ + u32 iRead = 0; /* If !=0, WAL frame to return data from */ + u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */ + int iHash; /* Used to loop through N hash tables */ + int iMinHash; + + /* This routine is only be called from within a read transaction. */ + assert( pWal->readLock>=0 || pWal->lockError ); + + /* If the "last page" field of the wal-index header snapshot is 0, then + ** no data will be read from the wal under any circumstances. Return early + ** in this case as an optimization. Likewise, if pWal->readLock==0, + ** then the WAL is ignored by the reader so return early, as if the + ** WAL were empty. + */ + if( iLast==0 || pWal->readLock==0 ){ + *piRead = 0; + return SQLITE_OK; + } + + /* Search the hash table or tables for an entry matching page number + ** pgno. Each iteration of the following for() loop searches one + ** hash table (each hash table indexes up to HASHTABLE_NPAGE frames). + ** + ** This code might run concurrently to the code in walIndexAppend() + ** that adds entries to the wal-index (and possibly to this hash + ** table). This means the value just read from the hash + ** slot (aHash[iKey]) may have been added before or after the + ** current read transaction was opened. Values added after the + ** read transaction was opened may have been written incorrectly - + ** i.e. these slots may contain garbage data. However, we assume + ** that any slots written before the current read transaction was + ** opened remain unmodified. + ** + ** For the reasons above, the if(...) condition featured in the inner + ** loop of the following block is more stringent that would be required + ** if we had exclusive access to the hash-table: + ** + ** (aPgno[iFrame]==pgno): + ** This condition filters out normal hash-table collisions. + ** + ** (iFrame<=iLast): + ** This condition filters out entries that were added to the hash + ** table after the current read-transaction had started. + */ + iMinHash = walFramePage(pWal->minFrame); + for(iHash=walFramePage(iLast); iHash>=iMinHash && iRead==0; iHash--){ + volatile ht_slot *aHash; /* Pointer to hash table */ + volatile u32 *aPgno; /* Pointer to array of page numbers */ + u32 iZero; /* Frame number corresponding to aPgno[0] */ + int iKey; /* Hash slot index */ + int nCollide; /* Number of hash collisions remaining */ + int rc; /* Error code */ + + rc = walHashGet(pWal, iHash, &aHash, &aPgno, &iZero); + if( rc!=SQLITE_OK ){ + return rc; + } + nCollide = HASHTABLE_NSLOT; + for(iKey=walHash(pgno); aHash[iKey]; iKey=walNextHash(iKey)){ + u32 iFrame = aHash[iKey] + iZero; + if( iFrame<=iLast && iFrame>=pWal->minFrame && aPgno[aHash[iKey]]==pgno ){ + assert( iFrame>iRead || CORRUPT_DB ); + iRead = iFrame; + } + if( (nCollide--)==0 ){ + return SQLITE_CORRUPT_BKPT; + } + } + } + +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + /* If expensive assert() statements are available, do a linear search + ** of the wal-index file content. Make sure the results agree with the + ** result obtained using the hash indexes above. */ + { + u32 iRead2 = 0; + u32 iTest; + assert( pWal->minFrame>0 ); + for(iTest=iLast; iTest>=pWal->minFrame; iTest--){ + if( walFramePgno(pWal, iTest)==pgno ){ + iRead2 = iTest; + break; + } + } + assert( iRead==iRead2 ); + } +#endif + + *piRead = iRead; + return SQLITE_OK; +} + +/* +** Read the contents of frame iRead from the wal file into buffer pOut +** (which is nOut bytes in size). Return SQLITE_OK if successful, or an +** error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3WalReadFrame( + Wal *pWal, /* WAL handle */ + u32 iRead, /* Frame to read */ + int nOut, /* Size of buffer pOut in bytes */ + u8 *pOut /* Buffer to write page data to */ +){ + int sz; + i64 iOffset; + sz = pWal->hdr.szPage; + sz = (sz&0xfe00) + ((sz&0x0001)<<16); + testcase( sz<=32768 ); + testcase( sz>=65536 ); + iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE; + /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */ + return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset); +} + +/* +** Return the size of the database in pages (or zero, if unknown). +*/ +SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal){ + if( pWal && ALWAYS(pWal->readLock>=0) ){ + return pWal->hdr.nPage; + } + return 0; +} + + +/* +** This function starts a write transaction on the WAL. +** +** A read transaction must have already been started by a prior call +** to sqlite3WalBeginReadTransaction(). +** +** If another thread or process has written into the database since +** the read transaction was started, then it is not possible for this +** thread to write as doing so would cause a fork. So this routine +** returns SQLITE_BUSY in that case and no write transaction is started. +** +** There can only be a single writer active at a time. +*/ +SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal){ + int rc; + + /* Cannot start a write transaction without first holding a read + ** transaction. */ + assert( pWal->readLock>=0 ); + + if( pWal->readOnly ){ + return SQLITE_READONLY; + } + + /* Only one writer allowed at a time. Get the write lock. Return + ** SQLITE_BUSY if unable. + */ + rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1, 0); + if( rc ){ + return rc; + } + pWal->writeLock = 1; + + /* If another connection has written to the database file since the + ** time the read transaction on this connection was started, then + ** the write is disallowed. + */ + if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){ + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + pWal->writeLock = 0; + rc = SQLITE_BUSY_SNAPSHOT; + } + + return rc; +} + +/* +** End a write transaction. The commit has already been done. This +** routine merely releases the lock. +*/ +SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal){ + if( pWal->writeLock ){ + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + pWal->writeLock = 0; + pWal->truncateOnCommit = 0; + } + return SQLITE_OK; +} + +/* +** If any data has been written (but not committed) to the log file, this +** function moves the write-pointer back to the start of the transaction. +** +** Additionally, the callback function is invoked for each frame written +** to the WAL since the start of the transaction. If the callback returns +** other than SQLITE_OK, it is not invoked again and the error code is +** returned to the caller. +** +** Otherwise, if the callback function does not return an error, this +** function returns SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){ + int rc = SQLITE_OK; + if( ALWAYS(pWal->writeLock) ){ + Pgno iMax = pWal->hdr.mxFrame; + Pgno iFrame; + + /* Restore the clients cache of the wal-index header to the state it + ** was in before the client began writing to the database. + */ + memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr)); + + for(iFrame=pWal->hdr.mxFrame+1; + ALWAYS(rc==SQLITE_OK) && iFrame<=iMax; + iFrame++ + ){ + /* This call cannot fail. Unless the page for which the page number + ** is passed as the second argument is (a) in the cache and + ** (b) has an outstanding reference, then xUndo is either a no-op + ** (if (a) is false) or simply expels the page from the cache (if (b) + ** is false). + ** + ** If the upper layer is doing a rollback, it is guaranteed that there + ** are no outstanding references to any page other than page 1. And + ** page 1 is never written to the log until the transaction is + ** committed. As a result, the call to xUndo may not fail. + */ + assert( walFramePgno(pWal, iFrame)!=1 ); + rc = xUndo(pUndoCtx, walFramePgno(pWal, iFrame)); + } + if( iMax!=pWal->hdr.mxFrame ) walCleanupHash(pWal); + } + return rc; +} + +/* +** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32 +** values. This function populates the array with values required to +** "rollback" the write position of the WAL handle back to the current +** point in the event of a savepoint rollback (via WalSavepointUndo()). +*/ +SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){ + assert( pWal->writeLock ); + aWalData[0] = pWal->hdr.mxFrame; + aWalData[1] = pWal->hdr.aFrameCksum[0]; + aWalData[2] = pWal->hdr.aFrameCksum[1]; + aWalData[3] = pWal->nCkpt; +} + +/* +** Move the write position of the WAL back to the point identified by +** the values in the aWalData[] array. aWalData must point to an array +** of WAL_SAVEPOINT_NDATA u32 values that has been previously populated +** by a call to WalSavepoint(). +*/ +SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){ + int rc = SQLITE_OK; + + assert( pWal->writeLock ); + assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame ); + + if( aWalData[3]!=pWal->nCkpt ){ + /* This savepoint was opened immediately after the write-transaction + ** was started. Right after that, the writer decided to wrap around + ** to the start of the log. Update the savepoint values to match. + */ + aWalData[0] = 0; + aWalData[3] = pWal->nCkpt; + } + + if( aWalData[0]hdr.mxFrame ){ + pWal->hdr.mxFrame = aWalData[0]; + pWal->hdr.aFrameCksum[0] = aWalData[1]; + pWal->hdr.aFrameCksum[1] = aWalData[2]; + walCleanupHash(pWal); + } + + return rc; +} + +/* +** This function is called just before writing a set of frames to the log +** file (see sqlite3WalFrames()). It checks to see if, instead of appending +** to the current log file, it is possible to overwrite the start of the +** existing log file with the new frames (i.e. "reset" the log). If so, +** it sets pWal->hdr.mxFrame to 0. Otherwise, pWal->hdr.mxFrame is left +** unchanged. +** +** SQLITE_OK is returned if no error is encountered (regardless of whether +** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned +** if an error occurs. +*/ +static int walRestartLog(Wal *pWal){ + int rc = SQLITE_OK; + int cnt; + + if( pWal->readLock==0 ){ + volatile WalCkptInfo *pInfo = walCkptInfo(pWal); + assert( pInfo->nBackfill==pWal->hdr.mxFrame ); + if( pInfo->nBackfill>0 ){ + u32 salt1; + sqlite3_randomness(4, &salt1); + rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1, 0); + if( rc==SQLITE_OK ){ + /* If all readers are using WAL_READ_LOCK(0) (in other words if no + ** readers are currently using the WAL), then the transactions + ** frames will overwrite the start of the existing log. Update the + ** wal-index header to reflect this. + ** + ** In theory it would be Ok to update the cache of the header only + ** at this point. But updating the actual wal-index header is also + ** safe and means there is no special case for sqlite3WalUndo() + ** to handle if this transaction is rolled back. */ + walRestartHdr(pWal, salt1); + walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1); + }else if( rc!=SQLITE_BUSY ){ + return rc; + } + } + walUnlockShared(pWal, WAL_READ_LOCK(0)); + pWal->readLock = -1; + cnt = 0; + do{ + int notUsed; + rc = walTryBeginRead(pWal, ¬Used, 1, ++cnt); + }while( rc==WAL_RETRY ); + assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */ + testcase( (rc&0xff)==SQLITE_IOERR ); + testcase( rc==SQLITE_PROTOCOL ); + testcase( rc==SQLITE_OK ); + } + return rc; +} + +/* +** Information about the current state of the WAL file and where +** the next fsync should occur - passed from sqlite3WalFrames() into +** walWriteToLog(). +*/ +typedef struct WalWriter { + Wal *pWal; /* The complete WAL information */ + sqlite3_file *pFd; /* The WAL file to which we write */ + sqlite3_int64 iSyncPoint; /* Fsync at this offset */ + int syncFlags; /* Flags for the fsync */ + int szPage; /* Size of one page */ +} WalWriter; + +/* +** Write iAmt bytes of content into the WAL file beginning at iOffset. +** Do a sync when crossing the p->iSyncPoint boundary. +** +** In other words, if iSyncPoint is in between iOffset and iOffset+iAmt, +** first write the part before iSyncPoint, then sync, then write the +** rest. +*/ +static int walWriteToLog( + WalWriter *p, /* WAL to write to */ + void *pContent, /* Content to be written */ + int iAmt, /* Number of bytes to write */ + sqlite3_int64 iOffset /* Start writing at this offset */ +){ + int rc; + if( iOffsetiSyncPoint && iOffset+iAmt>=p->iSyncPoint ){ + int iFirstAmt = (int)(p->iSyncPoint - iOffset); + rc = sqlite3OsWrite(p->pFd, pContent, iFirstAmt, iOffset); + if( rc ) return rc; + iOffset += iFirstAmt; + iAmt -= iFirstAmt; + pContent = (void*)(iFirstAmt + (char*)pContent); + assert( p->syncFlags & (SQLITE_SYNC_NORMAL|SQLITE_SYNC_FULL) ); + rc = sqlite3OsSync(p->pFd, p->syncFlags & SQLITE_SYNC_MASK); + if( iAmt==0 || rc ) return rc; + } + rc = sqlite3OsWrite(p->pFd, pContent, iAmt, iOffset); + return rc; +} + +/* +** Write out a single frame of the WAL +*/ +static int walWriteOneFrame( + WalWriter *p, /* Where to write the frame */ + PgHdr *pPage, /* The page of the frame to be written */ + int nTruncate, /* The commit flag. Usually 0. >0 for commit */ + sqlite3_int64 iOffset /* Byte offset at which to write */ +){ + int rc; /* Result code from subfunctions */ + void *pData; /* Data actually written */ + u8 aFrame[WAL_FRAME_HDRSIZE]; /* Buffer to assemble frame-header in */ +#if defined(SQLITE_HAS_CODEC) + if( (pData = sqlite3PagerCodec(pPage))==0 ) return SQLITE_NOMEM; +#else + pData = pPage->pData; +#endif + walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame); + rc = walWriteToLog(p, aFrame, sizeof(aFrame), iOffset); + if( rc ) return rc; + /* Write the page data */ + rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame)); + return rc; +} + +/* +** Write a set of frames to the log. The caller must hold the write-lock +** on the log file (obtained using sqlite3WalBeginWriteTransaction()). +*/ +SQLITE_PRIVATE int sqlite3WalFrames( + Wal *pWal, /* Wal handle to write to */ + int szPage, /* Database page-size in bytes */ + PgHdr *pList, /* List of dirty pages to write */ + Pgno nTruncate, /* Database size after this commit */ + int isCommit, /* True if this is a commit */ + int sync_flags /* Flags to pass to OsSync() (or 0) */ +){ + int rc; /* Used to catch return codes */ + u32 iFrame; /* Next frame address */ + PgHdr *p; /* Iterator to run through pList with. */ + PgHdr *pLast = 0; /* Last frame in list */ + int nExtra = 0; /* Number of extra copies of last page */ + int szFrame; /* The size of a single frame */ + i64 iOffset; /* Next byte to write in WAL file */ + WalWriter w; /* The writer */ + + assert( pList ); + assert( pWal->writeLock ); + + /* If this frame set completes a transaction, then nTruncate>0. If + ** nTruncate==0 then this frame set does not complete the transaction. */ + assert( (isCommit!=0)==(nTruncate!=0) ); + +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) + { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){} + WALTRACE(("WAL%p: frame write begin. %d frames. mxFrame=%d. %s\n", + pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill")); + } +#endif + + /* See if it is possible to write these frames into the start of the + ** log file, instead of appending to it at pWal->hdr.mxFrame. + */ + if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){ + return rc; + } + + /* If this is the first frame written into the log, write the WAL + ** header to the start of the WAL file. See comments at the top of + ** this source file for a description of the WAL header format. + */ + iFrame = pWal->hdr.mxFrame; + if( iFrame==0 ){ + u8 aWalHdr[WAL_HDRSIZE]; /* Buffer to assemble wal-header in */ + u32 aCksum[2]; /* Checksum for wal-header */ + + sqlite3Put4byte(&aWalHdr[0], (WAL_MAGIC | SQLITE_BIGENDIAN)); + sqlite3Put4byte(&aWalHdr[4], WAL_MAX_VERSION); + sqlite3Put4byte(&aWalHdr[8], szPage); + sqlite3Put4byte(&aWalHdr[12], pWal->nCkpt); + if( pWal->nCkpt==0 ) sqlite3_randomness(8, pWal->hdr.aSalt); + memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8); + walChecksumBytes(1, aWalHdr, WAL_HDRSIZE-2*4, 0, aCksum); + sqlite3Put4byte(&aWalHdr[24], aCksum[0]); + sqlite3Put4byte(&aWalHdr[28], aCksum[1]); + + pWal->szPage = szPage; + pWal->hdr.bigEndCksum = SQLITE_BIGENDIAN; + pWal->hdr.aFrameCksum[0] = aCksum[0]; + pWal->hdr.aFrameCksum[1] = aCksum[1]; + pWal->truncateOnCommit = 1; + + rc = sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0); + WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok")); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Sync the header (unless SQLITE_IOCAP_SEQUENTIAL is true or unless + ** all syncing is turned off by PRAGMA synchronous=OFF). Otherwise + ** an out-of-order write following a WAL restart could result in + ** database corruption. See the ticket: + ** + ** http://localhost:591/sqlite/info/ff5be73dee + */ + if( pWal->syncHeader && sync_flags ){ + rc = sqlite3OsSync(pWal->pWalFd, sync_flags & SQLITE_SYNC_MASK); + if( rc ) return rc; + } + } + assert( (int)pWal->szPage==szPage ); + + /* Setup information needed to write frames into the WAL */ + w.pWal = pWal; + w.pFd = pWal->pWalFd; + w.iSyncPoint = 0; + w.syncFlags = sync_flags; + w.szPage = szPage; + iOffset = walFrameOffset(iFrame+1, szPage); + szFrame = szPage + WAL_FRAME_HDRSIZE; + + /* Write all frames into the log file exactly once */ + for(p=pList; p; p=p->pDirty){ + int nDbSize; /* 0 normally. Positive == commit flag */ + iFrame++; + assert( iOffset==walFrameOffset(iFrame, szPage) ); + nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0; + rc = walWriteOneFrame(&w, p, nDbSize, iOffset); + if( rc ) return rc; + pLast = p; + iOffset += szFrame; + } + + /* If this is the end of a transaction, then we might need to pad + ** the transaction and/or sync the WAL file. + ** + ** Padding and syncing only occur if this set of frames complete a + ** transaction and if PRAGMA synchronous=FULL. If synchronous==NORMAL + ** or synchronous==OFF, then no padding or syncing are needed. + ** + ** If SQLITE_IOCAP_POWERSAFE_OVERWRITE is defined, then padding is not + ** needed and only the sync is done. If padding is needed, then the + ** final frame is repeated (with its commit mark) until the next sector + ** boundary is crossed. Only the part of the WAL prior to the last + ** sector boundary is synced; the part of the last frame that extends + ** past the sector boundary is written after the sync. + */ + if( isCommit && (sync_flags & WAL_SYNC_TRANSACTIONS)!=0 ){ + if( pWal->padToSectorBoundary ){ + int sectorSize = sqlite3SectorSize(pWal->pWalFd); + w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize; + while( iOffsettruncateOnCommit && pWal->mxWalSize>=0 ){ + i64 sz = pWal->mxWalSize; + if( walFrameOffset(iFrame+nExtra+1, szPage)>pWal->mxWalSize ){ + sz = walFrameOffset(iFrame+nExtra+1, szPage); + } + walLimitSize(pWal, sz); + pWal->truncateOnCommit = 0; + } + + /* Append data to the wal-index. It is not necessary to lock the + ** wal-index to do this as the SQLITE_SHM_WRITE lock held on the wal-index + ** guarantees that there are no other writers, and no data that may + ** be in use by existing readers is being overwritten. + */ + iFrame = pWal->hdr.mxFrame; + for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){ + iFrame++; + rc = walIndexAppend(pWal, iFrame, p->pgno); + } + while( rc==SQLITE_OK && nExtra>0 ){ + iFrame++; + nExtra--; + rc = walIndexAppend(pWal, iFrame, pLast->pgno); + } + + if( rc==SQLITE_OK ){ + /* Update the private copy of the header. */ + pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16)); + testcase( szPage<=32768 ); + testcase( szPage>=65536 ); + pWal->hdr.mxFrame = iFrame; + if( isCommit ){ + pWal->hdr.iChange++; + pWal->hdr.nPage = nTruncate; + } + /* If this is a commit, update the wal-index header too. */ + if( isCommit ){ + walIndexWriteHdr(pWal); + pWal->iCallback = iFrame; + } + } + + WALTRACE(("WAL%p: frame write %s\n", pWal, rc ? "failed" : "ok")); + return rc; +} + +/* +** This routine is called to implement sqlite3_wal_checkpoint() and +** related interfaces. +** +** Obtain a CHECKPOINT lock and then backfill as much information as +** we can from WAL into the database. +** +** If parameter xBusy is not NULL, it is a pointer to a busy-handler +** callback. In this case this function runs a blocking checkpoint. +*/ +SQLITE_PRIVATE int sqlite3WalCheckpoint( + Wal *pWal, /* Wal connection */ + int eMode, /* PASSIVE, FULL, RESTART, or TRUNCATE */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int sync_flags, /* Flags to sync db file with (or 0) */ + int nBuf, /* Size of temporary buffer */ + u8 *zBuf, /* Temporary buffer to use */ + int *pnLog, /* OUT: Number of frames in WAL */ + int *pnCkpt /* OUT: Number of backfilled frames in WAL */ +){ + int rc; /* Return code */ + int isChanged = 0; /* True if a new wal-index header is loaded */ + int eMode2 = eMode; /* Mode to pass to walCheckpoint() */ + int (*xBusy2)(void*) = xBusy; /* Busy handler for eMode2 */ + + assert( pWal->ckptLock==0 ); + assert( pWal->writeLock==0 ); + + /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked + ** in the SQLITE_CHECKPOINT_PASSIVE mode. */ + assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 ); + + if( pWal->readOnly ) return SQLITE_READONLY; + WALTRACE(("WAL%p: checkpoint begins\n", pWal)); + + /* IMPLEMENTATION-OF: R-62028-47212 All calls obtain an exclusive + ** "checkpoint" lock on the database file. */ + rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1, 0); + if( rc ){ + /* EVIDENCE-OF: R-10421-19736 If any other process is running a + ** checkpoint operation at the same time, the lock cannot be obtained and + ** SQLITE_BUSY is returned. + ** EVIDENCE-OF: R-53820-33897 Even if there is a busy-handler configured, + ** it will not be invoked in this case. + */ + testcase( rc==SQLITE_BUSY ); + testcase( xBusy!=0 ); + return rc; + } + pWal->ckptLock = 1; + + /* IMPLEMENTATION-OF: R-59782-36818 The SQLITE_CHECKPOINT_FULL, RESTART and + ** TRUNCATE modes also obtain the exclusive "writer" lock on the database + ** file. + ** + ** EVIDENCE-OF: R-60642-04082 If the writer lock cannot be obtained + ** immediately, and a busy-handler is configured, it is invoked and the + ** writer lock retried until either the busy-handler returns 0 or the + ** lock is successfully obtained. + */ + if( eMode!=SQLITE_CHECKPOINT_PASSIVE ){ + rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_WRITE_LOCK, 1); + if( rc==SQLITE_OK ){ + pWal->writeLock = 1; + }else if( rc==SQLITE_BUSY ){ + eMode2 = SQLITE_CHECKPOINT_PASSIVE; + xBusy2 = 0; + rc = SQLITE_OK; + } + } + + /* Read the wal-index header. */ + if( rc==SQLITE_OK ){ + rc = walIndexReadHdr(pWal, &isChanged); + if( isChanged && pWal->pDbFd->pMethods->iVersion>=3 ){ + sqlite3OsUnfetch(pWal->pDbFd, 0, 0); + } + } + + /* Copy data from the log to the database file. */ + if( rc==SQLITE_OK ){ + if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + rc = walCheckpoint(pWal, eMode2, xBusy2, pBusyArg, sync_flags, zBuf); + } + + /* If no error occurred, set the output variables. */ + if( rc==SQLITE_OK || rc==SQLITE_BUSY ){ + if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame; + if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill); + } + } + + if( isChanged ){ + /* If a new wal-index header was loaded before the checkpoint was + ** performed, then the pager-cache associated with pWal is now + ** out of date. So zero the cached wal-index header to ensure that + ** next time the pager opens a snapshot on this database it knows that + ** the cache needs to be reset. + */ + memset(&pWal->hdr, 0, sizeof(WalIndexHdr)); + } + + /* Release the locks. */ + sqlite3WalEndWriteTransaction(pWal); + walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1); + pWal->ckptLock = 0; + WALTRACE(("WAL%p: checkpoint %s\n", pWal, rc ? "failed" : "ok")); + return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc); +} + +/* Return the value to pass to a sqlite3_wal_hook callback, the +** number of frames in the WAL at the point of the last commit since +** sqlite3WalCallback() was called. If no commits have occurred since +** the last call, then return 0. +*/ +SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal){ + u32 ret = 0; + if( pWal ){ + ret = pWal->iCallback; + pWal->iCallback = 0; + } + return (int)ret; +} + +/* +** This function is called to change the WAL subsystem into or out +** of locking_mode=EXCLUSIVE. +** +** If op is zero, then attempt to change from locking_mode=EXCLUSIVE +** into locking_mode=NORMAL. This means that we must acquire a lock +** on the pWal->readLock byte. If the WAL is already in locking_mode=NORMAL +** or if the acquisition of the lock fails, then return 0. If the +** transition out of exclusive-mode is successful, return 1. This +** operation must occur while the pager is still holding the exclusive +** lock on the main database file. +** +** If op is one, then change from locking_mode=NORMAL into +** locking_mode=EXCLUSIVE. This means that the pWal->readLock must +** be released. Return 1 if the transition is made and 0 if the +** WAL is already in exclusive-locking mode - meaning that this +** routine is a no-op. The pager must already hold the exclusive lock +** on the main database file before invoking this operation. +** +** If op is negative, then do a dry-run of the op==1 case but do +** not actually change anything. The pager uses this to see if it +** should acquire the database exclusive lock prior to invoking +** the op==1 case. +*/ +SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op){ + int rc; + assert( pWal->writeLock==0 ); + assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 ); + + /* pWal->readLock is usually set, but might be -1 if there was a + ** prior error while attempting to acquire are read-lock. This cannot + ** happen if the connection is actually in exclusive mode (as no xShmLock + ** locks are taken in this case). Nor should the pager attempt to + ** upgrade to exclusive-mode following such an error. + */ + assert( pWal->readLock>=0 || pWal->lockError ); + assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) ); + + if( op==0 ){ + if( pWal->exclusiveMode ){ + pWal->exclusiveMode = 0; + if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){ + pWal->exclusiveMode = 1; + } + rc = pWal->exclusiveMode==0; + }else{ + /* Already in locking_mode=NORMAL */ + rc = 0; + } + }else if( op>0 ){ + assert( pWal->exclusiveMode==0 ); + assert( pWal->readLock>=0 ); + walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock)); + pWal->exclusiveMode = 1; + rc = 1; + }else{ + rc = pWal->exclusiveMode==0; + } + return rc; +} + +/* +** Return true if the argument is non-NULL and the WAL module is using +** heap-memory for the wal-index. Otherwise, if the argument is NULL or the +** WAL module is using shared-memory, return false. +*/ +SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal){ + return (pWal && pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ); +} + +#ifdef SQLITE_ENABLE_ZIPVFS +/* +** If the argument is not NULL, it points to a Wal object that holds a +** read-lock. This function returns the database page-size if it is known, +** or zero if it is not (or if pWal is NULL). +*/ +SQLITE_PRIVATE int sqlite3WalFramesize(Wal *pWal){ + assert( pWal==0 || pWal->readLock>=0 ); + return (pWal ? pWal->szPage : 0); +} +#endif + +#endif /* #ifndef SQLITE_OMIT_WAL */ + +/************** End of wal.c *************************************************/ +/************** Begin file btmutex.c *****************************************/ +/* +** 2007 August 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code used to implement mutexes on Btree objects. +** This code really belongs in btree.c. But btree.c is getting too +** big and we want to break it down some. This packaged seemed like +** a good breakout. +*/ +/************** Include btreeInt.h in the middle of btmutex.c ****************/ +/************** Begin file btreeInt.h ****************************************/ +/* +** 2004 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file implements an external (disk-based) database using BTrees. +** For a detailed discussion of BTrees, refer to +** +** Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3: +** "Sorting And Searching", pages 473-480. Addison-Wesley +** Publishing Company, Reading, Massachusetts. +** +** The basic idea is that each page of the file contains N database +** entries and N+1 pointers to subpages. +** +** ---------------------------------------------------------------- +** | Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N-1) | Ptr(N) | +** ---------------------------------------------------------------- +** +** All of the keys on the page that Ptr(0) points to have values less +** than Key(0). All of the keys on page Ptr(1) and its subpages have +** values greater than Key(0) and less than Key(1). All of the keys +** on Ptr(N) and its subpages have values greater than Key(N-1). And +** so forth. +** +** Finding a particular key requires reading O(log(M)) pages from the +** disk where M is the number of entries in the tree. +** +** In this implementation, a single file can hold one or more separate +** BTrees. Each BTree is identified by the index of its root page. The +** key and data for any entry are combined to form the "payload". A +** fixed amount of payload can be carried directly on the database +** page. If the payload is larger than the preset amount then surplus +** bytes are stored on overflow pages. The payload for an entry +** and the preceding pointer are combined to form a "Cell". Each +** page has a small header which contains the Ptr(N) pointer and other +** information such as the size of key and data. +** +** FORMAT DETAILS +** +** The file is divided into pages. The first page is called page 1, +** the second is page 2, and so forth. A page number of zero indicates +** "no such page". The page size can be any power of 2 between 512 and 65536. +** Each page can be either a btree page, a freelist page, an overflow +** page, or a pointer-map page. +** +** The first page is always a btree page. The first 100 bytes of the first +** page contain a special header (the "file header") that describes the file. +** The format of the file header is as follows: +** +** OFFSET SIZE DESCRIPTION +** 0 16 Header string: "SQLite format 3\000" +** 16 2 Page size in bytes. (1 means 65536) +** 18 1 File format write version +** 19 1 File format read version +** 20 1 Bytes of unused space at the end of each page +** 21 1 Max embedded payload fraction (must be 64) +** 22 1 Min embedded payload fraction (must be 32) +** 23 1 Min leaf payload fraction (must be 32) +** 24 4 File change counter +** 28 4 Reserved for future use +** 32 4 First freelist page +** 36 4 Number of freelist pages in the file +** 40 60 15 4-byte meta values passed to higher layers +** +** 40 4 Schema cookie +** 44 4 File format of schema layer +** 48 4 Size of page cache +** 52 4 Largest root-page (auto/incr_vacuum) +** 56 4 1=UTF-8 2=UTF16le 3=UTF16be +** 60 4 User version +** 64 4 Incremental vacuum mode +** 68 4 Application-ID +** 72 20 unused +** 92 4 The version-valid-for number +** 96 4 SQLITE_VERSION_NUMBER +** +** All of the integer values are big-endian (most significant byte first). +** +** The file change counter is incremented when the database is changed +** This counter allows other processes to know when the file has changed +** and thus when they need to flush their cache. +** +** The max embedded payload fraction is the amount of the total usable +** space in a page that can be consumed by a single cell for standard +** B-tree (non-LEAFDATA) tables. A value of 255 means 100%. The default +** is to limit the maximum cell size so that at least 4 cells will fit +** on one page. Thus the default max embedded payload fraction is 64. +** +** If the payload for a cell is larger than the max payload, then extra +** payload is spilled to overflow pages. Once an overflow page is allocated, +** as many bytes as possible are moved into the overflow pages without letting +** the cell size drop below the min embedded payload fraction. +** +** The min leaf payload fraction is like the min embedded payload fraction +** except that it applies to leaf nodes in a LEAFDATA tree. The maximum +** payload fraction for a LEAFDATA tree is always 100% (or 255) and it +** not specified in the header. +** +** Each btree pages is divided into three sections: The header, the +** cell pointer array, and the cell content area. Page 1 also has a 100-byte +** file header that occurs before the page header. +** +** |----------------| +** | file header | 100 bytes. Page 1 only. +** |----------------| +** | page header | 8 bytes for leaves. 12 bytes for interior nodes +** |----------------| +** | cell pointer | | 2 bytes per cell. Sorted order. +** | array | | Grows downward +** | | v +** |----------------| +** | unallocated | +** | space | +** |----------------| ^ Grows upwards +** | cell content | | Arbitrary order interspersed with freeblocks. +** | area | | and free space fragments. +** |----------------| +** +** The page headers looks like this: +** +** OFFSET SIZE DESCRIPTION +** 0 1 Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf +** 1 2 byte offset to the first freeblock +** 3 2 number of cells on this page +** 5 2 first byte of the cell content area +** 7 1 number of fragmented free bytes +** 8 4 Right child (the Ptr(N) value). Omitted on leaves. +** +** The flags define the format of this btree page. The leaf flag means that +** this page has no children. The zerodata flag means that this page carries +** only keys and no data. The intkey flag means that the key is an integer +** which is stored in the key size entry of the cell header rather than in +** the payload area. +** +** The cell pointer array begins on the first byte after the page header. +** The cell pointer array contains zero or more 2-byte numbers which are +** offsets from the beginning of the page to the cell content in the cell +** content area. The cell pointers occur in sorted order. The system strives +** to keep free space after the last cell pointer so that new cells can +** be easily added without having to defragment the page. +** +** Cell content is stored at the very end of the page and grows toward the +** beginning of the page. +** +** Unused space within the cell content area is collected into a linked list of +** freeblocks. Each freeblock is at least 4 bytes in size. The byte offset +** to the first freeblock is given in the header. Freeblocks occur in +** increasing order. Because a freeblock must be at least 4 bytes in size, +** any group of 3 or fewer unused bytes in the cell content area cannot +** exist on the freeblock chain. A group of 3 or fewer free bytes is called +** a fragment. The total number of bytes in all fragments is recorded. +** in the page header at offset 7. +** +** SIZE DESCRIPTION +** 2 Byte offset of the next freeblock +** 2 Bytes in this freeblock +** +** Cells are of variable length. Cells are stored in the cell content area at +** the end of the page. Pointers to the cells are in the cell pointer array +** that immediately follows the page header. Cells is not necessarily +** contiguous or in order, but cell pointers are contiguous and in order. +** +** Cell content makes use of variable length integers. A variable +** length integer is 1 to 9 bytes where the lower 7 bits of each +** byte are used. The integer consists of all bytes that have bit 8 set and +** the first byte with bit 8 clear. The most significant byte of the integer +** appears first. A variable-length integer may not be more than 9 bytes long. +** As a special case, all 8 bytes of the 9th byte are used as data. This +** allows a 64-bit integer to be encoded in 9 bytes. +** +** 0x00 becomes 0x00000000 +** 0x7f becomes 0x0000007f +** 0x81 0x00 becomes 0x00000080 +** 0x82 0x00 becomes 0x00000100 +** 0x80 0x7f becomes 0x0000007f +** 0x8a 0x91 0xd1 0xac 0x78 becomes 0x12345678 +** 0x81 0x81 0x81 0x81 0x01 becomes 0x10204081 +** +** Variable length integers are used for rowids and to hold the number of +** bytes of key and data in a btree cell. +** +** The content of a cell looks like this: +** +** SIZE DESCRIPTION +** 4 Page number of the left child. Omitted if leaf flag is set. +** var Number of bytes of data. Omitted if the zerodata flag is set. +** var Number of bytes of key. Or the key itself if intkey flag is set. +** * Payload +** 4 First page of the overflow chain. Omitted if no overflow +** +** Overflow pages form a linked list. Each page except the last is completely +** filled with data (pagesize - 4 bytes). The last page can have as little +** as 1 byte of data. +** +** SIZE DESCRIPTION +** 4 Page number of next overflow page +** * Data +** +** Freelist pages come in two subtypes: trunk pages and leaf pages. The +** file header points to the first in a linked list of trunk page. Each trunk +** page points to multiple leaf pages. The content of a leaf page is +** unspecified. A trunk page looks like this: +** +** SIZE DESCRIPTION +** 4 Page number of next trunk page +** 4 Number of leaf pointers on this page +** * zero or more pages numbers of leaves +*/ +/* #include "sqliteInt.h" */ + + +/* The following value is the maximum cell size assuming a maximum page +** size give above. +*/ +#define MX_CELL_SIZE(pBt) ((int)(pBt->pageSize-8)) + +/* The maximum number of cells on a single page of the database. This +** assumes a minimum cell size of 6 bytes (4 bytes for the cell itself +** plus 2 bytes for the index to the cell in the page header). Such +** small cells will be rare, but they are possible. +*/ +#define MX_CELL(pBt) ((pBt->pageSize-8)/6) + +/* Forward declarations */ +typedef struct MemPage MemPage; +typedef struct BtLock BtLock; +typedef struct CellInfo CellInfo; + +/* +** This is a magic string that appears at the beginning of every +** SQLite database in order to identify the file as a real database. +** +** You can change this value at compile-time by specifying a +** -DSQLITE_FILE_HEADER="..." on the compiler command-line. The +** header must be exactly 16 bytes including the zero-terminator so +** the string itself should be 15 characters long. If you change +** the header, then your custom library will not be able to read +** databases generated by the standard tools and the standard tools +** will not be able to read databases created by your custom library. +*/ +#ifndef SQLITE_FILE_HEADER /* 123456789 123456 */ +# define SQLITE_FILE_HEADER "SQLite format 3" +#endif + +/* +** Page type flags. An ORed combination of these flags appear as the +** first byte of on-disk image of every BTree page. +*/ +#define PTF_INTKEY 0x01 +#define PTF_ZERODATA 0x02 +#define PTF_LEAFDATA 0x04 +#define PTF_LEAF 0x08 + +/* +** As each page of the file is loaded into memory, an instance of the following +** structure is appended and initialized to zero. This structure stores +** information about the page that is decoded from the raw file page. +** +** The pParent field points back to the parent page. This allows us to +** walk up the BTree from any leaf to the root. Care must be taken to +** unref() the parent page pointer when this page is no longer referenced. +** The pageDestructor() routine handles that chore. +** +** Access to all fields of this structure is controlled by the mutex +** stored in MemPage.pBt->mutex. +*/ +struct MemPage { + u8 isInit; /* True if previously initialized. MUST BE FIRST! */ + u8 nOverflow; /* Number of overflow cell bodies in aCell[] */ + u8 intKey; /* True if table b-trees. False for index b-trees */ + u8 intKeyLeaf; /* True if the leaf of an intKey table */ + u8 noPayload; /* True if internal intKey page (thus w/o data) */ + u8 leaf; /* True if a leaf page */ + u8 hdrOffset; /* 100 for page 1. 0 otherwise */ + u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */ + u8 max1bytePayload; /* min(maxLocal,127) */ + u8 bBusy; /* Prevent endless loops on corrupt database files */ + u16 maxLocal; /* Copy of BtShared.maxLocal or BtShared.maxLeaf */ + u16 minLocal; /* Copy of BtShared.minLocal or BtShared.minLeaf */ + u16 cellOffset; /* Index in aData of first cell pointer */ + u16 nFree; /* Number of free bytes on the page */ + u16 nCell; /* Number of cells on this page, local and ovfl */ + u16 maskPage; /* Mask for page offset */ + u16 aiOvfl[5]; /* Insert the i-th overflow cell before the aiOvfl-th + ** non-overflow cell */ + u8 *apOvfl[5]; /* Pointers to the body of overflow cells */ + BtShared *pBt; /* Pointer to BtShared that this page is part of */ + u8 *aData; /* Pointer to disk image of the page data */ + u8 *aDataEnd; /* One byte past the end of usable data */ + u8 *aCellIdx; /* The cell index area */ + u8 *aDataOfst; /* Same as aData for leaves. aData+4 for interior */ + DbPage *pDbPage; /* Pager page handle */ + u16 (*xCellSize)(MemPage*,u8*); /* cellSizePtr method */ + void (*xParseCell)(MemPage*,u8*,CellInfo*); /* btreeParseCell method */ + Pgno pgno; /* Page number for this page */ +}; + +/* +** The in-memory image of a disk page has the auxiliary information appended +** to the end. EXTRA_SIZE is the number of bytes of space needed to hold +** that extra information. +*/ +#define EXTRA_SIZE sizeof(MemPage) + +/* +** A linked list of the following structures is stored at BtShared.pLock. +** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor +** is opened on the table with root page BtShared.iTable. Locks are removed +** from this list when a transaction is committed or rolled back, or when +** a btree handle is closed. +*/ +struct BtLock { + Btree *pBtree; /* Btree handle holding this lock */ + Pgno iTable; /* Root page of table */ + u8 eLock; /* READ_LOCK or WRITE_LOCK */ + BtLock *pNext; /* Next in BtShared.pLock list */ +}; + +/* Candidate values for BtLock.eLock */ +#define READ_LOCK 1 +#define WRITE_LOCK 2 + +/* A Btree handle +** +** A database connection contains a pointer to an instance of +** this object for every database file that it has open. This structure +** is opaque to the database connection. The database connection cannot +** see the internals of this structure and only deals with pointers to +** this structure. +** +** For some database files, the same underlying database cache might be +** shared between multiple connections. In that case, each connection +** has it own instance of this object. But each instance of this object +** points to the same BtShared object. The database cache and the +** schema associated with the database file are all contained within +** the BtShared object. +** +** All fields in this structure are accessed under sqlite3.mutex. +** The pBt pointer itself may not be changed while there exists cursors +** in the referenced BtShared that point back to this Btree since those +** cursors have to go through this Btree to find their BtShared and +** they often do so without holding sqlite3.mutex. +*/ +struct Btree { + sqlite3 *db; /* The database connection holding this btree */ + BtShared *pBt; /* Sharable content of this btree */ + u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */ + u8 sharable; /* True if we can share pBt with another db */ + u8 locked; /* True if db currently has pBt locked */ + u8 hasIncrblobCur; /* True if there are one or more Incrblob cursors */ + int wantToLock; /* Number of nested calls to sqlite3BtreeEnter() */ + int nBackup; /* Number of backup operations reading this btree */ + u32 iDataVersion; /* Combines with pBt->pPager->iDataVersion */ + Btree *pNext; /* List of other sharable Btrees from the same db */ + Btree *pPrev; /* Back pointer of the same list */ +#ifndef SQLITE_OMIT_SHARED_CACHE + BtLock lock; /* Object used to lock page 1 */ +#endif +}; + +/* +** Btree.inTrans may take one of the following values. +** +** If the shared-data extension is enabled, there may be multiple users +** of the Btree structure. At most one of these may open a write transaction, +** but any number may have active read transactions. +*/ +#define TRANS_NONE 0 +#define TRANS_READ 1 +#define TRANS_WRITE 2 + +/* +** An instance of this object represents a single database file. +** +** A single database file can be in use at the same time by two +** or more database connections. When two or more connections are +** sharing the same database file, each connection has it own +** private Btree object for the file and each of those Btrees points +** to this one BtShared object. BtShared.nRef is the number of +** connections currently sharing this database file. +** +** Fields in this structure are accessed under the BtShared.mutex +** mutex, except for nRef and pNext which are accessed under the +** global SQLITE_MUTEX_STATIC_MASTER mutex. The pPager field +** may not be modified once it is initially set as long as nRef>0. +** The pSchema field may be set once under BtShared.mutex and +** thereafter is unchanged as long as nRef>0. +** +** isPending: +** +** If a BtShared client fails to obtain a write-lock on a database +** table (because there exists one or more read-locks on the table), +** the shared-cache enters 'pending-lock' state and isPending is +** set to true. +** +** The shared-cache leaves the 'pending lock' state when either of +** the following occur: +** +** 1) The current writer (BtShared.pWriter) concludes its transaction, OR +** 2) The number of locks held by other connections drops to zero. +** +** while in the 'pending-lock' state, no connection may start a new +** transaction. +** +** This feature is included to help prevent writer-starvation. +*/ +struct BtShared { + Pager *pPager; /* The page cache */ + sqlite3 *db; /* Database connection currently using this Btree */ + BtCursor *pCursor; /* A list of all open cursors */ + MemPage *pPage1; /* First page of the database */ + u8 openFlags; /* Flags to sqlite3BtreeOpen() */ +#ifndef SQLITE_OMIT_AUTOVACUUM + u8 autoVacuum; /* True if auto-vacuum is enabled */ + u8 incrVacuum; /* True if incr-vacuum is enabled */ + u8 bDoTruncate; /* True to truncate db on commit */ +#endif + u8 inTransaction; /* Transaction state */ + u8 max1bytePayload; /* Maximum first byte of cell for a 1-byte payload */ +#ifdef SQLITE_HAS_CODEC + u8 optimalReserve; /* Desired amount of reserved space per page */ +#endif + u16 btsFlags; /* Boolean parameters. See BTS_* macros below */ + u16 maxLocal; /* Maximum local payload in non-LEAFDATA tables */ + u16 minLocal; /* Minimum local payload in non-LEAFDATA tables */ + u16 maxLeaf; /* Maximum local payload in a LEAFDATA table */ + u16 minLeaf; /* Minimum local payload in a LEAFDATA table */ + u32 pageSize; /* Total number of bytes on a page */ + u32 usableSize; /* Number of usable bytes on each page */ + int nTransaction; /* Number of open transactions (read + write) */ + u32 nPage; /* Number of pages in the database */ + void *pSchema; /* Pointer to space allocated by sqlite3BtreeSchema() */ + void (*xFreeSchema)(void*); /* Destructor for BtShared.pSchema */ + sqlite3_mutex *mutex; /* Non-recursive mutex required to access this object */ + Bitvec *pHasContent; /* Set of pages moved to free-list this transaction */ +#ifndef SQLITE_OMIT_SHARED_CACHE + int nRef; /* Number of references to this structure */ + BtShared *pNext; /* Next on a list of sharable BtShared structs */ + BtLock *pLock; /* List of locks held on this shared-btree struct */ + Btree *pWriter; /* Btree with currently open write transaction */ +#endif + u8 *pTmpSpace; /* Temp space sufficient to hold a single cell */ +}; + +/* +** Allowed values for BtShared.btsFlags +*/ +#define BTS_READ_ONLY 0x0001 /* Underlying file is readonly */ +#define BTS_PAGESIZE_FIXED 0x0002 /* Page size can no longer be changed */ +#define BTS_SECURE_DELETE 0x0004 /* PRAGMA secure_delete is enabled */ +#define BTS_INITIALLY_EMPTY 0x0008 /* Database was empty at trans start */ +#define BTS_NO_WAL 0x0010 /* Do not open write-ahead-log files */ +#define BTS_EXCLUSIVE 0x0020 /* pWriter has an exclusive lock */ +#define BTS_PENDING 0x0040 /* Waiting for read-locks to clear */ + +/* +** An instance of the following structure is used to hold information +** about a cell. The parseCellPtr() function fills in this structure +** based on information extract from the raw disk page. +*/ +struct CellInfo { + i64 nKey; /* The key for INTKEY tables, or nPayload otherwise */ + u8 *pPayload; /* Pointer to the start of payload */ + u32 nPayload; /* Bytes of payload */ + u16 nLocal; /* Amount of payload held locally, not on overflow */ + u16 iOverflow; /* Offset to overflow page number. Zero if no overflow */ + u16 nSize; /* Size of the cell content on the main b-tree page */ +}; + +/* +** Maximum depth of an SQLite B-Tree structure. Any B-Tree deeper than +** this will be declared corrupt. This value is calculated based on a +** maximum database size of 2^31 pages a minimum fanout of 2 for a +** root-node and 3 for all other internal nodes. +** +** If a tree that appears to be taller than this is encountered, it is +** assumed that the database is corrupt. +*/ +#define BTCURSOR_MAX_DEPTH 20 + +/* +** A cursor is a pointer to a particular entry within a particular +** b-tree within a database file. +** +** The entry is identified by its MemPage and the index in +** MemPage.aCell[] of the entry. +** +** A single database file can be shared by two more database connections, +** but cursors cannot be shared. Each cursor is associated with a +** particular database connection identified BtCursor.pBtree.db. +** +** Fields in this structure are accessed under the BtShared.mutex +** found at self->pBt->mutex. +** +** skipNext meaning: +** eState==SKIPNEXT && skipNext>0: Next sqlite3BtreeNext() is no-op. +** eState==SKIPNEXT && skipNext<0: Next sqlite3BtreePrevious() is no-op. +** eState==FAULT: Cursor fault with skipNext as error code. +*/ +struct BtCursor { + Btree *pBtree; /* The Btree to which this cursor belongs */ + BtShared *pBt; /* The BtShared this cursor points to */ + BtCursor *pNext; /* Forms a linked list of all cursors */ + Pgno *aOverflow; /* Cache of overflow page locations */ + CellInfo info; /* A parse of the cell we are pointing at */ + i64 nKey; /* Size of pKey, or last integer key */ + void *pKey; /* Saved key that was cursor last known position */ + Pgno pgnoRoot; /* The root page of this tree */ + int nOvflAlloc; /* Allocated size of aOverflow[] array */ + int skipNext; /* Prev() is noop if negative. Next() is noop if positive. + ** Error code if eState==CURSOR_FAULT */ + u8 curFlags; /* zero or more BTCF_* flags defined below */ + u8 curPagerFlags; /* Flags to send to sqlite3PagerAcquire() */ + u8 eState; /* One of the CURSOR_XXX constants (see below) */ + u8 hints; /* As configured by CursorSetHints() */ + /* All fields above are zeroed when the cursor is allocated. See + ** sqlite3BtreeCursorZero(). Fields that follow must be manually + ** initialized. */ + i8 iPage; /* Index of current page in apPage */ + u8 curIntKey; /* Value of apPage[0]->intKey */ + struct KeyInfo *pKeyInfo; /* Argument passed to comparison function */ + void *padding1; /* Make object size a multiple of 16 */ + u16 aiIdx[BTCURSOR_MAX_DEPTH]; /* Current index in apPage[i] */ + MemPage *apPage[BTCURSOR_MAX_DEPTH]; /* Pages from root to current page */ +}; + +/* +** Legal values for BtCursor.curFlags +*/ +#define BTCF_WriteFlag 0x01 /* True if a write cursor */ +#define BTCF_ValidNKey 0x02 /* True if info.nKey is valid */ +#define BTCF_ValidOvfl 0x04 /* True if aOverflow is valid */ +#define BTCF_AtLast 0x08 /* Cursor is pointing ot the last entry */ +#define BTCF_Incrblob 0x10 /* True if an incremental I/O handle */ +#define BTCF_Multiple 0x20 /* Maybe another cursor on the same btree */ + +/* +** Potential values for BtCursor.eState. +** +** CURSOR_INVALID: +** Cursor does not point to a valid entry. This can happen (for example) +** because the table is empty or because BtreeCursorFirst() has not been +** called. +** +** CURSOR_VALID: +** Cursor points to a valid entry. getPayload() etc. may be called. +** +** CURSOR_SKIPNEXT: +** Cursor is valid except that the Cursor.skipNext field is non-zero +** indicating that the next sqlite3BtreeNext() or sqlite3BtreePrevious() +** operation should be a no-op. +** +** CURSOR_REQUIRESEEK: +** The table that this cursor was opened on still exists, but has been +** modified since the cursor was last used. The cursor position is saved +** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in +** this state, restoreCursorPosition() can be called to attempt to +** seek the cursor to the saved position. +** +** CURSOR_FAULT: +** An unrecoverable error (an I/O error or a malloc failure) has occurred +** on a different connection that shares the BtShared cache with this +** cursor. The error has left the cache in an inconsistent state. +** Do nothing else with this cursor. Any attempt to use the cursor +** should return the error code stored in BtCursor.skipNext +*/ +#define CURSOR_INVALID 0 +#define CURSOR_VALID 1 +#define CURSOR_SKIPNEXT 2 +#define CURSOR_REQUIRESEEK 3 +#define CURSOR_FAULT 4 + +/* +** The database page the PENDING_BYTE occupies. This page is never used. +*/ +# define PENDING_BYTE_PAGE(pBt) PAGER_MJ_PGNO(pBt) + +/* +** These macros define the location of the pointer-map entry for a +** database page. The first argument to each is the number of usable +** bytes on each page of the database (often 1024). The second is the +** page number to look up in the pointer map. +** +** PTRMAP_PAGENO returns the database page number of the pointer-map +** page that stores the required pointer. PTRMAP_PTROFFSET returns +** the offset of the requested map entry. +** +** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page, +** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be +** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements +** this test. +*/ +#define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno) +#define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1)) +#define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno)) + +/* +** The pointer map is a lookup table that identifies the parent page for +** each child page in the database file. The parent page is the page that +** contains a pointer to the child. Every page in the database contains +** 0 or 1 parent pages. (In this context 'database page' refers +** to any page that is not part of the pointer map itself.) Each pointer map +** entry consists of a single byte 'type' and a 4 byte parent page number. +** The PTRMAP_XXX identifiers below are the valid types. +** +** The purpose of the pointer map is to facility moving pages from one +** position in the file to another as part of autovacuum. When a page +** is moved, the pointer in its parent must be updated to point to the +** new location. The pointer map is used to locate the parent page quickly. +** +** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not +** used in this case. +** +** PTRMAP_FREEPAGE: The database page is an unused (free) page. The page-number +** is not used in this case. +** +** PTRMAP_OVERFLOW1: The database page is the first page in a list of +** overflow pages. The page number identifies the page that +** contains the cell with a pointer to this overflow page. +** +** PTRMAP_OVERFLOW2: The database page is the second or later page in a list of +** overflow pages. The page-number identifies the previous +** page in the overflow page list. +** +** PTRMAP_BTREE: The database page is a non-root btree page. The page number +** identifies the parent page in the btree. +*/ +#define PTRMAP_ROOTPAGE 1 +#define PTRMAP_FREEPAGE 2 +#define PTRMAP_OVERFLOW1 3 +#define PTRMAP_OVERFLOW2 4 +#define PTRMAP_BTREE 5 + +/* A bunch of assert() statements to check the transaction state variables +** of handle p (type Btree*) are internally consistent. +*/ +#define btreeIntegrity(p) \ + assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \ + assert( p->pBt->inTransaction>=p->inTrans ); + + +/* +** The ISAUTOVACUUM macro is used within balance_nonroot() to determine +** if the database supports auto-vacuum or not. Because it is used +** within an expression that is an argument to another macro +** (sqliteMallocRaw), it is not possible to use conditional compilation. +** So, this macro is defined instead. +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +#define ISAUTOVACUUM (pBt->autoVacuum) +#else +#define ISAUTOVACUUM 0 +#endif + + +/* +** This structure is passed around through all the sanity checking routines +** in order to keep track of some global state information. +** +** The aRef[] array is allocated so that there is 1 bit for each page in +** the database. As the integrity-check proceeds, for each page used in +** the database the corresponding bit is set. This allows integrity-check to +** detect pages that are used twice and orphaned pages (both of which +** indicate corruption). +*/ +typedef struct IntegrityCk IntegrityCk; +struct IntegrityCk { + BtShared *pBt; /* The tree being checked out */ + Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */ + u8 *aPgRef; /* 1 bit per page in the db (see above) */ + Pgno nPage; /* Number of pages in the database */ + int mxErr; /* Stop accumulating errors when this reaches zero */ + int nErr; /* Number of messages written to zErrMsg so far */ + int mallocFailed; /* A memory allocation error has occurred */ + const char *zPfx; /* Error message prefix */ + int v1, v2; /* Values for up to two %d fields in zPfx */ + StrAccum errMsg; /* Accumulate the error message text here */ + u32 *heap; /* Min-heap used for analyzing cell coverage */ +}; + +/* +** Routines to read or write a two- and four-byte big-endian integer values. +*/ +#define get2byte(x) ((x)[0]<<8 | (x)[1]) +#define put2byte(p,v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v)) +#define get4byte sqlite3Get4byte +#define put4byte sqlite3Put4byte + +/* +** get2byteAligned(), unlike get2byte(), requires that its argument point to a +** two-byte aligned address. get2bytea() is only used for accessing the +** cell addresses in a btree header. +*/ +#if SQLITE_BYTEORDER==4321 +# define get2byteAligned(x) (*(u16*)(x)) +#elif SQLITE_BYTEORDER==1234 && !defined(SQLITE_DISABLE_INTRINSIC) \ + && GCC_VERSION>=4008000 +# define get2byteAligned(x) __builtin_bswap16(*(u16*)(x)) +#elif SQLITE_BYTEORDER==1234 && !defined(SQLITE_DISABLE_INTRINSIC) \ + && defined(_MSC_VER) && _MSC_VER>=1300 +# define get2byteAligned(x) _byteswap_ushort(*(u16*)(x)) +#else +# define get2byteAligned(x) ((x)[0]<<8 | (x)[1]) +#endif + +/************** End of btreeInt.h ********************************************/ +/************** Continuing where we left off in btmutex.c ********************/ +#ifndef SQLITE_OMIT_SHARED_CACHE +#if SQLITE_THREADSAFE + +/* +** Obtain the BtShared mutex associated with B-Tree handle p. Also, +** set BtShared.db to the database handle associated with p and the +** p->locked boolean to true. +*/ +static void lockBtreeMutex(Btree *p){ + assert( p->locked==0 ); + assert( sqlite3_mutex_notheld(p->pBt->mutex) ); + assert( sqlite3_mutex_held(p->db->mutex) ); + + sqlite3_mutex_enter(p->pBt->mutex); + p->pBt->db = p->db; + p->locked = 1; +} + +/* +** Release the BtShared mutex associated with B-Tree handle p and +** clear the p->locked boolean. +*/ +static void SQLITE_NOINLINE unlockBtreeMutex(Btree *p){ + BtShared *pBt = p->pBt; + assert( p->locked==1 ); + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( sqlite3_mutex_held(p->db->mutex) ); + assert( p->db==pBt->db ); + + sqlite3_mutex_leave(pBt->mutex); + p->locked = 0; +} + +/* Forward reference */ +static void SQLITE_NOINLINE btreeLockCarefully(Btree *p); + +/* +** Enter a mutex on the given BTree object. +** +** If the object is not sharable, then no mutex is ever required +** and this routine is a no-op. The underlying mutex is non-recursive. +** But we keep a reference count in Btree.wantToLock so the behavior +** of this interface is recursive. +** +** To avoid deadlocks, multiple Btrees are locked in the same order +** by all database connections. The p->pNext is a list of other +** Btrees belonging to the same database connection as the p Btree +** which need to be locked after p. If we cannot get a lock on +** p, then first unlock all of the others on p->pNext, then wait +** for the lock to become available on p, then relock all of the +** subsequent Btrees that desire a lock. +*/ +SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){ + /* Some basic sanity checking on the Btree. The list of Btrees + ** connected by pNext and pPrev should be in sorted order by + ** Btree.pBt value. All elements of the list should belong to + ** the same connection. Only shared Btrees are on the list. */ + assert( p->pNext==0 || p->pNext->pBt>p->pBt ); + assert( p->pPrev==0 || p->pPrev->pBtpBt ); + assert( p->pNext==0 || p->pNext->db==p->db ); + assert( p->pPrev==0 || p->pPrev->db==p->db ); + assert( p->sharable || (p->pNext==0 && p->pPrev==0) ); + + /* Check for locking consistency */ + assert( !p->locked || p->wantToLock>0 ); + assert( p->sharable || p->wantToLock==0 ); + + /* We should already hold a lock on the database connection */ + assert( sqlite3_mutex_held(p->db->mutex) ); + + /* Unless the database is sharable and unlocked, then BtShared.db + ** should already be set correctly. */ + assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db ); + + if( !p->sharable ) return; + p->wantToLock++; + if( p->locked ) return; + btreeLockCarefully(p); +} + +/* This is a helper function for sqlite3BtreeLock(). By moving +** complex, but seldom used logic, out of sqlite3BtreeLock() and +** into this routine, we avoid unnecessary stack pointer changes +** and thus help the sqlite3BtreeLock() routine to run much faster +** in the common case. +*/ +static void SQLITE_NOINLINE btreeLockCarefully(Btree *p){ + Btree *pLater; + + /* In most cases, we should be able to acquire the lock we + ** want without having to go through the ascending lock + ** procedure that follows. Just be sure not to block. + */ + if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){ + p->pBt->db = p->db; + p->locked = 1; + return; + } + + /* To avoid deadlock, first release all locks with a larger + ** BtShared address. Then acquire our lock. Then reacquire + ** the other BtShared locks that we used to hold in ascending + ** order. + */ + for(pLater=p->pNext; pLater; pLater=pLater->pNext){ + assert( pLater->sharable ); + assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt ); + assert( !pLater->locked || pLater->wantToLock>0 ); + if( pLater->locked ){ + unlockBtreeMutex(pLater); + } + } + lockBtreeMutex(p); + for(pLater=p->pNext; pLater; pLater=pLater->pNext){ + if( pLater->wantToLock ){ + lockBtreeMutex(pLater); + } + } +} + + +/* +** Exit the recursive mutex on a Btree. +*/ +SQLITE_PRIVATE void sqlite3BtreeLeave(Btree *p){ + assert( sqlite3_mutex_held(p->db->mutex) ); + if( p->sharable ){ + assert( p->wantToLock>0 ); + p->wantToLock--; + if( p->wantToLock==0 ){ + unlockBtreeMutex(p); + } + } +} + +#ifndef NDEBUG +/* +** Return true if the BtShared mutex is held on the btree, or if the +** B-Tree is not marked as sharable. +** +** This routine is used only from within assert() statements. +*/ +SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree *p){ + assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 ); + assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db ); + assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) ); + assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) ); + + return (p->sharable==0 || p->locked); +} +#endif + + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** Enter and leave a mutex on a Btree given a cursor owned by that +** Btree. These entry points are used by incremental I/O and can be +** omitted if that module is not used. +*/ +SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){ + sqlite3BtreeEnter(pCur->pBtree); +} +SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){ + sqlite3BtreeLeave(pCur->pBtree); +} +#endif /* SQLITE_OMIT_INCRBLOB */ + + +/* +** Enter the mutex on every Btree associated with a database +** connection. This is needed (for example) prior to parsing +** a statement since we will be comparing table and column names +** against all schemas and we do not want those schemas being +** reset out from under us. +** +** There is a corresponding leave-all procedures. +** +** Enter the mutexes in accending order by BtShared pointer address +** to avoid the possibility of deadlock when two threads with +** two or more btrees in common both try to lock all their btrees +** at the same instant. +*/ +SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){ + int i; + Btree *p; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inDb; i++){ + p = db->aDb[i].pBt; + if( p ) sqlite3BtreeEnter(p); + } +} +SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3 *db){ + int i; + Btree *p; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inDb; i++){ + p = db->aDb[i].pBt; + if( p ) sqlite3BtreeLeave(p); + } +} + +/* +** Return true if a particular Btree requires a lock. Return FALSE if +** no lock is ever required since it is not sharable. +*/ +SQLITE_PRIVATE int sqlite3BtreeSharable(Btree *p){ + return p->sharable; +} + +#ifndef NDEBUG +/* +** Return true if the current thread holds the database connection +** mutex and all required BtShared mutexes. +** +** This routine is used inside assert() statements only. +*/ +SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3 *db){ + int i; + if( !sqlite3_mutex_held(db->mutex) ){ + return 0; + } + for(i=0; inDb; i++){ + Btree *p; + p = db->aDb[i].pBt; + if( p && p->sharable && + (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){ + return 0; + } + } + return 1; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Return true if the correct mutexes are held for accessing the +** db->aDb[iDb].pSchema structure. The mutexes required for schema +** access are: +** +** (1) The mutex on db +** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt. +** +** If pSchema is not NULL, then iDb is computed from pSchema and +** db using sqlite3SchemaToIndex(). +*/ +SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){ + Btree *p; + assert( db!=0 ); + if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema); + assert( iDb>=0 && iDbnDb ); + if( !sqlite3_mutex_held(db->mutex) ) return 0; + if( iDb==1 ) return 1; + p = db->aDb[iDb].pBt; + assert( p!=0 ); + return p->sharable==0 || p->locked==1; +} +#endif /* NDEBUG */ + +#else /* SQLITE_THREADSAFE>0 above. SQLITE_THREADSAFE==0 below */ +/* +** The following are special cases for mutex enter routines for use +** in single threaded applications that use shared cache. Except for +** these two routines, all mutex operations are no-ops in that case and +** are null #defines in btree.h. +** +** If shared cache is disabled, then all btree mutex routines, including +** the ones below, are no-ops and are null #defines in btree.h. +*/ + +SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){ + p->pBt->db = p->db; +} +SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){ + int i; + for(i=0; inDb; i++){ + Btree *p = db->aDb[i].pBt; + if( p ){ + p->pBt->db = p->db; + } + } +} +#endif /* if SQLITE_THREADSAFE */ +#endif /* ifndef SQLITE_OMIT_SHARED_CACHE */ + +/************** End of btmutex.c *********************************************/ +/************** Begin file btree.c *******************************************/ +/* +** 2004 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file implements an external (disk-based) database using BTrees. +** See the header comment on "btreeInt.h" for additional information. +** Including a description of file format and an overview of operation. +*/ +/* #include "btreeInt.h" */ + +/* +** The header string that appears at the beginning of every +** SQLite database. +*/ +static const char zMagicHeader[] = SQLITE_FILE_HEADER; + +/* +** Set this global variable to 1 to enable tracing using the TRACE +** macro. +*/ +#if 0 +int sqlite3BtreeTrace=1; /* True to enable tracing */ +# define TRACE(X) if(sqlite3BtreeTrace){printf X;fflush(stdout);} +#else +# define TRACE(X) +#endif + +/* +** Extract a 2-byte big-endian integer from an array of unsigned bytes. +** But if the value is zero, make it 65536. +** +** This routine is used to extract the "offset to cell content area" value +** from the header of a btree page. If the page size is 65536 and the page +** is empty, the offset should be 65536, but the 2-byte value stores zero. +** This routine makes the necessary adjustment to 65536. +*/ +#define get2byteNotZero(X) (((((int)get2byte(X))-1)&0xffff)+1) + +/* +** Values passed as the 5th argument to allocateBtreePage() +*/ +#define BTALLOC_ANY 0 /* Allocate any page */ +#define BTALLOC_EXACT 1 /* Allocate exact page if possible */ +#define BTALLOC_LE 2 /* Allocate any page <= the parameter */ + +/* +** Macro IfNotOmitAV(x) returns (x) if SQLITE_OMIT_AUTOVACUUM is not +** defined, or 0 if it is. For example: +** +** bIncrVacuum = IfNotOmitAV(pBtShared->incrVacuum); +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +#define IfNotOmitAV(expr) (expr) +#else +#define IfNotOmitAV(expr) 0 +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** A list of BtShared objects that are eligible for participation +** in shared cache. This variable has file scope during normal builds, +** but the test harness needs to access it so we make it global for +** test builds. +** +** Access to this variable is protected by SQLITE_MUTEX_STATIC_MASTER. +*/ +#ifdef SQLITE_TEST +SQLITE_PRIVATE BtShared *SQLITE_WSD sqlite3SharedCacheList = 0; +#else +static BtShared *SQLITE_WSD sqlite3SharedCacheList = 0; +#endif +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Enable or disable the shared pager and schema features. +** +** This routine has no effect on existing database connections. +** The shared cache setting effects only future calls to +** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2(). +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_enable_shared_cache(int enable){ + sqlite3GlobalConfig.sharedCacheEnabled = enable; + return SQLITE_OK; +} +#endif + + + +#ifdef SQLITE_OMIT_SHARED_CACHE + /* + ** The functions querySharedCacheTableLock(), setSharedCacheTableLock(), + ** and clearAllSharedCacheTableLocks() + ** manipulate entries in the BtShared.pLock linked list used to store + ** shared-cache table level locks. If the library is compiled with the + ** shared-cache feature disabled, then there is only ever one user + ** of each BtShared structure and so this locking is not necessary. + ** So define the lock related functions as no-ops. + */ + #define querySharedCacheTableLock(a,b,c) SQLITE_OK + #define setSharedCacheTableLock(a,b,c) SQLITE_OK + #define clearAllSharedCacheTableLocks(a) + #define downgradeAllSharedCacheTableLocks(a) + #define hasSharedCacheTableLock(a,b,c,d) 1 + #define hasReadConflicts(a, b) 0 +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE + +#ifdef SQLITE_DEBUG +/* +**** This function is only used as part of an assert() statement. *** +** +** Check to see if pBtree holds the required locks to read or write to the +** table with root page iRoot. Return 1 if it does and 0 if not. +** +** For example, when writing to a table with root-page iRoot via +** Btree connection pBtree: +** +** assert( hasSharedCacheTableLock(pBtree, iRoot, 0, WRITE_LOCK) ); +** +** When writing to an index that resides in a sharable database, the +** caller should have first obtained a lock specifying the root page of +** the corresponding table. This makes things a bit more complicated, +** as this module treats each table as a separate structure. To determine +** the table corresponding to the index being written, this +** function has to search through the database schema. +** +** Instead of a lock on the table/index rooted at page iRoot, the caller may +** hold a write-lock on the schema table (root page 1). This is also +** acceptable. +*/ +static int hasSharedCacheTableLock( + Btree *pBtree, /* Handle that must hold lock */ + Pgno iRoot, /* Root page of b-tree */ + int isIndex, /* True if iRoot is the root of an index b-tree */ + int eLockType /* Required lock type (READ_LOCK or WRITE_LOCK) */ +){ + Schema *pSchema = (Schema *)pBtree->pBt->pSchema; + Pgno iTab = 0; + BtLock *pLock; + + /* If this database is not shareable, or if the client is reading + ** and has the read-uncommitted flag set, then no lock is required. + ** Return true immediately. + */ + if( (pBtree->sharable==0) + || (eLockType==READ_LOCK && (pBtree->db->flags & SQLITE_ReadUncommitted)) + ){ + return 1; + } + + /* If the client is reading or writing an index and the schema is + ** not loaded, then it is too difficult to actually check to see if + ** the correct locks are held. So do not bother - just return true. + ** This case does not come up very often anyhow. + */ + if( isIndex && (!pSchema || (pSchema->schemaFlags&DB_SchemaLoaded)==0) ){ + return 1; + } + + /* Figure out the root-page that the lock should be held on. For table + ** b-trees, this is just the root page of the b-tree being read or + ** written. For index b-trees, it is the root page of the associated + ** table. */ + if( isIndex ){ + HashElem *p; + for(p=sqliteHashFirst(&pSchema->idxHash); p; p=sqliteHashNext(p)){ + Index *pIdx = (Index *)sqliteHashData(p); + if( pIdx->tnum==(int)iRoot ){ + if( iTab ){ + /* Two or more indexes share the same root page. There must + ** be imposter tables. So just return true. The assert is not + ** useful in that case. */ + return 1; + } + iTab = pIdx->pTable->tnum; + } + } + }else{ + iTab = iRoot; + } + + /* Search for the required lock. Either a write-lock on root-page iTab, a + ** write-lock on the schema table, or (if the client is reading) a + ** read-lock on iTab will suffice. Return 1 if any of these are found. */ + for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){ + if( pLock->pBtree==pBtree + && (pLock->iTable==iTab || (pLock->eLock==WRITE_LOCK && pLock->iTable==1)) + && pLock->eLock>=eLockType + ){ + return 1; + } + } + + /* Failed to find the required lock. */ + return 0; +} +#endif /* SQLITE_DEBUG */ + +#ifdef SQLITE_DEBUG +/* +**** This function may be used as part of assert() statements only. **** +** +** Return true if it would be illegal for pBtree to write into the +** table or index rooted at iRoot because other shared connections are +** simultaneously reading that same table or index. +** +** It is illegal for pBtree to write if some other Btree object that +** shares the same BtShared object is currently reading or writing +** the iRoot table. Except, if the other Btree object has the +** read-uncommitted flag set, then it is OK for the other object to +** have a read cursor. +** +** For example, before writing to any part of the table or index +** rooted at page iRoot, one should call: +** +** assert( !hasReadConflicts(pBtree, iRoot) ); +*/ +static int hasReadConflicts(Btree *pBtree, Pgno iRoot){ + BtCursor *p; + for(p=pBtree->pBt->pCursor; p; p=p->pNext){ + if( p->pgnoRoot==iRoot + && p->pBtree!=pBtree + && 0==(p->pBtree->db->flags & SQLITE_ReadUncommitted) + ){ + return 1; + } + } + return 0; +} +#endif /* #ifdef SQLITE_DEBUG */ + +/* +** Query to see if Btree handle p may obtain a lock of type eLock +** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return +** SQLITE_OK if the lock may be obtained (by calling +** setSharedCacheTableLock()), or SQLITE_LOCKED if not. +*/ +static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){ + BtShared *pBt = p->pBt; + BtLock *pIter; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( eLock==READ_LOCK || eLock==WRITE_LOCK ); + assert( p->db!=0 ); + assert( !(p->db->flags&SQLITE_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 ); + + /* If requesting a write-lock, then the Btree must have an open write + ** transaction on this file. And, obviously, for this to be so there + ** must be an open write transaction on the file itself. + */ + assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) ); + assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE ); + + /* This routine is a no-op if the shared-cache is not enabled */ + if( !p->sharable ){ + return SQLITE_OK; + } + + /* If some other connection is holding an exclusive lock, the + ** requested lock may not be obtained. + */ + if( pBt->pWriter!=p && (pBt->btsFlags & BTS_EXCLUSIVE)!=0 ){ + sqlite3ConnectionBlocked(p->db, pBt->pWriter->db); + return SQLITE_LOCKED_SHAREDCACHE; + } + + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + /* The condition (pIter->eLock!=eLock) in the following if(...) + ** statement is a simplification of: + ** + ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK) + ** + ** since we know that if eLock==WRITE_LOCK, then no other connection + ** may hold a WRITE_LOCK on any table in this file (since there can + ** only be a single writer). + */ + assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK ); + assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK); + if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){ + sqlite3ConnectionBlocked(p->db, pIter->pBtree->db); + if( eLock==WRITE_LOCK ){ + assert( p==pBt->pWriter ); + pBt->btsFlags |= BTS_PENDING; + } + return SQLITE_LOCKED_SHAREDCACHE; + } + } + return SQLITE_OK; +} +#endif /* !SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Add a lock on the table with root-page iTable to the shared-btree used +** by Btree handle p. Parameter eLock must be either READ_LOCK or +** WRITE_LOCK. +** +** This function assumes the following: +** +** (a) The specified Btree object p is connected to a sharable +** database (one with the BtShared.sharable flag set), and +** +** (b) No other Btree objects hold a lock that conflicts +** with the requested lock (i.e. querySharedCacheTableLock() has +** already been called and returned SQLITE_OK). +** +** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM +** is returned if a malloc attempt fails. +*/ +static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){ + BtShared *pBt = p->pBt; + BtLock *pLock = 0; + BtLock *pIter; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( eLock==READ_LOCK || eLock==WRITE_LOCK ); + assert( p->db!=0 ); + + /* A connection with the read-uncommitted flag set will never try to + ** obtain a read-lock using this function. The only read-lock obtained + ** by a connection in read-uncommitted mode is on the sqlite_master + ** table, and that lock is obtained in BtreeBeginTrans(). */ + assert( 0==(p->db->flags&SQLITE_ReadUncommitted) || eLock==WRITE_LOCK ); + + /* This function should only be called on a sharable b-tree after it + ** has been determined that no other b-tree holds a conflicting lock. */ + assert( p->sharable ); + assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) ); + + /* First search the list for an existing lock on this table. */ + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + if( pIter->iTable==iTable && pIter->pBtree==p ){ + pLock = pIter; + break; + } + } + + /* If the above search did not find a BtLock struct associating Btree p + ** with table iTable, allocate one and link it into the list. + */ + if( !pLock ){ + pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock)); + if( !pLock ){ + return SQLITE_NOMEM; + } + pLock->iTable = iTable; + pLock->pBtree = p; + pLock->pNext = pBt->pLock; + pBt->pLock = pLock; + } + + /* Set the BtLock.eLock variable to the maximum of the current lock + ** and the requested lock. This means if a write-lock was already held + ** and a read-lock requested, we don't incorrectly downgrade the lock. + */ + assert( WRITE_LOCK>READ_LOCK ); + if( eLock>pLock->eLock ){ + pLock->eLock = eLock; + } + + return SQLITE_OK; +} +#endif /* !SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Release all the table locks (locks obtained via calls to +** the setSharedCacheTableLock() procedure) held by Btree object p. +** +** This function assumes that Btree p has an open read or write +** transaction. If it does not, then the BTS_PENDING flag +** may be incorrectly cleared. +*/ +static void clearAllSharedCacheTableLocks(Btree *p){ + BtShared *pBt = p->pBt; + BtLock **ppIter = &pBt->pLock; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( p->sharable || 0==*ppIter ); + assert( p->inTrans>0 ); + + while( *ppIter ){ + BtLock *pLock = *ppIter; + assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree ); + assert( pLock->pBtree->inTrans>=pLock->eLock ); + if( pLock->pBtree==p ){ + *ppIter = pLock->pNext; + assert( pLock->iTable!=1 || pLock==&p->lock ); + if( pLock->iTable!=1 ){ + sqlite3_free(pLock); + } + }else{ + ppIter = &pLock->pNext; + } + } + + assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter ); + if( pBt->pWriter==p ){ + pBt->pWriter = 0; + pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING); + }else if( pBt->nTransaction==2 ){ + /* This function is called when Btree p is concluding its + ** transaction. If there currently exists a writer, and p is not + ** that writer, then the number of locks held by connections other + ** than the writer must be about to drop to zero. In this case + ** set the BTS_PENDING flag to 0. + ** + ** If there is not currently a writer, then BTS_PENDING must + ** be zero already. So this next line is harmless in that case. + */ + pBt->btsFlags &= ~BTS_PENDING; + } +} + +/* +** This function changes all write-locks held by Btree p into read-locks. +*/ +static void downgradeAllSharedCacheTableLocks(Btree *p){ + BtShared *pBt = p->pBt; + if( pBt->pWriter==p ){ + BtLock *pLock; + pBt->pWriter = 0; + pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING); + for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){ + assert( pLock->eLock==READ_LOCK || pLock->pBtree==p ); + pLock->eLock = READ_LOCK; + } + } +} + +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +static void releasePage(MemPage *pPage); /* Forward reference */ + +/* +***** This routine is used inside of assert() only **** +** +** Verify that the cursor holds the mutex on its BtShared +*/ +#ifdef SQLITE_DEBUG +static int cursorHoldsMutex(BtCursor *p){ + return sqlite3_mutex_held(p->pBt->mutex); +} +#endif + +/* +** Invalidate the overflow cache of the cursor passed as the first argument. +** on the shared btree structure pBt. +*/ +#define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl) + +/* +** Invalidate the overflow page-list cache for all cursors opened +** on the shared btree structure pBt. +*/ +static void invalidateAllOverflowCache(BtShared *pBt){ + BtCursor *p; + assert( sqlite3_mutex_held(pBt->mutex) ); + for(p=pBt->pCursor; p; p=p->pNext){ + invalidateOverflowCache(p); + } +} + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** This function is called before modifying the contents of a table +** to invalidate any incrblob cursors that are open on the +** row or one of the rows being modified. +** +** If argument isClearTable is true, then the entire contents of the +** table is about to be deleted. In this case invalidate all incrblob +** cursors open on any row within the table with root-page pgnoRoot. +** +** Otherwise, if argument isClearTable is false, then the row with +** rowid iRow is being replaced or deleted. In this case invalidate +** only those incrblob cursors open on that specific row. +*/ +static void invalidateIncrblobCursors( + Btree *pBtree, /* The database file to check */ + i64 iRow, /* The rowid that might be changing */ + int isClearTable /* True if all rows are being deleted */ +){ + BtCursor *p; + if( pBtree->hasIncrblobCur==0 ) return; + assert( sqlite3BtreeHoldsMutex(pBtree) ); + pBtree->hasIncrblobCur = 0; + for(p=pBtree->pBt->pCursor; p; p=p->pNext){ + if( (p->curFlags & BTCF_Incrblob)!=0 ){ + pBtree->hasIncrblobCur = 1; + if( isClearTable || p->info.nKey==iRow ){ + p->eState = CURSOR_INVALID; + } + } + } +} + +#else + /* Stub function when INCRBLOB is omitted */ + #define invalidateIncrblobCursors(x,y,z) +#endif /* SQLITE_OMIT_INCRBLOB */ + +/* +** Set bit pgno of the BtShared.pHasContent bitvec. This is called +** when a page that previously contained data becomes a free-list leaf +** page. +** +** The BtShared.pHasContent bitvec exists to work around an obscure +** bug caused by the interaction of two useful IO optimizations surrounding +** free-list leaf pages: +** +** 1) When all data is deleted from a page and the page becomes +** a free-list leaf page, the page is not written to the database +** (as free-list leaf pages contain no meaningful data). Sometimes +** such a page is not even journalled (as it will not be modified, +** why bother journalling it?). +** +** 2) When a free-list leaf page is reused, its content is not read +** from the database or written to the journal file (why should it +** be, if it is not at all meaningful?). +** +** By themselves, these optimizations work fine and provide a handy +** performance boost to bulk delete or insert operations. However, if +** a page is moved to the free-list and then reused within the same +** transaction, a problem comes up. If the page is not journalled when +** it is moved to the free-list and it is also not journalled when it +** is extracted from the free-list and reused, then the original data +** may be lost. In the event of a rollback, it may not be possible +** to restore the database to its original configuration. +** +** The solution is the BtShared.pHasContent bitvec. Whenever a page is +** moved to become a free-list leaf page, the corresponding bit is +** set in the bitvec. Whenever a leaf page is extracted from the free-list, +** optimization 2 above is omitted if the corresponding bit is already +** set in BtShared.pHasContent. The contents of the bitvec are cleared +** at the end of every transaction. +*/ +static int btreeSetHasContent(BtShared *pBt, Pgno pgno){ + int rc = SQLITE_OK; + if( !pBt->pHasContent ){ + assert( pgno<=pBt->nPage ); + pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage); + if( !pBt->pHasContent ){ + rc = SQLITE_NOMEM; + } + } + if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){ + rc = sqlite3BitvecSet(pBt->pHasContent, pgno); + } + return rc; +} + +/* +** Query the BtShared.pHasContent vector. +** +** This function is called when a free-list leaf page is removed from the +** free-list for reuse. It returns false if it is safe to retrieve the +** page from the pager layer with the 'no-content' flag set. True otherwise. +*/ +static int btreeGetHasContent(BtShared *pBt, Pgno pgno){ + Bitvec *p = pBt->pHasContent; + return (p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTest(p, pgno))); +} + +/* +** Clear (destroy) the BtShared.pHasContent bitvec. This should be +** invoked at the conclusion of each write-transaction. +*/ +static void btreeClearHasContent(BtShared *pBt){ + sqlite3BitvecDestroy(pBt->pHasContent); + pBt->pHasContent = 0; +} + +/* +** Release all of the apPage[] pages for a cursor. +*/ +static void btreeReleaseAllCursorPages(BtCursor *pCur){ + int i; + for(i=0; i<=pCur->iPage; i++){ + releasePage(pCur->apPage[i]); + pCur->apPage[i] = 0; + } + pCur->iPage = -1; +} + +/* +** The cursor passed as the only argument must point to a valid entry +** when this function is called (i.e. have eState==CURSOR_VALID). This +** function saves the current cursor key in variables pCur->nKey and +** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error +** code otherwise. +** +** If the cursor is open on an intkey table, then the integer key +** (the rowid) is stored in pCur->nKey and pCur->pKey is left set to +** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is +** set to point to a malloced buffer pCur->nKey bytes in size containing +** the key. +*/ +static int saveCursorKey(BtCursor *pCur){ + int rc; + assert( CURSOR_VALID==pCur->eState ); + assert( 0==pCur->pKey ); + assert( cursorHoldsMutex(pCur) ); + + rc = sqlite3BtreeKeySize(pCur, &pCur->nKey); + assert( rc==SQLITE_OK ); /* KeySize() cannot fail */ + + /* If this is an intKey table, then the above call to BtreeKeySize() + ** stores the integer key in pCur->nKey. In this case this value is + ** all that is required. Otherwise, if pCur is not open on an intKey + ** table, then malloc space for and store the pCur->nKey bytes of key + ** data. */ + if( 0==pCur->curIntKey ){ + void *pKey = sqlite3Malloc( pCur->nKey ); + if( pKey ){ + rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey); + if( rc==SQLITE_OK ){ + pCur->pKey = pKey; + }else{ + sqlite3_free(pKey); + } + }else{ + rc = SQLITE_NOMEM; + } + } + assert( !pCur->curIntKey || !pCur->pKey ); + return rc; +} + +/* +** Save the current cursor position in the variables BtCursor.nKey +** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK. +** +** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID) +** prior to calling this routine. +*/ +static int saveCursorPosition(BtCursor *pCur){ + int rc; + + assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState ); + assert( 0==pCur->pKey ); + assert( cursorHoldsMutex(pCur) ); + + if( pCur->eState==CURSOR_SKIPNEXT ){ + pCur->eState = CURSOR_VALID; + }else{ + pCur->skipNext = 0; + } + + rc = saveCursorKey(pCur); + if( rc==SQLITE_OK ){ + btreeReleaseAllCursorPages(pCur); + pCur->eState = CURSOR_REQUIRESEEK; + } + + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast); + return rc; +} + +/* Forward reference */ +static int SQLITE_NOINLINE saveCursorsOnList(BtCursor*,Pgno,BtCursor*); + +/* +** Save the positions of all cursors (except pExcept) that are open on +** the table with root-page iRoot. "Saving the cursor position" means that +** the location in the btree is remembered in such a way that it can be +** moved back to the same spot after the btree has been modified. This +** routine is called just before cursor pExcept is used to modify the +** table, for example in BtreeDelete() or BtreeInsert(). +** +** If there are two or more cursors on the same btree, then all such +** cursors should have their BTCF_Multiple flag set. The btreeCursor() +** routine enforces that rule. This routine only needs to be called in +** the uncommon case when pExpect has the BTCF_Multiple flag set. +** +** If pExpect!=NULL and if no other cursors are found on the same root-page, +** then the BTCF_Multiple flag on pExpect is cleared, to avoid another +** pointless call to this routine. +** +** Implementation note: This routine merely checks to see if any cursors +** need to be saved. It calls out to saveCursorsOnList() in the (unusual) +** event that cursors are in need to being saved. +*/ +static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){ + BtCursor *p; + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pExcept==0 || pExcept->pBt==pBt ); + for(p=pBt->pCursor; p; p=p->pNext){ + if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ) break; + } + if( p ) return saveCursorsOnList(p, iRoot, pExcept); + if( pExcept ) pExcept->curFlags &= ~BTCF_Multiple; + return SQLITE_OK; +} + +/* This helper routine to saveAllCursors does the actual work of saving +** the cursors if and when a cursor is found that actually requires saving. +** The common case is that no cursors need to be saved, so this routine is +** broken out from its caller to avoid unnecessary stack pointer movement. +*/ +static int SQLITE_NOINLINE saveCursorsOnList( + BtCursor *p, /* The first cursor that needs saving */ + Pgno iRoot, /* Only save cursor with this iRoot. Save all if zero */ + BtCursor *pExcept /* Do not save this cursor */ +){ + do{ + if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ){ + if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){ + int rc = saveCursorPosition(p); + if( SQLITE_OK!=rc ){ + return rc; + } + }else{ + testcase( p->iPage>0 ); + btreeReleaseAllCursorPages(p); + } + } + p = p->pNext; + }while( p ); + return SQLITE_OK; +} + +/* +** Clear the current cursor position. +*/ +SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + sqlite3_free(pCur->pKey); + pCur->pKey = 0; + pCur->eState = CURSOR_INVALID; +} + +/* +** In this version of BtreeMoveto, pKey is a packed index record +** such as is generated by the OP_MakeRecord opcode. Unpack the +** record and then call BtreeMovetoUnpacked() to do the work. +*/ +static int btreeMoveto( + BtCursor *pCur, /* Cursor open on the btree to be searched */ + const void *pKey, /* Packed key if the btree is an index */ + i64 nKey, /* Integer key for tables. Size of pKey for indices */ + int bias, /* Bias search to the high end */ + int *pRes /* Write search results here */ +){ + int rc; /* Status code */ + UnpackedRecord *pIdxKey; /* Unpacked index key */ + char aSpace[200]; /* Temp space for pIdxKey - to avoid a malloc */ + char *pFree = 0; + + if( pKey ){ + assert( nKey==(i64)(int)nKey ); + pIdxKey = sqlite3VdbeAllocUnpackedRecord( + pCur->pKeyInfo, aSpace, sizeof(aSpace), &pFree + ); + if( pIdxKey==0 ) return SQLITE_NOMEM; + sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey); + if( pIdxKey->nField==0 ){ + sqlite3DbFree(pCur->pKeyInfo->db, pFree); + return SQLITE_CORRUPT_BKPT; + } + }else{ + pIdxKey = 0; + } + rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes); + if( pFree ){ + sqlite3DbFree(pCur->pKeyInfo->db, pFree); + } + return rc; +} + +/* +** Restore the cursor to the position it was in (or as close to as possible) +** when saveCursorPosition() was called. Note that this call deletes the +** saved position info stored by saveCursorPosition(), so there can be +** at most one effective restoreCursorPosition() call after each +** saveCursorPosition(). +*/ +static int btreeRestoreCursorPosition(BtCursor *pCur){ + int rc; + int skipNext; + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState>=CURSOR_REQUIRESEEK ); + if( pCur->eState==CURSOR_FAULT ){ + return pCur->skipNext; + } + pCur->eState = CURSOR_INVALID; + rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext); + if( rc==SQLITE_OK ){ + sqlite3_free(pCur->pKey); + pCur->pKey = 0; + assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID ); + pCur->skipNext |= skipNext; + if( pCur->skipNext && pCur->eState==CURSOR_VALID ){ + pCur->eState = CURSOR_SKIPNEXT; + } + } + return rc; +} + +#define restoreCursorPosition(p) \ + (p->eState>=CURSOR_REQUIRESEEK ? \ + btreeRestoreCursorPosition(p) : \ + SQLITE_OK) + +/* +** Determine whether or not a cursor has moved from the position where +** it was last placed, or has been invalidated for any other reason. +** Cursors can move when the row they are pointing at is deleted out +** from under them, for example. Cursor might also move if a btree +** is rebalanced. +** +** Calling this routine with a NULL cursor pointer returns false. +** +** Use the separate sqlite3BtreeCursorRestore() routine to restore a cursor +** back to where it ought to be if this routine returns true. +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){ + return pCur->eState!=CURSOR_VALID; +} + +/* +** This routine restores a cursor back to its original position after it +** has been moved by some outside activity (such as a btree rebalance or +** a row having been deleted out from under the cursor). +** +** On success, the *pDifferentRow parameter is false if the cursor is left +** pointing at exactly the same row. *pDifferntRow is the row the cursor +** was pointing to has been deleted, forcing the cursor to point to some +** nearby row. +** +** This routine should only be called for a cursor that just returned +** TRUE from sqlite3BtreeCursorHasMoved(). +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){ + int rc; + + assert( pCur!=0 ); + assert( pCur->eState!=CURSOR_VALID ); + rc = restoreCursorPosition(pCur); + if( rc ){ + *pDifferentRow = 1; + return rc; + } + if( pCur->eState!=CURSOR_VALID ){ + *pDifferentRow = 1; + }else{ + assert( pCur->skipNext==0 ); + *pDifferentRow = 0; + } + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Given a page number of a regular database page, return the page +** number for the pointer-map page that contains the entry for the +** input page number. +** +** Return 0 (not a valid page) for pgno==1 since there is +** no pointer map associated with page 1. The integrity_check logic +** requires that ptrmapPageno(*,1)!=1. +*/ +static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){ + int nPagesPerMapPage; + Pgno iPtrMap, ret; + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pgno<2 ) return 0; + nPagesPerMapPage = (pBt->usableSize/5)+1; + iPtrMap = (pgno-2)/nPagesPerMapPage; + ret = (iPtrMap*nPagesPerMapPage) + 2; + if( ret==PENDING_BYTE_PAGE(pBt) ){ + ret++; + } + return ret; +} + +/* +** Write an entry into the pointer map. +** +** This routine updates the pointer map entry for page number 'key' +** so that it maps to type 'eType' and parent page number 'pgno'. +** +** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is +** a no-op. If an error occurs, the appropriate error code is written +** into *pRC. +*/ +static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){ + DbPage *pDbPage; /* The pointer map page */ + u8 *pPtrmap; /* The pointer map data */ + Pgno iPtrmap; /* The pointer map page number */ + int offset; /* Offset in pointer map page */ + int rc; /* Return code from subfunctions */ + + if( *pRC ) return; + + assert( sqlite3_mutex_held(pBt->mutex) ); + /* The master-journal page number must never be used as a pointer map page */ + assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) ); + + assert( pBt->autoVacuum ); + if( key==0 ){ + *pRC = SQLITE_CORRUPT_BKPT; + return; + } + iPtrmap = PTRMAP_PAGENO(pBt, key); + rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage); + if( rc!=SQLITE_OK ){ + *pRC = rc; + return; + } + offset = PTRMAP_PTROFFSET(iPtrmap, key); + if( offset<0 ){ + *pRC = SQLITE_CORRUPT_BKPT; + goto ptrmap_exit; + } + assert( offset <= (int)pBt->usableSize-5 ); + pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); + + if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){ + TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent)); + *pRC= rc = sqlite3PagerWrite(pDbPage); + if( rc==SQLITE_OK ){ + pPtrmap[offset] = eType; + put4byte(&pPtrmap[offset+1], parent); + } + } + +ptrmap_exit: + sqlite3PagerUnref(pDbPage); +} + +/* +** Read an entry from the pointer map. +** +** This routine retrieves the pointer map entry for page 'key', writing +** the type and parent page number to *pEType and *pPgno respectively. +** An error code is returned if something goes wrong, otherwise SQLITE_OK. +*/ +static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){ + DbPage *pDbPage; /* The pointer map page */ + int iPtrmap; /* Pointer map page index */ + u8 *pPtrmap; /* Pointer map page data */ + int offset; /* Offset of entry in pointer map */ + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + + iPtrmap = PTRMAP_PAGENO(pBt, key); + rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage); + if( rc!=0 ){ + return rc; + } + pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); + + offset = PTRMAP_PTROFFSET(iPtrmap, key); + if( offset<0 ){ + sqlite3PagerUnref(pDbPage); + return SQLITE_CORRUPT_BKPT; + } + assert( offset <= (int)pBt->usableSize-5 ); + assert( pEType!=0 ); + *pEType = pPtrmap[offset]; + if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]); + + sqlite3PagerUnref(pDbPage); + if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_BKPT; + return SQLITE_OK; +} + +#else /* if defined SQLITE_OMIT_AUTOVACUUM */ + #define ptrmapPut(w,x,y,z,rc) + #define ptrmapGet(w,x,y,z) SQLITE_OK + #define ptrmapPutOvflPtr(x, y, rc) +#endif + +/* +** Given a btree page and a cell index (0 means the first cell on +** the page, 1 means the second cell, and so forth) return a pointer +** to the cell content. +** +** findCellPastPtr() does the same except it skips past the initial +** 4-byte child pointer found on interior pages, if there is one. +** +** This routine works only for pages that do not contain overflow cells. +*/ +#define findCell(P,I) \ + ((P)->aData + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)]))) +#define findCellPastPtr(P,I) \ + ((P)->aDataOfst + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)]))) + + +/* +** This is common tail processing for btreeParseCellPtr() and +** btreeParseCellPtrIndex() for the case when the cell does not fit entirely +** on a single B-tree page. Make necessary adjustments to the CellInfo +** structure. +*/ +static SQLITE_NOINLINE void btreeParseCellAdjustSizeForOverflow( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + /* If the payload will not fit completely on the local page, we have + ** to decide how much to store locally and how much to spill onto + ** overflow pages. The strategy is to minimize the amount of unused + ** space on overflow pages while keeping the amount of local storage + ** in between minLocal and maxLocal. + ** + ** Warning: changing the way overflow payload is distributed in any + ** way will result in an incompatible file format. + */ + int minLocal; /* Minimum amount of payload held locally */ + int maxLocal; /* Maximum amount of payload held locally */ + int surplus; /* Overflow payload available for local storage */ + + minLocal = pPage->minLocal; + maxLocal = pPage->maxLocal; + surplus = minLocal + (pInfo->nPayload - minLocal)%(pPage->pBt->usableSize-4); + testcase( surplus==maxLocal ); + testcase( surplus==maxLocal+1 ); + if( surplus <= maxLocal ){ + pInfo->nLocal = (u16)surplus; + }else{ + pInfo->nLocal = (u16)minLocal; + } + pInfo->iOverflow = (u16)(&pInfo->pPayload[pInfo->nLocal] - pCell); + pInfo->nSize = pInfo->iOverflow + 4; +} + +/* +** The following routines are implementations of the MemPage.xParseCell() +** method. +** +** Parse a cell content block and fill in the CellInfo structure. +** +** btreeParseCellPtr() => table btree leaf nodes +** btreeParseCellNoPayload() => table btree internal nodes +** btreeParseCellPtrIndex() => index btree nodes +** +** There is also a wrapper function btreeParseCell() that works for +** all MemPage types and that references the cell by index rather than +** by pointer. +*/ +static void btreeParseCellPtrNoPayload( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->leaf==0 ); + assert( pPage->noPayload ); + assert( pPage->childPtrSize==4 ); +#ifndef SQLITE_DEBUG + UNUSED_PARAMETER(pPage); +#endif + pInfo->nSize = 4 + getVarint(&pCell[4], (u64*)&pInfo->nKey); + pInfo->nPayload = 0; + pInfo->nLocal = 0; + pInfo->iOverflow = 0; + pInfo->pPayload = 0; + return; +} +static void btreeParseCellPtr( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + u8 *pIter; /* For scanning through pCell */ + u32 nPayload; /* Number of bytes of cell payload */ + u64 iKey; /* Extracted Key value */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->leaf==0 || pPage->leaf==1 ); + assert( pPage->intKeyLeaf || pPage->noPayload ); + assert( pPage->noPayload==0 ); + assert( pPage->intKeyLeaf ); + assert( pPage->childPtrSize==0 ); + pIter = pCell; + + /* The next block of code is equivalent to: + ** + ** pIter += getVarint32(pIter, nPayload); + ** + ** The code is inlined to avoid a function call. + */ + nPayload = *pIter; + if( nPayload>=0x80 ){ + u8 *pEnd = &pIter[8]; + nPayload &= 0x7f; + do{ + nPayload = (nPayload<<7) | (*++pIter & 0x7f); + }while( (*pIter)>=0x80 && pIternKey); + ** + ** The code is inlined to avoid a function call. + */ + iKey = *pIter; + if( iKey>=0x80 ){ + u8 *pEnd = &pIter[7]; + iKey &= 0x7f; + while(1){ + iKey = (iKey<<7) | (*++pIter & 0x7f); + if( (*pIter)<0x80 ) break; + if( pIter>=pEnd ){ + iKey = (iKey<<8) | *++pIter; + break; + } + } + } + pIter++; + + pInfo->nKey = *(i64*)&iKey; + pInfo->nPayload = nPayload; + pInfo->pPayload = pIter; + testcase( nPayload==pPage->maxLocal ); + testcase( nPayload==pPage->maxLocal+1 ); + if( nPayload<=pPage->maxLocal ){ + /* This is the (easy) common case where the entire payload fits + ** on the local page. No overflow is required. + */ + pInfo->nSize = nPayload + (u16)(pIter - pCell); + if( pInfo->nSize<4 ) pInfo->nSize = 4; + pInfo->nLocal = (u16)nPayload; + pInfo->iOverflow = 0; + }else{ + btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo); + } +} +static void btreeParseCellPtrIndex( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + u8 *pIter; /* For scanning through pCell */ + u32 nPayload; /* Number of bytes of cell payload */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->leaf==0 || pPage->leaf==1 ); + assert( pPage->intKeyLeaf==0 ); + assert( pPage->noPayload==0 ); + pIter = pCell + pPage->childPtrSize; + nPayload = *pIter; + if( nPayload>=0x80 ){ + u8 *pEnd = &pIter[8]; + nPayload &= 0x7f; + do{ + nPayload = (nPayload<<7) | (*++pIter & 0x7f); + }while( *(pIter)>=0x80 && pIternKey = nPayload; + pInfo->nPayload = nPayload; + pInfo->pPayload = pIter; + testcase( nPayload==pPage->maxLocal ); + testcase( nPayload==pPage->maxLocal+1 ); + if( nPayload<=pPage->maxLocal ){ + /* This is the (easy) common case where the entire payload fits + ** on the local page. No overflow is required. + */ + pInfo->nSize = nPayload + (u16)(pIter - pCell); + if( pInfo->nSize<4 ) pInfo->nSize = 4; + pInfo->nLocal = (u16)nPayload; + pInfo->iOverflow = 0; + }else{ + btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo); + } +} +static void btreeParseCell( + MemPage *pPage, /* Page containing the cell */ + int iCell, /* The cell index. First cell is 0 */ + CellInfo *pInfo /* Fill in this structure */ +){ + pPage->xParseCell(pPage, findCell(pPage, iCell), pInfo); +} + +/* +** The following routines are implementations of the MemPage.xCellSize +** method. +** +** Compute the total number of bytes that a Cell needs in the cell +** data area of the btree-page. The return number includes the cell +** data header and the local payload, but not any overflow page or +** the space used by the cell pointer. +** +** cellSizePtrNoPayload() => table internal nodes +** cellSizePtr() => all index nodes & table leaf nodes +*/ +static u16 cellSizePtr(MemPage *pPage, u8 *pCell){ + u8 *pIter = pCell + pPage->childPtrSize; /* For looping over bytes of pCell */ + u8 *pEnd; /* End mark for a varint */ + u32 nSize; /* Size value to return */ + +#ifdef SQLITE_DEBUG + /* The value returned by this function should always be the same as + ** the (CellInfo.nSize) value found by doing a full parse of the + ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of + ** this function verifies that this invariant is not violated. */ + CellInfo debuginfo; + pPage->xParseCell(pPage, pCell, &debuginfo); +#endif + + assert( pPage->noPayload==0 ); + nSize = *pIter; + if( nSize>=0x80 ){ + pEnd = &pIter[8]; + nSize &= 0x7f; + do{ + nSize = (nSize<<7) | (*++pIter & 0x7f); + }while( *(pIter)>=0x80 && pIterintKey ){ + /* pIter now points at the 64-bit integer key value, a variable length + ** integer. The following block moves pIter to point at the first byte + ** past the end of the key value. */ + pEnd = &pIter[9]; + while( (*pIter++)&0x80 && pItermaxLocal ); + testcase( nSize==pPage->maxLocal+1 ); + if( nSize<=pPage->maxLocal ){ + nSize += (u32)(pIter - pCell); + if( nSize<4 ) nSize = 4; + }else{ + int minLocal = pPage->minLocal; + nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4); + testcase( nSize==pPage->maxLocal ); + testcase( nSize==pPage->maxLocal+1 ); + if( nSize>pPage->maxLocal ){ + nSize = minLocal; + } + nSize += 4 + (u16)(pIter - pCell); + } + assert( nSize==debuginfo.nSize || CORRUPT_DB ); + return (u16)nSize; +} +static u16 cellSizePtrNoPayload(MemPage *pPage, u8 *pCell){ + u8 *pIter = pCell + 4; /* For looping over bytes of pCell */ + u8 *pEnd; /* End mark for a varint */ + +#ifdef SQLITE_DEBUG + /* The value returned by this function should always be the same as + ** the (CellInfo.nSize) value found by doing a full parse of the + ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of + ** this function verifies that this invariant is not violated. */ + CellInfo debuginfo; + pPage->xParseCell(pPage, pCell, &debuginfo); +#else + UNUSED_PARAMETER(pPage); +#endif + + assert( pPage->childPtrSize==4 ); + pEnd = pIter + 9; + while( (*pIter++)&0x80 && pIterxCellSize(pPage, findCell(pPage, iCell)); +} +#endif + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** If the cell pCell, part of page pPage contains a pointer +** to an overflow page, insert an entry into the pointer-map +** for the overflow page. +*/ +static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){ + CellInfo info; + if( *pRC ) return; + assert( pCell!=0 ); + pPage->xParseCell(pPage, pCell, &info); + if( info.iOverflow ){ + Pgno ovfl = get4byte(&pCell[info.iOverflow]); + ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC); + } +} +#endif + + +/* +** Defragment the page given. All Cells are moved to the +** end of the page and all free space is collected into one +** big FreeBlk that occurs in between the header and cell +** pointer array and the cell content area. +** +** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a +** b-tree page so that there are no freeblocks or fragment bytes, all +** unused bytes are contained in the unallocated space region, and all +** cells are packed tightly at the end of the page. +*/ +static int defragmentPage(MemPage *pPage){ + int i; /* Loop counter */ + int pc; /* Address of the i-th cell */ + int hdr; /* Offset to the page header */ + int size; /* Size of a cell */ + int usableSize; /* Number of usable bytes on a page */ + int cellOffset; /* Offset to the cell pointer array */ + int cbrk; /* Offset to the cell content area */ + int nCell; /* Number of cells on the page */ + unsigned char *data; /* The page data */ + unsigned char *temp; /* Temp area for cell content */ + unsigned char *src; /* Source of content */ + int iCellFirst; /* First allowable cell index */ + int iCellLast; /* Last possible cell index */ + + + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( pPage->pBt!=0 ); + assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE ); + assert( pPage->nOverflow==0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + temp = 0; + src = data = pPage->aData; + hdr = pPage->hdrOffset; + cellOffset = pPage->cellOffset; + nCell = pPage->nCell; + assert( nCell==get2byte(&data[hdr+3]) ); + usableSize = pPage->pBt->usableSize; + cbrk = usableSize; + iCellFirst = cellOffset + 2*nCell; + iCellLast = usableSize - 4; + for(i=0; iiCellLast ){ + return SQLITE_CORRUPT_BKPT; + } + assert( pc>=iCellFirst && pc<=iCellLast ); + size = pPage->xCellSize(pPage, &src[pc]); + cbrk -= size; + if( cbrkusableSize ){ + return SQLITE_CORRUPT_BKPT; + } + assert( cbrk+size<=usableSize && cbrk>=iCellFirst ); + testcase( cbrk+size==usableSize ); + testcase( pc+size==usableSize ); + put2byte(pAddr, cbrk); + if( temp==0 ){ + int x; + if( cbrk==pc ) continue; + temp = sqlite3PagerTempSpace(pPage->pBt->pPager); + x = get2byte(&data[hdr+5]); + memcpy(&temp[x], &data[x], (cbrk+size) - x); + src = temp; + } + memcpy(&data[cbrk], &src[pc], size); + } + assert( cbrk>=iCellFirst ); + put2byte(&data[hdr+5], cbrk); + data[hdr+1] = 0; + data[hdr+2] = 0; + data[hdr+7] = 0; + memset(&data[iCellFirst], 0, cbrk-iCellFirst); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + if( cbrk-iCellFirst!=pPage->nFree ){ + return SQLITE_CORRUPT_BKPT; + } + return SQLITE_OK; +} + +/* +** Search the free-list on page pPg for space to store a cell nByte bytes in +** size. If one can be found, return a pointer to the space and remove it +** from the free-list. +** +** If no suitable space can be found on the free-list, return NULL. +** +** This function may detect corruption within pPg. If corruption is +** detected then *pRc is set to SQLITE_CORRUPT and NULL is returned. +** +** Slots on the free list that are between 1 and 3 bytes larger than nByte +** will be ignored if adding the extra space to the fragmentation count +** causes the fragmentation count to exceed 60. +*/ +static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){ + const int hdr = pPg->hdrOffset; + u8 * const aData = pPg->aData; + int iAddr = hdr + 1; + int pc = get2byte(&aData[iAddr]); + int x; + int usableSize = pPg->pBt->usableSize; + + assert( pc>0 ); + do{ + int size; /* Size of the free slot */ + /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of + ** increasing offset. */ + if( pc>usableSize-4 || pc=0 ){ + testcase( x==4 ); + testcase( x==3 ); + if( pc < pPg->cellOffset+2*pPg->nCell || size+pc > usableSize ){ + *pRc = SQLITE_CORRUPT_BKPT; + return 0; + }else if( x<4 ){ + /* EVIDENCE-OF: R-11498-58022 In a well-formed b-tree page, the total + ** number of bytes in fragments may not exceed 60. */ + if( aData[hdr+7]>57 ) return 0; + + /* Remove the slot from the free-list. Update the number of + ** fragmented bytes within the page. */ + memcpy(&aData[iAddr], &aData[pc], 2); + aData[hdr+7] += (u8)x; + }else{ + /* The slot remains on the free-list. Reduce its size to account + ** for the portion used by the new allocation. */ + put2byte(&aData[pc+2], x); + } + return &aData[pc + x]; + } + iAddr = pc; + pc = get2byte(&aData[pc]); + }while( pc ); + + return 0; +} + +/* +** Allocate nByte bytes of space from within the B-Tree page passed +** as the first argument. Write into *pIdx the index into pPage->aData[] +** of the first byte of allocated space. Return either SQLITE_OK or +** an error code (usually SQLITE_CORRUPT). +** +** The caller guarantees that there is sufficient space to make the +** allocation. This routine might need to defragment in order to bring +** all the space together, however. This routine will avoid using +** the first two bytes past the cell pointer area since presumably this +** allocation is being made in order to insert a new cell, so we will +** also end up needing a new cell pointer. +*/ +static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){ + const int hdr = pPage->hdrOffset; /* Local cache of pPage->hdrOffset */ + u8 * const data = pPage->aData; /* Local cache of pPage->aData */ + int top; /* First byte of cell content area */ + int rc = SQLITE_OK; /* Integer return code */ + int gap; /* First byte of gap between cell pointers and cell content */ + + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( pPage->pBt ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( nByte>=0 ); /* Minimum cell size is 4 */ + assert( pPage->nFree>=nByte ); + assert( pPage->nOverflow==0 ); + assert( nByte < (int)(pPage->pBt->usableSize-8) ); + + assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf ); + gap = pPage->cellOffset + 2*pPage->nCell; + assert( gap<=65536 ); + /* EVIDENCE-OF: R-29356-02391 If the database uses a 65536-byte page size + ** and the reserved space is zero (the usual value for reserved space) + ** then the cell content offset of an empty page wants to be 65536. + ** However, that integer is too large to be stored in a 2-byte unsigned + ** integer, so a value of 0 is used in its place. */ + top = get2byte(&data[hdr+5]); + assert( top<=(int)pPage->pBt->usableSize ); /* Prevent by getAndInitPage() */ + if( gap>top ){ + if( top==0 && pPage->pBt->usableSize==65536 ){ + top = 65536; + }else{ + return SQLITE_CORRUPT_BKPT; + } + } + + /* If there is enough space between gap and top for one more cell pointer + ** array entry offset, and if the freelist is not empty, then search the + ** freelist looking for a free slot big enough to satisfy the request. + */ + testcase( gap+2==top ); + testcase( gap+1==top ); + testcase( gap==top ); + if( (data[hdr+2] || data[hdr+1]) && gap+2<=top ){ + u8 *pSpace = pageFindSlot(pPage, nByte, &rc); + if( pSpace ){ + assert( pSpace>=data && (pSpace - data)<65536 ); + *pIdx = (int)(pSpace - data); + return SQLITE_OK; + }else if( rc ){ + return rc; + } + } + + /* The request could not be fulfilled using a freelist slot. Check + ** to see if defragmentation is necessary. + */ + testcase( gap+2+nByte==top ); + if( gap+2+nByte>top ){ + assert( pPage->nCell>0 || CORRUPT_DB ); + rc = defragmentPage(pPage); + if( rc ) return rc; + top = get2byteNotZero(&data[hdr+5]); + assert( gap+nByte<=top ); + } + + + /* Allocate memory from the gap in between the cell pointer array + ** and the cell content area. The btreeInitPage() call has already + ** validated the freelist. Given that the freelist is valid, there + ** is no way that the allocation can extend off the end of the page. + ** The assert() below verifies the previous sentence. + */ + top -= nByte; + put2byte(&data[hdr+5], top); + assert( top+nByte <= (int)pPage->pBt->usableSize ); + *pIdx = top; + return SQLITE_OK; +} + +/* +** Return a section of the pPage->aData to the freelist. +** The first byte of the new free block is pPage->aData[iStart] +** and the size of the block is iSize bytes. +** +** Adjacent freeblocks are coalesced. +** +** Note that even though the freeblock list was checked by btreeInitPage(), +** that routine will not detect overlap between cells or freeblocks. Nor +** does it detect cells or freeblocks that encrouch into the reserved bytes +** at the end of the page. So do additional corruption checks inside this +** routine and return SQLITE_CORRUPT if any problems are found. +*/ +static int freeSpace(MemPage *pPage, u16 iStart, u16 iSize){ + u16 iPtr; /* Address of ptr to next freeblock */ + u16 iFreeBlk; /* Address of the next freeblock */ + u8 hdr; /* Page header size. 0 or 100 */ + u8 nFrag = 0; /* Reduction in fragmentation */ + u16 iOrigSize = iSize; /* Original value of iSize */ + u32 iLast = pPage->pBt->usableSize-4; /* Largest possible freeblock offset */ + u32 iEnd = iStart + iSize; /* First byte past the iStart buffer */ + unsigned char *data = pPage->aData; /* Page content */ + + assert( pPage->pBt!=0 ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( CORRUPT_DB || iStart>=pPage->hdrOffset+6+pPage->childPtrSize ); + assert( CORRUPT_DB || iEnd <= pPage->pBt->usableSize ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( iSize>=4 ); /* Minimum cell size is 4 */ + assert( iStart<=iLast ); + + /* Overwrite deleted information with zeros when the secure_delete + ** option is enabled */ + if( pPage->pBt->btsFlags & BTS_SECURE_DELETE ){ + memset(&data[iStart], 0, iSize); + } + + /* The list of freeblocks must be in ascending order. Find the + ** spot on the list where iStart should be inserted. + */ + hdr = pPage->hdrOffset; + iPtr = hdr + 1; + if( data[iPtr+1]==0 && data[iPtr]==0 ){ + iFreeBlk = 0; /* Shortcut for the case when the freelist is empty */ + }else{ + while( (iFreeBlk = get2byte(&data[iPtr]))>0 && iFreeBlkiLast ) return SQLITE_CORRUPT_BKPT; + assert( iFreeBlk>iPtr || iFreeBlk==0 ); + + /* At this point: + ** iFreeBlk: First freeblock after iStart, or zero if none + ** iPtr: The address of a pointer to iFreeBlk + ** + ** Check to see if iFreeBlk should be coalesced onto the end of iStart. + */ + if( iFreeBlk && iEnd+3>=iFreeBlk ){ + nFrag = iFreeBlk - iEnd; + if( iEnd>iFreeBlk ) return SQLITE_CORRUPT_BKPT; + iEnd = iFreeBlk + get2byte(&data[iFreeBlk+2]); + if( iEnd > pPage->pBt->usableSize ) return SQLITE_CORRUPT_BKPT; + iSize = iEnd - iStart; + iFreeBlk = get2byte(&data[iFreeBlk]); + } + + /* If iPtr is another freeblock (that is, if iPtr is not the freelist + ** pointer in the page header) then check to see if iStart should be + ** coalesced onto the end of iPtr. + */ + if( iPtr>hdr+1 ){ + int iPtrEnd = iPtr + get2byte(&data[iPtr+2]); + if( iPtrEnd+3>=iStart ){ + if( iPtrEnd>iStart ) return SQLITE_CORRUPT_BKPT; + nFrag += iStart - iPtrEnd; + iSize = iEnd - iPtr; + iStart = iPtr; + } + } + if( nFrag>data[hdr+7] ) return SQLITE_CORRUPT_BKPT; + data[hdr+7] -= nFrag; + } + if( iStart==get2byte(&data[hdr+5]) ){ + /* The new freeblock is at the beginning of the cell content area, + ** so just extend the cell content area rather than create another + ** freelist entry */ + if( iPtr!=hdr+1 ) return SQLITE_CORRUPT_BKPT; + put2byte(&data[hdr+1], iFreeBlk); + put2byte(&data[hdr+5], iEnd); + }else{ + /* Insert the new freeblock into the freelist */ + put2byte(&data[iPtr], iStart); + put2byte(&data[iStart], iFreeBlk); + put2byte(&data[iStart+2], iSize); + } + pPage->nFree += iOrigSize; + return SQLITE_OK; +} + +/* +** Decode the flags byte (the first byte of the header) for a page +** and initialize fields of the MemPage structure accordingly. +** +** Only the following combinations are supported. Anything different +** indicates a corrupt database files: +** +** PTF_ZERODATA +** PTF_ZERODATA | PTF_LEAF +** PTF_LEAFDATA | PTF_INTKEY +** PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF +*/ +static int decodeFlags(MemPage *pPage, int flagByte){ + BtShared *pBt; /* A copy of pPage->pBt */ + + assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 ); + flagByte &= ~PTF_LEAF; + pPage->childPtrSize = 4-4*pPage->leaf; + pPage->xCellSize = cellSizePtr; + pBt = pPage->pBt; + if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){ + /* EVIDENCE-OF: R-03640-13415 A value of 5 means the page is an interior + ** table b-tree page. */ + assert( (PTF_LEAFDATA|PTF_INTKEY)==5 ); + /* EVIDENCE-OF: R-20501-61796 A value of 13 means the page is a leaf + ** table b-tree page. */ + assert( (PTF_LEAFDATA|PTF_INTKEY|PTF_LEAF)==13 ); + pPage->intKey = 1; + if( pPage->leaf ){ + pPage->intKeyLeaf = 1; + pPage->noPayload = 0; + pPage->xParseCell = btreeParseCellPtr; + }else{ + pPage->intKeyLeaf = 0; + pPage->noPayload = 1; + pPage->xCellSize = cellSizePtrNoPayload; + pPage->xParseCell = btreeParseCellPtrNoPayload; + } + pPage->maxLocal = pBt->maxLeaf; + pPage->minLocal = pBt->minLeaf; + }else if( flagByte==PTF_ZERODATA ){ + /* EVIDENCE-OF: R-27225-53936 A value of 2 means the page is an interior + ** index b-tree page. */ + assert( (PTF_ZERODATA)==2 ); + /* EVIDENCE-OF: R-16571-11615 A value of 10 means the page is a leaf + ** index b-tree page. */ + assert( (PTF_ZERODATA|PTF_LEAF)==10 ); + pPage->intKey = 0; + pPage->intKeyLeaf = 0; + pPage->noPayload = 0; + pPage->xParseCell = btreeParseCellPtrIndex; + pPage->maxLocal = pBt->maxLocal; + pPage->minLocal = pBt->minLocal; + }else{ + /* EVIDENCE-OF: R-47608-56469 Any other value for the b-tree page type is + ** an error. */ + return SQLITE_CORRUPT_BKPT; + } + pPage->max1bytePayload = pBt->max1bytePayload; + return SQLITE_OK; +} + +/* +** Initialize the auxiliary information for a disk block. +** +** Return SQLITE_OK on success. If we see that the page does +** not contain a well-formed database page, then return +** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not +** guarantee that the page is well-formed. It only shows that +** we failed to detect any corruption. +*/ +static int btreeInitPage(MemPage *pPage){ + + assert( pPage->pBt!=0 ); + assert( pPage->pBt->db!=0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); + assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) ); + assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) ); + + if( !pPage->isInit ){ + u16 pc; /* Address of a freeblock within pPage->aData[] */ + u8 hdr; /* Offset to beginning of page header */ + u8 *data; /* Equal to pPage->aData */ + BtShared *pBt; /* The main btree structure */ + int usableSize; /* Amount of usable space on each page */ + u16 cellOffset; /* Offset from start of page to first cell pointer */ + int nFree; /* Number of unused bytes on the page */ + int top; /* First byte of the cell content area */ + int iCellFirst; /* First allowable cell or freeblock offset */ + int iCellLast; /* Last possible cell or freeblock offset */ + + pBt = pPage->pBt; + + hdr = pPage->hdrOffset; + data = pPage->aData; + /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating + ** the b-tree page type. */ + if( decodeFlags(pPage, data[hdr]) ) return SQLITE_CORRUPT_BKPT; + assert( pBt->pageSize>=512 && pBt->pageSize<=65536 ); + pPage->maskPage = (u16)(pBt->pageSize - 1); + pPage->nOverflow = 0; + usableSize = pBt->usableSize; + pPage->cellOffset = cellOffset = hdr + 8 + pPage->childPtrSize; + pPage->aDataEnd = &data[usableSize]; + pPage->aCellIdx = &data[cellOffset]; + pPage->aDataOfst = &data[pPage->childPtrSize]; + /* EVIDENCE-OF: R-58015-48175 The two-byte integer at offset 5 designates + ** the start of the cell content area. A zero value for this integer is + ** interpreted as 65536. */ + top = get2byteNotZero(&data[hdr+5]); + /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the + ** number of cells on the page. */ + pPage->nCell = get2byte(&data[hdr+3]); + if( pPage->nCell>MX_CELL(pBt) ){ + /* To many cells for a single page. The page must be corrupt */ + return SQLITE_CORRUPT_BKPT; + } + testcase( pPage->nCell==MX_CELL(pBt) ); + /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only + ** possible for a root page of a table that contains no rows) then the + ** offset to the cell content area will equal the page size minus the + ** bytes of reserved space. */ + assert( pPage->nCell>0 || top==usableSize || CORRUPT_DB ); + + /* A malformed database page might cause us to read past the end + ** of page when parsing a cell. + ** + ** The following block of code checks early to see if a cell extends + ** past the end of a page boundary and causes SQLITE_CORRUPT to be + ** returned if it does. + */ + iCellFirst = cellOffset + 2*pPage->nCell; + iCellLast = usableSize - 4; + if( pBt->db->flags & SQLITE_CellSizeCk ){ + int i; /* Index into the cell pointer array */ + int sz; /* Size of a cell */ + + if( !pPage->leaf ) iCellLast--; + for(i=0; inCell; i++){ + pc = get2byteAligned(&data[cellOffset+i*2]); + testcase( pc==iCellFirst ); + testcase( pc==iCellLast ); + if( pciCellLast ){ + return SQLITE_CORRUPT_BKPT; + } + sz = pPage->xCellSize(pPage, &data[pc]); + testcase( pc+sz==usableSize ); + if( pc+sz>usableSize ){ + return SQLITE_CORRUPT_BKPT; + } + } + if( !pPage->leaf ) iCellLast++; + } + + /* Compute the total free space on the page + ** EVIDENCE-OF: R-23588-34450 The two-byte integer at offset 1 gives the + ** start of the first freeblock on the page, or is zero if there are no + ** freeblocks. */ + pc = get2byte(&data[hdr+1]); + nFree = data[hdr+7] + top; /* Init nFree to non-freeblock free space */ + while( pc>0 ){ + u16 next, size; + if( pciCellLast ){ + /* EVIDENCE-OF: R-55530-52930 In a well-formed b-tree page, there will + ** always be at least one cell before the first freeblock. + ** + ** Or, the freeblock is off the end of the page + */ + return SQLITE_CORRUPT_BKPT; + } + next = get2byte(&data[pc]); + size = get2byte(&data[pc+2]); + if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){ + /* Free blocks must be in ascending order. And the last byte of + ** the free-block must lie on the database page. */ + return SQLITE_CORRUPT_BKPT; + } + nFree = nFree + size; + pc = next; + } + + /* At this point, nFree contains the sum of the offset to the start + ** of the cell-content area plus the number of free bytes within + ** the cell-content area. If this is greater than the usable-size + ** of the page, then the page must be corrupted. This check also + ** serves to verify that the offset to the start of the cell-content + ** area, according to the page header, lies within the page. + */ + if( nFree>usableSize ){ + return SQLITE_CORRUPT_BKPT; + } + pPage->nFree = (u16)(nFree - iCellFirst); + pPage->isInit = 1; + } + return SQLITE_OK; +} + +/* +** Set up a raw page so that it looks like a database page holding +** no entries. +*/ +static void zeroPage(MemPage *pPage, int flags){ + unsigned char *data = pPage->aData; + BtShared *pBt = pPage->pBt; + u8 hdr = pPage->hdrOffset; + u16 first; + + assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno ); + assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); + assert( sqlite3PagerGetData(pPage->pDbPage) == data ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pBt->btsFlags & BTS_SECURE_DELETE ){ + memset(&data[hdr], 0, pBt->usableSize - hdr); + } + data[hdr] = (char)flags; + first = hdr + ((flags&PTF_LEAF)==0 ? 12 : 8); + memset(&data[hdr+1], 0, 4); + data[hdr+7] = 0; + put2byte(&data[hdr+5], pBt->usableSize); + pPage->nFree = (u16)(pBt->usableSize - first); + decodeFlags(pPage, flags); + pPage->cellOffset = first; + pPage->aDataEnd = &data[pBt->usableSize]; + pPage->aCellIdx = &data[first]; + pPage->aDataOfst = &data[pPage->childPtrSize]; + pPage->nOverflow = 0; + assert( pBt->pageSize>=512 && pBt->pageSize<=65536 ); + pPage->maskPage = (u16)(pBt->pageSize - 1); + pPage->nCell = 0; + pPage->isInit = 1; +} + + +/* +** Convert a DbPage obtained from the pager into a MemPage used by +** the btree layer. +*/ +static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){ + MemPage *pPage = (MemPage*)sqlite3PagerGetExtra(pDbPage); + pPage->aData = sqlite3PagerGetData(pDbPage); + pPage->pDbPage = pDbPage; + pPage->pBt = pBt; + pPage->pgno = pgno; + pPage->hdrOffset = pgno==1 ? 100 : 0; + return pPage; +} + +/* +** Get a page from the pager. Initialize the MemPage.pBt and +** MemPage.aData elements if needed. See also: btreeGetUnusedPage(). +** +** If the PAGER_GET_NOCONTENT flag is set, it means that we do not care +** about the content of the page at this time. So do not go to the disk +** to fetch the content. Just fill in the content with zeros for now. +** If in the future we call sqlite3PagerWrite() on this page, that +** means we have started to be concerned about content and the disk +** read should occur at that point. +*/ +static int btreeGetPage( + BtShared *pBt, /* The btree */ + Pgno pgno, /* Number of the page to fetch */ + MemPage **ppPage, /* Return the page in this parameter */ + int flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */ +){ + int rc; + DbPage *pDbPage; + + assert( flags==0 || flags==PAGER_GET_NOCONTENT || flags==PAGER_GET_READONLY ); + assert( sqlite3_mutex_held(pBt->mutex) ); + rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, flags); + if( rc ) return rc; + *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt); + return SQLITE_OK; +} + +/* +** Retrieve a page from the pager cache. If the requested page is not +** already in the pager cache return NULL. Initialize the MemPage.pBt and +** MemPage.aData elements if needed. +*/ +static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){ + DbPage *pDbPage; + assert( sqlite3_mutex_held(pBt->mutex) ); + pDbPage = sqlite3PagerLookup(pBt->pPager, pgno); + if( pDbPage ){ + return btreePageFromDbPage(pDbPage, pgno, pBt); + } + return 0; +} + +/* +** Return the size of the database file in pages. If there is any kind of +** error, return ((unsigned int)-1). +*/ +static Pgno btreePagecount(BtShared *pBt){ + return pBt->nPage; +} +SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree *p){ + assert( sqlite3BtreeHoldsMutex(p) ); + assert( ((p->pBt->nPage)&0x8000000)==0 ); + return btreePagecount(p->pBt); +} + +/* +** Get a page from the pager and initialize it. +** +** If pCur!=0 then the page is being fetched as part of a moveToChild() +** call. Do additional sanity checking on the page in this case. +** And if the fetch fails, this routine must decrement pCur->iPage. +** +** The page is fetched as read-write unless pCur is not NULL and is +** a read-only cursor. +** +** If an error occurs, then *ppPage is undefined. It +** may remain unchanged, or it may be set to an invalid value. +*/ +static int getAndInitPage( + BtShared *pBt, /* The database file */ + Pgno pgno, /* Number of the page to get */ + MemPage **ppPage, /* Write the page pointer here */ + BtCursor *pCur, /* Cursor to receive the page, or NULL */ + int bReadOnly /* True for a read-only page */ +){ + int rc; + DbPage *pDbPage; + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pCur==0 || ppPage==&pCur->apPage[pCur->iPage] ); + assert( pCur==0 || bReadOnly==pCur->curPagerFlags ); + assert( pCur==0 || pCur->iPage>0 ); + + if( pgno>btreePagecount(pBt) ){ + rc = SQLITE_CORRUPT_BKPT; + goto getAndInitPage_error; + } + rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly); + if( rc ){ + goto getAndInitPage_error; + } + *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt); + if( (*ppPage)->isInit==0 ){ + rc = btreeInitPage(*ppPage); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + goto getAndInitPage_error; + } + } + + /* If obtaining a child page for a cursor, we must verify that the page is + ** compatible with the root page. */ + if( pCur + && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) + ){ + rc = SQLITE_CORRUPT_BKPT; + releasePage(*ppPage); + goto getAndInitPage_error; + } + return SQLITE_OK; + +getAndInitPage_error: + if( pCur ) pCur->iPage--; + testcase( pgno==0 ); + assert( pgno!=0 || rc==SQLITE_CORRUPT ); + return rc; +} + +/* +** Release a MemPage. This should be called once for each prior +** call to btreeGetPage. +*/ +static void releasePageNotNull(MemPage *pPage){ + assert( pPage->aData ); + assert( pPage->pBt ); + assert( pPage->pDbPage!=0 ); + assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); + assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + sqlite3PagerUnrefNotNull(pPage->pDbPage); +} +static void releasePage(MemPage *pPage){ + if( pPage ) releasePageNotNull(pPage); +} + +/* +** Get an unused page. +** +** This works just like btreeGetPage() with the addition: +** +** * If the page is already in use for some other purpose, immediately +** release it and return an SQLITE_CURRUPT error. +** * Make sure the isInit flag is clear +*/ +static int btreeGetUnusedPage( + BtShared *pBt, /* The btree */ + Pgno pgno, /* Number of the page to fetch */ + MemPage **ppPage, /* Return the page in this parameter */ + int flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */ +){ + int rc = btreeGetPage(pBt, pgno, ppPage, flags); + if( rc==SQLITE_OK ){ + if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){ + releasePage(*ppPage); + *ppPage = 0; + return SQLITE_CORRUPT_BKPT; + } + (*ppPage)->isInit = 0; + }else{ + *ppPage = 0; + } + return rc; +} + + +/* +** During a rollback, when the pager reloads information into the cache +** so that the cache is restored to its original state at the start of +** the transaction, for each page restored this routine is called. +** +** This routine needs to reset the extra data section at the end of the +** page to agree with the restored data. +*/ +static void pageReinit(DbPage *pData){ + MemPage *pPage; + pPage = (MemPage *)sqlite3PagerGetExtra(pData); + assert( sqlite3PagerPageRefcount(pData)>0 ); + if( pPage->isInit ){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pPage->isInit = 0; + if( sqlite3PagerPageRefcount(pData)>1 ){ + /* pPage might not be a btree page; it might be an overflow page + ** or ptrmap page or a free page. In those cases, the following + ** call to btreeInitPage() will likely return SQLITE_CORRUPT. + ** But no harm is done by this. And it is very important that + ** btreeInitPage() be called on every btree page so we make + ** the call for every page that comes in for re-initing. */ + btreeInitPage(pPage); + } + } +} + +/* +** Invoke the busy handler for a btree. +*/ +static int btreeInvokeBusyHandler(void *pArg){ + BtShared *pBt = (BtShared*)pArg; + assert( pBt->db ); + assert( sqlite3_mutex_held(pBt->db->mutex) ); + return sqlite3InvokeBusyHandler(&pBt->db->busyHandler); +} + +/* +** Open a database file. +** +** zFilename is the name of the database file. If zFilename is NULL +** then an ephemeral database is created. The ephemeral database might +** be exclusively in memory, or it might use a disk-based memory cache. +** Either way, the ephemeral database will be automatically deleted +** when sqlite3BtreeClose() is called. +** +** If zFilename is ":memory:" then an in-memory database is created +** that is automatically destroyed when it is closed. +** +** The "flags" parameter is a bitmask that might contain bits like +** BTREE_OMIT_JOURNAL and/or BTREE_MEMORY. +** +** If the database is already opened in the same database connection +** and we are in shared cache mode, then the open will fail with an +** SQLITE_CONSTRAINT error. We cannot allow two or more BtShared +** objects in the same database connection since doing so will lead +** to problems with locking. +*/ +SQLITE_PRIVATE int sqlite3BtreeOpen( + sqlite3_vfs *pVfs, /* VFS to use for this b-tree */ + const char *zFilename, /* Name of the file containing the BTree database */ + sqlite3 *db, /* Associated database handle */ + Btree **ppBtree, /* Pointer to new Btree object written here */ + int flags, /* Options */ + int vfsFlags /* Flags passed through to sqlite3_vfs.xOpen() */ +){ + BtShared *pBt = 0; /* Shared part of btree structure */ + Btree *p; /* Handle to return */ + sqlite3_mutex *mutexOpen = 0; /* Prevents a race condition. Ticket #3537 */ + int rc = SQLITE_OK; /* Result code from this function */ + u8 nReserve; /* Byte of unused space on each page */ + unsigned char zDbHeader[100]; /* Database header content */ + + /* True if opening an ephemeral, temporary database */ + const int isTempDb = zFilename==0 || zFilename[0]==0; + + /* Set the variable isMemdb to true for an in-memory database, or + ** false for a file-based database. + */ +#ifdef SQLITE_OMIT_MEMORYDB + const int isMemdb = 0; +#else + const int isMemdb = (zFilename && strcmp(zFilename, ":memory:")==0) + || (isTempDb && sqlite3TempInMemory(db)) + || (vfsFlags & SQLITE_OPEN_MEMORY)!=0; +#endif + + assert( db!=0 ); + assert( pVfs!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( (flags&0xff)==flags ); /* flags fit in 8 bits */ + + /* Only a BTREE_SINGLE database can be BTREE_UNORDERED */ + assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 ); + + /* A BTREE_SINGLE database is always a temporary and/or ephemeral */ + assert( (flags & BTREE_SINGLE)==0 || isTempDb ); + + if( isMemdb ){ + flags |= BTREE_MEMORY; + } + if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (isMemdb || isTempDb) ){ + vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB; + } + p = sqlite3MallocZero(sizeof(Btree)); + if( !p ){ + return SQLITE_NOMEM; + } + p->inTrans = TRANS_NONE; + p->db = db; +#ifndef SQLITE_OMIT_SHARED_CACHE + p->lock.pBtree = p; + p->lock.iTable = 1; +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* + ** If this Btree is a candidate for shared cache, try to find an + ** existing BtShared object that we can share with + */ + if( isTempDb==0 && (isMemdb==0 || (vfsFlags&SQLITE_OPEN_URI)!=0) ){ + if( vfsFlags & SQLITE_OPEN_SHAREDCACHE ){ + int nFilename = sqlite3Strlen30(zFilename)+1; + int nFullPathname = pVfs->mxPathname+1; + char *zFullPathname = sqlite3Malloc(MAX(nFullPathname,nFilename)); + MUTEX_LOGIC( sqlite3_mutex *mutexShared; ) + + p->sharable = 1; + if( !zFullPathname ){ + sqlite3_free(p); + return SQLITE_NOMEM; + } + if( isMemdb ){ + memcpy(zFullPathname, zFilename, nFilename); + }else{ + rc = sqlite3OsFullPathname(pVfs, zFilename, + nFullPathname, zFullPathname); + if( rc ){ + sqlite3_free(zFullPathname); + sqlite3_free(p); + return rc; + } + } +#if SQLITE_THREADSAFE + mutexOpen = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_OPEN); + sqlite3_mutex_enter(mutexOpen); + mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); + sqlite3_mutex_enter(mutexShared); +#endif + for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){ + assert( pBt->nRef>0 ); + if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0)) + && sqlite3PagerVfs(pBt->pPager)==pVfs ){ + int iDb; + for(iDb=db->nDb-1; iDb>=0; iDb--){ + Btree *pExisting = db->aDb[iDb].pBt; + if( pExisting && pExisting->pBt==pBt ){ + sqlite3_mutex_leave(mutexShared); + sqlite3_mutex_leave(mutexOpen); + sqlite3_free(zFullPathname); + sqlite3_free(p); + return SQLITE_CONSTRAINT; + } + } + p->pBt = pBt; + pBt->nRef++; + break; + } + } + sqlite3_mutex_leave(mutexShared); + sqlite3_free(zFullPathname); + } +#ifdef SQLITE_DEBUG + else{ + /* In debug mode, we mark all persistent databases as sharable + ** even when they are not. This exercises the locking code and + ** gives more opportunity for asserts(sqlite3_mutex_held()) + ** statements to find locking problems. + */ + p->sharable = 1; + } +#endif + } +#endif + if( pBt==0 ){ + /* + ** The following asserts make sure that structures used by the btree are + ** the right size. This is to guard against size changes that result + ** when compiling on a different architecture. + */ + assert( sizeof(i64)==8 ); + assert( sizeof(u64)==8 ); + assert( sizeof(u32)==4 ); + assert( sizeof(u16)==2 ); + assert( sizeof(Pgno)==4 ); + + pBt = sqlite3MallocZero( sizeof(*pBt) ); + if( pBt==0 ){ + rc = SQLITE_NOMEM; + goto btree_open_out; + } + rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename, + EXTRA_SIZE, flags, vfsFlags, pageReinit); + if( rc==SQLITE_OK ){ + sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap); + rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader); + } + if( rc!=SQLITE_OK ){ + goto btree_open_out; + } + pBt->openFlags = (u8)flags; + pBt->db = db; + sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt); + p->pBt = pBt; + + pBt->pCursor = 0; + pBt->pPage1 = 0; + if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY; +#ifdef SQLITE_SECURE_DELETE + pBt->btsFlags |= BTS_SECURE_DELETE; +#endif + /* EVIDENCE-OF: R-51873-39618 The page size for a database file is + ** determined by the 2-byte integer located at an offset of 16 bytes from + ** the beginning of the database file. */ + pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16); + if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE + || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){ + pBt->pageSize = 0; +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the magic name ":memory:" will create an in-memory database, then + ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if + ** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if + ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a + ** regular file-name. In this case the auto-vacuum applies as per normal. + */ + if( zFilename && !isMemdb ){ + pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0); + pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0); + } +#endif + nReserve = 0; + }else{ + /* EVIDENCE-OF: R-37497-42412 The size of the reserved region is + ** determined by the one-byte unsigned integer found at an offset of 20 + ** into the database file header. */ + nReserve = zDbHeader[20]; + pBt->btsFlags |= BTS_PAGESIZE_FIXED; +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0); + pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0); +#endif + } + rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve); + if( rc ) goto btree_open_out; + pBt->usableSize = pBt->pageSize - nReserve; + assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */ + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* Add the new BtShared object to the linked list sharable BtShareds. + */ + if( p->sharable ){ + MUTEX_LOGIC( sqlite3_mutex *mutexShared; ) + pBt->nRef = 1; + MUTEX_LOGIC( mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);) + if( SQLITE_THREADSAFE && sqlite3GlobalConfig.bCoreMutex ){ + pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST); + if( pBt->mutex==0 ){ + rc = SQLITE_NOMEM; + db->mallocFailed = 0; + goto btree_open_out; + } + } + sqlite3_mutex_enter(mutexShared); + pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList); + GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt; + sqlite3_mutex_leave(mutexShared); + } +#endif + } + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* If the new Btree uses a sharable pBtShared, then link the new + ** Btree into the list of all sharable Btrees for the same connection. + ** The list is kept in ascending order by pBt address. + */ + if( p->sharable ){ + int i; + Btree *pSib; + for(i=0; inDb; i++){ + if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){ + while( pSib->pPrev ){ pSib = pSib->pPrev; } + if( p->pBtpBt ){ + p->pNext = pSib; + p->pPrev = 0; + pSib->pPrev = p; + }else{ + while( pSib->pNext && pSib->pNext->pBtpBt ){ + pSib = pSib->pNext; + } + p->pNext = pSib->pNext; + p->pPrev = pSib; + if( p->pNext ){ + p->pNext->pPrev = p; + } + pSib->pNext = p; + } + break; + } + } + } +#endif + *ppBtree = p; + +btree_open_out: + if( rc!=SQLITE_OK ){ + if( pBt && pBt->pPager ){ + sqlite3PagerClose(pBt->pPager); + } + sqlite3_free(pBt); + sqlite3_free(p); + *ppBtree = 0; + }else{ + /* If the B-Tree was successfully opened, set the pager-cache size to the + ** default value. Except, when opening on an existing shared pager-cache, + ** do not change the pager-cache size. + */ + if( sqlite3BtreeSchema(p, 0, 0)==0 ){ + sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE); + } + } + if( mutexOpen ){ + assert( sqlite3_mutex_held(mutexOpen) ); + sqlite3_mutex_leave(mutexOpen); + } + return rc; +} + +/* +** Decrement the BtShared.nRef counter. When it reaches zero, +** remove the BtShared structure from the sharing list. Return +** true if the BtShared.nRef counter reaches zero and return +** false if it is still positive. +*/ +static int removeFromSharingList(BtShared *pBt){ +#ifndef SQLITE_OMIT_SHARED_CACHE + MUTEX_LOGIC( sqlite3_mutex *pMaster; ) + BtShared *pList; + int removed = 0; + + assert( sqlite3_mutex_notheld(pBt->mutex) ); + MUTEX_LOGIC( pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); ) + sqlite3_mutex_enter(pMaster); + pBt->nRef--; + if( pBt->nRef<=0 ){ + if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){ + GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext; + }else{ + pList = GLOBAL(BtShared*,sqlite3SharedCacheList); + while( ALWAYS(pList) && pList->pNext!=pBt ){ + pList=pList->pNext; + } + if( ALWAYS(pList) ){ + pList->pNext = pBt->pNext; + } + } + if( SQLITE_THREADSAFE ){ + sqlite3_mutex_free(pBt->mutex); + } + removed = 1; + } + sqlite3_mutex_leave(pMaster); + return removed; +#else + return 1; +#endif +} + +/* +** Make sure pBt->pTmpSpace points to an allocation of +** MX_CELL_SIZE(pBt) bytes with a 4-byte prefix for a left-child +** pointer. +*/ +static void allocateTempSpace(BtShared *pBt){ + if( !pBt->pTmpSpace ){ + pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize ); + + /* One of the uses of pBt->pTmpSpace is to format cells before + ** inserting them into a leaf page (function fillInCell()). If + ** a cell is less than 4 bytes in size, it is rounded up to 4 bytes + ** by the various routines that manipulate binary cells. Which + ** can mean that fillInCell() only initializes the first 2 or 3 + ** bytes of pTmpSpace, but that the first 4 bytes are copied from + ** it into a database page. This is not actually a problem, but it + ** does cause a valgrind error when the 1 or 2 bytes of unitialized + ** data is passed to system call write(). So to avoid this error, + ** zero the first 4 bytes of temp space here. + ** + ** Also: Provide four bytes of initialized space before the + ** beginning of pTmpSpace as an area available to prepend the + ** left-child pointer to the beginning of a cell. + */ + if( pBt->pTmpSpace ){ + memset(pBt->pTmpSpace, 0, 8); + pBt->pTmpSpace += 4; + } + } +} + +/* +** Free the pBt->pTmpSpace allocation +*/ +static void freeTempSpace(BtShared *pBt){ + if( pBt->pTmpSpace ){ + pBt->pTmpSpace -= 4; + sqlite3PageFree(pBt->pTmpSpace); + pBt->pTmpSpace = 0; + } +} + +/* +** Close an open database and invalidate all cursors. +*/ +SQLITE_PRIVATE int sqlite3BtreeClose(Btree *p){ + BtShared *pBt = p->pBt; + BtCursor *pCur; + + /* Close all cursors opened via this handle. */ + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + pCur = pBt->pCursor; + while( pCur ){ + BtCursor *pTmp = pCur; + pCur = pCur->pNext; + if( pTmp->pBtree==p ){ + sqlite3BtreeCloseCursor(pTmp); + } + } + + /* Rollback any active transaction and free the handle structure. + ** The call to sqlite3BtreeRollback() drops any table-locks held by + ** this handle. + */ + sqlite3BtreeRollback(p, SQLITE_OK, 0); + sqlite3BtreeLeave(p); + + /* If there are still other outstanding references to the shared-btree + ** structure, return now. The remainder of this procedure cleans + ** up the shared-btree. + */ + assert( p->wantToLock==0 && p->locked==0 ); + if( !p->sharable || removeFromSharingList(pBt) ){ + /* The pBt is no longer on the sharing list, so we can access + ** it without having to hold the mutex. + ** + ** Clean out and delete the BtShared object. + */ + assert( !pBt->pCursor ); + sqlite3PagerClose(pBt->pPager); + if( pBt->xFreeSchema && pBt->pSchema ){ + pBt->xFreeSchema(pBt->pSchema); + } + sqlite3DbFree(0, pBt->pSchema); + freeTempSpace(pBt); + sqlite3_free(pBt); + } + +#ifndef SQLITE_OMIT_SHARED_CACHE + assert( p->wantToLock==0 ); + assert( p->locked==0 ); + if( p->pPrev ) p->pPrev->pNext = p->pNext; + if( p->pNext ) p->pNext->pPrev = p->pPrev; +#endif + + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Change the limit on the number of pages allowed in the cache. +** +** The maximum number of cache pages is set to the absolute +** value of mxPage. If mxPage is negative, the pager will +** operate asynchronously - it will not stop to do fsync()s +** to insure data is written to the disk surface before +** continuing. Transactions still work if synchronous is off, +** and the database cannot be corrupted if this program +** crashes. But if the operating system crashes or there is +** an abrupt power failure when synchronous is off, the database +** could be left in an inconsistent and unrecoverable state. +** Synchronous is on by default so database corruption is not +** normally a worry. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetCachesize(pBt->pPager, mxPage); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** Change the limit on the amount of the database file that may be +** memory mapped. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetMmapLimit(Btree *p, sqlite3_int64 szMmap){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetMmapLimit(pBt->pPager, szMmap); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* +** Change the way data is synced to disk in order to increase or decrease +** how well the database resists damage due to OS crashes and power +** failures. Level 1 is the same as asynchronous (no syncs() occur and +** there is a high probability of damage) Level 2 is the default. There +** is a very low but non-zero probability of damage. Level 3 reduces the +** probability of damage to near zero but with a write performance reduction. +*/ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +SQLITE_PRIVATE int sqlite3BtreeSetPagerFlags( + Btree *p, /* The btree to set the safety level on */ + unsigned pgFlags /* Various PAGER_* flags */ +){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetFlags(pBt->pPager, pgFlags); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} +#endif + +/* +** Return TRUE if the given btree is set to safety level 1. In other +** words, return TRUE if no sync() occurs on the disk files. +*/ +SQLITE_PRIVATE int sqlite3BtreeSyncDisabled(Btree *p){ + BtShared *pBt = p->pBt; + int rc; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + assert( pBt && pBt->pPager ); + rc = sqlite3PagerNosync(pBt->pPager); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Change the default pages size and the number of reserved bytes per page. +** Or, if the page size has already been fixed, return SQLITE_READONLY +** without changing anything. +** +** The page size must be a power of 2 between 512 and 65536. If the page +** size supplied does not meet this constraint then the page size is not +** changed. +** +** Page sizes are constrained to be a power of two so that the region +** of the database file used for locking (beginning at PENDING_BYTE, +** the first byte past the 1GB boundary, 0x40000000) needs to occur +** at the beginning of a page. +** +** If parameter nReserve is less than zero, then the number of reserved +** bytes per page is left unchanged. +** +** If the iFix!=0 then the BTS_PAGESIZE_FIXED flag is set so that the page size +** and autovacuum mode can no longer be changed. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){ + int rc = SQLITE_OK; + BtShared *pBt = p->pBt; + assert( nReserve>=-1 && nReserve<=255 ); + sqlite3BtreeEnter(p); +#if SQLITE_HAS_CODEC + if( nReserve>pBt->optimalReserve ) pBt->optimalReserve = (u8)nReserve; +#endif + if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){ + sqlite3BtreeLeave(p); + return SQLITE_READONLY; + } + if( nReserve<0 ){ + nReserve = pBt->pageSize - pBt->usableSize; + } + assert( nReserve>=0 && nReserve<=255 ); + if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE && + ((pageSize-1)&pageSize)==0 ){ + assert( (pageSize & 7)==0 ); + assert( !pBt->pCursor ); + pBt->pageSize = (u32)pageSize; + freeTempSpace(pBt); + } + rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve); + pBt->usableSize = pBt->pageSize - (u16)nReserve; + if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED; + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Return the currently defined page size +*/ +SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree *p){ + return p->pBt->pageSize; +} + +/* +** This function is similar to sqlite3BtreeGetReserve(), except that it +** may only be called if it is guaranteed that the b-tree mutex is already +** held. +** +** This is useful in one special case in the backup API code where it is +** known that the shared b-tree mutex is held, but the mutex on the +** database handle that owns *p is not. In this case if sqlite3BtreeEnter() +** were to be called, it might collide with some other operation on the +** database handle that owns *p, causing undefined behavior. +*/ +SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p){ + int n; + assert( sqlite3_mutex_held(p->pBt->mutex) ); + n = p->pBt->pageSize - p->pBt->usableSize; + return n; +} + +/* +** Return the number of bytes of space at the end of every page that +** are intentually left unused. This is the "reserved" space that is +** sometimes used by extensions. +** +** If SQLITE_HAS_MUTEX is defined then the number returned is the +** greater of the current reserved space and the maximum requested +** reserve space. +*/ +SQLITE_PRIVATE int sqlite3BtreeGetOptimalReserve(Btree *p){ + int n; + sqlite3BtreeEnter(p); + n = sqlite3BtreeGetReserveNoMutex(p); +#ifdef SQLITE_HAS_CODEC + if( npBt->optimalReserve ) n = p->pBt->optimalReserve; +#endif + sqlite3BtreeLeave(p); + return n; +} + + +/* +** Set the maximum page count for a database if mxPage is positive. +** No changes are made if mxPage is 0 or negative. +** Regardless of the value of mxPage, return the maximum page count. +*/ +SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree *p, int mxPage){ + int n; + sqlite3BtreeEnter(p); + n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage); + sqlite3BtreeLeave(p); + return n; +} + +/* +** Set the BTS_SECURE_DELETE flag if newFlag is 0 or 1. If newFlag is -1, +** then make no changes. Always return the value of the BTS_SECURE_DELETE +** setting after the change. +*/ +SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree *p, int newFlag){ + int b; + if( p==0 ) return 0; + sqlite3BtreeEnter(p); + if( newFlag>=0 ){ + p->pBt->btsFlags &= ~BTS_SECURE_DELETE; + if( newFlag ) p->pBt->btsFlags |= BTS_SECURE_DELETE; + } + b = (p->pBt->btsFlags & BTS_SECURE_DELETE)!=0; + sqlite3BtreeLeave(p); + return b; +} + +/* +** Change the 'auto-vacuum' property of the database. If the 'autoVacuum' +** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it +** is disabled. The default value for the auto-vacuum property is +** determined by the SQLITE_DEFAULT_AUTOVACUUM macro. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){ +#ifdef SQLITE_OMIT_AUTOVACUUM + return SQLITE_READONLY; +#else + BtShared *pBt = p->pBt; + int rc = SQLITE_OK; + u8 av = (u8)autoVacuum; + + sqlite3BtreeEnter(p); + if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){ + rc = SQLITE_READONLY; + }else{ + pBt->autoVacuum = av ?1:0; + pBt->incrVacuum = av==2 ?1:0; + } + sqlite3BtreeLeave(p); + return rc; +#endif +} + +/* +** Return the value of the 'auto-vacuum' property. If auto-vacuum is +** enabled 1 is returned. Otherwise 0. +*/ +SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *p){ +#ifdef SQLITE_OMIT_AUTOVACUUM + return BTREE_AUTOVACUUM_NONE; +#else + int rc; + sqlite3BtreeEnter(p); + rc = ( + (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE: + (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL: + BTREE_AUTOVACUUM_INCR + ); + sqlite3BtreeLeave(p); + return rc; +#endif +} + + +/* +** Get a reference to pPage1 of the database file. This will +** also acquire a readlock on that file. +** +** SQLITE_OK is returned on success. If the file is not a +** well-formed database file, then SQLITE_CORRUPT is returned. +** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM +** is returned if we run out of memory. +*/ +static int lockBtree(BtShared *pBt){ + int rc; /* Result code from subfunctions */ + MemPage *pPage1; /* Page 1 of the database file */ + int nPage; /* Number of pages in the database */ + int nPageFile = 0; /* Number of pages in the database file */ + int nPageHeader; /* Number of pages in the database according to hdr */ + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pBt->pPage1==0 ); + rc = sqlite3PagerSharedLock(pBt->pPager); + if( rc!=SQLITE_OK ) return rc; + rc = btreeGetPage(pBt, 1, &pPage1, 0); + if( rc!=SQLITE_OK ) return rc; + + /* Do some checking to help insure the file we opened really is + ** a valid database file. + */ + nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData); + sqlite3PagerPagecount(pBt->pPager, &nPageFile); + if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){ + nPage = nPageFile; + } + if( nPage>0 ){ + u32 pageSize; + u32 usableSize; + u8 *page1 = pPage1->aData; + rc = SQLITE_NOTADB; + /* EVIDENCE-OF: R-43737-39999 Every valid SQLite database file begins + ** with the following 16 bytes (in hex): 53 51 4c 69 74 65 20 66 6f 72 6d + ** 61 74 20 33 00. */ + if( memcmp(page1, zMagicHeader, 16)!=0 ){ + goto page1_init_failed; + } + +#ifdef SQLITE_OMIT_WAL + if( page1[18]>1 ){ + pBt->btsFlags |= BTS_READ_ONLY; + } + if( page1[19]>1 ){ + goto page1_init_failed; + } +#else + if( page1[18]>2 ){ + pBt->btsFlags |= BTS_READ_ONLY; + } + if( page1[19]>2 ){ + goto page1_init_failed; + } + + /* If the write version is set to 2, this database should be accessed + ** in WAL mode. If the log is not already open, open it now. Then + ** return SQLITE_OK and return without populating BtShared.pPage1. + ** The caller detects this and calls this function again. This is + ** required as the version of page 1 currently in the page1 buffer + ** may not be the latest version - there may be a newer one in the log + ** file. + */ + if( page1[19]==2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){ + int isOpen = 0; + rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen); + if( rc!=SQLITE_OK ){ + goto page1_init_failed; + }else if( isOpen==0 ){ + releasePage(pPage1); + return SQLITE_OK; + } + rc = SQLITE_NOTADB; + } +#endif + + /* EVIDENCE-OF: R-15465-20813 The maximum and minimum embedded payload + ** fractions and the leaf payload fraction values must be 64, 32, and 32. + ** + ** The original design allowed these amounts to vary, but as of + ** version 3.6.0, we require them to be fixed. + */ + if( memcmp(&page1[21], "\100\040\040",3)!=0 ){ + goto page1_init_failed; + } + /* EVIDENCE-OF: R-51873-39618 The page size for a database file is + ** determined by the 2-byte integer located at an offset of 16 bytes from + ** the beginning of the database file. */ + pageSize = (page1[16]<<8) | (page1[17]<<16); + /* EVIDENCE-OF: R-25008-21688 The size of a page is a power of two + ** between 512 and 65536 inclusive. */ + if( ((pageSize-1)&pageSize)!=0 + || pageSize>SQLITE_MAX_PAGE_SIZE + || pageSize<=256 + ){ + goto page1_init_failed; + } + assert( (pageSize & 7)==0 ); + /* EVIDENCE-OF: R-59310-51205 The "reserved space" size in the 1-byte + ** integer at offset 20 is the number of bytes of space at the end of + ** each page to reserve for extensions. + ** + ** EVIDENCE-OF: R-37497-42412 The size of the reserved region is + ** determined by the one-byte unsigned integer found at an offset of 20 + ** into the database file header. */ + usableSize = pageSize - page1[20]; + if( (u32)pageSize!=pBt->pageSize ){ + /* After reading the first page of the database assuming a page size + ** of BtShared.pageSize, we have discovered that the page-size is + ** actually pageSize. Unlock the database, leave pBt->pPage1 at + ** zero and return SQLITE_OK. The caller will call this function + ** again with the correct page-size. + */ + releasePage(pPage1); + pBt->usableSize = usableSize; + pBt->pageSize = pageSize; + freeTempSpace(pBt); + rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, + pageSize-usableSize); + return rc; + } + if( (pBt->db->flags & SQLITE_RecoveryMode)==0 && nPage>nPageFile ){ + rc = SQLITE_CORRUPT_BKPT; + goto page1_init_failed; + } + /* EVIDENCE-OF: R-28312-64704 However, the usable size is not allowed to + ** be less than 480. In other words, if the page size is 512, then the + ** reserved space size cannot exceed 32. */ + if( usableSize<480 ){ + goto page1_init_failed; + } + pBt->pageSize = pageSize; + pBt->usableSize = usableSize; +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0); + pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0); +#endif + } + + /* maxLocal is the maximum amount of payload to store locally for + ** a cell. Make sure it is small enough so that at least minFanout + ** cells can will fit on one page. We assume a 10-byte page header. + ** Besides the payload, the cell must store: + ** 2-byte pointer to the cell + ** 4-byte child pointer + ** 9-byte nKey value + ** 4-byte nData value + ** 4-byte overflow page pointer + ** So a cell consists of a 2-byte pointer, a header which is as much as + ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow + ** page pointer. + */ + pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23); + pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23); + pBt->maxLeaf = (u16)(pBt->usableSize - 35); + pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23); + if( pBt->maxLocal>127 ){ + pBt->max1bytePayload = 127; + }else{ + pBt->max1bytePayload = (u8)pBt->maxLocal; + } + assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) ); + pBt->pPage1 = pPage1; + pBt->nPage = nPage; + return SQLITE_OK; + +page1_init_failed: + releasePage(pPage1); + pBt->pPage1 = 0; + return rc; +} + +#ifndef NDEBUG +/* +** Return the number of cursors open on pBt. This is for use +** in assert() expressions, so it is only compiled if NDEBUG is not +** defined. +** +** Only write cursors are counted if wrOnly is true. If wrOnly is +** false then all cursors are counted. +** +** For the purposes of this routine, a cursor is any cursor that +** is capable of reading or writing to the database. Cursors that +** have been tripped into the CURSOR_FAULT state are not counted. +*/ +static int countValidCursors(BtShared *pBt, int wrOnly){ + BtCursor *pCur; + int r = 0; + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0) + && pCur->eState!=CURSOR_FAULT ) r++; + } + return r; +} +#endif + +/* +** If there are no outstanding cursors and we are not in the middle +** of a transaction but there is a read lock on the database, then +** this routine unrefs the first page of the database file which +** has the effect of releasing the read lock. +** +** If there is a transaction in progress, this routine is a no-op. +*/ +static void unlockBtreeIfUnused(BtShared *pBt){ + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( countValidCursors(pBt,0)==0 || pBt->inTransaction>TRANS_NONE ); + if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){ + MemPage *pPage1 = pBt->pPage1; + assert( pPage1->aData ); + assert( sqlite3PagerRefcount(pBt->pPager)==1 ); + pBt->pPage1 = 0; + releasePageNotNull(pPage1); + } +} + +/* +** If pBt points to an empty file then convert that empty file +** into a new empty database by initializing the first page of +** the database. +*/ +static int newDatabase(BtShared *pBt){ + MemPage *pP1; + unsigned char *data; + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pBt->nPage>0 ){ + return SQLITE_OK; + } + pP1 = pBt->pPage1; + assert( pP1!=0 ); + data = pP1->aData; + rc = sqlite3PagerWrite(pP1->pDbPage); + if( rc ) return rc; + memcpy(data, zMagicHeader, sizeof(zMagicHeader)); + assert( sizeof(zMagicHeader)==16 ); + data[16] = (u8)((pBt->pageSize>>8)&0xff); + data[17] = (u8)((pBt->pageSize>>16)&0xff); + data[18] = 1; + data[19] = 1; + assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize); + data[20] = (u8)(pBt->pageSize - pBt->usableSize); + data[21] = 64; + data[22] = 32; + data[23] = 32; + memset(&data[24], 0, 100-24); + zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA ); + pBt->btsFlags |= BTS_PAGESIZE_FIXED; +#ifndef SQLITE_OMIT_AUTOVACUUM + assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 ); + assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 ); + put4byte(&data[36 + 4*4], pBt->autoVacuum); + put4byte(&data[36 + 7*4], pBt->incrVacuum); +#endif + pBt->nPage = 1; + data[31] = 1; + return SQLITE_OK; +} + +/* +** Initialize the first page of the database file (creating a database +** consisting of a single page and no schema objects). Return SQLITE_OK +** if successful, or an SQLite error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p){ + int rc; + sqlite3BtreeEnter(p); + p->pBt->nPage = 0; + rc = newDatabase(p->pBt); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Attempt to start a new transaction. A write-transaction +** is started if the second argument is nonzero, otherwise a read- +** transaction. If the second argument is 2 or more and exclusive +** transaction is started, meaning that no other process is allowed +** to access the database. A preexisting transaction may not be +** upgraded to exclusive by calling this routine a second time - the +** exclusivity flag only works for a new transaction. +** +** A write-transaction must be started before attempting any +** changes to the database. None of the following routines +** will work unless a transaction is started first: +** +** sqlite3BtreeCreateTable() +** sqlite3BtreeCreateIndex() +** sqlite3BtreeClearTable() +** sqlite3BtreeDropTable() +** sqlite3BtreeInsert() +** sqlite3BtreeDelete() +** sqlite3BtreeUpdateMeta() +** +** If an initial attempt to acquire the lock fails because of lock contention +** and the database was previously unlocked, then invoke the busy handler +** if there is one. But if there was previously a read-lock, do not +** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is +** returned when there is already a read-lock in order to avoid a deadlock. +** +** Suppose there are two processes A and B. A has a read lock and B has +** a reserved lock. B tries to promote to exclusive but is blocked because +** of A's read lock. A tries to promote to reserved but is blocked by B. +** One or the other of the two processes must give way or there can be +** no progress. By returning SQLITE_BUSY and not invoking the busy callback +** when A already has a read lock, we encourage A to give up and let B +** proceed. +*/ +SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag){ + sqlite3 *pBlock = 0; + BtShared *pBt = p->pBt; + int rc = SQLITE_OK; + + sqlite3BtreeEnter(p); + btreeIntegrity(p); + + /* If the btree is already in a write-transaction, or it + ** is already in a read-transaction and a read-transaction + ** is requested, this is a no-op. + */ + if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){ + goto trans_begun; + } + assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 ); + + /* Write transactions are not possible on a read-only database */ + if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){ + rc = SQLITE_READONLY; + goto trans_begun; + } + +#ifndef SQLITE_OMIT_SHARED_CACHE + /* If another database handle has already opened a write transaction + ** on this shared-btree structure and a second write transaction is + ** requested, return SQLITE_LOCKED. + */ + if( (wrflag && pBt->inTransaction==TRANS_WRITE) + || (pBt->btsFlags & BTS_PENDING)!=0 + ){ + pBlock = pBt->pWriter->db; + }else if( wrflag>1 ){ + BtLock *pIter; + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + if( pIter->pBtree!=p ){ + pBlock = pIter->pBtree->db; + break; + } + } + } + if( pBlock ){ + sqlite3ConnectionBlocked(p->db, pBlock); + rc = SQLITE_LOCKED_SHAREDCACHE; + goto trans_begun; + } +#endif + + /* Any read-only or read-write transaction implies a read-lock on + ** page 1. So if some other shared-cache client already has a write-lock + ** on page 1, the transaction cannot be opened. */ + rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK); + if( SQLITE_OK!=rc ) goto trans_begun; + + pBt->btsFlags &= ~BTS_INITIALLY_EMPTY; + if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY; + do { + /* Call lockBtree() until either pBt->pPage1 is populated or + ** lockBtree() returns something other than SQLITE_OK. lockBtree() + ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after + ** reading page 1 it discovers that the page-size of the database + ** file is not pBt->pageSize. In this case lockBtree() will update + ** pBt->pageSize to the page-size of the file on disk. + */ + while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) ); + + if( rc==SQLITE_OK && wrflag ){ + if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){ + rc = SQLITE_READONLY; + }else{ + rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db)); + if( rc==SQLITE_OK ){ + rc = newDatabase(pBt); + } + } + } + + if( rc!=SQLITE_OK ){ + unlockBtreeIfUnused(pBt); + } + }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE && + btreeInvokeBusyHandler(pBt) ); + + if( rc==SQLITE_OK ){ + if( p->inTrans==TRANS_NONE ){ + pBt->nTransaction++; +#ifndef SQLITE_OMIT_SHARED_CACHE + if( p->sharable ){ + assert( p->lock.pBtree==p && p->lock.iTable==1 ); + p->lock.eLock = READ_LOCK; + p->lock.pNext = pBt->pLock; + pBt->pLock = &p->lock; + } +#endif + } + p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ); + if( p->inTrans>pBt->inTransaction ){ + pBt->inTransaction = p->inTrans; + } + if( wrflag ){ + MemPage *pPage1 = pBt->pPage1; +#ifndef SQLITE_OMIT_SHARED_CACHE + assert( !pBt->pWriter ); + pBt->pWriter = p; + pBt->btsFlags &= ~BTS_EXCLUSIVE; + if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE; +#endif + + /* If the db-size header field is incorrect (as it may be if an old + ** client has been writing the database file), update it now. Doing + ** this sooner rather than later means the database size can safely + ** re-read the database size from page 1 if a savepoint or transaction + ** rollback occurs within the transaction. + */ + if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pPage1->aData[28], pBt->nPage); + } + } + } + } + + +trans_begun: + if( rc==SQLITE_OK && wrflag ){ + /* This call makes sure that the pager has the correct number of + ** open savepoints. If the second parameter is greater than 0 and + ** the sub-journal is not already open, then it will be opened here. + */ + rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint); + } + + btreeIntegrity(p); + sqlite3BtreeLeave(p); + return rc; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM + +/* +** Set the pointer-map entries for all children of page pPage. Also, if +** pPage contains cells that point to overflow pages, set the pointer +** map entries for the overflow pages as well. +*/ +static int setChildPtrmaps(MemPage *pPage){ + int i; /* Counter variable */ + int nCell; /* Number of cells in page pPage */ + int rc; /* Return code */ + BtShared *pBt = pPage->pBt; + u8 isInitOrig = pPage->isInit; + Pgno pgno = pPage->pgno; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + rc = btreeInitPage(pPage); + if( rc!=SQLITE_OK ){ + goto set_child_ptrmaps_out; + } + nCell = pPage->nCell; + + for(i=0; ileaf ){ + Pgno childPgno = get4byte(pCell); + ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc); + } + } + + if( !pPage->leaf ){ + Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc); + } + +set_child_ptrmaps_out: + pPage->isInit = isInitOrig; + return rc; +} + +/* +** Somewhere on pPage is a pointer to page iFrom. Modify this pointer so +** that it points to iTo. Parameter eType describes the type of pointer to +** be modified, as follows: +** +** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child +** page of pPage. +** +** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow +** page pointed to by one of the cells on pPage. +** +** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next +** overflow page in the list. +*/ +static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + if( eType==PTRMAP_OVERFLOW2 ){ + /* The pointer is always the first 4 bytes of the page in this case. */ + if( get4byte(pPage->aData)!=iFrom ){ + return SQLITE_CORRUPT_BKPT; + } + put4byte(pPage->aData, iTo); + }else{ + u8 isInitOrig = pPage->isInit; + int i; + int nCell; + int rc; + + rc = btreeInitPage(pPage); + if( rc ) return rc; + nCell = pPage->nCell; + + for(i=0; ixParseCell(pPage, pCell, &info); + if( info.iOverflow + && pCell+info.iOverflow+3<=pPage->aData+pPage->maskPage + && iFrom==get4byte(&pCell[info.iOverflow]) + ){ + put4byte(&pCell[info.iOverflow], iTo); + break; + } + }else{ + if( get4byte(pCell)==iFrom ){ + put4byte(pCell, iTo); + break; + } + } + } + + if( i==nCell ){ + if( eType!=PTRMAP_BTREE || + get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){ + return SQLITE_CORRUPT_BKPT; + } + put4byte(&pPage->aData[pPage->hdrOffset+8], iTo); + } + + pPage->isInit = isInitOrig; + } + return SQLITE_OK; +} + + +/* +** Move the open database page pDbPage to location iFreePage in the +** database. The pDbPage reference remains valid. +** +** The isCommit flag indicates that there is no need to remember that +** the journal needs to be sync()ed before database page pDbPage->pgno +** can be written to. The caller has already promised not to write to that +** page. +*/ +static int relocatePage( + BtShared *pBt, /* Btree */ + MemPage *pDbPage, /* Open page to move */ + u8 eType, /* Pointer map 'type' entry for pDbPage */ + Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */ + Pgno iFreePage, /* The location to move pDbPage to */ + int isCommit /* isCommit flag passed to sqlite3PagerMovepage */ +){ + MemPage *pPtrPage; /* The page that contains a pointer to pDbPage */ + Pgno iDbPage = pDbPage->pgno; + Pager *pPager = pBt->pPager; + int rc; + + assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 || + eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ); + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pDbPage->pBt==pBt ); + + /* Move page iDbPage from its current location to page number iFreePage */ + TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n", + iDbPage, iFreePage, iPtrPage, eType)); + rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit); + if( rc!=SQLITE_OK ){ + return rc; + } + pDbPage->pgno = iFreePage; + + /* If pDbPage was a btree-page, then it may have child pages and/or cells + ** that point to overflow pages. The pointer map entries for all these + ** pages need to be changed. + ** + ** If pDbPage is an overflow page, then the first 4 bytes may store a + ** pointer to a subsequent overflow page. If this is the case, then + ** the pointer map needs to be updated for the subsequent overflow page. + */ + if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){ + rc = setChildPtrmaps(pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + Pgno nextOvfl = get4byte(pDbPage->aData); + if( nextOvfl!=0 ){ + ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc); + if( rc!=SQLITE_OK ){ + return rc; + } + } + } + + /* Fix the database pointer on page iPtrPage that pointed at iDbPage so + ** that it points at iFreePage. Also fix the pointer map entry for + ** iPtrPage. + */ + if( eType!=PTRMAP_ROOTPAGE ){ + rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3PagerWrite(pPtrPage->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pPtrPage); + return rc; + } + rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType); + releasePage(pPtrPage); + if( rc==SQLITE_OK ){ + ptrmapPut(pBt, iFreePage, eType, iPtrPage, &rc); + } + } + return rc; +} + +/* Forward declaration required by incrVacuumStep(). */ +static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8); + +/* +** Perform a single step of an incremental-vacuum. If successful, return +** SQLITE_OK. If there is no work to do (and therefore no point in +** calling this function again), return SQLITE_DONE. Or, if an error +** occurs, return some other error code. +** +** More specifically, this function attempts to re-organize the database so +** that the last page of the file currently in use is no longer in use. +** +** Parameter nFin is the number of pages that this database would contain +** were this function called until it returns SQLITE_DONE. +** +** If the bCommit parameter is non-zero, this function assumes that the +** caller will keep calling incrVacuumStep() until it returns SQLITE_DONE +** or an error. bCommit is passed true for an auto-vacuum-on-commit +** operation, or false for an incremental vacuum. +*/ +static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg, int bCommit){ + Pgno nFreeList; /* Number of pages still on the free-list */ + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( iLastPg>nFin ); + + if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){ + u8 eType; + Pgno iPtrPage; + + nFreeList = get4byte(&pBt->pPage1->aData[36]); + if( nFreeList==0 ){ + return SQLITE_DONE; + } + + rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage); + if( rc!=SQLITE_OK ){ + return rc; + } + if( eType==PTRMAP_ROOTPAGE ){ + return SQLITE_CORRUPT_BKPT; + } + + if( eType==PTRMAP_FREEPAGE ){ + if( bCommit==0 ){ + /* Remove the page from the files free-list. This is not required + ** if bCommit is non-zero. In that case, the free-list will be + ** truncated to zero after this function returns, so it doesn't + ** matter if it still contains some garbage entries. + */ + Pgno iFreePg; + MemPage *pFreePg; + rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, BTALLOC_EXACT); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( iFreePg==iLastPg ); + releasePage(pFreePg); + } + } else { + Pgno iFreePg; /* Index of free page to move pLastPg to */ + MemPage *pLastPg; + u8 eMode = BTALLOC_ANY; /* Mode parameter for allocateBtreePage() */ + Pgno iNear = 0; /* nearby parameter for allocateBtreePage() */ + + rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* If bCommit is zero, this loop runs exactly once and page pLastPg + ** is swapped with the first free page pulled off the free list. + ** + ** On the other hand, if bCommit is greater than zero, then keep + ** looping until a free-page located within the first nFin pages + ** of the file is found. + */ + if( bCommit==0 ){ + eMode = BTALLOC_LE; + iNear = nFin; + } + do { + MemPage *pFreePg; + rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iNear, eMode); + if( rc!=SQLITE_OK ){ + releasePage(pLastPg); + return rc; + } + releasePage(pFreePg); + }while( bCommit && iFreePg>nFin ); + assert( iFreePgbDoTruncate = 1; + pBt->nPage = iLastPg; + } + return SQLITE_OK; +} + +/* +** The database opened by the first argument is an auto-vacuum database +** nOrig pages in size containing nFree free pages. Return the expected +** size of the database in pages following an auto-vacuum operation. +*/ +static Pgno finalDbSize(BtShared *pBt, Pgno nOrig, Pgno nFree){ + int nEntry; /* Number of entries on one ptrmap page */ + Pgno nPtrmap; /* Number of PtrMap pages to be freed */ + Pgno nFin; /* Return value */ + + nEntry = pBt->usableSize/5; + nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry; + nFin = nOrig - nFree - nPtrmap; + if( nOrig>PENDING_BYTE_PAGE(pBt) && nFinpBt; + + sqlite3BtreeEnter(p); + assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE ); + if( !pBt->autoVacuum ){ + rc = SQLITE_DONE; + }else{ + Pgno nOrig = btreePagecount(pBt); + Pgno nFree = get4byte(&pBt->pPage1->aData[36]); + Pgno nFin = finalDbSize(pBt, nOrig, nFree); + + if( nOrig0 ){ + rc = saveAllCursors(pBt, 0, 0); + if( rc==SQLITE_OK ){ + invalidateAllOverflowCache(pBt); + rc = incrVacuumStep(pBt, nFin, nOrig, 0); + } + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + put4byte(&pBt->pPage1->aData[28], pBt->nPage); + } + }else{ + rc = SQLITE_DONE; + } + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** This routine is called prior to sqlite3PagerCommit when a transaction +** is committed for an auto-vacuum database. +** +** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages +** the database file should be truncated to during the commit process. +** i.e. the database has been reorganized so that only the first *pnTrunc +** pages are in use. +*/ +static int autoVacuumCommit(BtShared *pBt){ + int rc = SQLITE_OK; + Pager *pPager = pBt->pPager; + VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager); ) + + assert( sqlite3_mutex_held(pBt->mutex) ); + invalidateAllOverflowCache(pBt); + assert(pBt->autoVacuum); + if( !pBt->incrVacuum ){ + Pgno nFin; /* Number of pages in database after autovacuuming */ + Pgno nFree; /* Number of pages on the freelist initially */ + Pgno iFree; /* The next page to be freed */ + Pgno nOrig; /* Database size before freeing */ + + nOrig = btreePagecount(pBt); + if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){ + /* It is not possible to create a database for which the final page + ** is either a pointer-map page or the pending-byte page. If one + ** is encountered, this indicates corruption. + */ + return SQLITE_CORRUPT_BKPT; + } + + nFree = get4byte(&pBt->pPage1->aData[36]); + nFin = finalDbSize(pBt, nOrig, nFree); + if( nFin>nOrig ) return SQLITE_CORRUPT_BKPT; + if( nFinnFin && rc==SQLITE_OK; iFree--){ + rc = incrVacuumStep(pBt, nFin, iFree, 1); + } + if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){ + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + put4byte(&pBt->pPage1->aData[32], 0); + put4byte(&pBt->pPage1->aData[36], 0); + put4byte(&pBt->pPage1->aData[28], nFin); + pBt->bDoTruncate = 1; + pBt->nPage = nFin; + } + if( rc!=SQLITE_OK ){ + sqlite3PagerRollback(pPager); + } + } + + assert( nRef>=sqlite3PagerRefcount(pPager) ); + return rc; +} + +#else /* ifndef SQLITE_OMIT_AUTOVACUUM */ +# define setChildPtrmaps(x) SQLITE_OK +#endif + +/* +** This routine does the first phase of a two-phase commit. This routine +** causes a rollback journal to be created (if it does not already exist) +** and populated with enough information so that if a power loss occurs +** the database can be restored to its original state by playing back +** the journal. Then the contents of the journal are flushed out to +** the disk. After the journal is safely on oxide, the changes to the +** database are written into the database file and flushed to oxide. +** At the end of this call, the rollback journal still exists on the +** disk and we are still holding all locks, so the transaction has not +** committed. See sqlite3BtreeCommitPhaseTwo() for the second phase of the +** commit process. +** +** This call is a no-op if no write-transaction is currently active on pBt. +** +** Otherwise, sync the database file for the btree pBt. zMaster points to +** the name of a master journal file that should be written into the +** individual journal file, or is NULL, indicating no master journal file +** (single database transaction). +** +** When this is called, the master journal should already have been +** created, populated with this journal pointer and synced to disk. +** +** Once this is routine has returned, the only thing required to commit +** the write-transaction for this database file is to delete the journal. +*/ +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zMaster){ + int rc = SQLITE_OK; + if( p->inTrans==TRANS_WRITE ){ + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + rc = autoVacuumCommit(pBt); + if( rc!=SQLITE_OK ){ + sqlite3BtreeLeave(p); + return rc; + } + } + if( pBt->bDoTruncate ){ + sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage); + } +#endif + rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0); + sqlite3BtreeLeave(p); + } + return rc; +} + +/* +** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback() +** at the conclusion of a transaction. +*/ +static void btreeEndTransaction(Btree *p){ + BtShared *pBt = p->pBt; + sqlite3 *db = p->db; + assert( sqlite3BtreeHoldsMutex(p) ); + +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->bDoTruncate = 0; +#endif + if( p->inTrans>TRANS_NONE && db->nVdbeRead>1 ){ + /* If there are other active statements that belong to this database + ** handle, downgrade to a read-only transaction. The other statements + ** may still be reading from the database. */ + downgradeAllSharedCacheTableLocks(p); + p->inTrans = TRANS_READ; + }else{ + /* If the handle had any kind of transaction open, decrement the + ** transaction count of the shared btree. If the transaction count + ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused() + ** call below will unlock the pager. */ + if( p->inTrans!=TRANS_NONE ){ + clearAllSharedCacheTableLocks(p); + pBt->nTransaction--; + if( 0==pBt->nTransaction ){ + pBt->inTransaction = TRANS_NONE; + } + } + + /* Set the current transaction state to TRANS_NONE and unlock the + ** pager if this call closed the only read or write transaction. */ + p->inTrans = TRANS_NONE; + unlockBtreeIfUnused(pBt); + } + + btreeIntegrity(p); +} + +/* +** Commit the transaction currently in progress. +** +** This routine implements the second phase of a 2-phase commit. The +** sqlite3BtreeCommitPhaseOne() routine does the first phase and should +** be invoked prior to calling this routine. The sqlite3BtreeCommitPhaseOne() +** routine did all the work of writing information out to disk and flushing the +** contents so that they are written onto the disk platter. All this +** routine has to do is delete or truncate or zero the header in the +** the rollback journal (which causes the transaction to commit) and +** drop locks. +** +** Normally, if an error occurs while the pager layer is attempting to +** finalize the underlying journal file, this function returns an error and +** the upper layer will attempt a rollback. However, if the second argument +** is non-zero then this b-tree transaction is part of a multi-file +** transaction. In this case, the transaction has already been committed +** (by deleting a master journal file) and the caller will ignore this +** functions return code. So, even if an error occurs in the pager layer, +** reset the b-tree objects internal state to indicate that the write +** transaction has been closed. This is quite safe, as the pager will have +** transitioned to the error state. +** +** This will release the write lock on the database file. If there +** are no active cursors, it also releases the read lock. +*/ +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){ + + if( p->inTrans==TRANS_NONE ) return SQLITE_OK; + sqlite3BtreeEnter(p); + btreeIntegrity(p); + + /* If the handle has a write-transaction open, commit the shared-btrees + ** transaction and set the shared state to TRANS_READ. + */ + if( p->inTrans==TRANS_WRITE ){ + int rc; + BtShared *pBt = p->pBt; + assert( pBt->inTransaction==TRANS_WRITE ); + assert( pBt->nTransaction>0 ); + rc = sqlite3PagerCommitPhaseTwo(pBt->pPager); + if( rc!=SQLITE_OK && bCleanup==0 ){ + sqlite3BtreeLeave(p); + return rc; + } + p->iDataVersion--; /* Compensate for pPager->iDataVersion++; */ + pBt->inTransaction = TRANS_READ; + btreeClearHasContent(pBt); + } + + btreeEndTransaction(p); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} + +/* +** Do both phases of a commit. +*/ +SQLITE_PRIVATE int sqlite3BtreeCommit(Btree *p){ + int rc; + sqlite3BtreeEnter(p); + rc = sqlite3BtreeCommitPhaseOne(p, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeCommitPhaseTwo(p, 0); + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** This routine sets the state to CURSOR_FAULT and the error +** code to errCode for every cursor on any BtShared that pBtree +** references. Or if the writeOnly flag is set to 1, then only +** trip write cursors and leave read cursors unchanged. +** +** Every cursor is a candidate to be tripped, including cursors +** that belong to other database connections that happen to be +** sharing the cache with pBtree. +** +** This routine gets called when a rollback occurs. If the writeOnly +** flag is true, then only write-cursors need be tripped - read-only +** cursors save their current positions so that they may continue +** following the rollback. Or, if writeOnly is false, all cursors are +** tripped. In general, writeOnly is false if the transaction being +** rolled back modified the database schema. In this case b-tree root +** pages may be moved or deleted from the database altogether, making +** it unsafe for read cursors to continue. +** +** If the writeOnly flag is true and an error is encountered while +** saving the current position of a read-only cursor, all cursors, +** including all read-cursors are tripped. +** +** SQLITE_OK is returned if successful, or if an error occurs while +** saving a cursor position, an SQLite error code. +*/ +SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode, int writeOnly){ + BtCursor *p; + int rc = SQLITE_OK; + + assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 ); + if( pBtree ){ + sqlite3BtreeEnter(pBtree); + for(p=pBtree->pBt->pCursor; p; p=p->pNext){ + int i; + if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ){ + if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){ + rc = saveCursorPosition(p); + if( rc!=SQLITE_OK ){ + (void)sqlite3BtreeTripAllCursors(pBtree, rc, 0); + break; + } + } + }else{ + sqlite3BtreeClearCursor(p); + p->eState = CURSOR_FAULT; + p->skipNext = errCode; + } + for(i=0; i<=p->iPage; i++){ + releasePage(p->apPage[i]); + p->apPage[i] = 0; + } + } + sqlite3BtreeLeave(pBtree); + } + return rc; +} + +/* +** Rollback the transaction in progress. +** +** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped). +** Only write cursors are tripped if writeOnly is true but all cursors are +** tripped if writeOnly is false. Any attempt to use +** a tripped cursor will result in an error. +** +** This will release the write lock on the database file. If there +** are no active cursors, it also releases the read lock. +*/ +SQLITE_PRIVATE int sqlite3BtreeRollback(Btree *p, int tripCode, int writeOnly){ + int rc; + BtShared *pBt = p->pBt; + MemPage *pPage1; + + assert( writeOnly==1 || writeOnly==0 ); + assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK ); + sqlite3BtreeEnter(p); + if( tripCode==SQLITE_OK ){ + rc = tripCode = saveAllCursors(pBt, 0, 0); + if( rc ) writeOnly = 0; + }else{ + rc = SQLITE_OK; + } + if( tripCode ){ + int rc2 = sqlite3BtreeTripAllCursors(p, tripCode, writeOnly); + assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) ); + if( rc2!=SQLITE_OK ) rc = rc2; + } + btreeIntegrity(p); + + if( p->inTrans==TRANS_WRITE ){ + int rc2; + + assert( TRANS_WRITE==pBt->inTransaction ); + rc2 = sqlite3PagerRollback(pBt->pPager); + if( rc2!=SQLITE_OK ){ + rc = rc2; + } + + /* The rollback may have destroyed the pPage1->aData value. So + ** call btreeGetPage() on page 1 again to make + ** sure pPage1->aData is set correctly. */ + if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){ + int nPage = get4byte(28+(u8*)pPage1->aData); + testcase( nPage==0 ); + if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage); + testcase( pBt->nPage!=nPage ); + pBt->nPage = nPage; + releasePage(pPage1); + } + assert( countValidCursors(pBt, 1)==0 ); + pBt->inTransaction = TRANS_READ; + btreeClearHasContent(pBt); + } + + btreeEndTransaction(p); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Start a statement subtransaction. The subtransaction can be rolled +** back independently of the main transaction. You must start a transaction +** before starting a subtransaction. The subtransaction is ended automatically +** if the main transaction commits or rolls back. +** +** Statement subtransactions are used around individual SQL statements +** that are contained within a BEGIN...COMMIT block. If a constraint +** error occurs within the statement, the effect of that one statement +** can be rolled back without having to rollback the entire transaction. +** +** A statement sub-transaction is implemented as an anonymous savepoint. The +** value passed as the second parameter is the total number of savepoints, +** including the new anonymous savepoint, open on the B-Tree. i.e. if there +** are no active savepoints and no other statement-transactions open, +** iStatement is 1. This anonymous savepoint can be released or rolled back +** using the sqlite3BtreeSavepoint() function. +*/ +SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree *p, int iStatement){ + int rc; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + assert( p->inTrans==TRANS_WRITE ); + assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); + assert( iStatement>0 ); + assert( iStatement>p->db->nSavepoint ); + assert( pBt->inTransaction==TRANS_WRITE ); + /* At the pager level, a statement transaction is a savepoint with + ** an index greater than all savepoints created explicitly using + ** SQL statements. It is illegal to open, release or rollback any + ** such savepoints while the statement transaction savepoint is active. + */ + rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** The second argument to this function, op, is always SAVEPOINT_ROLLBACK +** or SAVEPOINT_RELEASE. This function either releases or rolls back the +** savepoint identified by parameter iSavepoint, depending on the value +** of op. +** +** Normally, iSavepoint is greater than or equal to zero. However, if op is +** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the +** contents of the entire transaction are rolled back. This is different +** from a normal transaction rollback, as no locks are released and the +** transaction remains open. +*/ +SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){ + int rc = SQLITE_OK; + if( p && p->inTrans==TRANS_WRITE ){ + BtShared *pBt = p->pBt; + assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK ); + assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) ); + sqlite3BtreeEnter(p); + rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint); + if( rc==SQLITE_OK ){ + if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){ + pBt->nPage = 0; + } + rc = newDatabase(pBt); + pBt->nPage = get4byte(28 + pBt->pPage1->aData); + + /* The database size was written into the offset 28 of the header + ** when the transaction started, so we know that the value at offset + ** 28 is nonzero. */ + assert( pBt->nPage>0 ); + } + sqlite3BtreeLeave(p); + } + return rc; +} + +/* +** Create a new cursor for the BTree whose root is on the page +** iTable. If a read-only cursor is requested, it is assumed that +** the caller already has at least a read-only transaction open +** on the database already. If a write-cursor is requested, then +** the caller is assumed to have an open write transaction. +** +** If wrFlag==0, then the cursor can only be used for reading. +** If wrFlag==1, then the cursor can be used for reading or for +** writing if other conditions for writing are also met. These +** are the conditions that must be met in order for writing to +** be allowed: +** +** 1: The cursor must have been opened with wrFlag==1 +** +** 2: Other database connections that share the same pager cache +** but which are not in the READ_UNCOMMITTED state may not have +** cursors open with wrFlag==0 on the same table. Otherwise +** the changes made by this write cursor would be visible to +** the read cursors in the other database connection. +** +** 3: The database must be writable (not on read-only media) +** +** 4: There must be an active transaction. +** +** No checking is done to make sure that page iTable really is the +** root page of a b-tree. If it is not, then the cursor acquired +** will not work correctly. +** +** It is assumed that the sqlite3BtreeCursorZero() has been called +** on pCur to initialize the memory space prior to invoking this routine. +*/ +static int btreeCursor( + Btree *p, /* The btree */ + int iTable, /* Root page of table to open */ + int wrFlag, /* 1 to write. 0 read-only */ + struct KeyInfo *pKeyInfo, /* First arg to comparison function */ + BtCursor *pCur /* Space for new cursor */ +){ + BtShared *pBt = p->pBt; /* Shared b-tree handle */ + BtCursor *pX; /* Looping over other all cursors */ + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( wrFlag==0 || wrFlag==1 ); + + /* The following assert statements verify that if this is a sharable + ** b-tree database, the connection is holding the required table locks, + ** and that no other connection has any open cursor that conflicts with + ** this lock. */ + assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, wrFlag+1) ); + assert( wrFlag==0 || !hasReadConflicts(p, iTable) ); + + /* Assert that the caller has opened the required transaction. */ + assert( p->inTrans>TRANS_NONE ); + assert( wrFlag==0 || p->inTrans==TRANS_WRITE ); + assert( pBt->pPage1 && pBt->pPage1->aData ); + assert( wrFlag==0 || (pBt->btsFlags & BTS_READ_ONLY)==0 ); + + if( wrFlag ){ + allocateTempSpace(pBt); + if( pBt->pTmpSpace==0 ) return SQLITE_NOMEM; + } + if( iTable==1 && btreePagecount(pBt)==0 ){ + assert( wrFlag==0 ); + iTable = 0; + } + + /* Now that no other errors can occur, finish filling in the BtCursor + ** variables and link the cursor into the BtShared list. */ + pCur->pgnoRoot = (Pgno)iTable; + pCur->iPage = -1; + pCur->pKeyInfo = pKeyInfo; + pCur->pBtree = p; + pCur->pBt = pBt; + assert( wrFlag==0 || wrFlag==BTCF_WriteFlag ); + pCur->curFlags = wrFlag; + pCur->curPagerFlags = wrFlag ? 0 : PAGER_GET_READONLY; + /* If there are two or more cursors on the same btree, then all such + ** cursors *must* have the BTCF_Multiple flag set. */ + for(pX=pBt->pCursor; pX; pX=pX->pNext){ + if( pX->pgnoRoot==(Pgno)iTable ){ + pX->curFlags |= BTCF_Multiple; + pCur->curFlags |= BTCF_Multiple; + } + } + pCur->pNext = pBt->pCursor; + pBt->pCursor = pCur; + pCur->eState = CURSOR_INVALID; + return SQLITE_OK; +} +SQLITE_PRIVATE int sqlite3BtreeCursor( + Btree *p, /* The btree */ + int iTable, /* Root page of table to open */ + int wrFlag, /* 1 to write. 0 read-only */ + struct KeyInfo *pKeyInfo, /* First arg to xCompare() */ + BtCursor *pCur /* Write new cursor here */ +){ + int rc; + if( iTable<1 ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + sqlite3BtreeEnter(p); + rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur); + sqlite3BtreeLeave(p); + } + return rc; +} + +/* +** Return the size of a BtCursor object in bytes. +** +** This interfaces is needed so that users of cursors can preallocate +** sufficient storage to hold a cursor. The BtCursor object is opaque +** to users so they cannot do the sizeof() themselves - they must call +** this routine. +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorSize(void){ + return ROUND8(sizeof(BtCursor)); +} + +/* +** Initialize memory that will be converted into a BtCursor object. +** +** The simple approach here would be to memset() the entire object +** to zero. But it turns out that the apPage[] and aiIdx[] arrays +** do not need to be zeroed and they are large, so we can save a lot +** of run-time by skipping the initialization of those elements. +*/ +SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor *p){ + memset(p, 0, offsetof(BtCursor, iPage)); +} + +/* +** Close a cursor. The read lock on the database file is released +** when the last cursor is closed. +*/ +SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){ + Btree *pBtree = pCur->pBtree; + if( pBtree ){ + int i; + BtShared *pBt = pCur->pBt; + sqlite3BtreeEnter(pBtree); + sqlite3BtreeClearCursor(pCur); + assert( pBt->pCursor!=0 ); + if( pBt->pCursor==pCur ){ + pBt->pCursor = pCur->pNext; + }else{ + BtCursor *pPrev = pBt->pCursor; + do{ + if( pPrev->pNext==pCur ){ + pPrev->pNext = pCur->pNext; + break; + } + pPrev = pPrev->pNext; + }while( ALWAYS(pPrev) ); + } + for(i=0; i<=pCur->iPage; i++){ + releasePage(pCur->apPage[i]); + } + unlockBtreeIfUnused(pBt); + sqlite3_free(pCur->aOverflow); + /* sqlite3_free(pCur); */ + sqlite3BtreeLeave(pBtree); + } + return SQLITE_OK; +} + +/* +** Make sure the BtCursor* given in the argument has a valid +** BtCursor.info structure. If it is not already valid, call +** btreeParseCell() to fill it in. +** +** BtCursor.info is a cache of the information in the current cell. +** Using this cache reduces the number of calls to btreeParseCell(). +*/ +#ifndef NDEBUG + static void assertCellInfo(BtCursor *pCur){ + CellInfo info; + int iPage = pCur->iPage; + memset(&info, 0, sizeof(info)); + btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info); + assert( CORRUPT_DB || memcmp(&info, &pCur->info, sizeof(info))==0 ); + } +#else + #define assertCellInfo(x) +#endif +static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){ + if( pCur->info.nSize==0 ){ + int iPage = pCur->iPage; + pCur->curFlags |= BTCF_ValidNKey; + btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); + }else{ + assertCellInfo(pCur); + } +} + +#ifndef NDEBUG /* The next routine used only within assert() statements */ +/* +** Return true if the given BtCursor is valid. A valid cursor is one +** that is currently pointing to a row in a (non-empty) table. +** This is a verification routine is used only within assert() statements. +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){ + return pCur && pCur->eState==CURSOR_VALID; +} +#endif /* NDEBUG */ + +/* +** Set *pSize to the size of the buffer needed to hold the value of +** the key for the current entry. If the cursor is not pointing +** to a valid entry, *pSize is set to 0. +** +** For a table with the INTKEY flag set, this routine returns the key +** itself, not the number of bytes in the key. +** +** The caller must position the cursor prior to invoking this routine. +** +** This routine cannot fail. It always returns SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + getCellInfo(pCur); + *pSize = pCur->info.nKey; + return SQLITE_OK; +} + +/* +** Set *pSize to the number of bytes of data in the entry the +** cursor currently points to. +** +** The caller must guarantee that the cursor is pointing to a non-NULL +** valid entry. In other words, the calling procedure must guarantee +** that the cursor has Cursor.eState==CURSOR_VALID. +** +** Failure is not possible. This function always returns SQLITE_OK. +** It might just as well be a procedure (returning void) but we continue +** to return an integer result code for historical reasons. +*/ +SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPage>=0 ); + assert( pCur->iPageapPage[pCur->iPage]->intKeyLeaf==1 ); + getCellInfo(pCur); + *pSize = pCur->info.nPayload; + return SQLITE_OK; +} + +/* +** Given the page number of an overflow page in the database (parameter +** ovfl), this function finds the page number of the next page in the +** linked list of overflow pages. If possible, it uses the auto-vacuum +** pointer-map data instead of reading the content of page ovfl to do so. +** +** If an error occurs an SQLite error code is returned. Otherwise: +** +** The page number of the next overflow page in the linked list is +** written to *pPgnoNext. If page ovfl is the last page in its linked +** list, *pPgnoNext is set to zero. +** +** If ppPage is not NULL, and a reference to the MemPage object corresponding +** to page number pOvfl was obtained, then *ppPage is set to point to that +** reference. It is the responsibility of the caller to call releasePage() +** on *ppPage to free the reference. In no reference was obtained (because +** the pointer-map was used to obtain the value for *pPgnoNext), then +** *ppPage is set to zero. +*/ +static int getOverflowPage( + BtShared *pBt, /* The database file */ + Pgno ovfl, /* Current overflow page number */ + MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */ + Pgno *pPgnoNext /* OUT: Next overflow page number */ +){ + Pgno next = 0; + MemPage *pPage = 0; + int rc = SQLITE_OK; + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert(pPgnoNext); + +#ifndef SQLITE_OMIT_AUTOVACUUM + /* Try to find the next page in the overflow list using the + ** autovacuum pointer-map pages. Guess that the next page in + ** the overflow list is page number (ovfl+1). If that guess turns + ** out to be wrong, fall back to loading the data of page + ** number ovfl to determine the next page number. + */ + if( pBt->autoVacuum ){ + Pgno pgno; + Pgno iGuess = ovfl+1; + u8 eType; + + while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){ + iGuess++; + } + + if( iGuess<=btreePagecount(pBt) ){ + rc = ptrmapGet(pBt, iGuess, &eType, &pgno); + if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){ + next = iGuess; + rc = SQLITE_DONE; + } + } + } +#endif + + assert( next==0 || rc==SQLITE_DONE ); + if( rc==SQLITE_OK ){ + rc = btreeGetPage(pBt, ovfl, &pPage, (ppPage==0) ? PAGER_GET_READONLY : 0); + assert( rc==SQLITE_OK || pPage==0 ); + if( rc==SQLITE_OK ){ + next = get4byte(pPage->aData); + } + } + + *pPgnoNext = next; + if( ppPage ){ + *ppPage = pPage; + }else{ + releasePage(pPage); + } + return (rc==SQLITE_DONE ? SQLITE_OK : rc); +} + +/* +** Copy data from a buffer to a page, or from a page to a buffer. +** +** pPayload is a pointer to data stored on database page pDbPage. +** If argument eOp is false, then nByte bytes of data are copied +** from pPayload to the buffer pointed at by pBuf. If eOp is true, +** then sqlite3PagerWrite() is called on pDbPage and nByte bytes +** of data are copied from the buffer pBuf to pPayload. +** +** SQLITE_OK is returned on success, otherwise an error code. +*/ +static int copyPayload( + void *pPayload, /* Pointer to page data */ + void *pBuf, /* Pointer to buffer */ + int nByte, /* Number of bytes to copy */ + int eOp, /* 0 -> copy from page, 1 -> copy to page */ + DbPage *pDbPage /* Page containing pPayload */ +){ + if( eOp ){ + /* Copy data from buffer to page (a write operation) */ + int rc = sqlite3PagerWrite(pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + memcpy(pPayload, pBuf, nByte); + }else{ + /* Copy data from page to buffer (a read operation) */ + memcpy(pBuf, pPayload, nByte); + } + return SQLITE_OK; +} + +/* +** This function is used to read or overwrite payload information +** for the entry that the pCur cursor is pointing to. The eOp +** argument is interpreted as follows: +** +** 0: The operation is a read. Populate the overflow cache. +** 1: The operation is a write. Populate the overflow cache. +** 2: The operation is a read. Do not populate the overflow cache. +** +** A total of "amt" bytes are read or written beginning at "offset". +** Data is read to or from the buffer pBuf. +** +** The content being read or written might appear on the main page +** or be scattered out on multiple overflow pages. +** +** If the current cursor entry uses one or more overflow pages and the +** eOp argument is not 2, this function may allocate space for and lazily +** populates the overflow page-list cache array (BtCursor.aOverflow). +** Subsequent calls use this cache to make seeking to the supplied offset +** more efficient. +** +** Once an overflow page-list cache has been allocated, it may be +** invalidated if some other cursor writes to the same table, or if +** the cursor is moved to a different row. Additionally, in auto-vacuum +** mode, the following events may invalidate an overflow page-list cache. +** +** * An incremental vacuum, +** * A commit in auto_vacuum="full" mode, +** * Creating a table (may require moving an overflow page). +*/ +static int accessPayload( + BtCursor *pCur, /* Cursor pointing to entry to read from */ + u32 offset, /* Begin reading this far into payload */ + u32 amt, /* Read this many bytes */ + unsigned char *pBuf, /* Write the bytes into this buffer */ + int eOp /* zero to read. non-zero to write. */ +){ + unsigned char *aPayload; + int rc = SQLITE_OK; + int iIdx = 0; + MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */ + BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */ +#ifdef SQLITE_DIRECT_OVERFLOW_READ + unsigned char * const pBufStart = pBuf; + int bEnd; /* True if reading to end of data */ +#endif + + assert( pPage ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->aiIdx[pCur->iPage]nCell ); + assert( cursorHoldsMutex(pCur) ); + assert( eOp!=2 || offset==0 ); /* Always start from beginning for eOp==2 */ + + getCellInfo(pCur); + aPayload = pCur->info.pPayload; +#ifdef SQLITE_DIRECT_OVERFLOW_READ + bEnd = offset+amt==pCur->info.nPayload; +#endif + assert( offset+amt <= pCur->info.nPayload ); + + if( &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize] ){ + /* Trying to read or write past the end of the data is an error */ + return SQLITE_CORRUPT_BKPT; + } + + /* Check if data must be read/written to/from the btree page itself. */ + if( offsetinfo.nLocal ){ + int a = amt; + if( a+offset>pCur->info.nLocal ){ + a = pCur->info.nLocal - offset; + } + rc = copyPayload(&aPayload[offset], pBuf, a, (eOp & 0x01), pPage->pDbPage); + offset = 0; + pBuf += a; + amt -= a; + }else{ + offset -= pCur->info.nLocal; + } + + + if( rc==SQLITE_OK && amt>0 ){ + const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */ + Pgno nextPage; + + nextPage = get4byte(&aPayload[pCur->info.nLocal]); + + /* If the BtCursor.aOverflow[] has not been allocated, allocate it now. + ** Except, do not allocate aOverflow[] for eOp==2. + ** + ** The aOverflow[] array is sized at one entry for each overflow page + ** in the overflow chain. The page number of the first overflow page is + ** stored in aOverflow[0], etc. A value of 0 in the aOverflow[] array + ** means "not yet known" (the cache is lazily populated). + */ + if( eOp!=2 && (pCur->curFlags & BTCF_ValidOvfl)==0 ){ + int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize; + if( nOvfl>pCur->nOvflAlloc ){ + Pgno *aNew = (Pgno*)sqlite3Realloc( + pCur->aOverflow, nOvfl*2*sizeof(Pgno) + ); + if( aNew==0 ){ + rc = SQLITE_NOMEM; + }else{ + pCur->nOvflAlloc = nOvfl*2; + pCur->aOverflow = aNew; + } + } + if( rc==SQLITE_OK ){ + memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno)); + pCur->curFlags |= BTCF_ValidOvfl; + } + } + + /* If the overflow page-list cache has been allocated and the + ** entry for the first required overflow page is valid, skip + ** directly to it. + */ + if( (pCur->curFlags & BTCF_ValidOvfl)!=0 + && pCur->aOverflow[offset/ovflSize] + ){ + iIdx = (offset/ovflSize); + nextPage = pCur->aOverflow[iIdx]; + offset = (offset%ovflSize); + } + + for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){ + + /* If required, populate the overflow page-list cache. */ + if( (pCur->curFlags & BTCF_ValidOvfl)!=0 ){ + assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage); + pCur->aOverflow[iIdx] = nextPage; + } + + if( offset>=ovflSize ){ + /* The only reason to read this page is to obtain the page + ** number for the next page in the overflow chain. The page + ** data is not required. So first try to lookup the overflow + ** page-list cache, if any, then fall back to the getOverflowPage() + ** function. + ** + ** Note that the aOverflow[] array must be allocated because eOp!=2 + ** here. If eOp==2, then offset==0 and this branch is never taken. + */ + assert( eOp!=2 ); + assert( pCur->curFlags & BTCF_ValidOvfl ); + assert( pCur->pBtree->db==pBt->db ); + if( pCur->aOverflow[iIdx+1] ){ + nextPage = pCur->aOverflow[iIdx+1]; + }else{ + rc = getOverflowPage(pBt, nextPage, 0, &nextPage); + } + offset -= ovflSize; + }else{ + /* Need to read this page properly. It contains some of the + ** range of data that is being read (eOp==0) or written (eOp!=0). + */ +#ifdef SQLITE_DIRECT_OVERFLOW_READ + sqlite3_file *fd; +#endif + int a = amt; + if( a + offset > ovflSize ){ + a = ovflSize - offset; + } + +#ifdef SQLITE_DIRECT_OVERFLOW_READ + /* If all the following are true: + ** + ** 1) this is a read operation, and + ** 2) data is required from the start of this overflow page, and + ** 3) the database is file-backed, and + ** 4) there is no open write-transaction, and + ** 5) the database is not a WAL database, + ** 6) all data from the page is being read. + ** 7) at least 4 bytes have already been read into the output buffer + ** + ** then data can be read directly from the database file into the + ** output buffer, bypassing the page-cache altogether. This speeds + ** up loading large records that span many overflow pages. + */ + if( (eOp&0x01)==0 /* (1) */ + && offset==0 /* (2) */ + && (bEnd || a==ovflSize) /* (6) */ + && pBt->inTransaction==TRANS_READ /* (4) */ + && (fd = sqlite3PagerFile(pBt->pPager))->pMethods /* (3) */ + && pBt->pPage1->aData[19]==0x01 /* (5) */ + && &pBuf[-4]>=pBufStart /* (7) */ + ){ + u8 aSave[4]; + u8 *aWrite = &pBuf[-4]; + assert( aWrite>=pBufStart ); /* hence (7) */ + memcpy(aSave, aWrite, 4); + rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1)); + nextPage = get4byte(aWrite); + memcpy(aWrite, aSave, 4); + }else +#endif + + { + DbPage *pDbPage; + rc = sqlite3PagerAcquire(pBt->pPager, nextPage, &pDbPage, + ((eOp&0x01)==0 ? PAGER_GET_READONLY : 0) + ); + if( rc==SQLITE_OK ){ + aPayload = sqlite3PagerGetData(pDbPage); + nextPage = get4byte(aPayload); + rc = copyPayload(&aPayload[offset+4], pBuf, a, (eOp&0x01), pDbPage); + sqlite3PagerUnref(pDbPage); + offset = 0; + } + } + amt -= a; + pBuf += a; + } + } + } + + if( rc==SQLITE_OK && amt>0 ){ + return SQLITE_CORRUPT_BKPT; + } + return rc; +} + +/* +** Read part of the key associated with cursor pCur. Exactly +** "amt" bytes will be transferred into pBuf[]. The transfer +** begins at "offset". +** +** The caller must ensure that pCur is pointing to a valid row +** in the table. +** +** Return SQLITE_OK on success or an error code if anything goes +** wrong. An error is returned if "offset+amt" is larger than +** the available payload. +*/ +SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] ); + assert( pCur->aiIdx[pCur->iPage]apPage[pCur->iPage]->nCell ); + return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0); +} + +/* +** Read part of the data associated with cursor pCur. Exactly +** "amt" bytes will be transfered into pBuf[]. The transfer +** begins at "offset". +** +** Return SQLITE_OK on success or an error code if anything goes +** wrong. An error is returned if "offset+amt" is larger than +** the available payload. +*/ +SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ + int rc; + +#ifndef SQLITE_OMIT_INCRBLOB + if ( pCur->eState==CURSOR_INVALID ){ + return SQLITE_ABORT; + } +#endif + + assert( cursorHoldsMutex(pCur) ); + rc = restoreCursorPosition(pCur); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] ); + assert( pCur->aiIdx[pCur->iPage]apPage[pCur->iPage]->nCell ); + rc = accessPayload(pCur, offset, amt, pBuf, 0); + } + return rc; +} + +/* +** Return a pointer to payload information from the entry that the +** pCur cursor is pointing to. The pointer is to the beginning of +** the key if index btrees (pPage->intKey==0) and is the data for +** table btrees (pPage->intKey==1). The number of bytes of available +** key/data is written into *pAmt. If *pAmt==0, then the value +** returned will not be a valid pointer. +** +** This routine is an optimization. It is common for the entire key +** and data to fit on the local page and for there to be no overflow +** pages. When that is so, this routine can be used to access the +** key and data without making a copy. If the key and/or data spills +** onto overflow pages, then accessPayload() must be used to reassemble +** the key/data and copy it into a preallocated buffer. +** +** The pointer returned by this routine looks directly into the cached +** page of the database. The data might change or move the next time +** any btree routine is called. +*/ +static const void *fetchPayload( + BtCursor *pCur, /* Cursor pointing to entry to read from */ + u32 *pAmt /* Write the number of available bytes here */ +){ + u32 amt; + assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]); + assert( pCur->eState==CURSOR_VALID ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + assert( cursorHoldsMutex(pCur) ); + assert( pCur->aiIdx[pCur->iPage]apPage[pCur->iPage]->nCell ); + assert( pCur->info.nSize>0 ); + assert( pCur->info.pPayload>pCur->apPage[pCur->iPage]->aData || CORRUPT_DB ); + assert( pCur->info.pPayloadapPage[pCur->iPage]->aDataEnd ||CORRUPT_DB); + amt = (int)(pCur->apPage[pCur->iPage]->aDataEnd - pCur->info.pPayload); + if( pCur->info.nLocalinfo.nLocal; + *pAmt = amt; + return (void*)pCur->info.pPayload; +} + + +/* +** For the entry that cursor pCur is point to, return as +** many bytes of the key or data as are available on the local +** b-tree page. Write the number of available bytes into *pAmt. +** +** The pointer returned is ephemeral. The key/data may move +** or be destroyed on the next call to any Btree routine, +** including calls from other threads against the same cache. +** Hence, a mutex on the BtShared should be held prior to calling +** this routine. +** +** These routines is used to get quick access to key and data +** in the common case where no overflow pages are used. +*/ +SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, u32 *pAmt){ + return fetchPayload(pCur, pAmt); +} +SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, u32 *pAmt){ + return fetchPayload(pCur, pAmt); +} + + +/* +** Move the cursor down to a new child page. The newPgno argument is the +** page number of the child page to move to. +** +** This function returns SQLITE_CORRUPT if the page-header flags field of +** the new child page does not match the flags field of the parent (i.e. +** if an intkey page appears to be the parent of a non-intkey page, or +** vice-versa). +*/ +static int moveToChild(BtCursor *pCur, u32 newPgno){ + BtShared *pBt = pCur->pBt; + + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPageiPage>=0 ); + if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){ + return SQLITE_CORRUPT_BKPT; + } + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); + pCur->iPage++; + pCur->aiIdx[pCur->iPage] = 0; + return getAndInitPage(pBt, newPgno, &pCur->apPage[pCur->iPage], + pCur, pCur->curPagerFlags); +} + +#if SQLITE_DEBUG +/* +** Page pParent is an internal (non-leaf) tree page. This function +** asserts that page number iChild is the left-child if the iIdx'th +** cell in page pParent. Or, if iIdx is equal to the total number of +** cells in pParent, that page number iChild is the right-child of +** the page. +*/ +static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){ + if( CORRUPT_DB ) return; /* The conditions tested below might not be true + ** in a corrupt database */ + assert( iIdx<=pParent->nCell ); + if( iIdx==pParent->nCell ){ + assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild ); + }else{ + assert( get4byte(findCell(pParent, iIdx))==iChild ); + } +} +#else +# define assertParentIndex(x,y,z) +#endif + +/* +** Move the cursor up to the parent page. +** +** pCur->idx is set to the cell index that contains the pointer +** to the page we are coming from. If we are coming from the +** right-most child page then pCur->idx is set to one more than +** the largest cell index. +*/ +static void moveToParent(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPage>0 ); + assert( pCur->apPage[pCur->iPage] ); + assertParentIndex( + pCur->apPage[pCur->iPage-1], + pCur->aiIdx[pCur->iPage-1], + pCur->apPage[pCur->iPage]->pgno + ); + testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell ); + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); + releasePageNotNull(pCur->apPage[pCur->iPage--]); +} + +/* +** Move the cursor to point to the root page of its b-tree structure. +** +** If the table has a virtual root page, then the cursor is moved to point +** to the virtual root page instead of the actual root page. A table has a +** virtual root page when the actual root page contains no cells and a +** single child page. This can only happen with the table rooted at page 1. +** +** If the b-tree structure is empty, the cursor state is set to +** CURSOR_INVALID. Otherwise, the cursor is set to point to the first +** cell located on the root (or virtual root) page and the cursor state +** is set to CURSOR_VALID. +** +** If this function returns successfully, it may be assumed that the +** page-header flags indicate that the [virtual] root-page is the expected +** kind of b-tree page (i.e. if when opening the cursor the caller did not +** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D, +** indicating a table b-tree, or if the caller did specify a KeyInfo +** structure the flags byte is set to 0x02 or 0x0A, indicating an index +** b-tree). +*/ +static int moveToRoot(BtCursor *pCur){ + MemPage *pRoot; + int rc = SQLITE_OK; + + assert( cursorHoldsMutex(pCur) ); + assert( CURSOR_INVALID < CURSOR_REQUIRESEEK ); + assert( CURSOR_VALID < CURSOR_REQUIRESEEK ); + assert( CURSOR_FAULT > CURSOR_REQUIRESEEK ); + if( pCur->eState>=CURSOR_REQUIRESEEK ){ + if( pCur->eState==CURSOR_FAULT ){ + assert( pCur->skipNext!=SQLITE_OK ); + return pCur->skipNext; + } + sqlite3BtreeClearCursor(pCur); + } + + if( pCur->iPage>=0 ){ + while( pCur->iPage ){ + assert( pCur->apPage[pCur->iPage]!=0 ); + releasePageNotNull(pCur->apPage[pCur->iPage--]); + } + }else if( pCur->pgnoRoot==0 ){ + pCur->eState = CURSOR_INVALID; + return SQLITE_OK; + }else{ + assert( pCur->iPage==(-1) ); + rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->apPage[0], + 0, pCur->curPagerFlags); + if( rc!=SQLITE_OK ){ + pCur->eState = CURSOR_INVALID; + return rc; + } + pCur->iPage = 0; + pCur->curIntKey = pCur->apPage[0]->intKey; + } + pRoot = pCur->apPage[0]; + assert( pRoot->pgno==pCur->pgnoRoot ); + + /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor + ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is + ** NULL, the caller expects a table b-tree. If this is not the case, + ** return an SQLITE_CORRUPT error. + ** + ** Earlier versions of SQLite assumed that this test could not fail + ** if the root page was already loaded when this function was called (i.e. + ** if pCur->iPage>=0). But this is not so if the database is corrupted + ** in such a way that page pRoot is linked into a second b-tree table + ** (or the freelist). */ + assert( pRoot->intKey==1 || pRoot->intKey==0 ); + if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){ + return SQLITE_CORRUPT_BKPT; + } + + pCur->aiIdx[0] = 0; + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl); + + if( pRoot->nCell>0 ){ + pCur->eState = CURSOR_VALID; + }else if( !pRoot->leaf ){ + Pgno subpage; + if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT; + subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]); + pCur->eState = CURSOR_VALID; + rc = moveToChild(pCur, subpage); + }else{ + pCur->eState = CURSOR_INVALID; + } + return rc; +} + +/* +** Move the cursor down to the left-most leaf entry beneath the +** entry to which it is currently pointing. +** +** The left-most leaf is the one with the smallest key - the first +** in ascending order. +*/ +static int moveToLeftmost(BtCursor *pCur){ + Pgno pgno; + int rc = SQLITE_OK; + MemPage *pPage; + + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){ + assert( pCur->aiIdx[pCur->iPage]nCell ); + pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage])); + rc = moveToChild(pCur, pgno); + } + return rc; +} + +/* +** Move the cursor down to the right-most leaf entry beneath the +** page to which it is currently pointing. Notice the difference +** between moveToLeftmost() and moveToRightmost(). moveToLeftmost() +** finds the left-most entry beneath the *entry* whereas moveToRightmost() +** finds the right-most entry beneath the *page*. +** +** The right-most entry is the one with the largest key - the last +** key in ascending order. +*/ +static int moveToRightmost(BtCursor *pCur){ + Pgno pgno; + int rc = SQLITE_OK; + MemPage *pPage = 0; + + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + while( !(pPage = pCur->apPage[pCur->iPage])->leaf ){ + pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + pCur->aiIdx[pCur->iPage] = pPage->nCell; + rc = moveToChild(pCur, pgno); + if( rc ) return rc; + } + pCur->aiIdx[pCur->iPage] = pPage->nCell-1; + assert( pCur->info.nSize==0 ); + assert( (pCur->curFlags & BTCF_ValidNKey)==0 ); + return SQLITE_OK; +} + +/* Move the cursor to the first entry in the table. Return SQLITE_OK +** on success. Set *pRes to 0 if the cursor actually points to something +** or set *pRes to 1 if the table is empty. +*/ +SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){ + int rc; + + assert( cursorHoldsMutex(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + rc = moveToRoot(pCur); + if( rc==SQLITE_OK ){ + if( pCur->eState==CURSOR_INVALID ){ + assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 ); + *pRes = 1; + }else{ + assert( pCur->apPage[pCur->iPage]->nCell>0 ); + *pRes = 0; + rc = moveToLeftmost(pCur); + } + } + return rc; +} + +/* Move the cursor to the last entry in the table. Return SQLITE_OK +** on success. Set *pRes to 0 if the cursor actually points to something +** or set *pRes to 1 if the table is empty. +*/ +SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){ + int rc; + + assert( cursorHoldsMutex(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + + /* If the cursor already points to the last entry, this is a no-op. */ + if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){ +#ifdef SQLITE_DEBUG + /* This block serves to assert() that the cursor really does point + ** to the last entry in the b-tree. */ + int ii; + for(ii=0; iiiPage; ii++){ + assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell ); + } + assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 ); + assert( pCur->apPage[pCur->iPage]->leaf ); +#endif + return SQLITE_OK; + } + + rc = moveToRoot(pCur); + if( rc==SQLITE_OK ){ + if( CURSOR_INVALID==pCur->eState ){ + assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 ); + *pRes = 1; + }else{ + assert( pCur->eState==CURSOR_VALID ); + *pRes = 0; + rc = moveToRightmost(pCur); + if( rc==SQLITE_OK ){ + pCur->curFlags |= BTCF_AtLast; + }else{ + pCur->curFlags &= ~BTCF_AtLast; + } + + } + } + return rc; +} + +/* Move the cursor so that it points to an entry near the key +** specified by pIdxKey or intKey. Return a success code. +** +** For INTKEY tables, the intKey parameter is used. pIdxKey +** must be NULL. For index tables, pIdxKey is used and intKey +** is ignored. +** +** If an exact match is not found, then the cursor is always +** left pointing at a leaf page which would hold the entry if it +** were present. The cursor might point to an entry that comes +** before or after the key. +** +** An integer is written into *pRes which is the result of +** comparing the key with the entry to which the cursor is +** pointing. The meaning of the integer written into +** *pRes is as follows: +** +** *pRes<0 The cursor is left pointing at an entry that +** is smaller than intKey/pIdxKey or if the table is empty +** and the cursor is therefore left point to nothing. +** +** *pRes==0 The cursor is left pointing at an entry that +** exactly matches intKey/pIdxKey. +** +** *pRes>0 The cursor is left pointing at an entry that +** is larger than intKey/pIdxKey. +** +*/ +SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( + BtCursor *pCur, /* The cursor to be moved */ + UnpackedRecord *pIdxKey, /* Unpacked index key */ + i64 intKey, /* The table key */ + int biasRight, /* If true, bias the search to the high end */ + int *pRes /* Write search results here */ +){ + int rc; + RecordCompare xRecordCompare; + + assert( cursorHoldsMutex(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + assert( pRes ); + assert( (pIdxKey==0)==(pCur->pKeyInfo==0) ); + + /* If the cursor is already positioned at the point we are trying + ** to move to, then just return without doing any work */ + if( pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 + && pCur->curIntKey + ){ + if( pCur->info.nKey==intKey ){ + *pRes = 0; + return SQLITE_OK; + } + if( (pCur->curFlags & BTCF_AtLast)!=0 && pCur->info.nKeyerrCode = 0; + assert( pIdxKey->default_rc==1 + || pIdxKey->default_rc==0 + || pIdxKey->default_rc==-1 + ); + }else{ + xRecordCompare = 0; /* All keys are integers */ + } + + rc = moveToRoot(pCur); + if( rc ){ + return rc; + } + assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] ); + assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit ); + assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 ); + if( pCur->eState==CURSOR_INVALID ){ + *pRes = -1; + assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 ); + return SQLITE_OK; + } + assert( pCur->apPage[0]->intKey==pCur->curIntKey ); + assert( pCur->curIntKey || pIdxKey ); + for(;;){ + int lwr, upr, idx, c; + Pgno chldPg; + MemPage *pPage = pCur->apPage[pCur->iPage]; + u8 *pCell; /* Pointer to current cell in pPage */ + + /* pPage->nCell must be greater than zero. If this is the root-page + ** the cursor would have been INVALID above and this for(;;) loop + ** not run. If this is not the root-page, then the moveToChild() routine + ** would have already detected db corruption. Similarly, pPage must + ** be the right kind (index or table) of b-tree page. Otherwise + ** a moveToChild() or moveToRoot() call would have detected corruption. */ + assert( pPage->nCell>0 ); + assert( pPage->intKey==(pIdxKey==0) ); + lwr = 0; + upr = pPage->nCell-1; + assert( biasRight==0 || biasRight==1 ); + idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */ + pCur->aiIdx[pCur->iPage] = (u16)idx; + if( xRecordCompare==0 ){ + for(;;){ + i64 nCellKey; + pCell = findCellPastPtr(pPage, idx); + if( pPage->intKeyLeaf ){ + while( 0x80 <= *(pCell++) ){ + if( pCell>=pPage->aDataEnd ) return SQLITE_CORRUPT_BKPT; + } + } + getVarint(pCell, (u64*)&nCellKey); + if( nCellKeyupr ){ c = -1; break; } + }else if( nCellKey>intKey ){ + upr = idx-1; + if( lwr>upr ){ c = +1; break; } + }else{ + assert( nCellKey==intKey ); + pCur->curFlags |= BTCF_ValidNKey; + pCur->info.nKey = nCellKey; + pCur->aiIdx[pCur->iPage] = (u16)idx; + if( !pPage->leaf ){ + lwr = idx; + goto moveto_next_layer; + }else{ + *pRes = 0; + rc = SQLITE_OK; + goto moveto_finish; + } + } + assert( lwr+upr>=0 ); + idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2; */ + } + }else{ + for(;;){ + int nCell; /* Size of the pCell cell in bytes */ + pCell = findCellPastPtr(pPage, idx); + + /* The maximum supported page-size is 65536 bytes. This means that + ** the maximum number of record bytes stored on an index B-Tree + ** page is less than 16384 bytes and may be stored as a 2-byte + ** varint. This information is used to attempt to avoid parsing + ** the entire cell by checking for the cases where the record is + ** stored entirely within the b-tree page by inspecting the first + ** 2 bytes of the cell. + */ + nCell = pCell[0]; + if( nCell<=pPage->max1bytePayload ){ + /* This branch runs if the record-size field of the cell is a + ** single byte varint and the record fits entirely on the main + ** b-tree page. */ + testcase( pCell+nCell+1==pPage->aDataEnd ); + c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey); + }else if( !(pCell[1] & 0x80) + && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal + ){ + /* The record-size field is a 2 byte varint and the record + ** fits entirely on the main b-tree page. */ + testcase( pCell+nCell+2==pPage->aDataEnd ); + c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey); + }else{ + /* The record flows over onto one or more overflow pages. In + ** this case the whole cell needs to be parsed, a buffer allocated + ** and accessPayload() used to retrieve the record into the + ** buffer before VdbeRecordCompare() can be called. + ** + ** If the record is corrupt, the xRecordCompare routine may read + ** up to two varints past the end of the buffer. An extra 18 + ** bytes of padding is allocated at the end of the buffer in + ** case this happens. */ + void *pCellKey; + u8 * const pCellBody = pCell - pPage->childPtrSize; + pPage->xParseCell(pPage, pCellBody, &pCur->info); + nCell = (int)pCur->info.nKey; + testcase( nCell<0 ); /* True if key size is 2^32 or more */ + testcase( nCell==0 ); /* Invalid key size: 0x80 0x80 0x00 */ + testcase( nCell==1 ); /* Invalid key size: 0x80 0x80 0x01 */ + testcase( nCell==2 ); /* Minimum legal index key size */ + if( nCell<2 ){ + rc = SQLITE_CORRUPT_BKPT; + goto moveto_finish; + } + pCellKey = sqlite3Malloc( nCell+18 ); + if( pCellKey==0 ){ + rc = SQLITE_NOMEM; + goto moveto_finish; + } + pCur->aiIdx[pCur->iPage] = (u16)idx; + rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 2); + if( rc ){ + sqlite3_free(pCellKey); + goto moveto_finish; + } + c = xRecordCompare(nCell, pCellKey, pIdxKey); + sqlite3_free(pCellKey); + } + assert( + (pIdxKey->errCode!=SQLITE_CORRUPT || c==0) + && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed) + ); + if( c<0 ){ + lwr = idx+1; + }else if( c>0 ){ + upr = idx-1; + }else{ + assert( c==0 ); + *pRes = 0; + rc = SQLITE_OK; + pCur->aiIdx[pCur->iPage] = (u16)idx; + if( pIdxKey->errCode ) rc = SQLITE_CORRUPT; + goto moveto_finish; + } + if( lwr>upr ) break; + assert( lwr+upr>=0 ); + idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2 */ + } + } + assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) ); + assert( pPage->isInit ); + if( pPage->leaf ){ + assert( pCur->aiIdx[pCur->iPage]apPage[pCur->iPage]->nCell ); + pCur->aiIdx[pCur->iPage] = (u16)idx; + *pRes = c; + rc = SQLITE_OK; + goto moveto_finish; + } +moveto_next_layer: + if( lwr>=pPage->nCell ){ + chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]); + }else{ + chldPg = get4byte(findCell(pPage, lwr)); + } + pCur->aiIdx[pCur->iPage] = (u16)lwr; + rc = moveToChild(pCur, chldPg); + if( rc ) break; + } +moveto_finish: + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); + return rc; +} + + +/* +** Return TRUE if the cursor is not pointing at an entry of the table. +** +** TRUE will be returned after a call to sqlite3BtreeNext() moves +** past the last entry in the table or sqlite3BtreePrev() moves past +** the first entry. TRUE is also returned if the table is empty. +*/ +SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){ + /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries + ** have been deleted? This API will need to change to return an error code + ** as well as the boolean result value. + */ + return (CURSOR_VALID!=pCur->eState); +} + +/* +** Advance the cursor to the next entry in the database. If +** successful then set *pRes=0. If the cursor +** was already pointing to the last entry in the database before +** this routine was called, then set *pRes=1. +** +** The main entry point is sqlite3BtreeNext(). That routine is optimized +** for the common case of merely incrementing the cell counter BtCursor.aiIdx +** to the next cell on the current page. The (slower) btreeNext() helper +** routine is called when it is necessary to move to a different page or +** to restore the cursor. +** +** The calling function will set *pRes to 0 or 1. The initial *pRes value +** will be 1 if the cursor being stepped corresponds to an SQL index and +** if this routine could have been skipped if that SQL index had been +** a unique index. Otherwise the caller will have set *pRes to zero. +** Zero is the common case. The btree implementation is free to use the +** initial *pRes value as a hint to improve performance, but the current +** SQLite btree implementation does not. (Note that the comdb2 btree +** implementation does use this hint, however.) +*/ +static SQLITE_NOINLINE int btreeNext(BtCursor *pCur, int *pRes){ + int rc; + int idx; + MemPage *pPage; + + assert( cursorHoldsMutex(pCur) ); + assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID ); + assert( *pRes==0 ); + if( pCur->eState!=CURSOR_VALID ){ + assert( (pCur->curFlags & BTCF_ValidOvfl)==0 ); + rc = restoreCursorPosition(pCur); + if( rc!=SQLITE_OK ){ + return rc; + } + if( CURSOR_INVALID==pCur->eState ){ + *pRes = 1; + return SQLITE_OK; + } + if( pCur->skipNext ){ + assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT ); + pCur->eState = CURSOR_VALID; + if( pCur->skipNext>0 ){ + pCur->skipNext = 0; + return SQLITE_OK; + } + pCur->skipNext = 0; + } + } + + pPage = pCur->apPage[pCur->iPage]; + idx = ++pCur->aiIdx[pCur->iPage]; + assert( pPage->isInit ); + + /* If the database file is corrupt, it is possible for the value of idx + ** to be invalid here. This can only occur if a second cursor modifies + ** the page while cursor pCur is holding a reference to it. Which can + ** only happen if the database is corrupt in such a way as to link the + ** page into more than one b-tree structure. */ + testcase( idx>pPage->nCell ); + + if( idx>=pPage->nCell ){ + if( !pPage->leaf ){ + rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); + if( rc ) return rc; + return moveToLeftmost(pCur); + } + do{ + if( pCur->iPage==0 ){ + *pRes = 1; + pCur->eState = CURSOR_INVALID; + return SQLITE_OK; + } + moveToParent(pCur); + pPage = pCur->apPage[pCur->iPage]; + }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell ); + if( pPage->intKey ){ + return sqlite3BtreeNext(pCur, pRes); + }else{ + return SQLITE_OK; + } + } + if( pPage->leaf ){ + return SQLITE_OK; + }else{ + return moveToLeftmost(pCur); + } +} +SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){ + MemPage *pPage; + assert( cursorHoldsMutex(pCur) ); + assert( pRes!=0 ); + assert( *pRes==0 || *pRes==1 ); + assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID ); + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); + *pRes = 0; + if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur, pRes); + pPage = pCur->apPage[pCur->iPage]; + if( (++pCur->aiIdx[pCur->iPage])>=pPage->nCell ){ + pCur->aiIdx[pCur->iPage]--; + return btreeNext(pCur, pRes); + } + if( pPage->leaf ){ + return SQLITE_OK; + }else{ + return moveToLeftmost(pCur); + } +} + +/* +** Step the cursor to the back to the previous entry in the database. If +** successful then set *pRes=0. If the cursor +** was already pointing to the first entry in the database before +** this routine was called, then set *pRes=1. +** +** The main entry point is sqlite3BtreePrevious(). That routine is optimized +** for the common case of merely decrementing the cell counter BtCursor.aiIdx +** to the previous cell on the current page. The (slower) btreePrevious() +** helper routine is called when it is necessary to move to a different page +** or to restore the cursor. +** +** The calling function will set *pRes to 0 or 1. The initial *pRes value +** will be 1 if the cursor being stepped corresponds to an SQL index and +** if this routine could have been skipped if that SQL index had been +** a unique index. Otherwise the caller will have set *pRes to zero. +** Zero is the common case. The btree implementation is free to use the +** initial *pRes value as a hint to improve performance, but the current +** SQLite btree implementation does not. (Note that the comdb2 btree +** implementation does use this hint, however.) +*/ +static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur, int *pRes){ + int rc; + MemPage *pPage; + + assert( cursorHoldsMutex(pCur) ); + assert( pRes!=0 ); + assert( *pRes==0 ); + assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID ); + assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 ); + assert( pCur->info.nSize==0 ); + if( pCur->eState!=CURSOR_VALID ){ + rc = restoreCursorPosition(pCur); + if( rc!=SQLITE_OK ){ + return rc; + } + if( CURSOR_INVALID==pCur->eState ){ + *pRes = 1; + return SQLITE_OK; + } + if( pCur->skipNext ){ + assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT ); + pCur->eState = CURSOR_VALID; + if( pCur->skipNext<0 ){ + pCur->skipNext = 0; + return SQLITE_OK; + } + pCur->skipNext = 0; + } + } + + pPage = pCur->apPage[pCur->iPage]; + assert( pPage->isInit ); + if( !pPage->leaf ){ + int idx = pCur->aiIdx[pCur->iPage]; + rc = moveToChild(pCur, get4byte(findCell(pPage, idx))); + if( rc ) return rc; + rc = moveToRightmost(pCur); + }else{ + while( pCur->aiIdx[pCur->iPage]==0 ){ + if( pCur->iPage==0 ){ + pCur->eState = CURSOR_INVALID; + *pRes = 1; + return SQLITE_OK; + } + moveToParent(pCur); + } + assert( pCur->info.nSize==0 ); + assert( (pCur->curFlags & (BTCF_ValidNKey|BTCF_ValidOvfl))==0 ); + + pCur->aiIdx[pCur->iPage]--; + pPage = pCur->apPage[pCur->iPage]; + if( pPage->intKey && !pPage->leaf ){ + rc = sqlite3BtreePrevious(pCur, pRes); + }else{ + rc = SQLITE_OK; + } + } + return rc; +} +SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){ + assert( cursorHoldsMutex(pCur) ); + assert( pRes!=0 ); + assert( *pRes==0 || *pRes==1 ); + assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID ); + *pRes = 0; + pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey); + pCur->info.nSize = 0; + if( pCur->eState!=CURSOR_VALID + || pCur->aiIdx[pCur->iPage]==0 + || pCur->apPage[pCur->iPage]->leaf==0 + ){ + return btreePrevious(pCur, pRes); + } + pCur->aiIdx[pCur->iPage]--; + return SQLITE_OK; +} + +/* +** Allocate a new page from the database file. +** +** The new page is marked as dirty. (In other words, sqlite3PagerWrite() +** has already been called on the new page.) The new page has also +** been referenced and the calling routine is responsible for calling +** sqlite3PagerUnref() on the new page when it is done. +** +** SQLITE_OK is returned on success. Any other return value indicates +** an error. *ppPage is set to NULL in the event of an error. +** +** If the "nearby" parameter is not 0, then an effort is made to +** locate a page close to the page number "nearby". This can be used in an +** attempt to keep related pages close to each other in the database file, +** which in turn can make database access faster. +** +** If the eMode parameter is BTALLOC_EXACT and the nearby page exists +** anywhere on the free-list, then it is guaranteed to be returned. If +** eMode is BTALLOC_LT then the page returned will be less than or equal +** to nearby if any such page exists. If eMode is BTALLOC_ANY then there +** are no restrictions on which page is returned. +*/ +static int allocateBtreePage( + BtShared *pBt, /* The btree */ + MemPage **ppPage, /* Store pointer to the allocated page here */ + Pgno *pPgno, /* Store the page number here */ + Pgno nearby, /* Search for a page near this one */ + u8 eMode /* BTALLOC_EXACT, BTALLOC_LT, or BTALLOC_ANY */ +){ + MemPage *pPage1; + int rc; + u32 n; /* Number of pages on the freelist */ + u32 k; /* Number of leaves on the trunk of the freelist */ + MemPage *pTrunk = 0; + MemPage *pPrevTrunk = 0; + Pgno mxPage; /* Total size of the database file */ + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( eMode==BTALLOC_ANY || (nearby>0 && IfNotOmitAV(pBt->autoVacuum)) ); + pPage1 = pBt->pPage1; + mxPage = btreePagecount(pBt); + /* EVIDENCE-OF: R-05119-02637 The 4-byte big-endian integer at offset 36 + ** stores stores the total number of pages on the freelist. */ + n = get4byte(&pPage1->aData[36]); + testcase( n==mxPage-1 ); + if( n>=mxPage ){ + return SQLITE_CORRUPT_BKPT; + } + if( n>0 ){ + /* There are pages on the freelist. Reuse one of those pages. */ + Pgno iTrunk; + u8 searchList = 0; /* If the free-list must be searched for 'nearby' */ + u32 nSearch = 0; /* Count of the number of search attempts */ + + /* If eMode==BTALLOC_EXACT and a query of the pointer-map + ** shows that the page 'nearby' is somewhere on the free-list, then + ** the entire-list will be searched for that page. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( eMode==BTALLOC_EXACT ){ + if( nearby<=mxPage ){ + u8 eType; + assert( nearby>0 ); + assert( pBt->autoVacuum ); + rc = ptrmapGet(pBt, nearby, &eType, 0); + if( rc ) return rc; + if( eType==PTRMAP_FREEPAGE ){ + searchList = 1; + } + } + }else if( eMode==BTALLOC_LE ){ + searchList = 1; + } +#endif + + /* Decrement the free-list count by 1. Set iTrunk to the index of the + ** first free-list trunk page. iPrevTrunk is initially 1. + */ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc ) return rc; + put4byte(&pPage1->aData[36], n-1); + + /* The code within this loop is run only once if the 'searchList' variable + ** is not true. Otherwise, it runs once for each trunk-page on the + ** free-list until the page 'nearby' is located (eMode==BTALLOC_EXACT) + ** or until a page less than 'nearby' is located (eMode==BTALLOC_LT) + */ + do { + pPrevTrunk = pTrunk; + if( pPrevTrunk ){ + /* EVIDENCE-OF: R-01506-11053 The first integer on a freelist trunk page + ** is the page number of the next freelist trunk page in the list or + ** zero if this is the last freelist trunk page. */ + iTrunk = get4byte(&pPrevTrunk->aData[0]); + }else{ + /* EVIDENCE-OF: R-59841-13798 The 4-byte big-endian integer at offset 32 + ** stores the page number of the first page of the freelist, or zero if + ** the freelist is empty. */ + iTrunk = get4byte(&pPage1->aData[32]); + } + testcase( iTrunk==mxPage ); + if( iTrunk>mxPage || nSearch++ > n ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + rc = btreeGetUnusedPage(pBt, iTrunk, &pTrunk, 0); + } + if( rc ){ + pTrunk = 0; + goto end_allocate_page; + } + assert( pTrunk!=0 ); + assert( pTrunk->aData!=0 ); + /* EVIDENCE-OF: R-13523-04394 The second integer on a freelist trunk page + ** is the number of leaf page pointers to follow. */ + k = get4byte(&pTrunk->aData[4]); + if( k==0 && !searchList ){ + /* The trunk has no leaves and the list is not being searched. + ** So extract the trunk page itself and use it as the newly + ** allocated page */ + assert( pPrevTrunk==0 ); + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc ){ + goto end_allocate_page; + } + *pPgno = iTrunk; + memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); + *ppPage = pTrunk; + pTrunk = 0; + TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1)); + }else if( k>(u32)(pBt->usableSize/4 - 2) ){ + /* Value of k is out of range. Database corruption */ + rc = SQLITE_CORRUPT_BKPT; + goto end_allocate_page; +#ifndef SQLITE_OMIT_AUTOVACUUM + }else if( searchList + && (nearby==iTrunk || (iTrunkpDbPage); + if( rc ){ + goto end_allocate_page; + } + if( k==0 ){ + if( !pPrevTrunk ){ + memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); + }else{ + rc = sqlite3PagerWrite(pPrevTrunk->pDbPage); + if( rc!=SQLITE_OK ){ + goto end_allocate_page; + } + memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4); + } + }else{ + /* The trunk page is required by the caller but it contains + ** pointers to free-list leaves. The first leaf becomes a trunk + ** page in this case. + */ + MemPage *pNewTrunk; + Pgno iNewTrunk = get4byte(&pTrunk->aData[8]); + if( iNewTrunk>mxPage ){ + rc = SQLITE_CORRUPT_BKPT; + goto end_allocate_page; + } + testcase( iNewTrunk==mxPage ); + rc = btreeGetUnusedPage(pBt, iNewTrunk, &pNewTrunk, 0); + if( rc!=SQLITE_OK ){ + goto end_allocate_page; + } + rc = sqlite3PagerWrite(pNewTrunk->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pNewTrunk); + goto end_allocate_page; + } + memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4); + put4byte(&pNewTrunk->aData[4], k-1); + memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4); + releasePage(pNewTrunk); + if( !pPrevTrunk ){ + assert( sqlite3PagerIswriteable(pPage1->pDbPage) ); + put4byte(&pPage1->aData[32], iNewTrunk); + }else{ + rc = sqlite3PagerWrite(pPrevTrunk->pDbPage); + if( rc ){ + goto end_allocate_page; + } + put4byte(&pPrevTrunk->aData[0], iNewTrunk); + } + } + pTrunk = 0; + TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1)); +#endif + }else if( k>0 ){ + /* Extract a leaf from the trunk */ + u32 closest; + Pgno iPage; + unsigned char *aData = pTrunk->aData; + if( nearby>0 ){ + u32 i; + closest = 0; + if( eMode==BTALLOC_LE ){ + for(i=0; imxPage ){ + rc = SQLITE_CORRUPT_BKPT; + goto end_allocate_page; + } + testcase( iPage==mxPage ); + if( !searchList + || (iPage==nearby || (iPagepgno, n-1)); + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc ) goto end_allocate_page; + if( closestpDbPage); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + *ppPage = 0; + } + } + searchList = 0; + } + } + releasePage(pPrevTrunk); + pPrevTrunk = 0; + }while( searchList ); + }else{ + /* There are no pages on the freelist, so append a new page to the + ** database image. + ** + ** Normally, new pages allocated by this block can be requested from the + ** pager layer with the 'no-content' flag set. This prevents the pager + ** from trying to read the pages content from disk. However, if the + ** current transaction has already run one or more incremental-vacuum + ** steps, then the page we are about to allocate may contain content + ** that is required in the event of a rollback. In this case, do + ** not set the no-content flag. This causes the pager to load and journal + ** the current page content before overwriting it. + ** + ** Note that the pager will not actually attempt to load or journal + ** content for any page that really does lie past the end of the database + ** file on disk. So the effects of disabling the no-content optimization + ** here are confined to those pages that lie between the end of the + ** database image and the end of the database file. + */ + int bNoContent = (0==IfNotOmitAV(pBt->bDoTruncate))? PAGER_GET_NOCONTENT:0; + + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( rc ) return rc; + pBt->nPage++; + if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++; + +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){ + /* If *pPgno refers to a pointer-map page, allocate two new pages + ** at the end of the file instead of one. The first allocated page + ** becomes a new pointer-map page, the second is used by the caller. + */ + MemPage *pPg = 0; + TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage)); + assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) ); + rc = btreeGetUnusedPage(pBt, pBt->nPage, &pPg, bNoContent); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pPg->pDbPage); + releasePage(pPg); + } + if( rc ) return rc; + pBt->nPage++; + if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; } + } +#endif + put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage); + *pPgno = pBt->nPage; + + assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); + rc = btreeGetUnusedPage(pBt, *pPgno, ppPage, bNoContent); + if( rc ) return rc; + rc = sqlite3PagerWrite((*ppPage)->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + *ppPage = 0; + } + TRACE(("ALLOCATE: %d from end of file\n", *pPgno)); + } + + assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); + +end_allocate_page: + releasePage(pTrunk); + releasePage(pPrevTrunk); + assert( rc!=SQLITE_OK || sqlite3PagerPageRefcount((*ppPage)->pDbPage)<=1 ); + assert( rc!=SQLITE_OK || (*ppPage)->isInit==0 ); + return rc; +} + +/* +** This function is used to add page iPage to the database file free-list. +** It is assumed that the page is not already a part of the free-list. +** +** The value passed as the second argument to this function is optional. +** If the caller happens to have a pointer to the MemPage object +** corresponding to page iPage handy, it may pass it as the second value. +** Otherwise, it may pass NULL. +** +** If a pointer to a MemPage object is passed as the second argument, +** its reference count is not altered by this function. +*/ +static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){ + MemPage *pTrunk = 0; /* Free-list trunk page */ + Pgno iTrunk = 0; /* Page number of free-list trunk page */ + MemPage *pPage1 = pBt->pPage1; /* Local reference to page 1 */ + MemPage *pPage; /* Page being freed. May be NULL. */ + int rc; /* Return Code */ + int nFree; /* Initial number of pages on free-list */ + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( CORRUPT_DB || iPage>1 ); + assert( !pMemPage || pMemPage->pgno==iPage ); + + if( iPage<2 ) return SQLITE_CORRUPT_BKPT; + if( pMemPage ){ + pPage = pMemPage; + sqlite3PagerRef(pPage->pDbPage); + }else{ + pPage = btreePageLookup(pBt, iPage); + } + + /* Increment the free page count on pPage1 */ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc ) goto freepage_out; + nFree = get4byte(&pPage1->aData[36]); + put4byte(&pPage1->aData[36], nFree+1); + + if( pBt->btsFlags & BTS_SECURE_DELETE ){ + /* If the secure_delete option is enabled, then + ** always fully overwrite deleted information with zeros. + */ + if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) ) + || ((rc = sqlite3PagerWrite(pPage->pDbPage))!=0) + ){ + goto freepage_out; + } + memset(pPage->aData, 0, pPage->pBt->pageSize); + } + + /* If the database supports auto-vacuum, write an entry in the pointer-map + ** to indicate that the page is free. + */ + if( ISAUTOVACUUM ){ + ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc); + if( rc ) goto freepage_out; + } + + /* Now manipulate the actual database free-list structure. There are two + ** possibilities. If the free-list is currently empty, or if the first + ** trunk page in the free-list is full, then this page will become a + ** new free-list trunk page. Otherwise, it will become a leaf of the + ** first trunk page in the current free-list. This block tests if it + ** is possible to add the page as a new free-list leaf. + */ + if( nFree!=0 ){ + u32 nLeaf; /* Initial number of leaf cells on trunk page */ + + iTrunk = get4byte(&pPage1->aData[32]); + rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0); + if( rc!=SQLITE_OK ){ + goto freepage_out; + } + + nLeaf = get4byte(&pTrunk->aData[4]); + assert( pBt->usableSize>32 ); + if( nLeaf > (u32)pBt->usableSize/4 - 2 ){ + rc = SQLITE_CORRUPT_BKPT; + goto freepage_out; + } + if( nLeaf < (u32)pBt->usableSize/4 - 8 ){ + /* In this case there is room on the trunk page to insert the page + ** being freed as a new leaf. + ** + ** Note that the trunk page is not really full until it contains + ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have + ** coded. But due to a coding error in versions of SQLite prior to + ** 3.6.0, databases with freelist trunk pages holding more than + ** usableSize/4 - 8 entries will be reported as corrupt. In order + ** to maintain backwards compatibility with older versions of SQLite, + ** we will continue to restrict the number of entries to usableSize/4 - 8 + ** for now. At some point in the future (once everyone has upgraded + ** to 3.6.0 or later) we should consider fixing the conditional above + ** to read "usableSize/4-2" instead of "usableSize/4-8". + ** + ** EVIDENCE-OF: R-19920-11576 However, newer versions of SQLite still + ** avoid using the last six entries in the freelist trunk page array in + ** order that database files created by newer versions of SQLite can be + ** read by older versions of SQLite. + */ + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pTrunk->aData[4], nLeaf+1); + put4byte(&pTrunk->aData[8+nLeaf*4], iPage); + if( pPage && (pBt->btsFlags & BTS_SECURE_DELETE)==0 ){ + sqlite3PagerDontWrite(pPage->pDbPage); + } + rc = btreeSetHasContent(pBt, iPage); + } + TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno)); + goto freepage_out; + } + } + + /* If control flows to this point, then it was not possible to add the + ** the page being freed as a leaf page of the first trunk in the free-list. + ** Possibly because the free-list is empty, or possibly because the + ** first trunk in the free-list is full. Either way, the page being freed + ** will become the new first trunk page in the free-list. + */ + if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){ + goto freepage_out; + } + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc!=SQLITE_OK ){ + goto freepage_out; + } + put4byte(pPage->aData, iTrunk); + put4byte(&pPage->aData[4], 0); + put4byte(&pPage1->aData[32], iPage); + TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk)); + +freepage_out: + if( pPage ){ + pPage->isInit = 0; + } + releasePage(pPage); + releasePage(pTrunk); + return rc; +} +static void freePage(MemPage *pPage, int *pRC){ + if( (*pRC)==SQLITE_OK ){ + *pRC = freePage2(pPage->pBt, pPage, pPage->pgno); + } +} + +/* +** Free any overflow pages associated with the given Cell. Write the +** local Cell size (the number of bytes on the original page, omitting +** overflow) into *pnSize. +*/ +static int clearCell( + MemPage *pPage, /* The page that contains the Cell */ + unsigned char *pCell, /* First byte of the Cell */ + u16 *pnSize /* Write the size of the Cell here */ +){ + BtShared *pBt = pPage->pBt; + CellInfo info; + Pgno ovflPgno; + int rc; + int nOvfl; + u32 ovflPageSize; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pPage->xParseCell(pPage, pCell, &info); + *pnSize = info.nSize; + if( info.iOverflow==0 ){ + return SQLITE_OK; /* No overflow pages. Return without doing anything */ + } + if( pCell+info.iOverflow+3 > pPage->aData+pPage->maskPage ){ + return SQLITE_CORRUPT_BKPT; /* Cell extends past end of page */ + } + ovflPgno = get4byte(&pCell[info.iOverflow]); + assert( pBt->usableSize > 4 ); + ovflPageSize = pBt->usableSize - 4; + nOvfl = (info.nPayload - info.nLocal + ovflPageSize - 1)/ovflPageSize; + assert( nOvfl>0 || + (CORRUPT_DB && (info.nPayload + ovflPageSize)btreePagecount(pBt) ){ + /* 0 is not a legal page number and page 1 cannot be an + ** overflow page. Therefore if ovflPgno<2 or past the end of the + ** file the database must be corrupt. */ + return SQLITE_CORRUPT_BKPT; + } + if( nOvfl ){ + rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext); + if( rc ) return rc; + } + + if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) ) + && sqlite3PagerPageRefcount(pOvfl->pDbPage)!=1 + ){ + /* There is no reason any cursor should have an outstanding reference + ** to an overflow page belonging to a cell that is being deleted/updated. + ** So if there exists more than one reference to this page, then it + ** must not really be an overflow page and the database must be corrupt. + ** It is helpful to detect this before calling freePage2(), as + ** freePage2() may zero the page contents if secure-delete mode is + ** enabled. If this 'overflow' page happens to be a page that the + ** caller is iterating through or using in some other way, this + ** can be problematic. + */ + rc = SQLITE_CORRUPT_BKPT; + }else{ + rc = freePage2(pBt, pOvfl, ovflPgno); + } + + if( pOvfl ){ + sqlite3PagerUnref(pOvfl->pDbPage); + } + if( rc ) return rc; + ovflPgno = iNext; + } + return SQLITE_OK; +} + +/* +** Create the byte sequence used to represent a cell on page pPage +** and write that byte sequence into pCell[]. Overflow pages are +** allocated and filled in as necessary. The calling procedure +** is responsible for making sure sufficient space has been allocated +** for pCell[]. +** +** Note that pCell does not necessary need to point to the pPage->aData +** area. pCell might point to some temporary storage. The cell will +** be constructed in this temporary area then copied into pPage->aData +** later. +*/ +static int fillInCell( + MemPage *pPage, /* The page that contains the cell */ + unsigned char *pCell, /* Complete text of the cell */ + const void *pKey, i64 nKey, /* The key */ + const void *pData,int nData, /* The data */ + int nZero, /* Extra zero bytes to append to pData */ + int *pnSize /* Write cell size here */ +){ + int nPayload; + const u8 *pSrc; + int nSrc, n, rc; + int spaceLeft; + MemPage *pOvfl = 0; + MemPage *pToRelease = 0; + unsigned char *pPrior; + unsigned char *pPayload; + BtShared *pBt = pPage->pBt; + Pgno pgnoOvfl = 0; + int nHeader; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + + /* pPage is not necessarily writeable since pCell might be auxiliary + ** buffer space that is separate from the pPage buffer area */ + assert( pCellaData || pCell>=&pPage->aData[pBt->pageSize] + || sqlite3PagerIswriteable(pPage->pDbPage) ); + + /* Fill in the header. */ + nHeader = pPage->childPtrSize; + nPayload = nData + nZero; + if( pPage->intKeyLeaf ){ + nHeader += putVarint32(&pCell[nHeader], nPayload); + }else{ + assert( nData==0 ); + assert( nZero==0 ); + } + nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey); + + /* Fill in the payload size */ + if( pPage->intKey ){ + pSrc = pData; + nSrc = nData; + nData = 0; + }else{ + assert( nKey<=0x7fffffff && pKey!=0 ); + nPayload = (int)nKey; + pSrc = pKey; + nSrc = (int)nKey; + } + if( nPayload<=pPage->maxLocal ){ + n = nHeader + nPayload; + testcase( n==3 ); + testcase( n==4 ); + if( n<4 ) n = 4; + *pnSize = n; + spaceLeft = nPayload; + pPrior = pCell; + }else{ + int mn = pPage->minLocal; + n = mn + (nPayload - mn) % (pPage->pBt->usableSize - 4); + testcase( n==pPage->maxLocal ); + testcase( n==pPage->maxLocal+1 ); + if( n > pPage->maxLocal ) n = mn; + spaceLeft = n; + *pnSize = n + nHeader + 4; + pPrior = &pCell[nHeader+n]; + } + pPayload = &pCell[nHeader]; + + /* At this point variables should be set as follows: + ** + ** nPayload Total payload size in bytes + ** pPayload Begin writing payload here + ** spaceLeft Space available at pPayload. If nPayload>spaceLeft, + ** that means content must spill into overflow pages. + ** *pnSize Size of the local cell (not counting overflow pages) + ** pPrior Where to write the pgno of the first overflow page + ** + ** Use a call to btreeParseCellPtr() to verify that the values above + ** were computed correctly. + */ +#if SQLITE_DEBUG + { + CellInfo info; + pPage->xParseCell(pPage, pCell, &info); + assert( nHeader=(int)(info.pPayload - pCell) ); + assert( info.nKey==nKey ); + assert( *pnSize == info.nSize ); + assert( spaceLeft == info.nLocal ); + assert( pPrior == &pCell[info.iOverflow] ); + } +#endif + + /* Write the payload into the local Cell and any extra into overflow pages */ + while( nPayload>0 ){ + if( spaceLeft==0 ){ +#ifndef SQLITE_OMIT_AUTOVACUUM + Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */ + if( pBt->autoVacuum ){ + do{ + pgnoOvfl++; + } while( + PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt) + ); + } +#endif + rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the database supports auto-vacuum, and the second or subsequent + ** overflow page is being allocated, add an entry to the pointer-map + ** for that page now. + ** + ** If this is the first overflow page, then write a partial entry + ** to the pointer-map. If we write nothing to this pointer-map slot, + ** then the optimistic overflow chain processing in clearCell() + ** may misinterpret the uninitialized values and delete the + ** wrong pages from the database. + */ + if( pBt->autoVacuum && rc==SQLITE_OK ){ + u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1); + ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc); + if( rc ){ + releasePage(pOvfl); + } + } +#endif + if( rc ){ + releasePage(pToRelease); + return rc; + } + + /* If pToRelease is not zero than pPrior points into the data area + ** of pToRelease. Make sure pToRelease is still writeable. */ + assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) ); + + /* If pPrior is part of the data area of pPage, then make sure pPage + ** is still writeable */ + assert( pPrioraData || pPrior>=&pPage->aData[pBt->pageSize] + || sqlite3PagerIswriteable(pPage->pDbPage) ); + + put4byte(pPrior, pgnoOvfl); + releasePage(pToRelease); + pToRelease = pOvfl; + pPrior = pOvfl->aData; + put4byte(pPrior, 0); + pPayload = &pOvfl->aData[4]; + spaceLeft = pBt->usableSize - 4; + } + n = nPayload; + if( n>spaceLeft ) n = spaceLeft; + + /* If pToRelease is not zero than pPayload points into the data area + ** of pToRelease. Make sure pToRelease is still writeable. */ + assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) ); + + /* If pPayload is part of the data area of pPage, then make sure pPage + ** is still writeable */ + assert( pPayloadaData || pPayload>=&pPage->aData[pBt->pageSize] + || sqlite3PagerIswriteable(pPage->pDbPage) ); + + if( nSrc>0 ){ + if( n>nSrc ) n = nSrc; + assert( pSrc ); + memcpy(pPayload, pSrc, n); + }else{ + memset(pPayload, 0, n); + } + nPayload -= n; + pPayload += n; + pSrc += n; + nSrc -= n; + spaceLeft -= n; + if( nSrc==0 ){ + nSrc = nData; + pSrc = pData; + } + } + releasePage(pToRelease); + return SQLITE_OK; +} + +/* +** Remove the i-th cell from pPage. This routine effects pPage only. +** The cell content is not freed or deallocated. It is assumed that +** the cell content has been copied someplace else. This routine just +** removes the reference to the cell from pPage. +** +** "sz" must be the number of bytes in the cell. +*/ +static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){ + u32 pc; /* Offset to cell content of cell being deleted */ + u8 *data; /* pPage->aData */ + u8 *ptr; /* Used to move bytes around within data[] */ + int rc; /* The return code */ + int hdr; /* Beginning of the header. 0 most pages. 100 page 1 */ + + if( *pRC ) return; + + assert( idx>=0 && idxnCell ); + assert( CORRUPT_DB || sz==cellSize(pPage, idx) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + data = pPage->aData; + ptr = &pPage->aCellIdx[2*idx]; + pc = get2byte(ptr); + hdr = pPage->hdrOffset; + testcase( pc==get2byte(&data[hdr+5]) ); + testcase( pc+sz==pPage->pBt->usableSize ); + if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){ + *pRC = SQLITE_CORRUPT_BKPT; + return; + } + rc = freeSpace(pPage, pc, sz); + if( rc ){ + *pRC = rc; + return; + } + pPage->nCell--; + if( pPage->nCell==0 ){ + memset(&data[hdr+1], 0, 4); + data[hdr+7] = 0; + put2byte(&data[hdr+5], pPage->pBt->usableSize); + pPage->nFree = pPage->pBt->usableSize - pPage->hdrOffset + - pPage->childPtrSize - 8; + }else{ + memmove(ptr, ptr+2, 2*(pPage->nCell - idx)); + put2byte(&data[hdr+3], pPage->nCell); + pPage->nFree += 2; + } +} + +/* +** Insert a new cell on pPage at cell index "i". pCell points to the +** content of the cell. +** +** If the cell content will fit on the page, then put it there. If it +** will not fit, then make a copy of the cell content into pTemp if +** pTemp is not null. Regardless of pTemp, allocate a new entry +** in pPage->apOvfl[] and make it point to the cell content (either +** in pTemp or the original pCell) and also record its index. +** Allocating a new entry in pPage->aCell[] implies that +** pPage->nOverflow is incremented. +*/ +static void insertCell( + MemPage *pPage, /* Page into which we are copying */ + int i, /* New cell becomes the i-th cell of the page */ + u8 *pCell, /* Content of the new cell */ + int sz, /* Bytes of content in pCell */ + u8 *pTemp, /* Temp storage space for pCell, if needed */ + Pgno iChild, /* If non-zero, replace first 4 bytes with this value */ + int *pRC /* Read and write return code from here */ +){ + int idx = 0; /* Where to write new cell content in data[] */ + int j; /* Loop counter */ + u8 *data; /* The content of the whole page */ + u8 *pIns; /* The point in pPage->aCellIdx[] where no cell inserted */ + + if( *pRC ) return; + + assert( i>=0 && i<=pPage->nCell+pPage->nOverflow ); + assert( MX_CELL(pPage->pBt)<=10921 ); + assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB ); + assert( pPage->nOverflow<=ArraySize(pPage->apOvfl) ); + assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + /* The cell should normally be sized correctly. However, when moving a + ** malformed cell from a leaf page to an interior page, if the cell size + ** wanted to be less than 4 but got rounded up to 4 on the leaf, then size + ** might be less than 8 (leaf-size + pointer) on the interior node. Hence + ** the term after the || in the following assert(). */ + assert( sz==pPage->xCellSize(pPage, pCell) || (sz==8 && iChild>0) ); + if( pPage->nOverflow || sz+2>pPage->nFree ){ + if( pTemp ){ + memcpy(pTemp, pCell, sz); + pCell = pTemp; + } + if( iChild ){ + put4byte(pCell, iChild); + } + j = pPage->nOverflow++; + assert( j<(int)(sizeof(pPage->apOvfl)/sizeof(pPage->apOvfl[0])) ); + pPage->apOvfl[j] = pCell; + pPage->aiOvfl[j] = (u16)i; + + /* When multiple overflows occur, they are always sequential and in + ** sorted order. This invariants arise because multiple overflows can + ** only occur when inserting divider cells into the parent page during + ** balancing, and the dividers are adjacent and sorted. + */ + assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */ + assert( j==0 || i==pPage->aiOvfl[j-1]+1 ); /* Overflows are sequential */ + }else{ + int rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc!=SQLITE_OK ){ + *pRC = rc; + return; + } + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + data = pPage->aData; + assert( &data[pPage->cellOffset]==pPage->aCellIdx ); + rc = allocateSpace(pPage, sz, &idx); + if( rc ){ *pRC = rc; return; } + /* The allocateSpace() routine guarantees the following properties + ** if it returns successfully */ + assert( idx >= 0 ); + assert( idx >= pPage->cellOffset+2*pPage->nCell+2 || CORRUPT_DB ); + assert( idx+sz <= (int)pPage->pBt->usableSize ); + pPage->nFree -= (u16)(2 + sz); + memcpy(&data[idx], pCell, sz); + if( iChild ){ + put4byte(&data[idx], iChild); + } + pIns = pPage->aCellIdx + i*2; + memmove(pIns+2, pIns, 2*(pPage->nCell - i)); + put2byte(pIns, idx); + pPage->nCell++; + /* increment the cell count */ + if( (++data[pPage->hdrOffset+4])==0 ) data[pPage->hdrOffset+3]++; + assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell ); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pPage->pBt->autoVacuum ){ + /* The cell may contain a pointer to an overflow page. If so, write + ** the entry for the overflow page into the pointer map. + */ + ptrmapPutOvflPtr(pPage, pCell, pRC); + } +#endif + } +} + +/* +** A CellArray object contains a cache of pointers and sizes for a +** consecutive sequence of cells that might be held multiple pages. +*/ +typedef struct CellArray CellArray; +struct CellArray { + int nCell; /* Number of cells in apCell[] */ + MemPage *pRef; /* Reference page */ + u8 **apCell; /* All cells begin balanced */ + u16 *szCell; /* Local size of all cells in apCell[] */ +}; + +/* +** Make sure the cell sizes at idx, idx+1, ..., idx+N-1 have been +** computed. +*/ +static void populateCellCache(CellArray *p, int idx, int N){ + assert( idx>=0 && idx+N<=p->nCell ); + while( N>0 ){ + assert( p->apCell[idx]!=0 ); + if( p->szCell[idx]==0 ){ + p->szCell[idx] = p->pRef->xCellSize(p->pRef, p->apCell[idx]); + }else{ + assert( CORRUPT_DB || + p->szCell[idx]==p->pRef->xCellSize(p->pRef, p->apCell[idx]) ); + } + idx++; + N--; + } +} + +/* +** Return the size of the Nth element of the cell array +*/ +static SQLITE_NOINLINE u16 computeCellSize(CellArray *p, int N){ + assert( N>=0 && NnCell ); + assert( p->szCell[N]==0 ); + p->szCell[N] = p->pRef->xCellSize(p->pRef, p->apCell[N]); + return p->szCell[N]; +} +static u16 cachedCellSize(CellArray *p, int N){ + assert( N>=0 && NnCell ); + if( p->szCell[N] ) return p->szCell[N]; + return computeCellSize(p, N); +} + +/* +** Array apCell[] contains pointers to nCell b-tree page cells. The +** szCell[] array contains the size in bytes of each cell. This function +** replaces the current contents of page pPg with the contents of the cell +** array. +** +** Some of the cells in apCell[] may currently be stored in pPg. This +** function works around problems caused by this by making a copy of any +** such cells before overwriting the page data. +** +** The MemPage.nFree field is invalidated by this function. It is the +** responsibility of the caller to set it correctly. +*/ +static int rebuildPage( + MemPage *pPg, /* Edit this page */ + int nCell, /* Final number of cells on page */ + u8 **apCell, /* Array of cells */ + u16 *szCell /* Array of cell sizes */ +){ + const int hdr = pPg->hdrOffset; /* Offset of header on pPg */ + u8 * const aData = pPg->aData; /* Pointer to data for pPg */ + const int usableSize = pPg->pBt->usableSize; + u8 * const pEnd = &aData[usableSize]; + int i; + u8 *pCellptr = pPg->aCellIdx; + u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager); + u8 *pData; + + i = get2byte(&aData[hdr+5]); + memcpy(&pTmp[i], &aData[i], usableSize - i); + + pData = pEnd; + for(i=0; iaData && pCellxCellSize(pPg, pCell) || CORRUPT_DB ); + testcase( szCell[i]!=pPg->xCellSize(pPg,pCell) ); + } + + /* The pPg->nFree field is now set incorrectly. The caller will fix it. */ + pPg->nCell = nCell; + pPg->nOverflow = 0; + + put2byte(&aData[hdr+1], 0); + put2byte(&aData[hdr+3], pPg->nCell); + put2byte(&aData[hdr+5], pData - aData); + aData[hdr+7] = 0x00; + return SQLITE_OK; +} + +/* +** Array apCell[] contains nCell pointers to b-tree cells. Array szCell +** contains the size in bytes of each such cell. This function attempts to +** add the cells stored in the array to page pPg. If it cannot (because +** the page needs to be defragmented before the cells will fit), non-zero +** is returned. Otherwise, if the cells are added successfully, zero is +** returned. +** +** Argument pCellptr points to the first entry in the cell-pointer array +** (part of page pPg) to populate. After cell apCell[0] is written to the +** page body, a 16-bit offset is written to pCellptr. And so on, for each +** cell in the array. It is the responsibility of the caller to ensure +** that it is safe to overwrite this part of the cell-pointer array. +** +** When this function is called, *ppData points to the start of the +** content area on page pPg. If the size of the content area is extended, +** *ppData is updated to point to the new start of the content area +** before returning. +** +** Finally, argument pBegin points to the byte immediately following the +** end of the space required by this page for the cell-pointer area (for +** all cells - not just those inserted by the current call). If the content +** area must be extended to before this point in order to accomodate all +** cells in apCell[], then the cells do not fit and non-zero is returned. +*/ +static int pageInsertArray( + MemPage *pPg, /* Page to add cells to */ + u8 *pBegin, /* End of cell-pointer array */ + u8 **ppData, /* IN/OUT: Page content -area pointer */ + u8 *pCellptr, /* Pointer to cell-pointer area */ + int iFirst, /* Index of first cell to add */ + int nCell, /* Number of cells to add to pPg */ + CellArray *pCArray /* Array of cells */ +){ + int i; + u8 *aData = pPg->aData; + u8 *pData = *ppData; + int iEnd = iFirst + nCell; + assert( CORRUPT_DB || pPg->hdrOffset==0 ); /* Never called on page 1 */ + for(i=iFirst; iapCell[i] will never overlap on a well-formed + ** database. But they might for a corrupt database. Hence use memmove() + ** since memcpy() sends SIGABORT with overlapping buffers on OpenBSD */ + assert( (pSlot+sz)<=pCArray->apCell[i] + || pSlot>=(pCArray->apCell[i]+sz) + || CORRUPT_DB ); + memmove(pSlot, pCArray->apCell[i], sz); + put2byte(pCellptr, (pSlot - aData)); + pCellptr += 2; + } + *ppData = pData; + return 0; +} + +/* +** Array apCell[] contains nCell pointers to b-tree cells. Array szCell +** contains the size in bytes of each such cell. This function adds the +** space associated with each cell in the array that is currently stored +** within the body of pPg to the pPg free-list. The cell-pointers and other +** fields of the page are not updated. +** +** This function returns the total number of cells added to the free-list. +*/ +static int pageFreeArray( + MemPage *pPg, /* Page to edit */ + int iFirst, /* First cell to delete */ + int nCell, /* Cells to delete */ + CellArray *pCArray /* Array of cells */ +){ + u8 * const aData = pPg->aData; + u8 * const pEnd = &aData[pPg->pBt->usableSize]; + u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize]; + int nRet = 0; + int i; + int iEnd = iFirst + nCell; + u8 *pFree = 0; + int szFree = 0; + + for(i=iFirst; iapCell[i]; + if( pCell>=pStart && pCellszCell[i]; assert( sz>0 ); + if( pFree!=(pCell + sz) ){ + if( pFree ){ + assert( pFree>aData && (pFree - aData)<65536 ); + freeSpace(pPg, (u16)(pFree - aData), szFree); + } + pFree = pCell; + szFree = sz; + if( pFree+sz>pEnd ) return 0; + }else{ + pFree = pCell; + szFree += sz; + } + nRet++; + } + } + if( pFree ){ + assert( pFree>aData && (pFree - aData)<65536 ); + freeSpace(pPg, (u16)(pFree - aData), szFree); + } + return nRet; +} + +/* +** apCell[] and szCell[] contains pointers to and sizes of all cells in the +** pages being balanced. The current page, pPg, has pPg->nCell cells starting +** with apCell[iOld]. After balancing, this page should hold nNew cells +** starting at apCell[iNew]. +** +** This routine makes the necessary adjustments to pPg so that it contains +** the correct cells after being balanced. +** +** The pPg->nFree field is invalid when this function returns. It is the +** responsibility of the caller to set it correctly. +*/ +static int editPage( + MemPage *pPg, /* Edit this page */ + int iOld, /* Index of first cell currently on page */ + int iNew, /* Index of new first cell on page */ + int nNew, /* Final number of cells on page */ + CellArray *pCArray /* Array of cells and sizes */ +){ + u8 * const aData = pPg->aData; + const int hdr = pPg->hdrOffset; + u8 *pBegin = &pPg->aCellIdx[nNew * 2]; + int nCell = pPg->nCell; /* Cells stored on pPg */ + u8 *pData; + u8 *pCellptr; + int i; + int iOldEnd = iOld + pPg->nCell + pPg->nOverflow; + int iNewEnd = iNew + nNew; + +#ifdef SQLITE_DEBUG + u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager); + memcpy(pTmp, aData, pPg->pBt->usableSize); +#endif + + /* Remove cells from the start and end of the page */ + if( iOldaCellIdx, &pPg->aCellIdx[nShift*2], nCell*2); + nCell -= nShift; + } + if( iNewEnd < iOldEnd ){ + nCell -= pageFreeArray(pPg, iNewEnd, iOldEnd - iNewEnd, pCArray); + } + + pData = &aData[get2byteNotZero(&aData[hdr+5])]; + if( pDataaCellIdx; + memmove(&pCellptr[nAdd*2], pCellptr, nCell*2); + if( pageInsertArray( + pPg, pBegin, &pData, pCellptr, + iNew, nAdd, pCArray + ) ) goto editpage_fail; + nCell += nAdd; + } + + /* Add any overflow cells */ + for(i=0; inOverflow; i++){ + int iCell = (iOld + pPg->aiOvfl[i]) - iNew; + if( iCell>=0 && iCellaCellIdx[iCell * 2]; + memmove(&pCellptr[2], pCellptr, (nCell - iCell) * 2); + nCell++; + if( pageInsertArray( + pPg, pBegin, &pData, pCellptr, + iCell+iNew, 1, pCArray + ) ) goto editpage_fail; + } + } + + /* Append cells to the end of the page */ + pCellptr = &pPg->aCellIdx[nCell*2]; + if( pageInsertArray( + pPg, pBegin, &pData, pCellptr, + iNew+nCell, nNew-nCell, pCArray + ) ) goto editpage_fail; + + pPg->nCell = nNew; + pPg->nOverflow = 0; + + put2byte(&aData[hdr+3], pPg->nCell); + put2byte(&aData[hdr+5], pData - aData); + +#ifdef SQLITE_DEBUG + for(i=0; iapCell[i+iNew]; + int iOff = get2byteAligned(&pPg->aCellIdx[i*2]); + if( pCell>=aData && pCell<&aData[pPg->pBt->usableSize] ){ + pCell = &pTmp[pCell - aData]; + } + assert( 0==memcmp(pCell, &aData[iOff], + pCArray->pRef->xCellSize(pCArray->pRef, pCArray->apCell[i+iNew])) ); + } +#endif + + return SQLITE_OK; + editpage_fail: + /* Unable to edit this page. Rebuild it from scratch instead. */ + populateCellCache(pCArray, iNew, nNew); + return rebuildPage(pPg, nNew, &pCArray->apCell[iNew], &pCArray->szCell[iNew]); +} + +/* +** The following parameters determine how many adjacent pages get involved +** in a balancing operation. NN is the number of neighbors on either side +** of the page that participate in the balancing operation. NB is the +** total number of pages that participate, including the target page and +** NN neighbors on either side. +** +** The minimum value of NN is 1 (of course). Increasing NN above 1 +** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance +** in exchange for a larger degradation in INSERT and UPDATE performance. +** The value of NN appears to give the best results overall. +*/ +#define NN 1 /* Number of neighbors on either side of pPage */ +#define NB (NN*2+1) /* Total pages involved in the balance */ + + +#ifndef SQLITE_OMIT_QUICKBALANCE +/* +** This version of balance() handles the common special case where +** a new entry is being inserted on the extreme right-end of the +** tree, in other words, when the new entry will become the largest +** entry in the tree. +** +** Instead of trying to balance the 3 right-most leaf pages, just add +** a new page to the right-hand side and put the one new entry in +** that page. This leaves the right side of the tree somewhat +** unbalanced. But odds are that we will be inserting new entries +** at the end soon afterwards so the nearly empty page will quickly +** fill up. On average. +** +** pPage is the leaf page which is the right-most page in the tree. +** pParent is its parent. pPage must have a single overflow entry +** which is also the right-most entry on the page. +** +** The pSpace buffer is used to store a temporary copy of the divider +** cell that will be inserted into pParent. Such a cell consists of a 4 +** byte page number followed by a variable length integer. In other +** words, at most 13 bytes. Hence the pSpace buffer must be at +** least 13 bytes in size. +*/ +static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){ + BtShared *const pBt = pPage->pBt; /* B-Tree Database */ + MemPage *pNew; /* Newly allocated page */ + int rc; /* Return Code */ + Pgno pgnoNew; /* Page number of pNew */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + assert( pPage->nOverflow==1 ); + + /* This error condition is now caught prior to reaching this function */ + if( NEVER(pPage->nCell==0) ) return SQLITE_CORRUPT_BKPT; + + /* Allocate a new page. This page will become the right-sibling of + ** pPage. Make the parent page writable, so that the new divider cell + ** may be inserted. If both these operations are successful, proceed. + */ + rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0); + + if( rc==SQLITE_OK ){ + + u8 *pOut = &pSpace[4]; + u8 *pCell = pPage->apOvfl[0]; + u16 szCell = pPage->xCellSize(pPage, pCell); + u8 *pStop; + + assert( sqlite3PagerIswriteable(pNew->pDbPage) ); + assert( pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) ); + zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF); + rc = rebuildPage(pNew, 1, &pCell, &szCell); + if( NEVER(rc) ) return rc; + pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - szCell; + + /* If this is an auto-vacuum database, update the pointer map + ** with entries for the new page, and any pointer from the + ** cell on the page to an overflow page. If either of these + ** operations fails, the return code is set, but the contents + ** of the parent page are still manipulated by thh code below. + ** That is Ok, at this point the parent page is guaranteed to + ** be marked as dirty. Returning an error code will cause a + ** rollback, undoing any changes made to the parent page. + */ + if( ISAUTOVACUUM ){ + ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc); + if( szCell>pNew->minLocal ){ + ptrmapPutOvflPtr(pNew, pCell, &rc); + } + } + + /* Create a divider cell to insert into pParent. The divider cell + ** consists of a 4-byte page number (the page number of pPage) and + ** a variable length key value (which must be the same value as the + ** largest key on pPage). + ** + ** To find the largest key value on pPage, first find the right-most + ** cell on pPage. The first two fields of this cell are the + ** record-length (a variable length integer at most 32-bits in size) + ** and the key value (a variable length integer, may have any value). + ** The first of the while(...) loops below skips over the record-length + ** field. The second while(...) loop copies the key value from the + ** cell on pPage into the pSpace buffer. + */ + pCell = findCell(pPage, pPage->nCell-1); + pStop = &pCell[9]; + while( (*(pCell++)&0x80) && pCellnCell, pSpace, (int)(pOut-pSpace), + 0, pPage->pgno, &rc); + + /* Set the right-child pointer of pParent to point to the new page. */ + put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew); + + /* Release the reference to the new page. */ + releasePage(pNew); + } + + return rc; +} +#endif /* SQLITE_OMIT_QUICKBALANCE */ + +#if 0 +/* +** This function does not contribute anything to the operation of SQLite. +** it is sometimes activated temporarily while debugging code responsible +** for setting pointer-map entries. +*/ +static int ptrmapCheckPages(MemPage **apPage, int nPage){ + int i, j; + for(i=0; ipBt; + assert( pPage->isInit ); + + for(j=0; jnCell; j++){ + CellInfo info; + u8 *z; + + z = findCell(pPage, j); + pPage->xParseCell(pPage, z, &info); + if( info.iOverflow ){ + Pgno ovfl = get4byte(&z[info.iOverflow]); + ptrmapGet(pBt, ovfl, &e, &n); + assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 ); + } + if( !pPage->leaf ){ + Pgno child = get4byte(z); + ptrmapGet(pBt, child, &e, &n); + assert( n==pPage->pgno && e==PTRMAP_BTREE ); + } + } + if( !pPage->leaf ){ + Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]); + ptrmapGet(pBt, child, &e, &n); + assert( n==pPage->pgno && e==PTRMAP_BTREE ); + } + } + return 1; +} +#endif + +/* +** This function is used to copy the contents of the b-tree node stored +** on page pFrom to page pTo. If page pFrom was not a leaf page, then +** the pointer-map entries for each child page are updated so that the +** parent page stored in the pointer map is page pTo. If pFrom contained +** any cells with overflow page pointers, then the corresponding pointer +** map entries are also updated so that the parent page is page pTo. +** +** If pFrom is currently carrying any overflow cells (entries in the +** MemPage.apOvfl[] array), they are not copied to pTo. +** +** Before returning, page pTo is reinitialized using btreeInitPage(). +** +** The performance of this function is not critical. It is only used by +** the balance_shallower() and balance_deeper() procedures, neither of +** which are called often under normal circumstances. +*/ +static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){ + if( (*pRC)==SQLITE_OK ){ + BtShared * const pBt = pFrom->pBt; + u8 * const aFrom = pFrom->aData; + u8 * const aTo = pTo->aData; + int const iFromHdr = pFrom->hdrOffset; + int const iToHdr = ((pTo->pgno==1) ? 100 : 0); + int rc; + int iData; + + + assert( pFrom->isInit ); + assert( pFrom->nFree>=iToHdr ); + assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize ); + + /* Copy the b-tree node content from page pFrom to page pTo. */ + iData = get2byte(&aFrom[iFromHdr+5]); + memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData); + memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell); + + /* Reinitialize page pTo so that the contents of the MemPage structure + ** match the new data. The initialization of pTo can actually fail under + ** fairly obscure circumstances, even though it is a copy of initialized + ** page pFrom. + */ + pTo->isInit = 0; + rc = btreeInitPage(pTo); + if( rc!=SQLITE_OK ){ + *pRC = rc; + return; + } + + /* If this is an auto-vacuum database, update the pointer-map entries + ** for any b-tree or overflow pages that pTo now contains the pointers to. + */ + if( ISAUTOVACUUM ){ + *pRC = setChildPtrmaps(pTo); + } + } +} + +/* +** This routine redistributes cells on the iParentIdx'th child of pParent +** (hereafter "the page") and up to 2 siblings so that all pages have about the +** same amount of free space. Usually a single sibling on either side of the +** page are used in the balancing, though both siblings might come from one +** side if the page is the first or last child of its parent. If the page +** has fewer than 2 siblings (something which can only happen if the page +** is a root page or a child of a root page) then all available siblings +** participate in the balancing. +** +** The number of siblings of the page might be increased or decreased by +** one or two in an effort to keep pages nearly full but not over full. +** +** Note that when this routine is called, some of the cells on the page +** might not actually be stored in MemPage.aData[]. This can happen +** if the page is overfull. This routine ensures that all cells allocated +** to the page and its siblings fit into MemPage.aData[] before returning. +** +** In the course of balancing the page and its siblings, cells may be +** inserted into or removed from the parent page (pParent). Doing so +** may cause the parent page to become overfull or underfull. If this +** happens, it is the responsibility of the caller to invoke the correct +** balancing routine to fix this problem (see the balance() routine). +** +** If this routine fails for any reason, it might leave the database +** in a corrupted state. So if this routine fails, the database should +** be rolled back. +** +** The third argument to this function, aOvflSpace, is a pointer to a +** buffer big enough to hold one page. If while inserting cells into the parent +** page (pParent) the parent page becomes overfull, this buffer is +** used to store the parent's overflow cells. Because this function inserts +** a maximum of four divider cells into the parent page, and the maximum +** size of a cell stored within an internal node is always less than 1/4 +** of the page-size, the aOvflSpace[] buffer is guaranteed to be large +** enough for all overflow cells. +** +** If aOvflSpace is set to a null pointer, this function returns +** SQLITE_NOMEM. +*/ +#if defined(_MSC_VER) && _MSC_VER >= 1700 && defined(_M_ARM) +#pragma optimize("", off) +#endif +static int balance_nonroot( + MemPage *pParent, /* Parent page of siblings being balanced */ + int iParentIdx, /* Index of "the page" in pParent */ + u8 *aOvflSpace, /* page-size bytes of space for parent ovfl */ + int isRoot, /* True if pParent is a root-page */ + int bBulk /* True if this call is part of a bulk load */ +){ + BtShared *pBt; /* The whole database */ + int nMaxCells = 0; /* Allocated size of apCell, szCell, aFrom. */ + int nNew = 0; /* Number of pages in apNew[] */ + int nOld; /* Number of pages in apOld[] */ + int i, j, k; /* Loop counters */ + int nxDiv; /* Next divider slot in pParent->aCell[] */ + int rc = SQLITE_OK; /* The return code */ + u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */ + int leafData; /* True if pPage is a leaf of a LEAFDATA tree */ + int usableSpace; /* Bytes in pPage beyond the header */ + int pageFlags; /* Value of pPage->aData[0] */ + int iSpace1 = 0; /* First unused byte of aSpace1[] */ + int iOvflSpace = 0; /* First unused byte of aOvflSpace[] */ + int szScratch; /* Size of scratch memory requested */ + MemPage *apOld[NB]; /* pPage and up to two siblings */ + MemPage *apNew[NB+2]; /* pPage and up to NB siblings after balancing */ + u8 *pRight; /* Location in parent of right-sibling pointer */ + u8 *apDiv[NB-1]; /* Divider cells in pParent */ + int cntNew[NB+2]; /* Index in b.paCell[] of cell after i-th page */ + int cntOld[NB+2]; /* Old index in b.apCell[] */ + int szNew[NB+2]; /* Combined size of cells placed on i-th page */ + u8 *aSpace1; /* Space for copies of dividers cells */ + Pgno pgno; /* Temp var to store a page number in */ + u8 abDone[NB+2]; /* True after i'th new page is populated */ + Pgno aPgno[NB+2]; /* Page numbers of new pages before shuffling */ + Pgno aPgOrder[NB+2]; /* Copy of aPgno[] used for sorting pages */ + u16 aPgFlags[NB+2]; /* flags field of new pages before shuffling */ + CellArray b; /* Parsed information on cells being balanced */ + + memset(abDone, 0, sizeof(abDone)); + b.nCell = 0; + b.apCell = 0; + pBt = pParent->pBt; + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + +#if 0 + TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno)); +#endif + + /* At this point pParent may have at most one overflow cell. And if + ** this overflow cell is present, it must be the cell with + ** index iParentIdx. This scenario comes about when this function + ** is called (indirectly) from sqlite3BtreeDelete(). + */ + assert( pParent->nOverflow==0 || pParent->nOverflow==1 ); + assert( pParent->nOverflow==0 || pParent->aiOvfl[0]==iParentIdx ); + + if( !aOvflSpace ){ + return SQLITE_NOMEM; + } + + /* Find the sibling pages to balance. Also locate the cells in pParent + ** that divide the siblings. An attempt is made to find NN siblings on + ** either side of pPage. More siblings are taken from one side, however, + ** if there are fewer than NN siblings on the other side. If pParent + ** has NB or fewer children then all children of pParent are taken. + ** + ** This loop also drops the divider cells from the parent page. This + ** way, the remainder of the function does not have to deal with any + ** overflow cells in the parent page, since if any existed they will + ** have already been removed. + */ + i = pParent->nOverflow + pParent->nCell; + if( i<2 ){ + nxDiv = 0; + }else{ + assert( bBulk==0 || bBulk==1 ); + if( iParentIdx==0 ){ + nxDiv = 0; + }else if( iParentIdx==i ){ + nxDiv = i-2+bBulk; + }else{ + nxDiv = iParentIdx-1; + } + i = 2-bBulk; + } + nOld = i+1; + if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){ + pRight = &pParent->aData[pParent->hdrOffset+8]; + }else{ + pRight = findCell(pParent, i+nxDiv-pParent->nOverflow); + } + pgno = get4byte(pRight); + while( 1 ){ + rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0); + if( rc ){ + memset(apOld, 0, (i+1)*sizeof(MemPage*)); + goto balance_cleanup; + } + nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow; + if( (i--)==0 ) break; + + if( i+nxDiv==pParent->aiOvfl[0] && pParent->nOverflow ){ + apDiv[i] = pParent->apOvfl[0]; + pgno = get4byte(apDiv[i]); + szNew[i] = pParent->xCellSize(pParent, apDiv[i]); + pParent->nOverflow = 0; + }else{ + apDiv[i] = findCell(pParent, i+nxDiv-pParent->nOverflow); + pgno = get4byte(apDiv[i]); + szNew[i] = pParent->xCellSize(pParent, apDiv[i]); + + /* Drop the cell from the parent page. apDiv[i] still points to + ** the cell within the parent, even though it has been dropped. + ** This is safe because dropping a cell only overwrites the first + ** four bytes of it, and this function does not need the first + ** four bytes of the divider cell. So the pointer is safe to use + ** later on. + ** + ** But not if we are in secure-delete mode. In secure-delete mode, + ** the dropCell() routine will overwrite the entire cell with zeroes. + ** In this case, temporarily copy the cell into the aOvflSpace[] + ** buffer. It will be copied out again as soon as the aSpace[] buffer + ** is allocated. */ + if( pBt->btsFlags & BTS_SECURE_DELETE ){ + int iOff; + + iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData); + if( (iOff+szNew[i])>(int)pBt->usableSize ){ + rc = SQLITE_CORRUPT_BKPT; + memset(apOld, 0, (i+1)*sizeof(MemPage*)); + goto balance_cleanup; + }else{ + memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]); + apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData]; + } + } + dropCell(pParent, i+nxDiv-pParent->nOverflow, szNew[i], &rc); + } + } + + /* Make nMaxCells a multiple of 4 in order to preserve 8-byte + ** alignment */ + nMaxCells = (nMaxCells + 3)&~3; + + /* + ** Allocate space for memory structures + */ + szScratch = + nMaxCells*sizeof(u8*) /* b.apCell */ + + nMaxCells*sizeof(u16) /* b.szCell */ + + pBt->pageSize; /* aSpace1 */ + + /* EVIDENCE-OF: R-28375-38319 SQLite will never request a scratch buffer + ** that is more than 6 times the database page size. */ + assert( szScratch<=6*(int)pBt->pageSize ); + b.apCell = sqlite3ScratchMalloc( szScratch ); + if( b.apCell==0 ){ + rc = SQLITE_NOMEM; + goto balance_cleanup; + } + b.szCell = (u16*)&b.apCell[nMaxCells]; + aSpace1 = (u8*)&b.szCell[nMaxCells]; + assert( EIGHT_BYTE_ALIGNMENT(aSpace1) ); + + /* + ** Load pointers to all cells on sibling pages and the divider cells + ** into the local b.apCell[] array. Make copies of the divider cells + ** into space obtained from aSpace1[]. The divider cells have already + ** been removed from pParent. + ** + ** If the siblings are on leaf pages, then the child pointers of the + ** divider cells are stripped from the cells before they are copied + ** into aSpace1[]. In this way, all cells in b.apCell[] are without + ** child pointers. If siblings are not leaves, then all cell in + ** b.apCell[] include child pointers. Either way, all cells in b.apCell[] + ** are alike. + ** + ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf. + ** leafData: 1 if pPage holds key+data and pParent holds only keys. + */ + b.pRef = apOld[0]; + leafCorrection = b.pRef->leaf*4; + leafData = b.pRef->intKeyLeaf; + for(i=0; inCell; + u8 *aData = pOld->aData; + u16 maskPage = pOld->maskPage; + u8 *piCell = aData + pOld->cellOffset; + u8 *piEnd; + + /* Verify that all sibling pages are of the same "type" (table-leaf, + ** table-interior, index-leaf, or index-interior). + */ + if( pOld->aData[0]!=apOld[0]->aData[0] ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + + /* Load b.apCell[] with pointers to all cells in pOld. If pOld + ** constains overflow cells, include them in the b.apCell[] array + ** in the correct spot. + ** + ** Note that when there are multiple overflow cells, it is always the + ** case that they are sequential and adjacent. This invariant arises + ** because multiple overflows can only occurs when inserting divider + ** cells into a parent on a prior balance, and divider cells are always + ** adjacent and are inserted in order. There is an assert() tagged + ** with "NOTE 1" in the overflow cell insertion loop to prove this + ** invariant. + ** + ** This must be done in advance. Once the balance starts, the cell + ** offset section of the btree page will be overwritten and we will no + ** long be able to find the cells if a pointer to each cell is not saved + ** first. + */ + memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*limit); + if( pOld->nOverflow>0 ){ + memset(&b.szCell[b.nCell+limit], 0, sizeof(b.szCell[0])*pOld->nOverflow); + limit = pOld->aiOvfl[0]; + for(j=0; jnOverflow; k++){ + assert( k==0 || pOld->aiOvfl[k-1]+1==pOld->aiOvfl[k] );/* NOTE 1 */ + b.apCell[b.nCell] = pOld->apOvfl[k]; + b.nCell++; + } + } + piEnd = aData + pOld->cellOffset + 2*pOld->nCell; + while( piCellmaxLocal+23 ); + assert( iSpace1 <= (int)pBt->pageSize ); + memcpy(pTemp, apDiv[i], sz); + b.apCell[b.nCell] = pTemp+leafCorrection; + assert( leafCorrection==0 || leafCorrection==4 ); + b.szCell[b.nCell] = b.szCell[b.nCell] - leafCorrection; + if( !pOld->leaf ){ + assert( leafCorrection==0 ); + assert( pOld->hdrOffset==0 ); + /* The right pointer of the child page pOld becomes the left + ** pointer of the divider cell */ + memcpy(b.apCell[b.nCell], &pOld->aData[8], 4); + }else{ + assert( leafCorrection==4 ); + while( b.szCell[b.nCell]<4 ){ + /* Do not allow any cells smaller than 4 bytes. If a smaller cell + ** does exist, pad it with 0x00 bytes. */ + assert( b.szCell[b.nCell]==3 || CORRUPT_DB ); + assert( b.apCell[b.nCell]==&aSpace1[iSpace1-3] || CORRUPT_DB ); + aSpace1[iSpace1++] = 0x00; + b.szCell[b.nCell]++; + } + } + b.nCell++; + } + } + + /* + ** Figure out the number of pages needed to hold all b.nCell cells. + ** Store this number in "k". Also compute szNew[] which is the total + ** size of all cells on the i-th page and cntNew[] which is the index + ** in b.apCell[] of the cell that divides page i from page i+1. + ** cntNew[k] should equal b.nCell. + ** + ** Values computed by this block: + ** + ** k: The total number of sibling pages + ** szNew[i]: Spaced used on the i-th sibling page. + ** cntNew[i]: Index in b.apCell[] and b.szCell[] for the first cell to + ** the right of the i-th sibling page. + ** usableSpace: Number of bytes of space available on each sibling. + ** + */ + usableSpace = pBt->usableSize - 12 + leafCorrection; + for(i=0; inFree; + if( szNew[i]<0 ){ rc = SQLITE_CORRUPT_BKPT; goto balance_cleanup; } + for(j=0; jnOverflow; j++){ + szNew[i] += 2 + p->xCellSize(p, p->apOvfl[j]); + } + cntNew[i] = cntOld[i]; + } + k = nOld; + for(i=0; iusableSpace ){ + if( i+1>=k ){ + k = i+2; + if( k>NB+2 ){ rc = SQLITE_CORRUPT_BKPT; goto balance_cleanup; } + szNew[k-1] = 0; + cntNew[k-1] = b.nCell; + } + sz = 2 + cachedCellSize(&b, cntNew[i]-1); + szNew[i] -= sz; + if( !leafData ){ + if( cntNew[i]usableSpace ) break; + szNew[i] += sz; + cntNew[i]++; + if( !leafData ){ + if( cntNew[i]=b.nCell ){ + k = i+1; + }else if( cntNew[i] <= (i>0 ? cntNew[i-1] : 0) ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + } + + /* + ** The packing computed by the previous block is biased toward the siblings + ** on the left side (siblings with smaller keys). The left siblings are + ** always nearly full, while the right-most sibling might be nearly empty. + ** The next block of code attempts to adjust the packing of siblings to + ** get a better balance. + ** + ** This adjustment is more than an optimization. The packing above might + ** be so out of balance as to be illegal. For example, the right-most + ** sibling might be completely empty. This adjustment is not optional. + */ + for(i=k-1; i>0; i--){ + int szRight = szNew[i]; /* Size of sibling on the right */ + int szLeft = szNew[i-1]; /* Size of sibling on the left */ + int r; /* Index of right-most cell in left sibling */ + int d; /* Index of first cell to the left of right sibling */ + + r = cntNew[i-1] - 1; + d = r + 1 - leafData; + (void)cachedCellSize(&b, d); + do{ + assert( d szLeft-(b.szCell[r]+2)) ){ + break; + } + szRight += b.szCell[d] + 2; + szLeft -= b.szCell[r] + 2; + cntNew[i-1] = r; + r--; + d--; + }while( r>=0 ); + szNew[i] = szRight; + szNew[i-1] = szLeft; + if( cntNew[i-1] <= (i>1 ? cntNew[i-2] : 0) ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + } + + /* Sanity check: For a non-corrupt database file one of the follwing + ** must be true: + ** (1) We found one or more cells (cntNew[0])>0), or + ** (2) pPage is a virtual root page. A virtual root page is when + ** the real root page is page 1 and we are the only child of + ** that page. + */ + assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) || CORRUPT_DB); + TRACE(("BALANCE: old: %d(nc=%d) %d(nc=%d) %d(nc=%d)\n", + apOld[0]->pgno, apOld[0]->nCell, + nOld>=2 ? apOld[1]->pgno : 0, nOld>=2 ? apOld[1]->nCell : 0, + nOld>=3 ? apOld[2]->pgno : 0, nOld>=3 ? apOld[2]->nCell : 0 + )); + + /* + ** Allocate k new pages. Reuse old pages where possible. + */ + pageFlags = apOld[0]->aData[0]; + for(i=0; ipDbPage); + nNew++; + if( rc ) goto balance_cleanup; + }else{ + assert( i>0 ); + rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0); + if( rc ) goto balance_cleanup; + zeroPage(pNew, pageFlags); + apNew[i] = pNew; + nNew++; + cntOld[i] = b.nCell; + + /* Set the pointer-map entry for the new sibling page. */ + if( ISAUTOVACUUM ){ + ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc); + if( rc!=SQLITE_OK ){ + goto balance_cleanup; + } + } + } + } + + /* + ** Reassign page numbers so that the new pages are in ascending order. + ** This helps to keep entries in the disk file in order so that a scan + ** of the table is closer to a linear scan through the file. That in turn + ** helps the operating system to deliver pages from the disk more rapidly. + ** + ** An O(n^2) insertion sort algorithm is used, but since n is never more + ** than (NB+2) (a small constant), that should not be a problem. + ** + ** When NB==3, this one optimization makes the database about 25% faster + ** for large insertions and deletions. + */ + for(i=0; ipgno; + aPgFlags[i] = apNew[i]->pDbPage->flags; + for(j=0; ji ){ + sqlite3PagerRekey(apNew[iBest]->pDbPage, pBt->nPage+iBest+1, 0); + } + sqlite3PagerRekey(apNew[i]->pDbPage, pgno, aPgFlags[iBest]); + apNew[i]->pgno = pgno; + } + } + + TRACE(("BALANCE: new: %d(%d nc=%d) %d(%d nc=%d) %d(%d nc=%d) " + "%d(%d nc=%d) %d(%d nc=%d)\n", + apNew[0]->pgno, szNew[0], cntNew[0], + nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0, + nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0, + nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0, + nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0, + nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0, + nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0, + nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0, + nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0 + )); + + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + put4byte(pRight, apNew[nNew-1]->pgno); + + /* If the sibling pages are not leaves, ensure that the right-child pointer + ** of the right-most new sibling page is set to the value that was + ** originally in the same field of the right-most old sibling page. */ + if( (pageFlags & PTF_LEAF)==0 && nOld!=nNew ){ + MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1]; + memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4); + } + + /* Make any required updates to pointer map entries associated with + ** cells stored on sibling pages following the balance operation. Pointer + ** map entries associated with divider cells are set by the insertCell() + ** routine. The associated pointer map entries are: + ** + ** a) if the cell contains a reference to an overflow chain, the + ** entry associated with the first page in the overflow chain, and + ** + ** b) if the sibling pages are not leaves, the child page associated + ** with the cell. + ** + ** If the sibling pages are not leaves, then the pointer map entry + ** associated with the right-child of each sibling may also need to be + ** updated. This happens below, after the sibling pages have been + ** populated, not here. + */ + if( ISAUTOVACUUM ){ + MemPage *pNew = apNew[0]; + u8 *aOld = pNew->aData; + int cntOldNext = pNew->nCell + pNew->nOverflow; + int usableSize = pBt->usableSize; + int iNew = 0; + int iOld = 0; + + for(i=0; inCell + pOld->nOverflow + !leafData; + aOld = pOld->aData; + } + if( i==cntNew[iNew] ){ + pNew = apNew[++iNew]; + if( !leafData ) continue; + } + + /* Cell pCell is destined for new sibling page pNew. Originally, it + ** was either part of sibling page iOld (possibly an overflow cell), + ** or else the divider cell to the left of sibling page iOld. So, + ** if sibling page iOld had the same page number as pNew, and if + ** pCell really was a part of sibling page iOld (not a divider or + ** overflow cell), we can skip updating the pointer map entries. */ + if( iOld>=nNew + || pNew->pgno!=aPgno[iOld] + || pCell=&aOld[usableSize] + ){ + if( !leafCorrection ){ + ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc); + } + if( cachedCellSize(&b,i)>pNew->minLocal ){ + ptrmapPutOvflPtr(pNew, pCell, &rc); + } + if( rc ) goto balance_cleanup; + } + } + } + + /* Insert new divider cells into pParent. */ + for(i=0; ileaf ){ + memcpy(&pNew->aData[8], pCell, 4); + }else if( leafData ){ + /* If the tree is a leaf-data tree, and the siblings are leaves, + ** then there is no divider cell in b.apCell[]. Instead, the divider + ** cell consists of the integer key for the right-most cell of + ** the sibling-page assembled above only. + */ + CellInfo info; + j--; + pNew->xParseCell(pNew, b.apCell[j], &info); + pCell = pTemp; + sz = 4 + putVarint(&pCell[4], info.nKey); + pTemp = 0; + }else{ + pCell -= 4; + /* Obscure case for non-leaf-data trees: If the cell at pCell was + ** previously stored on a leaf node, and its reported size was 4 + ** bytes, then it may actually be smaller than this + ** (see btreeParseCellPtr(), 4 bytes is the minimum size of + ** any cell). But it is important to pass the correct size to + ** insertCell(), so reparse the cell now. + ** + ** Note that this can never happen in an SQLite data file, as all + ** cells are at least 4 bytes. It only happens in b-trees used + ** to evaluate "IN (SELECT ...)" and similar clauses. + */ + if( b.szCell[j]==4 ){ + assert(leafCorrection==4); + sz = pParent->xCellSize(pParent, pCell); + } + } + iOvflSpace += sz; + assert( sz<=pBt->maxLocal+23 ); + assert( iOvflSpace <= (int)pBt->pageSize ); + insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno, &rc); + if( rc!=SQLITE_OK ) goto balance_cleanup; + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + } + + /* Now update the actual sibling pages. The order in which they are updated + ** is important, as this code needs to avoid disrupting any page from which + ** cells may still to be read. In practice, this means: + ** + ** (1) If cells are moving left (from apNew[iPg] to apNew[iPg-1]) + ** then it is not safe to update page apNew[iPg] until after + ** the left-hand sibling apNew[iPg-1] has been updated. + ** + ** (2) If cells are moving right (from apNew[iPg] to apNew[iPg+1]) + ** then it is not safe to update page apNew[iPg] until after + ** the right-hand sibling apNew[iPg+1] has been updated. + ** + ** If neither of the above apply, the page is safe to update. + ** + ** The iPg value in the following loop starts at nNew-1 goes down + ** to 0, then back up to nNew-1 again, thus making two passes over + ** the pages. On the initial downward pass, only condition (1) above + ** needs to be tested because (2) will always be true from the previous + ** step. On the upward pass, both conditions are always true, so the + ** upwards pass simply processes pages that were missed on the downward + ** pass. + */ + for(i=1-nNew; i=0 && iPg=0 /* On the upwards pass, or... */ + || cntOld[iPg-1]>=cntNew[iPg-1] /* Condition (1) is true */ + ){ + int iNew; + int iOld; + int nNewCell; + + /* Verify condition (1): If cells are moving left, update iPg + ** only after iPg-1 has already been updated. */ + assert( iPg==0 || cntOld[iPg-1]>=cntNew[iPg-1] || abDone[iPg-1] ); + + /* Verify condition (2): If cells are moving right, update iPg + ** only after iPg+1 has already been updated. */ + assert( cntNew[iPg]>=cntOld[iPg] || abDone[iPg+1] ); + + if( iPg==0 ){ + iNew = iOld = 0; + nNewCell = cntNew[0]; + }else{ + iOld = iPgnFree = usableSpace-szNew[iPg]; + assert( apNew[iPg]->nOverflow==0 ); + assert( apNew[iPg]->nCell==nNewCell ); + } + } + + /* All pages have been processed exactly once */ + assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 ); + + assert( nOld>0 ); + assert( nNew>0 ); + + if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){ + /* The root page of the b-tree now contains no cells. The only sibling + ** page is the right-child of the parent. Copy the contents of the + ** child page into the parent, decreasing the overall height of the + ** b-tree structure by one. This is described as the "balance-shallower" + ** sub-algorithm in some documentation. + ** + ** If this is an auto-vacuum database, the call to copyNodeContent() + ** sets all pointer-map entries corresponding to database image pages + ** for which the pointer is stored within the content being copied. + ** + ** It is critical that the child page be defragmented before being + ** copied into the parent, because if the parent is page 1 then it will + ** by smaller than the child due to the database header, and so all the + ** free space needs to be up front. + */ + assert( nNew==1 || CORRUPT_DB ); + rc = defragmentPage(apNew[0]); + testcase( rc!=SQLITE_OK ); + assert( apNew[0]->nFree == + (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2) + || rc!=SQLITE_OK + ); + copyNodeContent(apNew[0], pParent, &rc); + freePage(apNew[0], &rc); + }else if( ISAUTOVACUUM && !leafCorrection ){ + /* Fix the pointer map entries associated with the right-child of each + ** sibling page. All other pointer map entries have already been taken + ** care of. */ + for(i=0; iaData[8]); + ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc); + } + } + + assert( pParent->isInit ); + TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n", + nOld, nNew, b.nCell)); + + /* Free any old pages that were not reused as new pages. + */ + for(i=nNew; iisInit ){ + /* The ptrmapCheckPages() contains assert() statements that verify that + ** all pointer map pages are set correctly. This is helpful while + ** debugging. This is usually disabled because a corrupt database may + ** cause an assert() statement to fail. */ + ptrmapCheckPages(apNew, nNew); + ptrmapCheckPages(&pParent, 1); + } +#endif + + /* + ** Cleanup before returning. + */ +balance_cleanup: + sqlite3ScratchFree(b.apCell); + for(i=0; i= 1700 && defined(_M_ARM) +#pragma optimize("", on) +#endif + + +/* +** This function is called when the root page of a b-tree structure is +** overfull (has one or more overflow pages). +** +** A new child page is allocated and the contents of the current root +** page, including overflow cells, are copied into the child. The root +** page is then overwritten to make it an empty page with the right-child +** pointer pointing to the new page. +** +** Before returning, all pointer-map entries corresponding to pages +** that the new child-page now contains pointers to are updated. The +** entry corresponding to the new right-child pointer of the root +** page is also updated. +** +** If successful, *ppChild is set to contain a reference to the child +** page and SQLITE_OK is returned. In this case the caller is required +** to call releasePage() on *ppChild exactly once. If an error occurs, +** an error code is returned and *ppChild is set to 0. +*/ +static int balance_deeper(MemPage *pRoot, MemPage **ppChild){ + int rc; /* Return value from subprocedures */ + MemPage *pChild = 0; /* Pointer to a new child page */ + Pgno pgnoChild = 0; /* Page number of the new child page */ + BtShared *pBt = pRoot->pBt; /* The BTree */ + + assert( pRoot->nOverflow>0 ); + assert( sqlite3_mutex_held(pBt->mutex) ); + + /* Make pRoot, the root page of the b-tree, writable. Allocate a new + ** page that will become the new right-child of pPage. Copy the contents + ** of the node stored on pRoot into the new child page. + */ + rc = sqlite3PagerWrite(pRoot->pDbPage); + if( rc==SQLITE_OK ){ + rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0); + copyNodeContent(pRoot, pChild, &rc); + if( ISAUTOVACUUM ){ + ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc); + } + } + if( rc ){ + *ppChild = 0; + releasePage(pChild); + return rc; + } + assert( sqlite3PagerIswriteable(pChild->pDbPage) ); + assert( sqlite3PagerIswriteable(pRoot->pDbPage) ); + assert( pChild->nCell==pRoot->nCell ); + + TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno)); + + /* Copy the overflow cells from pRoot to pChild */ + memcpy(pChild->aiOvfl, pRoot->aiOvfl, + pRoot->nOverflow*sizeof(pRoot->aiOvfl[0])); + memcpy(pChild->apOvfl, pRoot->apOvfl, + pRoot->nOverflow*sizeof(pRoot->apOvfl[0])); + pChild->nOverflow = pRoot->nOverflow; + + /* Zero the contents of pRoot. Then install pChild as the right-child. */ + zeroPage(pRoot, pChild->aData[0] & ~PTF_LEAF); + put4byte(&pRoot->aData[pRoot->hdrOffset+8], pgnoChild); + + *ppChild = pChild; + return SQLITE_OK; +} + +/* +** The page that pCur currently points to has just been modified in +** some way. This function figures out if this modification means the +** tree needs to be balanced, and if so calls the appropriate balancing +** routine. Balancing routines are: +** +** balance_quick() +** balance_deeper() +** balance_nonroot() +*/ +static int balance(BtCursor *pCur){ + int rc = SQLITE_OK; + const int nMin = pCur->pBt->usableSize * 2 / 3; + u8 aBalanceQuickSpace[13]; + u8 *pFree = 0; + + TESTONLY( int balance_quick_called = 0 ); + TESTONLY( int balance_deeper_called = 0 ); + + do { + int iPage = pCur->iPage; + MemPage *pPage = pCur->apPage[iPage]; + + if( iPage==0 ){ + if( pPage->nOverflow ){ + /* The root page of the b-tree is overfull. In this case call the + ** balance_deeper() function to create a new child for the root-page + ** and copy the current contents of the root-page to it. The + ** next iteration of the do-loop will balance the child page. + */ + assert( (balance_deeper_called++)==0 ); + rc = balance_deeper(pPage, &pCur->apPage[1]); + if( rc==SQLITE_OK ){ + pCur->iPage = 1; + pCur->aiIdx[0] = 0; + pCur->aiIdx[1] = 0; + assert( pCur->apPage[1]->nOverflow ); + } + }else{ + break; + } + }else if( pPage->nOverflow==0 && pPage->nFree<=nMin ){ + break; + }else{ + MemPage * const pParent = pCur->apPage[iPage-1]; + int const iIdx = pCur->aiIdx[iPage-1]; + + rc = sqlite3PagerWrite(pParent->pDbPage); + if( rc==SQLITE_OK ){ +#ifndef SQLITE_OMIT_QUICKBALANCE + if( pPage->intKeyLeaf + && pPage->nOverflow==1 + && pPage->aiOvfl[0]==pPage->nCell + && pParent->pgno!=1 + && pParent->nCell==iIdx + ){ + /* Call balance_quick() to create a new sibling of pPage on which + ** to store the overflow cell. balance_quick() inserts a new cell + ** into pParent, which may cause pParent overflow. If this + ** happens, the next iteration of the do-loop will balance pParent + ** use either balance_nonroot() or balance_deeper(). Until this + ** happens, the overflow cell is stored in the aBalanceQuickSpace[] + ** buffer. + ** + ** The purpose of the following assert() is to check that only a + ** single call to balance_quick() is made for each call to this + ** function. If this were not verified, a subtle bug involving reuse + ** of the aBalanceQuickSpace[] might sneak in. + */ + assert( (balance_quick_called++)==0 ); + rc = balance_quick(pParent, pPage, aBalanceQuickSpace); + }else +#endif + { + /* In this case, call balance_nonroot() to redistribute cells + ** between pPage and up to 2 of its sibling pages. This involves + ** modifying the contents of pParent, which may cause pParent to + ** become overfull or underfull. The next iteration of the do-loop + ** will balance the parent page to correct this. + ** + ** If the parent page becomes overfull, the overflow cell or cells + ** are stored in the pSpace buffer allocated immediately below. + ** A subsequent iteration of the do-loop will deal with this by + ** calling balance_nonroot() (balance_deeper() may be called first, + ** but it doesn't deal with overflow cells - just moves them to a + ** different page). Once this subsequent call to balance_nonroot() + ** has completed, it is safe to release the pSpace buffer used by + ** the previous call, as the overflow cell data will have been + ** copied either into the body of a database page or into the new + ** pSpace buffer passed to the latter call to balance_nonroot(). + */ + u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize); + rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1, + pCur->hints&BTREE_BULKLOAD); + if( pFree ){ + /* If pFree is not NULL, it points to the pSpace buffer used + ** by a previous call to balance_nonroot(). Its contents are + ** now stored either on real database pages or within the + ** new pSpace buffer, so it may be safely freed here. */ + sqlite3PageFree(pFree); + } + + /* The pSpace buffer will be freed after the next call to + ** balance_nonroot(), or just before this function returns, whichever + ** comes first. */ + pFree = pSpace; + } + } + + pPage->nOverflow = 0; + + /* The next iteration of the do-loop balances the parent page. */ + releasePage(pPage); + pCur->iPage--; + assert( pCur->iPage>=0 ); + } + }while( rc==SQLITE_OK ); + + if( pFree ){ + sqlite3PageFree(pFree); + } + return rc; +} + + +/* +** Insert a new record into the BTree. The key is given by (pKey,nKey) +** and the data is given by (pData,nData). The cursor is used only to +** define what table the record should be inserted into. The cursor +** is left pointing at a random location. +** +** For an INTKEY table, only the nKey value of the key is used. pKey is +** ignored. For a ZERODATA table, the pData and nData are both ignored. +** +** If the seekResult parameter is non-zero, then a successful call to +** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already +** been performed. seekResult is the search result returned (a negative +** number if pCur points at an entry that is smaller than (pKey, nKey), or +** a positive value if pCur points at an entry that is larger than +** (pKey, nKey)). +** +** If the seekResult parameter is non-zero, then the caller guarantees that +** cursor pCur is pointing at the existing copy of a row that is to be +** overwritten. If the seekResult parameter is 0, then cursor pCur may +** point to any entry or to no entry at all and so this function has to seek +** the cursor before the new key can be inserted. +*/ +SQLITE_PRIVATE int sqlite3BtreeInsert( + BtCursor *pCur, /* Insert data into the table of this cursor */ + const void *pKey, i64 nKey, /* The key of the new record */ + const void *pData, int nData, /* The data of the new record */ + int nZero, /* Number of extra 0 bytes to append to data */ + int appendBias, /* True if this is likely an append */ + int seekResult /* Result of prior MovetoUnpacked() call */ +){ + int rc; + int loc = seekResult; /* -1: before desired location +1: after */ + int szNew = 0; + int idx; + MemPage *pPage; + Btree *p = pCur->pBtree; + BtShared *pBt = p->pBt; + unsigned char *oldCell; + unsigned char *newCell = 0; + + if( pCur->eState==CURSOR_FAULT ){ + assert( pCur->skipNext!=SQLITE_OK ); + return pCur->skipNext; + } + + assert( cursorHoldsMutex(pCur) ); + assert( (pCur->curFlags & BTCF_WriteFlag)!=0 + && pBt->inTransaction==TRANS_WRITE + && (pBt->btsFlags & BTS_READ_ONLY)==0 ); + assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) ); + + /* Assert that the caller has been consistent. If this cursor was opened + ** expecting an index b-tree, then the caller should be inserting blob + ** keys with no associated data. If the cursor was opened expecting an + ** intkey table, the caller should be inserting integer keys with a + ** blob of associated data. */ + assert( (pKey==0)==(pCur->pKeyInfo==0) ); + + /* Save the positions of any other cursors open on this table. + ** + ** In some cases, the call to btreeMoveto() below is a no-op. For + ** example, when inserting data into a table with auto-generated integer + ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the + ** integer key to use. It then calls this function to actually insert the + ** data into the intkey B-Tree. In this case btreeMoveto() recognizes + ** that the cursor is already where it needs to be and returns without + ** doing any work. To avoid thwarting these optimizations, it is important + ** not to clear the cursor here. + */ + if( pCur->curFlags & BTCF_Multiple ){ + rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur); + if( rc ) return rc; + } + + if( pCur->pKeyInfo==0 ){ + assert( pKey==0 ); + /* If this is an insert into a table b-tree, invalidate any incrblob + ** cursors open on the row being replaced */ + invalidateIncrblobCursors(p, nKey, 0); + + /* If the cursor is currently on the last row and we are appending a + ** new row onto the end, set the "loc" to avoid an unnecessary + ** btreeMoveto() call */ + if( (pCur->curFlags&BTCF_ValidNKey)!=0 && nKey>0 + && pCur->info.nKey==nKey-1 ){ + loc = -1; + }else if( loc==0 ){ + rc = sqlite3BtreeMovetoUnpacked(pCur, 0, nKey, appendBias, &loc); + if( rc ) return rc; + } + }else if( loc==0 ){ + rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc); + if( rc ) return rc; + } + assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) ); + + pPage = pCur->apPage[pCur->iPage]; + assert( pPage->intKey || nKey>=0 ); + assert( pPage->leaf || !pPage->intKey ); + + TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n", + pCur->pgnoRoot, nKey, nData, pPage->pgno, + loc==0 ? "overwrite" : "new entry")); + assert( pPage->isInit ); + newCell = pBt->pTmpSpace; + assert( newCell!=0 ); + rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew); + if( rc ) goto end_insert; + assert( szNew==pPage->xCellSize(pPage, newCell) ); + assert( szNew <= MX_CELL_SIZE(pBt) ); + idx = pCur->aiIdx[pCur->iPage]; + if( loc==0 ){ + u16 szOld; + assert( idxnCell ); + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ){ + goto end_insert; + } + oldCell = findCell(pPage, idx); + if( !pPage->leaf ){ + memcpy(newCell, oldCell, 4); + } + rc = clearCell(pPage, oldCell, &szOld); + dropCell(pPage, idx, szOld, &rc); + if( rc ) goto end_insert; + }else if( loc<0 && pPage->nCell>0 ){ + assert( pPage->leaf ); + idx = ++pCur->aiIdx[pCur->iPage]; + }else{ + assert( pPage->leaf ); + } + insertCell(pPage, idx, newCell, szNew, 0, 0, &rc); + assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 ); + + /* If no error has occurred and pPage has an overflow cell, call balance() + ** to redistribute the cells within the tree. Since balance() may move + ** the cursor, zero the BtCursor.info.nSize and BTCF_ValidNKey + ** variables. + ** + ** Previous versions of SQLite called moveToRoot() to move the cursor + ** back to the root page as balance() used to invalidate the contents + ** of BtCursor.apPage[] and BtCursor.aiIdx[]. Instead of doing that, + ** set the cursor state to "invalid". This makes common insert operations + ** slightly faster. + ** + ** There is a subtle but important optimization here too. When inserting + ** multiple records into an intkey b-tree using a single cursor (as can + ** happen while processing an "INSERT INTO ... SELECT" statement), it + ** is advantageous to leave the cursor pointing to the last entry in + ** the b-tree if possible. If the cursor is left pointing to the last + ** entry in the table, and the next row inserted has an integer key + ** larger than the largest existing key, it is possible to insert the + ** row without seeking the cursor. This can be a big performance boost. + */ + pCur->info.nSize = 0; + if( rc==SQLITE_OK && pPage->nOverflow ){ + pCur->curFlags &= ~(BTCF_ValidNKey); + rc = balance(pCur); + + /* Must make sure nOverflow is reset to zero even if the balance() + ** fails. Internal data structure corruption will result otherwise. + ** Also, set the cursor state to invalid. This stops saveCursorPosition() + ** from trying to save the current position of the cursor. */ + pCur->apPage[pCur->iPage]->nOverflow = 0; + pCur->eState = CURSOR_INVALID; + } + assert( pCur->apPage[pCur->iPage]->nOverflow==0 ); + +end_insert: + return rc; +} + +/* +** Delete the entry that the cursor is pointing to. +** +** If the second parameter is zero, then the cursor is left pointing at an +** arbitrary location after the delete. If it is non-zero, then the cursor +** is left in a state such that the next call to BtreeNext() or BtreePrev() +** moves it to the same row as it would if the call to BtreeDelete() had +** been omitted. +*/ +SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, int bPreserve){ + Btree *p = pCur->pBtree; + BtShared *pBt = p->pBt; + int rc; /* Return code */ + MemPage *pPage; /* Page to delete cell from */ + unsigned char *pCell; /* Pointer to cell to delete */ + int iCellIdx; /* Index of cell to delete */ + int iCellDepth; /* Depth of node containing pCell */ + u16 szCell; /* Size of the cell being deleted */ + int bSkipnext = 0; /* Leaf cursor in SKIPNEXT state */ + + assert( cursorHoldsMutex(pCur) ); + assert( pBt->inTransaction==TRANS_WRITE ); + assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); + assert( pCur->curFlags & BTCF_WriteFlag ); + assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) ); + assert( !hasReadConflicts(p, pCur->pgnoRoot) ); + assert( pCur->aiIdx[pCur->iPage]apPage[pCur->iPage]->nCell ); + assert( pCur->eState==CURSOR_VALID ); + + iCellDepth = pCur->iPage; + iCellIdx = pCur->aiIdx[iCellDepth]; + pPage = pCur->apPage[iCellDepth]; + pCell = findCell(pPage, iCellIdx); + + /* If the page containing the entry to delete is not a leaf page, move + ** the cursor to the largest entry in the tree that is smaller than + ** the entry being deleted. This cell will replace the cell being deleted + ** from the internal node. The 'previous' entry is used for this instead + ** of the 'next' entry, as the previous entry is always a part of the + ** sub-tree headed by the child page of the cell being deleted. This makes + ** balancing the tree following the delete operation easier. */ + if( !pPage->leaf ){ + int notUsed = 0; + rc = sqlite3BtreePrevious(pCur, ¬Used); + if( rc ) return rc; + } + + /* Save the positions of any other cursors open on this table before + ** making any modifications. */ + if( pCur->curFlags & BTCF_Multiple ){ + rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur); + if( rc ) return rc; + } + + /* If this is a delete operation to remove a row from a table b-tree, + ** invalidate any incrblob cursors open on the row being deleted. */ + if( pCur->pKeyInfo==0 ){ + invalidateIncrblobCursors(p, pCur->info.nKey, 0); + } + + /* If the bPreserve flag is set to true, then the cursor position must + ** be preserved following this delete operation. If the current delete + ** will cause a b-tree rebalance, then this is done by saving the cursor + ** key and leaving the cursor in CURSOR_REQUIRESEEK state before + ** returning. + ** + ** Or, if the current delete will not cause a rebalance, then the cursor + ** will be left in CURSOR_SKIPNEXT state pointing to the entry immediately + ** before or after the deleted entry. In this case set bSkipnext to true. */ + if( bPreserve ){ + if( !pPage->leaf + || (pPage->nFree+cellSizePtr(pPage,pCell)+2)>(int)(pBt->usableSize*2/3) + ){ + /* A b-tree rebalance will be required after deleting this entry. + ** Save the cursor key. */ + rc = saveCursorKey(pCur); + if( rc ) return rc; + }else{ + bSkipnext = 1; + } + } + + /* Make the page containing the entry to be deleted writable. Then free any + ** overflow pages associated with the entry and finally remove the cell + ** itself from within the page. */ + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ) return rc; + rc = clearCell(pPage, pCell, &szCell); + dropCell(pPage, iCellIdx, szCell, &rc); + if( rc ) return rc; + + /* If the cell deleted was not located on a leaf page, then the cursor + ** is currently pointing to the largest entry in the sub-tree headed + ** by the child-page of the cell that was just deleted from an internal + ** node. The cell from the leaf node needs to be moved to the internal + ** node to replace the deleted cell. */ + if( !pPage->leaf ){ + MemPage *pLeaf = pCur->apPage[pCur->iPage]; + int nCell; + Pgno n = pCur->apPage[iCellDepth+1]->pgno; + unsigned char *pTmp; + + pCell = findCell(pLeaf, pLeaf->nCell-1); + if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_BKPT; + nCell = pLeaf->xCellSize(pLeaf, pCell); + assert( MX_CELL_SIZE(pBt) >= nCell ); + pTmp = pBt->pTmpSpace; + assert( pTmp!=0 ); + rc = sqlite3PagerWrite(pLeaf->pDbPage); + insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc); + dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc); + if( rc ) return rc; + } + + /* Balance the tree. If the entry deleted was located on a leaf page, + ** then the cursor still points to that page. In this case the first + ** call to balance() repairs the tree, and the if(...) condition is + ** never true. + ** + ** Otherwise, if the entry deleted was on an internal node page, then + ** pCur is pointing to the leaf page from which a cell was removed to + ** replace the cell deleted from the internal node. This is slightly + ** tricky as the leaf node may be underfull, and the internal node may + ** be either under or overfull. In this case run the balancing algorithm + ** on the leaf node first. If the balance proceeds far enough up the + ** tree that we can be sure that any problem in the internal node has + ** been corrected, so be it. Otherwise, after balancing the leaf node, + ** walk the cursor up the tree to the internal node and balance it as + ** well. */ + rc = balance(pCur); + if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){ + while( pCur->iPage>iCellDepth ){ + releasePage(pCur->apPage[pCur->iPage--]); + } + rc = balance(pCur); + } + + if( rc==SQLITE_OK ){ + if( bSkipnext ){ + assert( bPreserve && pCur->iPage==iCellDepth ); + assert( pPage==pCur->apPage[pCur->iPage] ); + assert( (pPage->nCell>0 || CORRUPT_DB) && iCellIdx<=pPage->nCell ); + pCur->eState = CURSOR_SKIPNEXT; + if( iCellIdx>=pPage->nCell ){ + pCur->skipNext = -1; + pCur->aiIdx[iCellDepth] = pPage->nCell-1; + }else{ + pCur->skipNext = 1; + } + }else{ + rc = moveToRoot(pCur); + if( bPreserve ){ + pCur->eState = CURSOR_REQUIRESEEK; + } + } + } + return rc; +} + +/* +** Create a new BTree table. Write into *piTable the page +** number for the root page of the new table. +** +** The type of type is determined by the flags parameter. Only the +** following values of flags are currently in use. Other values for +** flags might not work: +** +** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys +** BTREE_ZERODATA Used for SQL indices +*/ +static int btreeCreateTable(Btree *p, int *piTable, int createTabFlags){ + BtShared *pBt = p->pBt; + MemPage *pRoot; + Pgno pgnoRoot; + int rc; + int ptfFlags; /* Page-type flage for the root page of new table */ + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( pBt->inTransaction==TRANS_WRITE ); + assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); + +#ifdef SQLITE_OMIT_AUTOVACUUM + rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0); + if( rc ){ + return rc; + } +#else + if( pBt->autoVacuum ){ + Pgno pgnoMove; /* Move a page here to make room for the root-page */ + MemPage *pPageMove; /* The page to move to. */ + + /* Creating a new table may probably require moving an existing database + ** to make room for the new tables root page. In case this page turns + ** out to be an overflow page, delete all overflow page-map caches + ** held by open cursors. + */ + invalidateAllOverflowCache(pBt); + + /* Read the value of meta[3] from the database to determine where the + ** root page of the new table should go. meta[3] is the largest root-page + ** created so far, so the new root-page is (meta[3]+1). + */ + sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &pgnoRoot); + pgnoRoot++; + + /* The new root-page may not be allocated on a pointer-map page, or the + ** PENDING_BYTE page. + */ + while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) || + pgnoRoot==PENDING_BYTE_PAGE(pBt) ){ + pgnoRoot++; + } + assert( pgnoRoot>=3 || CORRUPT_DB ); + testcase( pgnoRoot<3 ); + + /* Allocate a page. The page that currently resides at pgnoRoot will + ** be moved to the allocated page (unless the allocated page happens + ** to reside at pgnoRoot). + */ + rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, BTALLOC_EXACT); + if( rc!=SQLITE_OK ){ + return rc; + } + + if( pgnoMove!=pgnoRoot ){ + /* pgnoRoot is the page that will be used for the root-page of + ** the new table (assuming an error did not occur). But we were + ** allocated pgnoMove. If required (i.e. if it was not allocated + ** by extending the file), the current page at position pgnoMove + ** is already journaled. + */ + u8 eType = 0; + Pgno iPtrPage = 0; + + /* Save the positions of any open cursors. This is required in + ** case they are holding a reference to an xFetch reference + ** corresponding to page pgnoRoot. */ + rc = saveAllCursors(pBt, 0, 0); + releasePage(pPageMove); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Move the page currently at pgnoRoot to pgnoMove. */ + rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage); + if( eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){ + rc = SQLITE_CORRUPT_BKPT; + } + if( rc!=SQLITE_OK ){ + releasePage(pRoot); + return rc; + } + assert( eType!=PTRMAP_ROOTPAGE ); + assert( eType!=PTRMAP_FREEPAGE ); + rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0); + releasePage(pRoot); + + /* Obtain the page at pgnoRoot */ + if( rc!=SQLITE_OK ){ + return rc; + } + rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3PagerWrite(pRoot->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pRoot); + return rc; + } + }else{ + pRoot = pPageMove; + } + + /* Update the pointer-map and meta-data with the new root-page number. */ + ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc); + if( rc ){ + releasePage(pRoot); + return rc; + } + + /* When the new root page was allocated, page 1 was made writable in + ** order either to increase the database filesize, or to decrement the + ** freelist count. Hence, the sqlite3BtreeUpdateMeta() call cannot fail. + */ + assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) ); + rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot); + if( NEVER(rc) ){ + releasePage(pRoot); + return rc; + } + + }else{ + rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0); + if( rc ) return rc; + } +#endif + assert( sqlite3PagerIswriteable(pRoot->pDbPage) ); + if( createTabFlags & BTREE_INTKEY ){ + ptfFlags = PTF_INTKEY | PTF_LEAFDATA | PTF_LEAF; + }else{ + ptfFlags = PTF_ZERODATA | PTF_LEAF; + } + zeroPage(pRoot, ptfFlags); + sqlite3PagerUnref(pRoot->pDbPage); + assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 ); + *piTable = (int)pgnoRoot; + return SQLITE_OK; +} +SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){ + int rc; + sqlite3BtreeEnter(p); + rc = btreeCreateTable(p, piTable, flags); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Erase the given database page and all its children. Return +** the page to the freelist. +*/ +static int clearDatabasePage( + BtShared *pBt, /* The BTree that contains the table */ + Pgno pgno, /* Page number to clear */ + int freePageFlag, /* Deallocate page if true */ + int *pnChange /* Add number of Cells freed to this counter */ +){ + MemPage *pPage; + int rc; + unsigned char *pCell; + int i; + int hdr; + u16 szCell; + + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pgno>btreePagecount(pBt) ){ + return SQLITE_CORRUPT_BKPT; + } + rc = getAndInitPage(pBt, pgno, &pPage, 0, 0); + if( rc ) return rc; + if( pPage->bBusy ){ + rc = SQLITE_CORRUPT_BKPT; + goto cleardatabasepage_out; + } + pPage->bBusy = 1; + hdr = pPage->hdrOffset; + for(i=0; inCell; i++){ + pCell = findCell(pPage, i); + if( !pPage->leaf ){ + rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange); + if( rc ) goto cleardatabasepage_out; + } + rc = clearCell(pPage, pCell, &szCell); + if( rc ) goto cleardatabasepage_out; + } + if( !pPage->leaf ){ + rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange); + if( rc ) goto cleardatabasepage_out; + }else if( pnChange ){ + assert( pPage->intKey || CORRUPT_DB ); + testcase( !pPage->intKey ); + *pnChange += pPage->nCell; + } + if( freePageFlag ){ + freePage(pPage, &rc); + }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){ + zeroPage(pPage, pPage->aData[hdr] | PTF_LEAF); + } + +cleardatabasepage_out: + pPage->bBusy = 0; + releasePage(pPage); + return rc; +} + +/* +** Delete all information from a single table in the database. iTable is +** the page number of the root of the table. After this routine returns, +** the root page is empty, but still exists. +** +** This routine will fail with SQLITE_LOCKED if there are any open +** read cursors on the table. Open write cursors are moved to the +** root of the table. +** +** If pnChange is not NULL, then table iTable must be an intkey table. The +** integer value pointed to by pnChange is incremented by the number of +** entries in the table. +*/ +SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, int *pnChange){ + int rc; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + assert( p->inTrans==TRANS_WRITE ); + + rc = saveAllCursors(pBt, (Pgno)iTable, 0); + + if( SQLITE_OK==rc ){ + /* Invalidate all incrblob cursors open on table iTable (assuming iTable + ** is the root of a table b-tree - if it is not, the following call is + ** a no-op). */ + invalidateIncrblobCursors(p, 0, 1); + rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange); + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Delete all information from the single table that pCur is open on. +** +** This routine only work for pCur on an ephemeral table. +*/ +SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){ + return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0); +} + +/* +** Erase all information in a table and add the root of the table to +** the freelist. Except, the root of the principle table (the one on +** page 1) is never added to the freelist. +** +** This routine will fail with SQLITE_LOCKED if there are any open +** cursors on the table. +** +** If AUTOVACUUM is enabled and the page at iTable is not the last +** root page in the database file, then the last root page +** in the database file is moved into the slot formerly occupied by +** iTable and that last slot formerly occupied by the last root page +** is added to the freelist instead of iTable. In this say, all +** root pages are kept at the beginning of the database file, which +** is necessary for AUTOVACUUM to work right. *piMoved is set to the +** page number that used to be the last root page in the file before +** the move. If no page gets moved, *piMoved is set to 0. +** The last root page is recorded in meta[3] and the value of +** meta[3] is updated by this procedure. +*/ +static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){ + int rc; + MemPage *pPage = 0; + BtShared *pBt = p->pBt; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( p->inTrans==TRANS_WRITE ); + + /* It is illegal to drop a table if any cursors are open on the + ** database. This is because in auto-vacuum mode the backend may + ** need to move another root-page to fill a gap left by the deleted + ** root page. If an open cursor was using this page a problem would + ** occur. + ** + ** This error is caught long before control reaches this point. + */ + if( NEVER(pBt->pCursor) ){ + sqlite3ConnectionBlocked(p->db, pBt->pCursor->pBtree->db); + return SQLITE_LOCKED_SHAREDCACHE; + } + + rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0); + if( rc ) return rc; + rc = sqlite3BtreeClearTable(p, iTable, 0); + if( rc ){ + releasePage(pPage); + return rc; + } + + *piMoved = 0; + + if( iTable>1 ){ +#ifdef SQLITE_OMIT_AUTOVACUUM + freePage(pPage, &rc); + releasePage(pPage); +#else + if( pBt->autoVacuum ){ + Pgno maxRootPgno; + sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno); + + if( iTable==maxRootPgno ){ + /* If the table being dropped is the table with the largest root-page + ** number in the database, put the root page on the free list. + */ + freePage(pPage, &rc); + releasePage(pPage); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + /* The table being dropped does not have the largest root-page + ** number in the database. So move the page that does into the + ** gap left by the deleted root-page. + */ + MemPage *pMove; + releasePage(pPage); + rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0); + releasePage(pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + pMove = 0; + rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0); + freePage(pMove, &rc); + releasePage(pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + *piMoved = maxRootPgno; + } + + /* Set the new 'max-root-page' value in the database header. This + ** is the old value less one, less one more if that happens to + ** be a root-page number, less one again if that is the + ** PENDING_BYTE_PAGE. + */ + maxRootPgno--; + while( maxRootPgno==PENDING_BYTE_PAGE(pBt) + || PTRMAP_ISPAGE(pBt, maxRootPgno) ){ + maxRootPgno--; + } + assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) ); + + rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno); + }else{ + freePage(pPage, &rc); + releasePage(pPage); + } +#endif + }else{ + /* If sqlite3BtreeDropTable was called on page 1. + ** This really never should happen except in a corrupt + ** database. + */ + zeroPage(pPage, PTF_INTKEY|PTF_LEAF ); + releasePage(pPage); + } + return rc; +} +SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){ + int rc; + sqlite3BtreeEnter(p); + rc = btreeDropTable(p, iTable, piMoved); + sqlite3BtreeLeave(p); + return rc; +} + + +/* +** This function may only be called if the b-tree connection already +** has a read or write transaction open on the database. +** +** Read the meta-information out of a database file. Meta[0] +** is the number of free pages currently in the database. Meta[1] +** through meta[15] are available for use by higher layers. Meta[0] +** is read-only, the others are read/write. +** +** The schema layer numbers meta values differently. At the schema +** layer (and the SetCookie and ReadCookie opcodes) the number of +** free pages is not visible. So Cookie[0] is the same as Meta[1]. +** +** This routine treats Meta[BTREE_DATA_VERSION] as a special case. Instead +** of reading the value out of the header, it instead loads the "DataVersion" +** from the pager. The BTREE_DATA_VERSION value is not actually stored in the +** database file. It is a number computed by the pager. But its access +** pattern is the same as header meta values, and so it is convenient to +** read it from this routine. +*/ +SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){ + BtShared *pBt = p->pBt; + + sqlite3BtreeEnter(p); + assert( p->inTrans>TRANS_NONE ); + assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) ); + assert( pBt->pPage1 ); + assert( idx>=0 && idx<=15 ); + + if( idx==BTREE_DATA_VERSION ){ + *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion; + }else{ + *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]); + } + + /* If auto-vacuum is disabled in this build and this is an auto-vacuum + ** database, mark the database as read-only. */ +#ifdef SQLITE_OMIT_AUTOVACUUM + if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ){ + pBt->btsFlags |= BTS_READ_ONLY; + } +#endif + + sqlite3BtreeLeave(p); +} + +/* +** Write meta-information back into the database. Meta[0] is +** read-only and may not be written. +*/ +SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){ + BtShared *pBt = p->pBt; + unsigned char *pP1; + int rc; + assert( idx>=1 && idx<=15 ); + sqlite3BtreeEnter(p); + assert( p->inTrans==TRANS_WRITE ); + assert( pBt->pPage1!=0 ); + pP1 = pBt->pPage1->aData; + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pP1[36 + idx*4], iMeta); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( idx==BTREE_INCR_VACUUM ){ + assert( pBt->autoVacuum || iMeta==0 ); + assert( iMeta==0 || iMeta==1 ); + pBt->incrVacuum = (u8)iMeta; + } +#endif + } + sqlite3BtreeLeave(p); + return rc; +} + +#ifndef SQLITE_OMIT_BTREECOUNT +/* +** The first argument, pCur, is a cursor opened on some b-tree. Count the +** number of entries in the b-tree and write the result to *pnEntry. +** +** SQLITE_OK is returned if the operation is successfully executed. +** Otherwise, if an error is encountered (i.e. an IO error or database +** corruption) an SQLite error code is returned. +*/ +SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){ + i64 nEntry = 0; /* Value to return in *pnEntry */ + int rc; /* Return code */ + + if( pCur->pgnoRoot==0 ){ + *pnEntry = 0; + return SQLITE_OK; + } + rc = moveToRoot(pCur); + + /* Unless an error occurs, the following loop runs one iteration for each + ** page in the B-Tree structure (not including overflow pages). + */ + while( rc==SQLITE_OK ){ + int iIdx; /* Index of child node in parent */ + MemPage *pPage; /* Current page of the b-tree */ + + /* If this is a leaf page or the tree is not an int-key tree, then + ** this page contains countable entries. Increment the entry counter + ** accordingly. + */ + pPage = pCur->apPage[pCur->iPage]; + if( pPage->leaf || !pPage->intKey ){ + nEntry += pPage->nCell; + } + + /* pPage is a leaf node. This loop navigates the cursor so that it + ** points to the first interior cell that it points to the parent of + ** the next page in the tree that has not yet been visited. The + ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell + ** of the page, or to the number of cells in the page if the next page + ** to visit is the right-child of its parent. + ** + ** If all pages in the tree have been visited, return SQLITE_OK to the + ** caller. + */ + if( pPage->leaf ){ + do { + if( pCur->iPage==0 ){ + /* All pages of the b-tree have been visited. Return successfully. */ + *pnEntry = nEntry; + return moveToRoot(pCur); + } + moveToParent(pCur); + }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell ); + + pCur->aiIdx[pCur->iPage]++; + pPage = pCur->apPage[pCur->iPage]; + } + + /* Descend to the child node of the cell that the cursor currently + ** points at. This is the right-child if (iIdx==pPage->nCell). + */ + iIdx = pCur->aiIdx[pCur->iPage]; + if( iIdx==pPage->nCell ){ + rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); + }else{ + rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx))); + } + } + + /* An error has occurred. Return an error code. */ + return rc; +} +#endif + +/* +** Return the pager associated with a BTree. This routine is used for +** testing and debugging only. +*/ +SQLITE_PRIVATE Pager *sqlite3BtreePager(Btree *p){ + return p->pBt->pPager; +} + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* +** Append a message to the error message string. +*/ +static void checkAppendMsg( + IntegrityCk *pCheck, + const char *zFormat, + ... +){ + va_list ap; + if( !pCheck->mxErr ) return; + pCheck->mxErr--; + pCheck->nErr++; + va_start(ap, zFormat); + if( pCheck->errMsg.nChar ){ + sqlite3StrAccumAppend(&pCheck->errMsg, "\n", 1); + } + if( pCheck->zPfx ){ + sqlite3XPrintf(&pCheck->errMsg, 0, pCheck->zPfx, pCheck->v1, pCheck->v2); + } + sqlite3VXPrintf(&pCheck->errMsg, 1, zFormat, ap); + va_end(ap); + if( pCheck->errMsg.accError==STRACCUM_NOMEM ){ + pCheck->mallocFailed = 1; + } +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK + +/* +** Return non-zero if the bit in the IntegrityCk.aPgRef[] array that +** corresponds to page iPg is already set. +*/ +static int getPageReferenced(IntegrityCk *pCheck, Pgno iPg){ + assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 ); + return (pCheck->aPgRef[iPg/8] & (1 << (iPg & 0x07))); +} + +/* +** Set the bit in the IntegrityCk.aPgRef[] array that corresponds to page iPg. +*/ +static void setPageReferenced(IntegrityCk *pCheck, Pgno iPg){ + assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 ); + pCheck->aPgRef[iPg/8] |= (1 << (iPg & 0x07)); +} + + +/* +** Add 1 to the reference count for page iPage. If this is the second +** reference to the page, add an error message to pCheck->zErrMsg. +** Return 1 if there are 2 or more references to the page and 0 if +** if this is the first reference to the page. +** +** Also check that the page number is in bounds. +*/ +static int checkRef(IntegrityCk *pCheck, Pgno iPage){ + if( iPage==0 ) return 1; + if( iPage>pCheck->nPage ){ + checkAppendMsg(pCheck, "invalid page number %d", iPage); + return 1; + } + if( getPageReferenced(pCheck, iPage) ){ + checkAppendMsg(pCheck, "2nd reference to page %d", iPage); + return 1; + } + setPageReferenced(pCheck, iPage); + return 0; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Check that the entry in the pointer-map for page iChild maps to +** page iParent, pointer type ptrType. If not, append an error message +** to pCheck. +*/ +static void checkPtrmap( + IntegrityCk *pCheck, /* Integrity check context */ + Pgno iChild, /* Child page number */ + u8 eType, /* Expected pointer map type */ + Pgno iParent /* Expected pointer map parent page number */ +){ + int rc; + u8 ePtrmapType; + Pgno iPtrmapParent; + + rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) pCheck->mallocFailed = 1; + checkAppendMsg(pCheck, "Failed to read ptrmap key=%d", iChild); + return; + } + + if( ePtrmapType!=eType || iPtrmapParent!=iParent ){ + checkAppendMsg(pCheck, + "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)", + iChild, eType, iParent, ePtrmapType, iPtrmapParent); + } +} +#endif + +/* +** Check the integrity of the freelist or of an overflow page list. +** Verify that the number of pages on the list is N. +*/ +static void checkList( + IntegrityCk *pCheck, /* Integrity checking context */ + int isFreeList, /* True for a freelist. False for overflow page list */ + int iPage, /* Page number for first page in the list */ + int N /* Expected number of pages in the list */ +){ + int i; + int expected = N; + int iFirst = iPage; + while( N-- > 0 && pCheck->mxErr ){ + DbPage *pOvflPage; + unsigned char *pOvflData; + if( iPage<1 ){ + checkAppendMsg(pCheck, + "%d of %d pages missing from overflow list starting at %d", + N+1, expected, iFirst); + break; + } + if( checkRef(pCheck, iPage) ) break; + if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){ + checkAppendMsg(pCheck, "failed to get page %d", iPage); + break; + } + pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage); + if( isFreeList ){ + int n = get4byte(&pOvflData[4]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pCheck->pBt->autoVacuum ){ + checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0); + } +#endif + if( n>(int)pCheck->pBt->usableSize/4-2 ){ + checkAppendMsg(pCheck, + "freelist leaf count too big on page %d", iPage); + N--; + }else{ + for(i=0; ipBt->autoVacuum ){ + checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0); + } +#endif + checkRef(pCheck, iFreePage); + } + N -= n; + } + } +#ifndef SQLITE_OMIT_AUTOVACUUM + else{ + /* If this database supports auto-vacuum and iPage is not the last + ** page in this overflow list, check that the pointer-map entry for + ** the following page matches iPage. + */ + if( pCheck->pBt->autoVacuum && N>0 ){ + i = get4byte(pOvflData); + checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage); + } + } +#endif + iPage = get4byte(pOvflData); + sqlite3PagerUnref(pOvflPage); + + if( isFreeList && N<(iPage!=0) ){ + checkAppendMsg(pCheck, "free-page count in header is too small"); + } + } +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +/* +** An implementation of a min-heap. +** +** aHeap[0] is the number of elements on the heap. aHeap[1] is the +** root element. The daughter nodes of aHeap[N] are aHeap[N*2] +** and aHeap[N*2+1]. +** +** The heap property is this: Every node is less than or equal to both +** of its daughter nodes. A consequence of the heap property is that the +** root node aHeap[1] is always the minimum value currently in the heap. +** +** The btreeHeapInsert() routine inserts an unsigned 32-bit number onto +** the heap, preserving the heap property. The btreeHeapPull() routine +** removes the root element from the heap (the minimum value in the heap) +** and then moves other nodes around as necessary to preserve the heap +** property. +** +** This heap is used for cell overlap and coverage testing. Each u32 +** entry represents the span of a cell or freeblock on a btree page. +** The upper 16 bits are the index of the first byte of a range and the +** lower 16 bits are the index of the last byte of that range. +*/ +static void btreeHeapInsert(u32 *aHeap, u32 x){ + u32 j, i = ++aHeap[0]; + aHeap[i] = x; + while( (j = i/2)>0 && aHeap[j]>aHeap[i] ){ + x = aHeap[j]; + aHeap[j] = aHeap[i]; + aHeap[i] = x; + i = j; + } +} +static int btreeHeapPull(u32 *aHeap, u32 *pOut){ + u32 j, i, x; + if( (x = aHeap[0])==0 ) return 0; + *pOut = aHeap[1]; + aHeap[1] = aHeap[x]; + aHeap[x] = 0xffffffff; + aHeap[0]--; + i = 1; + while( (j = i*2)<=aHeap[0] ){ + if( aHeap[j]>aHeap[j+1] ) j++; + if( aHeap[i]zPfx; + int saved_v1 = pCheck->v1; + int saved_v2 = pCheck->v2; + u8 savedIsInit = 0; + + /* Check that the page exists + */ + pBt = pCheck->pBt; + usableSize = pBt->usableSize; + if( iPage==0 ) return 0; + if( checkRef(pCheck, iPage) ) return 0; + pCheck->zPfx = "Page %d: "; + pCheck->v1 = iPage; + if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){ + checkAppendMsg(pCheck, + "unable to get the page. error code=%d", rc); + goto end_of_check; + } + + /* Clear MemPage.isInit to make sure the corruption detection code in + ** btreeInitPage() is executed. */ + savedIsInit = pPage->isInit; + pPage->isInit = 0; + if( (rc = btreeInitPage(pPage))!=0 ){ + assert( rc==SQLITE_CORRUPT ); /* The only possible error from InitPage */ + checkAppendMsg(pCheck, + "btreeInitPage() returns error code %d", rc); + goto end_of_check; + } + data = pPage->aData; + hdr = pPage->hdrOffset; + + /* Set up for cell analysis */ + pCheck->zPfx = "On tree page %d cell %d: "; + contentOffset = get2byteNotZero(&data[hdr+5]); + assert( contentOffset<=usableSize ); /* Enforced by btreeInitPage() */ + + /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the + ** number of cells on the page. */ + nCell = get2byte(&data[hdr+3]); + assert( pPage->nCell==nCell ); + + /* EVIDENCE-OF: R-23882-45353 The cell pointer array of a b-tree page + ** immediately follows the b-tree page header. */ + cellStart = hdr + 12 - 4*pPage->leaf; + assert( pPage->aCellIdx==&data[cellStart] ); + pCellIdx = &data[cellStart + 2*(nCell-1)]; + + if( !pPage->leaf ){ + /* Analyze the right-child page of internal pages */ + pgno = get4byte(&data[hdr+8]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + pCheck->zPfx = "On page %d at right child: "; + checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage); + } +#endif + depth = checkTreePage(pCheck, pgno, &maxKey, maxKey); + keyCanBeEqual = 0; + }else{ + /* For leaf pages, the coverage check will occur in the same loop + ** as the other cell checks, so initialize the heap. */ + heap = pCheck->heap; + heap[0] = 0; + } + + /* EVIDENCE-OF: R-02776-14802 The cell pointer array consists of K 2-byte + ** integer offsets to the cell contents. */ + for(i=nCell-1; i>=0 && pCheck->mxErr; i--){ + CellInfo info; + + /* Check cell size */ + pCheck->v2 = i; + assert( pCellIdx==&data[cellStart + i*2] ); + pc = get2byteAligned(pCellIdx); + pCellIdx -= 2; + if( pcusableSize-4 ){ + checkAppendMsg(pCheck, "Offset %d out of range %d..%d", + pc, contentOffset, usableSize-4); + doCoverageCheck = 0; + continue; + } + pCell = &data[pc]; + pPage->xParseCell(pPage, pCell, &info); + if( pc+info.nSize>usableSize ){ + checkAppendMsg(pCheck, "Extends off end of page"); + doCoverageCheck = 0; + continue; + } + + /* Check for integer primary key out of range */ + if( pPage->intKey ){ + if( keyCanBeEqual ? (info.nKey > maxKey) : (info.nKey >= maxKey) ){ + checkAppendMsg(pCheck, "Rowid %lld out of order", info.nKey); + } + maxKey = info.nKey; + } + + /* Check the content overflow list */ + if( info.nPayload>info.nLocal ){ + int nPage; /* Number of pages on the overflow chain */ + Pgno pgnoOvfl; /* First page of the overflow chain */ + assert( pc + info.iOverflow <= usableSize ); + nPage = (info.nPayload - info.nLocal + usableSize - 5)/(usableSize - 4); + pgnoOvfl = get4byte(&pCell[info.iOverflow]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage); + } +#endif + checkList(pCheck, 0, pgnoOvfl, nPage); + } + + if( !pPage->leaf ){ + /* Check sanity of left child page for internal pages */ + pgno = get4byte(pCell); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage); + } +#endif + d2 = checkTreePage(pCheck, pgno, &maxKey, maxKey); + keyCanBeEqual = 0; + if( d2!=depth ){ + checkAppendMsg(pCheck, "Child page depth differs"); + depth = d2; + } + }else{ + /* Populate the coverage-checking heap for leaf pages */ + btreeHeapInsert(heap, (pc<<16)|(pc+info.nSize-1)); + } + } + *piMinKey = maxKey; + + /* Check for complete coverage of the page + */ + pCheck->zPfx = 0; + if( doCoverageCheck && pCheck->mxErr>0 ){ + /* For leaf pages, the min-heap has already been initialized and the + ** cells have already been inserted. But for internal pages, that has + ** not yet been done, so do it now */ + if( !pPage->leaf ){ + heap = pCheck->heap; + heap[0] = 0; + for(i=nCell-1; i>=0; i--){ + u32 size; + pc = get2byteAligned(&data[cellStart+i*2]); + size = pPage->xCellSize(pPage, &data[pc]); + btreeHeapInsert(heap, (pc<<16)|(pc+size-1)); + } + } + /* Add the freeblocks to the min-heap + ** + ** EVIDENCE-OF: R-20690-50594 The second field of the b-tree page header + ** is the offset of the first freeblock, or zero if there are no + ** freeblocks on the page. + */ + i = get2byte(&data[hdr+1]); + while( i>0 ){ + int size, j; + assert( (u32)i<=usableSize-4 ); /* Enforced by btreeInitPage() */ + size = get2byte(&data[i+2]); + assert( (u32)(i+size)<=usableSize ); /* Enforced by btreeInitPage() */ + btreeHeapInsert(heap, (((u32)i)<<16)|(i+size-1)); + /* EVIDENCE-OF: R-58208-19414 The first 2 bytes of a freeblock are a + ** big-endian integer which is the offset in the b-tree page of the next + ** freeblock in the chain, or zero if the freeblock is the last on the + ** chain. */ + j = get2byte(&data[i]); + /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of + ** increasing offset. */ + assert( j==0 || j>i+size ); /* Enforced by btreeInitPage() */ + assert( (u32)j<=usableSize-4 ); /* Enforced by btreeInitPage() */ + i = j; + } + /* Analyze the min-heap looking for overlap between cells and/or + ** freeblocks, and counting the number of untracked bytes in nFrag. + ** + ** Each min-heap entry is of the form: (start_address<<16)|end_address. + ** There is an implied first entry the covers the page header, the cell + ** pointer index, and the gap between the cell pointer index and the start + ** of cell content. + ** + ** The loop below pulls entries from the min-heap in order and compares + ** the start_address against the previous end_address. If there is an + ** overlap, that means bytes are used multiple times. If there is a gap, + ** that gap is added to the fragmentation count. + */ + nFrag = 0; + prev = contentOffset - 1; /* Implied first min-heap entry */ + while( btreeHeapPull(heap,&x) ){ + if( (prev&0xffff)>=(x>>16) ){ + checkAppendMsg(pCheck, + "Multiple uses for byte %u of page %d", x>>16, iPage); + break; + }else{ + nFrag += (x>>16) - (prev&0xffff) - 1; + prev = x; + } + } + nFrag += usableSize - (prev&0xffff) - 1; + /* EVIDENCE-OF: R-43263-13491 The total number of bytes in all fragments + ** is stored in the fifth field of the b-tree page header. + ** EVIDENCE-OF: R-07161-27322 The one-byte integer at offset 7 gives the + ** number of fragmented free bytes within the cell content area. + */ + if( heap[0]==0 && nFrag!=data[hdr+7] ){ + checkAppendMsg(pCheck, + "Fragmentation of %d bytes reported as %d on page %d", + nFrag, data[hdr+7], iPage); + } + } + +end_of_check: + if( !doCoverageCheck ) pPage->isInit = savedIsInit; + releasePage(pPage); + pCheck->zPfx = saved_zPfx; + pCheck->v1 = saved_v1; + pCheck->v2 = saved_v2; + return depth+1; +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* +** This routine does a complete check of the given BTree file. aRoot[] is +** an array of pages numbers were each page number is the root page of +** a table. nRoot is the number of entries in aRoot. +** +** A read-only or read-write transaction must be opened before calling +** this function. +** +** Write the number of error seen in *pnErr. Except for some memory +** allocation errors, an error message held in memory obtained from +** malloc is returned if *pnErr is non-zero. If *pnErr==0 then NULL is +** returned. If a memory allocation error occurs, NULL is returned. +*/ +SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck( + Btree *p, /* The btree to be checked */ + int *aRoot, /* An array of root pages numbers for individual trees */ + int nRoot, /* Number of entries in aRoot[] */ + int mxErr, /* Stop reporting errors after this many */ + int *pnErr /* Write number of errors seen to this variable */ +){ + Pgno i; + IntegrityCk sCheck; + BtShared *pBt = p->pBt; + int savedDbFlags = pBt->db->flags; + char zErr[100]; + VVA_ONLY( int nRef ); + + sqlite3BtreeEnter(p); + assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE ); + assert( (nRef = sqlite3PagerRefcount(pBt->pPager))>=0 ); + sCheck.pBt = pBt; + sCheck.pPager = pBt->pPager; + sCheck.nPage = btreePagecount(sCheck.pBt); + sCheck.mxErr = mxErr; + sCheck.nErr = 0; + sCheck.mallocFailed = 0; + sCheck.zPfx = 0; + sCheck.v1 = 0; + sCheck.v2 = 0; + sCheck.aPgRef = 0; + sCheck.heap = 0; + sqlite3StrAccumInit(&sCheck.errMsg, 0, zErr, sizeof(zErr), SQLITE_MAX_LENGTH); + if( sCheck.nPage==0 ){ + goto integrity_ck_cleanup; + } + + sCheck.aPgRef = sqlite3MallocZero((sCheck.nPage / 8)+ 1); + if( !sCheck.aPgRef ){ + sCheck.mallocFailed = 1; + goto integrity_ck_cleanup; + } + sCheck.heap = (u32*)sqlite3PageMalloc( pBt->pageSize ); + if( sCheck.heap==0 ){ + sCheck.mallocFailed = 1; + goto integrity_ck_cleanup; + } + + i = PENDING_BYTE_PAGE(pBt); + if( i<=sCheck.nPage ) setPageReferenced(&sCheck, i); + + /* Check the integrity of the freelist + */ + sCheck.zPfx = "Main freelist: "; + checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]), + get4byte(&pBt->pPage1->aData[36])); + sCheck.zPfx = 0; + + /* Check all the tables. + */ + testcase( pBt->db->flags & SQLITE_CellSizeCk ); + pBt->db->flags &= ~SQLITE_CellSizeCk; + for(i=0; (int)iautoVacuum && aRoot[i]>1 ){ + checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0); + } +#endif + checkTreePage(&sCheck, aRoot[i], ¬Used, LARGEST_INT64); + } + pBt->db->flags = savedDbFlags; + + /* Make sure every page in the file is referenced + */ + for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){ +#ifdef SQLITE_OMIT_AUTOVACUUM + if( getPageReferenced(&sCheck, i)==0 ){ + checkAppendMsg(&sCheck, "Page %d is never used", i); + } +#else + /* If the database supports auto-vacuum, make sure no tables contain + ** references to pointer-map pages. + */ + if( getPageReferenced(&sCheck, i)==0 && + (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){ + checkAppendMsg(&sCheck, "Page %d is never used", i); + } + if( getPageReferenced(&sCheck, i)!=0 && + (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){ + checkAppendMsg(&sCheck, "Pointer map page %d is referenced", i); + } +#endif + } + + /* Clean up and report errors. + */ +integrity_ck_cleanup: + sqlite3PageFree(sCheck.heap); + sqlite3_free(sCheck.aPgRef); + if( sCheck.mallocFailed ){ + sqlite3StrAccumReset(&sCheck.errMsg); + sCheck.nErr++; + } + *pnErr = sCheck.nErr; + if( sCheck.nErr==0 ) sqlite3StrAccumReset(&sCheck.errMsg); + /* Make sure this analysis did not leave any unref() pages. */ + assert( nRef==sqlite3PagerRefcount(pBt->pPager) ); + sqlite3BtreeLeave(p); + return sqlite3StrAccumFinish(&sCheck.errMsg); +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +/* +** Return the full pathname of the underlying database file. Return +** an empty string if the database is in-memory or a TEMP database. +** +** The pager filename is invariant as long as the pager is +** open so it is safe to access without the BtShared mutex. +*/ +SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3PagerFilename(p->pBt->pPager, 1); +} + +/* +** Return the pathname of the journal file for this database. The return +** value of this routine is the same regardless of whether the journal file +** has been created or not. +** +** The pager journal filename is invariant as long as the pager is +** open so it is safe to access without the BtShared mutex. +*/ +SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3PagerJournalname(p->pBt->pPager); +} + +/* +** Return non-zero if a transaction is active. +*/ +SQLITE_PRIVATE int sqlite3BtreeIsInTrans(Btree *p){ + assert( p==0 || sqlite3_mutex_held(p->db->mutex) ); + return (p && (p->inTrans==TRANS_WRITE)); +} + +#ifndef SQLITE_OMIT_WAL +/* +** Run a checkpoint on the Btree passed as the first argument. +** +** Return SQLITE_LOCKED if this or any other connection has an open +** transaction on the shared-cache the argument Btree is connected to. +** +** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART. +*/ +SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree *p, int eMode, int *pnLog, int *pnCkpt){ + int rc = SQLITE_OK; + if( p ){ + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + if( pBt->inTransaction!=TRANS_NONE ){ + rc = SQLITE_LOCKED; + }else{ + rc = sqlite3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt); + } + sqlite3BtreeLeave(p); + } + return rc; +} +#endif + +/* +** Return non-zero if a read (or write) transaction is active. +*/ +SQLITE_PRIVATE int sqlite3BtreeIsInReadTrans(Btree *p){ + assert( p ); + assert( sqlite3_mutex_held(p->db->mutex) ); + return p->inTrans!=TRANS_NONE; +} + +SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree *p){ + assert( p ); + assert( sqlite3_mutex_held(p->db->mutex) ); + return p->nBackup!=0; +} + +/* +** This function returns a pointer to a blob of memory associated with +** a single shared-btree. The memory is used by client code for its own +** purposes (for example, to store a high-level schema associated with +** the shared-btree). The btree layer manages reference counting issues. +** +** The first time this is called on a shared-btree, nBytes bytes of memory +** are allocated, zeroed, and returned to the caller. For each subsequent +** call the nBytes parameter is ignored and a pointer to the same blob +** of memory returned. +** +** If the nBytes parameter is 0 and the blob of memory has not yet been +** allocated, a null pointer is returned. If the blob has already been +** allocated, it is returned as normal. +** +** Just before the shared-btree is closed, the function passed as the +** xFree argument when the memory allocation was made is invoked on the +** blob of allocated memory. The xFree function should not call sqlite3_free() +** on the memory, the btree layer does that. +*/ +SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){ + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + if( !pBt->pSchema && nBytes ){ + pBt->pSchema = sqlite3DbMallocZero(0, nBytes); + pBt->xFreeSchema = xFree; + } + sqlite3BtreeLeave(p); + return pBt->pSchema; +} + +/* +** Return SQLITE_LOCKED_SHAREDCACHE if another user of the same shared +** btree as the argument handle holds an exclusive lock on the +** sqlite_master table. Otherwise SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *p){ + int rc; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK); + assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE ); + sqlite3BtreeLeave(p); + return rc; +} + + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Obtain a lock on the table whose root page is iTab. The +** lock is a write lock if isWritelock is true or a read lock +** if it is false. +*/ +SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){ + int rc = SQLITE_OK; + assert( p->inTrans!=TRANS_NONE ); + if( p->sharable ){ + u8 lockType = READ_LOCK + isWriteLock; + assert( READ_LOCK+1==WRITE_LOCK ); + assert( isWriteLock==0 || isWriteLock==1 ); + + sqlite3BtreeEnter(p); + rc = querySharedCacheTableLock(p, iTab, lockType); + if( rc==SQLITE_OK ){ + rc = setSharedCacheTableLock(p, iTab, lockType); + } + sqlite3BtreeLeave(p); + } + return rc; +} +#endif + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** Argument pCsr must be a cursor opened for writing on an +** INTKEY table currently pointing at a valid table entry. +** This function modifies the data stored as part of that entry. +** +** Only the data content may only be modified, it is not possible to +** change the length of the data stored. If this function is called with +** parameters that attempt to write past the end of the existing data, +** no modifications are made and SQLITE_CORRUPT is returned. +*/ +SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){ + int rc; + assert( cursorHoldsMutex(pCsr) ); + assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) ); + assert( pCsr->curFlags & BTCF_Incrblob ); + + rc = restoreCursorPosition(pCsr); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( pCsr->eState!=CURSOR_REQUIRESEEK ); + if( pCsr->eState!=CURSOR_VALID ){ + return SQLITE_ABORT; + } + + /* Save the positions of all other cursors open on this table. This is + ** required in case any of them are holding references to an xFetch + ** version of the b-tree page modified by the accessPayload call below. + ** + ** Note that pCsr must be open on a INTKEY table and saveCursorPosition() + ** and hence saveAllCursors() cannot fail on a BTREE_INTKEY table, hence + ** saveAllCursors can only return SQLITE_OK. + */ + VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr); + assert( rc==SQLITE_OK ); + + /* Check some assumptions: + ** (a) the cursor is open for writing, + ** (b) there is a read/write transaction open, + ** (c) the connection holds a write-lock on the table (if required), + ** (d) there are no conflicting read-locks, and + ** (e) the cursor points at a valid row of an intKey table. + */ + if( (pCsr->curFlags & BTCF_WriteFlag)==0 ){ + return SQLITE_READONLY; + } + assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0 + && pCsr->pBt->inTransaction==TRANS_WRITE ); + assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) ); + assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) ); + assert( pCsr->apPage[pCsr->iPage]->intKey ); + + return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1); +} + +/* +** Mark this cursor as an incremental blob cursor. +*/ +SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){ + pCur->curFlags |= BTCF_Incrblob; + pCur->pBtree->hasIncrblobCur = 1; +} +#endif + +/* +** Set both the "read version" (single byte at byte offset 18) and +** "write version" (single byte at byte offset 19) fields in the database +** header to iVersion. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBtree, int iVersion){ + BtShared *pBt = pBtree->pBt; + int rc; /* Return code */ + + assert( iVersion==1 || iVersion==2 ); + + /* If setting the version fields to 1, do not automatically open the + ** WAL connection, even if the version fields are currently set to 2. + */ + pBt->btsFlags &= ~BTS_NO_WAL; + if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL; + + rc = sqlite3BtreeBeginTrans(pBtree, 0); + if( rc==SQLITE_OK ){ + u8 *aData = pBt->pPage1->aData; + if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){ + rc = sqlite3BtreeBeginTrans(pBtree, 2); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( rc==SQLITE_OK ){ + aData[18] = (u8)iVersion; + aData[19] = (u8)iVersion; + } + } + } + } + + pBt->btsFlags &= ~BTS_NO_WAL; + return rc; +} + +/* +** set the mask of hint flags for cursor pCsr. +*/ +SQLITE_PRIVATE void sqlite3BtreeCursorHints(BtCursor *pCsr, unsigned int mask){ + assert( mask==BTREE_BULKLOAD || mask==BTREE_SEEK_EQ || mask==0 ); + pCsr->hints = mask; +} + +#ifdef SQLITE_DEBUG +/* +** Return true if the cursor has a hint specified. This routine is +** only used from within assert() statements +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor *pCsr, unsigned int mask){ + return (pCsr->hints & mask)!=0; +} +#endif + +/* +** Return true if the given Btree is read-only. +*/ +SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *p){ + return (p->pBt->btsFlags & BTS_READ_ONLY)!=0; +} + +/* +** Return the size of the header added to each page by this module. +*/ +SQLITE_PRIVATE int sqlite3HeaderSizeBtree(void){ return ROUND8(sizeof(MemPage)); } + +/************** End of btree.c ***********************************************/ +/************** Begin file backup.c ******************************************/ +/* +** 2009 January 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the implementation of the sqlite3_backup_XXX() +** API functions and the related features. +*/ +/* #include "sqliteInt.h" */ +/* #include "btreeInt.h" */ + +/* +** Structure allocated for each backup operation. +*/ +struct sqlite3_backup { + sqlite3* pDestDb; /* Destination database handle */ + Btree *pDest; /* Destination b-tree file */ + u32 iDestSchema; /* Original schema cookie in destination */ + int bDestLocked; /* True once a write-transaction is open on pDest */ + + Pgno iNext; /* Page number of the next source page to copy */ + sqlite3* pSrcDb; /* Source database handle */ + Btree *pSrc; /* Source b-tree file */ + + int rc; /* Backup process error code */ + + /* These two variables are set by every call to backup_step(). They are + ** read by calls to backup_remaining() and backup_pagecount(). + */ + Pgno nRemaining; /* Number of pages left to copy */ + Pgno nPagecount; /* Total number of pages to copy */ + + int isAttached; /* True once backup has been registered with pager */ + sqlite3_backup *pNext; /* Next backup associated with source pager */ +}; + +/* +** THREAD SAFETY NOTES: +** +** Once it has been created using backup_init(), a single sqlite3_backup +** structure may be accessed via two groups of thread-safe entry points: +** +** * Via the sqlite3_backup_XXX() API function backup_step() and +** backup_finish(). Both these functions obtain the source database +** handle mutex and the mutex associated with the source BtShared +** structure, in that order. +** +** * Via the BackupUpdate() and BackupRestart() functions, which are +** invoked by the pager layer to report various state changes in +** the page cache associated with the source database. The mutex +** associated with the source database BtShared structure will always +** be held when either of these functions are invoked. +** +** The other sqlite3_backup_XXX() API functions, backup_remaining() and +** backup_pagecount() are not thread-safe functions. If they are called +** while some other thread is calling backup_step() or backup_finish(), +** the values returned may be invalid. There is no way for a call to +** BackupUpdate() or BackupRestart() to interfere with backup_remaining() +** or backup_pagecount(). +** +** Depending on the SQLite configuration, the database handles and/or +** the Btree objects may have their own mutexes that require locking. +** Non-sharable Btrees (in-memory databases for example), do not have +** associated mutexes. +*/ + +/* +** Return a pointer corresponding to database zDb (i.e. "main", "temp") +** in connection handle pDb. If such a database cannot be found, return +** a NULL pointer and write an error message to pErrorDb. +** +** If the "temp" database is requested, it may need to be opened by this +** function. If an error occurs while doing so, return 0 and write an +** error message to pErrorDb. +*/ +static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){ + int i = sqlite3FindDbName(pDb, zDb); + + if( i==1 ){ + Parse *pParse; + int rc = 0; + pParse = sqlite3StackAllocZero(pErrorDb, sizeof(*pParse)); + if( pParse==0 ){ + sqlite3ErrorWithMsg(pErrorDb, SQLITE_NOMEM, "out of memory"); + rc = SQLITE_NOMEM; + }else{ + pParse->db = pDb; + if( sqlite3OpenTempDatabase(pParse) ){ + sqlite3ErrorWithMsg(pErrorDb, pParse->rc, "%s", pParse->zErrMsg); + rc = SQLITE_ERROR; + } + sqlite3DbFree(pErrorDb, pParse->zErrMsg); + sqlite3ParserReset(pParse); + sqlite3StackFree(pErrorDb, pParse); + } + if( rc ){ + return 0; + } + } + + if( i<0 ){ + sqlite3ErrorWithMsg(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb); + return 0; + } + + return pDb->aDb[i].pBt; +} + +/* +** Attempt to set the page size of the destination to match the page size +** of the source. +*/ +static int setDestPgsz(sqlite3_backup *p){ + int rc; + rc = sqlite3BtreeSetPageSize(p->pDest,sqlite3BtreeGetPageSize(p->pSrc),-1,0); + return rc; +} + +/* +** Check that there is no open read-transaction on the b-tree passed as the +** second argument. If there is not, return SQLITE_OK. Otherwise, if there +** is an open read-transaction, return SQLITE_ERROR and leave an error +** message in database handle db. +*/ +static int checkReadTransaction(sqlite3 *db, Btree *p){ + if( sqlite3BtreeIsInReadTrans(p) ){ + sqlite3ErrorWithMsg(db, SQLITE_ERROR, "destination database is in use"); + return SQLITE_ERROR; + } + return SQLITE_OK; +} + +/* +** Create an sqlite3_backup process to copy the contents of zSrcDb from +** connection handle pSrcDb to zDestDb in pDestDb. If successful, return +** a pointer to the new sqlite3_backup object. +** +** If an error occurs, NULL is returned and an error code and error message +** stored in database handle pDestDb. +*/ +SQLITE_API sqlite3_backup *SQLITE_STDCALL sqlite3_backup_init( + sqlite3* pDestDb, /* Database to write to */ + const char *zDestDb, /* Name of database within pDestDb */ + sqlite3* pSrcDb, /* Database connection to read from */ + const char *zSrcDb /* Name of database within pSrcDb */ +){ + sqlite3_backup *p; /* Value to return */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(pSrcDb)||!sqlite3SafetyCheckOk(pDestDb) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + + /* Lock the source database handle. The destination database + ** handle is not locked in this routine, but it is locked in + ** sqlite3_backup_step(). The user is required to ensure that no + ** other thread accesses the destination handle for the duration + ** of the backup operation. Any attempt to use the destination + ** database connection while a backup is in progress may cause + ** a malfunction or a deadlock. + */ + sqlite3_mutex_enter(pSrcDb->mutex); + sqlite3_mutex_enter(pDestDb->mutex); + + if( pSrcDb==pDestDb ){ + sqlite3ErrorWithMsg( + pDestDb, SQLITE_ERROR, "source and destination must be distinct" + ); + p = 0; + }else { + /* Allocate space for a new sqlite3_backup object... + ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a + ** call to sqlite3_backup_init() and is destroyed by a call to + ** sqlite3_backup_finish(). */ + p = (sqlite3_backup *)sqlite3MallocZero(sizeof(sqlite3_backup)); + if( !p ){ + sqlite3Error(pDestDb, SQLITE_NOMEM); + } + } + + /* If the allocation succeeded, populate the new object. */ + if( p ){ + p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb); + p->pDest = findBtree(pDestDb, pDestDb, zDestDb); + p->pDestDb = pDestDb; + p->pSrcDb = pSrcDb; + p->iNext = 1; + p->isAttached = 0; + + if( 0==p->pSrc || 0==p->pDest + || setDestPgsz(p)==SQLITE_NOMEM + || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK + ){ + /* One (or both) of the named databases did not exist or an OOM + ** error was hit. Or there is a transaction open on the destination + ** database. The error has already been written into the pDestDb + ** handle. All that is left to do here is free the sqlite3_backup + ** structure. */ + sqlite3_free(p); + p = 0; + } + } + if( p ){ + p->pSrc->nBackup++; + } + + sqlite3_mutex_leave(pDestDb->mutex); + sqlite3_mutex_leave(pSrcDb->mutex); + return p; +} + +/* +** Argument rc is an SQLite error code. Return true if this error is +** considered fatal if encountered during a backup operation. All errors +** are considered fatal except for SQLITE_BUSY and SQLITE_LOCKED. +*/ +static int isFatalError(int rc){ + return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED)); +} + +/* +** Parameter zSrcData points to a buffer containing the data for +** page iSrcPg from the source database. Copy this data into the +** destination database. +*/ +static int backupOnePage( + sqlite3_backup *p, /* Backup handle */ + Pgno iSrcPg, /* Source database page to backup */ + const u8 *zSrcData, /* Source database page data */ + int bUpdate /* True for an update, false otherwise */ +){ + Pager * const pDestPager = sqlite3BtreePager(p->pDest); + const int nSrcPgsz = sqlite3BtreeGetPageSize(p->pSrc); + int nDestPgsz = sqlite3BtreeGetPageSize(p->pDest); + const int nCopy = MIN(nSrcPgsz, nDestPgsz); + const i64 iEnd = (i64)iSrcPg*(i64)nSrcPgsz; +#ifdef SQLITE_HAS_CODEC + /* Use BtreeGetReserveNoMutex() for the source b-tree, as although it is + ** guaranteed that the shared-mutex is held by this thread, handle + ** p->pSrc may not actually be the owner. */ + int nSrcReserve = sqlite3BtreeGetReserveNoMutex(p->pSrc); + int nDestReserve = sqlite3BtreeGetOptimalReserve(p->pDest); +#endif + int rc = SQLITE_OK; + i64 iOff; + + assert( sqlite3BtreeGetReserveNoMutex(p->pSrc)>=0 ); + assert( p->bDestLocked ); + assert( !isFatalError(p->rc) ); + assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ); + assert( zSrcData ); + + /* Catch the case where the destination is an in-memory database and the + ** page sizes of the source and destination differ. + */ + if( nSrcPgsz!=nDestPgsz && sqlite3PagerIsMemdb(pDestPager) ){ + rc = SQLITE_READONLY; + } + +#ifdef SQLITE_HAS_CODEC + /* Backup is not possible if the page size of the destination is changing + ** and a codec is in use. + */ + if( nSrcPgsz!=nDestPgsz && sqlite3PagerGetCodec(pDestPager)!=0 ){ + rc = SQLITE_READONLY; + } + + /* Backup is not possible if the number of bytes of reserve space differ + ** between source and destination. If there is a difference, try to + ** fix the destination to agree with the source. If that is not possible, + ** then the backup cannot proceed. + */ + if( nSrcReserve!=nDestReserve ){ + u32 newPgsz = nSrcPgsz; + rc = sqlite3PagerSetPagesize(pDestPager, &newPgsz, nSrcReserve); + if( rc==SQLITE_OK && newPgsz!=nSrcPgsz ) rc = SQLITE_READONLY; + } +#endif + + /* This loop runs once for each destination page spanned by the source + ** page. For each iteration, variable iOff is set to the byte offset + ** of the destination page. + */ + for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOffpDest->pBt) ) continue; + if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg)) + && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg)) + ){ + const u8 *zIn = &zSrcData[iOff%nSrcPgsz]; + u8 *zDestData = sqlite3PagerGetData(pDestPg); + u8 *zOut = &zDestData[iOff%nDestPgsz]; + + /* Copy the data from the source page into the destination page. + ** Then clear the Btree layer MemPage.isInit flag. Both this module + ** and the pager code use this trick (clearing the first byte + ** of the page 'extra' space to invalidate the Btree layers + ** cached parse of the page). MemPage.isInit is marked + ** "MUST BE FIRST" for this purpose. + */ + memcpy(zOut, zIn, nCopy); + ((u8 *)sqlite3PagerGetExtra(pDestPg))[0] = 0; + if( iOff==0 && bUpdate==0 ){ + sqlite3Put4byte(&zOut[28], sqlite3BtreeLastPage(p->pSrc)); + } + } + sqlite3PagerUnref(pDestPg); + } + + return rc; +} + +/* +** If pFile is currently larger than iSize bytes, then truncate it to +** exactly iSize bytes. If pFile is not larger than iSize bytes, then +** this function is a no-op. +** +** Return SQLITE_OK if everything is successful, or an SQLite error +** code if an error occurs. +*/ +static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){ + i64 iCurrent; + int rc = sqlite3OsFileSize(pFile, &iCurrent); + if( rc==SQLITE_OK && iCurrent>iSize ){ + rc = sqlite3OsTruncate(pFile, iSize); + } + return rc; +} + +/* +** Register this backup object with the associated source pager for +** callbacks when pages are changed or the cache invalidated. +*/ +static void attachBackupObject(sqlite3_backup *p){ + sqlite3_backup **pp; + assert( sqlite3BtreeHoldsMutex(p->pSrc) ); + pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc)); + p->pNext = *pp; + *pp = p; + p->isAttached = 1; +} + +/* +** Copy nPage pages from the source b-tree to the destination. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_backup_step(sqlite3_backup *p, int nPage){ + int rc; + int destMode; /* Destination journal mode */ + int pgszSrc = 0; /* Source page size */ + int pgszDest = 0; /* Destination page size */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( p==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(p->pSrcDb->mutex); + sqlite3BtreeEnter(p->pSrc); + if( p->pDestDb ){ + sqlite3_mutex_enter(p->pDestDb->mutex); + } + + rc = p->rc; + if( !isFatalError(rc) ){ + Pager * const pSrcPager = sqlite3BtreePager(p->pSrc); /* Source pager */ + Pager * const pDestPager = sqlite3BtreePager(p->pDest); /* Dest pager */ + int ii; /* Iterator variable */ + int nSrcPage = -1; /* Size of source db in pages */ + int bCloseTrans = 0; /* True if src db requires unlocking */ + + /* If the source pager is currently in a write-transaction, return + ** SQLITE_BUSY immediately. + */ + if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){ + rc = SQLITE_BUSY; + }else{ + rc = SQLITE_OK; + } + + /* Lock the destination database, if it is not locked already. */ + if( SQLITE_OK==rc && p->bDestLocked==0 + && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2)) + ){ + p->bDestLocked = 1; + sqlite3BtreeGetMeta(p->pDest, BTREE_SCHEMA_VERSION, &p->iDestSchema); + } + + /* If there is no open read-transaction on the source database, open + ** one now. If a transaction is opened here, then it will be closed + ** before this function exits. + */ + if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){ + rc = sqlite3BtreeBeginTrans(p->pSrc, 0); + bCloseTrans = 1; + } + + /* Do not allow backup if the destination database is in WAL mode + ** and the page sizes are different between source and destination */ + pgszSrc = sqlite3BtreeGetPageSize(p->pSrc); + pgszDest = sqlite3BtreeGetPageSize(p->pDest); + destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest)); + if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){ + rc = SQLITE_READONLY; + } + + /* Now that there is a read-lock on the source database, query the + ** source pager for the number of pages in the database. + */ + nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc); + assert( nSrcPage>=0 ); + for(ii=0; (nPage<0 || iiiNext<=(Pgno)nSrcPage && !rc; ii++){ + const Pgno iSrcPg = p->iNext; /* Source page number */ + if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){ + DbPage *pSrcPg; /* Source page object */ + rc = sqlite3PagerAcquire(pSrcPager, iSrcPg, &pSrcPg, + PAGER_GET_READONLY); + if( rc==SQLITE_OK ){ + rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg), 0); + sqlite3PagerUnref(pSrcPg); + } + } + p->iNext++; + } + if( rc==SQLITE_OK ){ + p->nPagecount = nSrcPage; + p->nRemaining = nSrcPage+1-p->iNext; + if( p->iNext>(Pgno)nSrcPage ){ + rc = SQLITE_DONE; + }else if( !p->isAttached ){ + attachBackupObject(p); + } + } + + /* Update the schema version field in the destination database. This + ** is to make sure that the schema-version really does change in + ** the case where the source and destination databases have the + ** same schema version. + */ + if( rc==SQLITE_DONE ){ + if( nSrcPage==0 ){ + rc = sqlite3BtreeNewDb(p->pDest); + nSrcPage = 1; + } + if( rc==SQLITE_OK || rc==SQLITE_DONE ){ + rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1); + } + if( rc==SQLITE_OK ){ + if( p->pDestDb ){ + sqlite3ResetAllSchemasOfConnection(p->pDestDb); + } + if( destMode==PAGER_JOURNALMODE_WAL ){ + rc = sqlite3BtreeSetVersion(p->pDest, 2); + } + } + if( rc==SQLITE_OK ){ + int nDestTruncate; + /* Set nDestTruncate to the final number of pages in the destination + ** database. The complication here is that the destination page + ** size may be different to the source page size. + ** + ** If the source page size is smaller than the destination page size, + ** round up. In this case the call to sqlite3OsTruncate() below will + ** fix the size of the file. However it is important to call + ** sqlite3PagerTruncateImage() here so that any pages in the + ** destination file that lie beyond the nDestTruncate page mark are + ** journalled by PagerCommitPhaseOne() before they are destroyed + ** by the file truncation. + */ + assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) ); + assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) ); + if( pgszSrcpDest->pBt) ){ + nDestTruncate--; + } + }else{ + nDestTruncate = nSrcPage * (pgszSrc/pgszDest); + } + assert( nDestTruncate>0 ); + + if( pgszSrc= iSize || ( + nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1) + && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest + )); + + /* This block ensures that all data required to recreate the original + ** database has been stored in the journal for pDestPager and the + ** journal synced to disk. So at this point we may safely modify + ** the database file in any way, knowing that if a power failure + ** occurs, the original database will be reconstructed from the + ** journal file. */ + sqlite3PagerPagecount(pDestPager, &nDstPage); + for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){ + if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){ + DbPage *pPg; + rc = sqlite3PagerGet(pDestPager, iPg, &pPg); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pPg); + sqlite3PagerUnref(pPg); + } + } + } + if( rc==SQLITE_OK ){ + rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 1); + } + + /* Write the extra pages and truncate the database file as required */ + iEnd = MIN(PENDING_BYTE + pgszDest, iSize); + for( + iOff=PENDING_BYTE+pgszSrc; + rc==SQLITE_OK && iOffpDest, 0)) + ){ + rc = SQLITE_DONE; + } + } + } + + /* If bCloseTrans is true, then this function opened a read transaction + ** on the source database. Close the read transaction here. There is + ** no need to check the return values of the btree methods here, as + ** "committing" a read-only transaction cannot fail. + */ + if( bCloseTrans ){ + TESTONLY( int rc2 ); + TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0); + TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0); + assert( rc2==SQLITE_OK ); + } + + if( rc==SQLITE_IOERR_NOMEM ){ + rc = SQLITE_NOMEM; + } + p->rc = rc; + } + if( p->pDestDb ){ + sqlite3_mutex_leave(p->pDestDb->mutex); + } + sqlite3BtreeLeave(p->pSrc); + sqlite3_mutex_leave(p->pSrcDb->mutex); + return rc; +} + +/* +** Release all resources associated with an sqlite3_backup* handle. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_backup_finish(sqlite3_backup *p){ + sqlite3_backup **pp; /* Ptr to head of pagers backup list */ + sqlite3 *pSrcDb; /* Source database connection */ + int rc; /* Value to return */ + + /* Enter the mutexes */ + if( p==0 ) return SQLITE_OK; + pSrcDb = p->pSrcDb; + sqlite3_mutex_enter(pSrcDb->mutex); + sqlite3BtreeEnter(p->pSrc); + if( p->pDestDb ){ + sqlite3_mutex_enter(p->pDestDb->mutex); + } + + /* Detach this backup from the source pager. */ + if( p->pDestDb ){ + p->pSrc->nBackup--; + } + if( p->isAttached ){ + pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc)); + while( *pp!=p ){ + pp = &(*pp)->pNext; + } + *pp = p->pNext; + } + + /* If a transaction is still open on the Btree, roll it back. */ + sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0); + + /* Set the error code of the destination database handle. */ + rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc; + if( p->pDestDb ){ + sqlite3Error(p->pDestDb, rc); + + /* Exit the mutexes and free the backup context structure. */ + sqlite3LeaveMutexAndCloseZombie(p->pDestDb); + } + sqlite3BtreeLeave(p->pSrc); + if( p->pDestDb ){ + /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a + ** call to sqlite3_backup_init() and is destroyed by a call to + ** sqlite3_backup_finish(). */ + sqlite3_free(p); + } + sqlite3LeaveMutexAndCloseZombie(pSrcDb); + return rc; +} + +/* +** Return the number of pages still to be backed up as of the most recent +** call to sqlite3_backup_step(). +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_backup_remaining(sqlite3_backup *p){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( p==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return p->nRemaining; +} + +/* +** Return the total number of pages in the source database as of the most +** recent call to sqlite3_backup_step(). +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_backup_pagecount(sqlite3_backup *p){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( p==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return p->nPagecount; +} + +/* +** This function is called after the contents of page iPage of the +** source database have been modified. If page iPage has already been +** copied into the destination database, then the data written to the +** destination is now invalidated. The destination copy of iPage needs +** to be updated with the new data before the backup operation is +** complete. +** +** It is assumed that the mutex associated with the BtShared object +** corresponding to the source database is held when this function is +** called. +*/ +static SQLITE_NOINLINE void backupUpdate( + sqlite3_backup *p, + Pgno iPage, + const u8 *aData +){ + assert( p!=0 ); + do{ + assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) ); + if( !isFatalError(p->rc) && iPageiNext ){ + /* The backup process p has already copied page iPage. But now it + ** has been modified by a transaction on the source pager. Copy + ** the new data into the backup. + */ + int rc; + assert( p->pDestDb ); + sqlite3_mutex_enter(p->pDestDb->mutex); + rc = backupOnePage(p, iPage, aData, 1); + sqlite3_mutex_leave(p->pDestDb->mutex); + assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED ); + if( rc!=SQLITE_OK ){ + p->rc = rc; + } + } + }while( (p = p->pNext)!=0 ); +} +SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){ + if( pBackup ) backupUpdate(pBackup, iPage, aData); +} + +/* +** Restart the backup process. This is called when the pager layer +** detects that the database has been modified by an external database +** connection. In this case there is no way of knowing which of the +** pages that have been copied into the destination database are still +** valid and which are not, so the entire process needs to be restarted. +** +** It is assumed that the mutex associated with the BtShared object +** corresponding to the source database is held when this function is +** called. +*/ +SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *pBackup){ + sqlite3_backup *p; /* Iterator variable */ + for(p=pBackup; p; p=p->pNext){ + assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) ); + p->iNext = 1; + } +} + +#ifndef SQLITE_OMIT_VACUUM +/* +** Copy the complete content of pBtFrom into pBtTo. A transaction +** must be active for both files. +** +** The size of file pTo may be reduced by this operation. If anything +** goes wrong, the transaction on pTo is rolled back. If successful, the +** transaction is committed before returning. +*/ +SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){ + int rc; + sqlite3_file *pFd; /* File descriptor for database pTo */ + sqlite3_backup b; + sqlite3BtreeEnter(pTo); + sqlite3BtreeEnter(pFrom); + + assert( sqlite3BtreeIsInTrans(pTo) ); + pFd = sqlite3PagerFile(sqlite3BtreePager(pTo)); + if( pFd->pMethods ){ + i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom); + rc = sqlite3OsFileControl(pFd, SQLITE_FCNTL_OVERWRITE, &nByte); + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + if( rc ) goto copy_finished; + } + + /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set + ** to 0. This is used by the implementations of sqlite3_backup_step() + ** and sqlite3_backup_finish() to detect that they are being called + ** from this function, not directly by the user. + */ + memset(&b, 0, sizeof(b)); + b.pSrcDb = pFrom->db; + b.pSrc = pFrom; + b.pDest = pTo; + b.iNext = 1; + +#ifdef SQLITE_HAS_CODEC + sqlite3PagerAlignReserve(sqlite3BtreePager(pTo), sqlite3BtreePager(pFrom)); +#endif + + /* 0x7FFFFFFF is the hard limit for the number of pages in a database + ** file. By passing this as the number of pages to copy to + ** sqlite3_backup_step(), we can guarantee that the copy finishes + ** within a single call (unless an error occurs). The assert() statement + ** checks this assumption - (p->rc) should be set to either SQLITE_DONE + ** or an error code. + */ + sqlite3_backup_step(&b, 0x7FFFFFFF); + assert( b.rc!=SQLITE_OK ); + rc = sqlite3_backup_finish(&b); + if( rc==SQLITE_OK ){ + pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED; + }else{ + sqlite3PagerClearCache(sqlite3BtreePager(b.pDest)); + } + + assert( sqlite3BtreeIsInTrans(pTo)==0 ); +copy_finished: + sqlite3BtreeLeave(pFrom); + sqlite3BtreeLeave(pTo); + return rc; +} +#endif /* SQLITE_OMIT_VACUUM */ + +/************** End of backup.c **********************************************/ +/************** Begin file vdbemem.c *****************************************/ +/* +** 2004 May 26 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code use to manipulate "Mem" structure. A "Mem" +** stores a single value in the VDBE. Mem is an opaque structure visible +** only within the VDBE. Interface routines refer to a Mem using the +** name sqlite_value +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#ifdef SQLITE_DEBUG +/* +** Check invariants on a Mem object. +** +** This routine is intended for use inside of assert() statements, like +** this: assert( sqlite3VdbeCheckMemInvariants(pMem) ); +*/ +SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){ + /* If MEM_Dyn is set then Mem.xDel!=0. + ** Mem.xDel is might not be initialized if MEM_Dyn is clear. + */ + assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 ); + + /* MEM_Dyn may only be set if Mem.szMalloc==0. In this way we + ** ensure that if Mem.szMalloc>0 then it is safe to do + ** Mem.z = Mem.zMalloc without having to check Mem.flags&MEM_Dyn. + ** That saves a few cycles in inner loops. */ + assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 ); + + /* Cannot be both MEM_Int and MEM_Real at the same time */ + assert( (p->flags & (MEM_Int|MEM_Real))!=(MEM_Int|MEM_Real) ); + + /* The szMalloc field holds the correct memory allocation size */ + assert( p->szMalloc==0 + || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc) ); + + /* If p holds a string or blob, the Mem.z must point to exactly + ** one of the following: + ** + ** (1) Memory in Mem.zMalloc and managed by the Mem object + ** (2) Memory to be freed using Mem.xDel + ** (3) An ephemeral string or blob + ** (4) A static string or blob + */ + if( (p->flags & (MEM_Str|MEM_Blob)) && p->n>0 ){ + assert( + ((p->szMalloc>0 && p->z==p->zMalloc)? 1 : 0) + + ((p->flags&MEM_Dyn)!=0 ? 1 : 0) + + ((p->flags&MEM_Ephem)!=0 ? 1 : 0) + + ((p->flags&MEM_Static)!=0 ? 1 : 0) == 1 + ); + } + return 1; +} +#endif + + +/* +** If pMem is an object with a valid string representation, this routine +** ensures the internal encoding for the string representation is +** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE. +** +** If pMem is not a string object, or the encoding of the string +** representation is already stored using the requested encoding, then this +** routine is a no-op. +** +** SQLITE_OK is returned if the conversion is successful (or not required). +** SQLITE_NOMEM may be returned if a malloc() fails during conversion +** between formats. +*/ +SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){ +#ifndef SQLITE_OMIT_UTF16 + int rc; +#endif + assert( (pMem->flags&MEM_RowSet)==0 ); + assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE + || desiredEnc==SQLITE_UTF16BE ); + if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){ + return SQLITE_OK; + } + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); +#ifdef SQLITE_OMIT_UTF16 + return SQLITE_ERROR; +#else + + /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned, + ** then the encoding of the value may not have changed. + */ + rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc); + assert(rc==SQLITE_OK || rc==SQLITE_NOMEM); + assert(rc==SQLITE_OK || pMem->enc!=desiredEnc); + assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc); + return rc; +#endif +} + +/* +** Make sure pMem->z points to a writable allocation of at least +** min(n,32) bytes. +** +** If the bPreserve argument is true, then copy of the content of +** pMem->z into the new allocation. pMem must be either a string or +** blob if bPreserve is true. If bPreserve is false, any prior content +** in pMem->z is discarded. +*/ +SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){ + assert( sqlite3VdbeCheckMemInvariants(pMem) ); + assert( (pMem->flags&MEM_RowSet)==0 ); + + /* If the bPreserve flag is set to true, then the memory cell must already + ** contain a valid string or blob value. */ + assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) ); + testcase( bPreserve && pMem->z==0 ); + + assert( pMem->szMalloc==0 + || pMem->szMalloc==sqlite3DbMallocSize(pMem->db, pMem->zMalloc) ); + if( pMem->szMallocszMalloc>0 && pMem->z==pMem->zMalloc ){ + pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n); + bPreserve = 0; + }else{ + if( pMem->szMalloc>0 ) sqlite3DbFree(pMem->db, pMem->zMalloc); + pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n); + } + if( pMem->zMalloc==0 ){ + sqlite3VdbeMemSetNull(pMem); + pMem->z = 0; + pMem->szMalloc = 0; + return SQLITE_NOMEM; + }else{ + pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc); + } + } + + if( bPreserve && pMem->z && pMem->z!=pMem->zMalloc ){ + memcpy(pMem->zMalloc, pMem->z, pMem->n); + } + if( (pMem->flags&MEM_Dyn)!=0 ){ + assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC ); + pMem->xDel((void *)(pMem->z)); + } + + pMem->z = pMem->zMalloc; + pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static); + return SQLITE_OK; +} + +/* +** Change the pMem->zMalloc allocation to be at least szNew bytes. +** If pMem->zMalloc already meets or exceeds the requested size, this +** routine is a no-op. +** +** Any prior string or blob content in the pMem object may be discarded. +** The pMem->xDel destructor is called, if it exists. Though MEM_Str +** and MEM_Blob values may be discarded, MEM_Int, MEM_Real, and MEM_Null +** values are preserved. +** +** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM) +** if unable to complete the resizing. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int szNew){ + assert( szNew>0 ); + assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 ); + if( pMem->szMallocflags & MEM_Dyn)==0 ); + pMem->z = pMem->zMalloc; + pMem->flags &= (MEM_Null|MEM_Int|MEM_Real); + return SQLITE_OK; +} + +/* +** Change pMem so that its MEM_Str or MEM_Blob value is stored in +** MEM.zMalloc, where it can be safely written. +** +** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){ + int f; + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( (pMem->flags&MEM_RowSet)==0 ); + ExpandBlob(pMem); + f = pMem->flags; + if( (f&(MEM_Str|MEM_Blob)) && (pMem->szMalloc==0 || pMem->z!=pMem->zMalloc) ){ + if( sqlite3VdbeMemGrow(pMem, pMem->n + 2, 1) ){ + return SQLITE_NOMEM; + } + pMem->z[pMem->n] = 0; + pMem->z[pMem->n+1] = 0; + pMem->flags |= MEM_Term; + } + pMem->flags &= ~MEM_Ephem; +#ifdef SQLITE_DEBUG + pMem->pScopyFrom = 0; +#endif + + return SQLITE_OK; +} + +/* +** If the given Mem* has a zero-filled tail, turn it into an ordinary +** blob stored in dynamically allocated space. +*/ +#ifndef SQLITE_OMIT_INCRBLOB +SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){ + if( pMem->flags & MEM_Zero ){ + int nByte; + assert( pMem->flags&MEM_Blob ); + assert( (pMem->flags&MEM_RowSet)==0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + + /* Set nByte to the number of bytes required to store the expanded blob. */ + nByte = pMem->n + pMem->u.nZero; + if( nByte<=0 ){ + nByte = 1; + } + if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){ + return SQLITE_NOMEM; + } + + memset(&pMem->z[pMem->n], 0, pMem->u.nZero); + pMem->n += pMem->u.nZero; + pMem->flags &= ~(MEM_Zero|MEM_Term); + } + return SQLITE_OK; +} +#endif + +/* +** It is already known that pMem contains an unterminated string. +** Add the zero terminator. +*/ +static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){ + if( sqlite3VdbeMemGrow(pMem, pMem->n+2, 1) ){ + return SQLITE_NOMEM; + } + pMem->z[pMem->n] = 0; + pMem->z[pMem->n+1] = 0; + pMem->flags |= MEM_Term; + return SQLITE_OK; +} + +/* +** Make sure the given Mem is \u0000 terminated. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){ + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) ); + testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 ); + if( (pMem->flags & (MEM_Term|MEM_Str))!=MEM_Str ){ + return SQLITE_OK; /* Nothing to do */ + }else{ + return vdbeMemAddTerminator(pMem); + } +} + +/* +** Add MEM_Str to the set of representations for the given Mem. Numbers +** are converted using sqlite3_snprintf(). Converting a BLOB to a string +** is a no-op. +** +** Existing representations MEM_Int and MEM_Real are invalidated if +** bForce is true but are retained if bForce is false. +** +** A MEM_Null value will never be passed to this function. This function is +** used for converting values to text for returning to the user (i.e. via +** sqlite3_value_text()), or for ensuring that values to be used as btree +** keys are strings. In the former case a NULL pointer is returned the +** user and the latter is an internal programming error. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){ + int fg = pMem->flags; + const int nByte = 32; + + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( !(fg&MEM_Zero) ); + assert( !(fg&(MEM_Str|MEM_Blob)) ); + assert( fg&(MEM_Int|MEM_Real) ); + assert( (pMem->flags&MEM_RowSet)==0 ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + + if( sqlite3VdbeMemClearAndResize(pMem, nByte) ){ + return SQLITE_NOMEM; + } + + /* For a Real or Integer, use sqlite3_snprintf() to produce the UTF-8 + ** string representation of the value. Then, if the required encoding + ** is UTF-16le or UTF-16be do a translation. + ** + ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16. + */ + if( fg & MEM_Int ){ + sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i); + }else{ + assert( fg & MEM_Real ); + sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->u.r); + } + pMem->n = sqlite3Strlen30(pMem->z); + pMem->enc = SQLITE_UTF8; + pMem->flags |= MEM_Str|MEM_Term; + if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real); + sqlite3VdbeChangeEncoding(pMem, enc); + return SQLITE_OK; +} + +/* +** Memory cell pMem contains the context of an aggregate function. +** This routine calls the finalize method for that function. The +** result of the aggregate is stored back into pMem. +** +** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK +** otherwise. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){ + int rc = SQLITE_OK; + if( ALWAYS(pFunc && pFunc->xFinalize) ){ + sqlite3_context ctx; + Mem t; + assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + memset(&ctx, 0, sizeof(ctx)); + memset(&t, 0, sizeof(t)); + t.flags = MEM_Null; + t.db = pMem->db; + ctx.pOut = &t; + ctx.pMem = pMem; + ctx.pFunc = pFunc; + pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */ + assert( (pMem->flags & MEM_Dyn)==0 ); + if( pMem->szMalloc>0 ) sqlite3DbFree(pMem->db, pMem->zMalloc); + memcpy(pMem, &t, sizeof(t)); + rc = ctx.isError; + } + return rc; +} + +/* +** If the memory cell contains a value that must be freed by +** invoking the external callback in Mem.xDel, then this routine +** will free that value. It also sets Mem.flags to MEM_Null. +** +** This is a helper routine for sqlite3VdbeMemSetNull() and +** for sqlite3VdbeMemRelease(). Use those other routines as the +** entry point for releasing Mem resources. +*/ +static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){ + assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) ); + assert( VdbeMemDynamic(p) ); + if( p->flags&MEM_Agg ){ + sqlite3VdbeMemFinalize(p, p->u.pDef); + assert( (p->flags & MEM_Agg)==0 ); + testcase( p->flags & MEM_Dyn ); + } + if( p->flags&MEM_Dyn ){ + assert( (p->flags&MEM_RowSet)==0 ); + assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 ); + p->xDel((void *)p->z); + }else if( p->flags&MEM_RowSet ){ + sqlite3RowSetClear(p->u.pRowSet); + }else if( p->flags&MEM_Frame ){ + VdbeFrame *pFrame = p->u.pFrame; + pFrame->pParent = pFrame->v->pDelFrame; + pFrame->v->pDelFrame = pFrame; + } + p->flags = MEM_Null; +} + +/* +** Release memory held by the Mem p, both external memory cleared +** by p->xDel and memory in p->zMalloc. +** +** This is a helper routine invoked by sqlite3VdbeMemRelease() in +** the unusual case where there really is memory in p that needs +** to be freed. +*/ +static SQLITE_NOINLINE void vdbeMemClear(Mem *p){ + if( VdbeMemDynamic(p) ){ + vdbeMemClearExternAndSetNull(p); + } + if( p->szMalloc ){ + sqlite3DbFree(p->db, p->zMalloc); + p->szMalloc = 0; + } + p->z = 0; +} + +/* +** Release any memory resources held by the Mem. Both the memory that is +** free by Mem.xDel and the Mem.zMalloc allocation are freed. +** +** Use this routine prior to clean up prior to abandoning a Mem, or to +** reset a Mem back to its minimum memory utilization. +** +** Use sqlite3VdbeMemSetNull() to release just the Mem.xDel space +** prior to inserting new content into the Mem. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){ + assert( sqlite3VdbeCheckMemInvariants(p) ); + if( VdbeMemDynamic(p) || p->szMalloc ){ + vdbeMemClear(p); + } +} + +/* +** Convert a 64-bit IEEE double into a 64-bit signed integer. +** If the double is out of range of a 64-bit signed integer then +** return the closest available 64-bit signed integer. +*/ +static i64 doubleToInt64(double r){ +#ifdef SQLITE_OMIT_FLOATING_POINT + /* When floating-point is omitted, double and int64 are the same thing */ + return r; +#else + /* + ** Many compilers we encounter do not define constants for the + ** minimum and maximum 64-bit integers, or they define them + ** inconsistently. And many do not understand the "LL" notation. + ** So we define our own static constants here using nothing + ** larger than a 32-bit integer constant. + */ + static const i64 maxInt = LARGEST_INT64; + static const i64 minInt = SMALLEST_INT64; + + if( r<=(double)minInt ){ + return minInt; + }else if( r>=(double)maxInt ){ + return maxInt; + }else{ + return (i64)r; + } +#endif +} + +/* +** Return some kind of integer value which is the best we can do +** at representing the value that *pMem describes as an integer. +** If pMem is an integer, then the value is exact. If pMem is +** a floating-point then the value returned is the integer part. +** If pMem is a string or blob, then we make an attempt to convert +** it into an integer and return that. If pMem represents an +** an SQL-NULL value, return 0. +** +** If pMem represents a string value, its encoding might be changed. +*/ +SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){ + int flags; + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + flags = pMem->flags; + if( flags & MEM_Int ){ + return pMem->u.i; + }else if( flags & MEM_Real ){ + return doubleToInt64(pMem->u.r); + }else if( flags & (MEM_Str|MEM_Blob) ){ + i64 value = 0; + assert( pMem->z || pMem->n==0 ); + sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc); + return value; + }else{ + return 0; + } +} + +/* +** Return the best representation of pMem that we can get into a +** double. If pMem is already a double or an integer, return its +** value. If it is a string or blob, try to convert it to a double. +** If it is a NULL, return 0.0. +*/ +SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){ + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + if( pMem->flags & MEM_Real ){ + return pMem->u.r; + }else if( pMem->flags & MEM_Int ){ + return (double)pMem->u.i; + }else if( pMem->flags & (MEM_Str|MEM_Blob) ){ + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + double val = (double)0; + sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc); + return val; + }else{ + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + return (double)0; + } +} + +/* +** The MEM structure is already a MEM_Real. Try to also make it a +** MEM_Int if we can. +*/ +SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){ + i64 ix; + assert( pMem->flags & MEM_Real ); + assert( (pMem->flags & MEM_RowSet)==0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + ix = doubleToInt64(pMem->u.r); + + /* Only mark the value as an integer if + ** + ** (1) the round-trip conversion real->int->real is a no-op, and + ** (2) The integer is neither the largest nor the smallest + ** possible integer (ticket #3922) + ** + ** The second and third terms in the following conditional enforces + ** the second condition under the assumption that addition overflow causes + ** values to wrap around. + */ + if( pMem->u.r==ix && ix>SMALLEST_INT64 && ixu.i = ix; + MemSetTypeFlag(pMem, MEM_Int); + } +} + +/* +** Convert pMem to type integer. Invalidate any prior representations. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){ + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( (pMem->flags & MEM_RowSet)==0 ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + pMem->u.i = sqlite3VdbeIntValue(pMem); + MemSetTypeFlag(pMem, MEM_Int); + return SQLITE_OK; +} + +/* +** Convert pMem so that it is of type MEM_Real. +** Invalidate any prior representations. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){ + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + pMem->u.r = sqlite3VdbeRealValue(pMem); + MemSetTypeFlag(pMem, MEM_Real); + return SQLITE_OK; +} + +/* +** Convert pMem so that it has types MEM_Real or MEM_Int or both. +** Invalidate any prior representations. +** +** Every effort is made to force the conversion, even if the input +** is a string that does not look completely like a number. Convert +** as much of the string as we can and ignore the rest. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){ + if( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 ){ + assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + if( 0==sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc) ){ + MemSetTypeFlag(pMem, MEM_Int); + }else{ + pMem->u.r = sqlite3VdbeRealValue(pMem); + MemSetTypeFlag(pMem, MEM_Real); + sqlite3VdbeIntegerAffinity(pMem); + } + } + assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 ); + pMem->flags &= ~(MEM_Str|MEM_Blob); + return SQLITE_OK; +} + +/* +** Cast the datatype of the value in pMem according to the affinity +** "aff". Casting is different from applying affinity in that a cast +** is forced. In other words, the value is converted into the desired +** affinity even if that results in loss of data. This routine is +** used (for example) to implement the SQL "cast()" operator. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemCast(Mem *pMem, u8 aff, u8 encoding){ + if( pMem->flags & MEM_Null ) return; + switch( aff ){ + case SQLITE_AFF_BLOB: { /* Really a cast to BLOB */ + if( (pMem->flags & MEM_Blob)==0 ){ + sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding); + assert( pMem->flags & MEM_Str || pMem->db->mallocFailed ); + MemSetTypeFlag(pMem, MEM_Blob); + }else{ + pMem->flags &= ~(MEM_TypeMask&~MEM_Blob); + } + break; + } + case SQLITE_AFF_NUMERIC: { + sqlite3VdbeMemNumerify(pMem); + break; + } + case SQLITE_AFF_INTEGER: { + sqlite3VdbeMemIntegerify(pMem); + break; + } + case SQLITE_AFF_REAL: { + sqlite3VdbeMemRealify(pMem); + break; + } + default: { + assert( aff==SQLITE_AFF_TEXT ); + assert( MEM_Str==(MEM_Blob>>3) ); + pMem->flags |= (pMem->flags&MEM_Blob)>>3; + sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding); + assert( pMem->flags & MEM_Str || pMem->db->mallocFailed ); + pMem->flags &= ~(MEM_Int|MEM_Real|MEM_Blob|MEM_Zero); + break; + } + } +} + +/* +** Initialize bulk memory to be a consistent Mem object. +** +** The minimum amount of initialization feasible is performed. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){ + assert( (flags & ~MEM_TypeMask)==0 ); + pMem->flags = flags; + pMem->db = db; + pMem->szMalloc = 0; +} + + +/* +** Delete any previous value and set the value stored in *pMem to NULL. +** +** This routine calls the Mem.xDel destructor to dispose of values that +** require the destructor. But it preserves the Mem.zMalloc memory allocation. +** To free all resources, use sqlite3VdbeMemRelease(), which both calls this +** routine to invoke the destructor and deallocates Mem.zMalloc. +** +** Use this routine to reset the Mem prior to insert a new value. +** +** Use sqlite3VdbeMemRelease() to complete erase the Mem prior to abandoning it. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){ + if( VdbeMemDynamic(pMem) ){ + vdbeMemClearExternAndSetNull(pMem); + }else{ + pMem->flags = MEM_Null; + } +} +SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value *p){ + sqlite3VdbeMemSetNull((Mem*)p); +} + +/* +** Delete any previous value and set the value to be a BLOB of length +** n containing all zeros. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){ + sqlite3VdbeMemRelease(pMem); + pMem->flags = MEM_Blob|MEM_Zero; + pMem->n = 0; + if( n<0 ) n = 0; + pMem->u.nZero = n; + pMem->enc = SQLITE_UTF8; + pMem->z = 0; +} + +/* +** The pMem is known to contain content that needs to be destroyed prior +** to a value change. So invoke the destructor, then set the value to +** a 64-bit integer. +*/ +static SQLITE_NOINLINE void vdbeReleaseAndSetInt64(Mem *pMem, i64 val){ + sqlite3VdbeMemSetNull(pMem); + pMem->u.i = val; + pMem->flags = MEM_Int; +} + +/* +** Delete any previous value and set the value stored in *pMem to val, +** manifest type INTEGER. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){ + if( VdbeMemDynamic(pMem) ){ + vdbeReleaseAndSetInt64(pMem, val); + }else{ + pMem->u.i = val; + pMem->flags = MEM_Int; + } +} + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** Delete any previous value and set the value stored in *pMem to val, +** manifest type REAL. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){ + sqlite3VdbeMemSetNull(pMem); + if( !sqlite3IsNaN(val) ){ + pMem->u.r = val; + pMem->flags = MEM_Real; + } +} +#endif + +/* +** Delete any previous value and set the value of pMem to be an +** empty boolean index. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem *pMem){ + sqlite3 *db = pMem->db; + assert( db!=0 ); + assert( (pMem->flags & MEM_RowSet)==0 ); + sqlite3VdbeMemRelease(pMem); + pMem->zMalloc = sqlite3DbMallocRaw(db, 64); + if( db->mallocFailed ){ + pMem->flags = MEM_Null; + pMem->szMalloc = 0; + }else{ + assert( pMem->zMalloc ); + pMem->szMalloc = sqlite3DbMallocSize(db, pMem->zMalloc); + pMem->u.pRowSet = sqlite3RowSetInit(db, pMem->zMalloc, pMem->szMalloc); + assert( pMem->u.pRowSet!=0 ); + pMem->flags = MEM_RowSet; + } +} + +/* +** Return true if the Mem object contains a TEXT or BLOB that is +** too large - whose size exceeds SQLITE_MAX_LENGTH. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem *p){ + assert( p->db!=0 ); + if( p->flags & (MEM_Str|MEM_Blob) ){ + int n = p->n; + if( p->flags & MEM_Zero ){ + n += p->u.nZero; + } + return n>p->db->aLimit[SQLITE_LIMIT_LENGTH]; + } + return 0; +} + +#ifdef SQLITE_DEBUG +/* +** This routine prepares a memory cell for modification by breaking +** its link to a shallow copy and by marking any current shallow +** copies of this cell as invalid. +** +** This is used for testing and debugging only - to make sure shallow +** copies are not misused. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){ + int i; + Mem *pX; + for(i=1, pX=&pVdbe->aMem[1]; i<=pVdbe->nMem; i++, pX++){ + if( pX->pScopyFrom==pMem ){ + pX->flags |= MEM_Undefined; + pX->pScopyFrom = 0; + } + } + pMem->pScopyFrom = 0; +} +#endif /* SQLITE_DEBUG */ + + +/* +** Make an shallow copy of pFrom into pTo. Prior contents of +** pTo are freed. The pFrom->z field is not duplicated. If +** pFrom->z is used, then pTo->z points to the same thing as pFrom->z +** and flags gets srcType (either MEM_Ephem or MEM_Static). +*/ +static SQLITE_NOINLINE void vdbeClrCopy(Mem *pTo, const Mem *pFrom, int eType){ + vdbeMemClearExternAndSetNull(pTo); + assert( !VdbeMemDynamic(pTo) ); + sqlite3VdbeMemShallowCopy(pTo, pFrom, eType); +} +SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){ + assert( (pFrom->flags & MEM_RowSet)==0 ); + assert( pTo->db==pFrom->db ); + if( VdbeMemDynamic(pTo) ){ vdbeClrCopy(pTo,pFrom,srcType); return; } + memcpy(pTo, pFrom, MEMCELLSIZE); + if( (pFrom->flags&MEM_Static)==0 ){ + pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem); + assert( srcType==MEM_Ephem || srcType==MEM_Static ); + pTo->flags |= srcType; + } +} + +/* +** Make a full copy of pFrom into pTo. Prior contents of pTo are +** freed before the copy is made. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){ + int rc = SQLITE_OK; + + /* The pFrom==0 case in the following assert() is when an sqlite3_value + ** from sqlite3_value_dup() is used as the argument + ** to sqlite3_result_value(). */ + assert( pTo->db==pFrom->db || pFrom->db==0 ); + assert( (pFrom->flags & MEM_RowSet)==0 ); + if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo); + memcpy(pTo, pFrom, MEMCELLSIZE); + pTo->flags &= ~MEM_Dyn; + if( pTo->flags&(MEM_Str|MEM_Blob) ){ + if( 0==(pFrom->flags&MEM_Static) ){ + pTo->flags |= MEM_Ephem; + rc = sqlite3VdbeMemMakeWriteable(pTo); + } + } + + return rc; +} + +/* +** Transfer the contents of pFrom to pTo. Any existing value in pTo is +** freed. If pFrom contains ephemeral data, a copy is made. +** +** pFrom contains an SQL NULL when this routine returns. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){ + assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) ); + assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) ); + assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db ); + + sqlite3VdbeMemRelease(pTo); + memcpy(pTo, pFrom, sizeof(Mem)); + pFrom->flags = MEM_Null; + pFrom->szMalloc = 0; +} + +/* +** Change the value of a Mem to be a string or a BLOB. +** +** The memory management strategy depends on the value of the xDel +** parameter. If the value passed is SQLITE_TRANSIENT, then the +** string is copied into a (possibly existing) buffer managed by the +** Mem structure. Otherwise, any existing buffer is freed and the +** pointer copied. +** +** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH +** size limit) then no memory allocation occurs. If the string can be +** stored without allocating memory, then it is. If a memory allocation +** is required to store the string, then value of pMem is unchanged. In +** either case, SQLITE_TOOBIG is returned. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemSetStr( + Mem *pMem, /* Memory cell to set to string value */ + const char *z, /* String pointer */ + int n, /* Bytes in string, or negative */ + u8 enc, /* Encoding of z. 0 for BLOBs */ + void (*xDel)(void*) /* Destructor function */ +){ + int nByte = n; /* New value for pMem->n */ + int iLimit; /* Maximum allowed string or blob size */ + u16 flags = 0; /* New value for pMem->flags */ + + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( (pMem->flags & MEM_RowSet)==0 ); + + /* If z is a NULL pointer, set pMem to contain an SQL NULL. */ + if( !z ){ + sqlite3VdbeMemSetNull(pMem); + return SQLITE_OK; + } + + if( pMem->db ){ + iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH]; + }else{ + iLimit = SQLITE_MAX_LENGTH; + } + flags = (enc==0?MEM_Blob:MEM_Str); + if( nByte<0 ){ + assert( enc!=0 ); + if( enc==SQLITE_UTF8 ){ + nByte = sqlite3Strlen30(z); + if( nByte>iLimit ) nByte = iLimit+1; + }else{ + for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){} + } + flags |= MEM_Term; + } + + /* The following block sets the new values of Mem.z and Mem.xDel. It + ** also sets a flag in local variable "flags" to indicate the memory + ** management (one of MEM_Dyn or MEM_Static). + */ + if( xDel==SQLITE_TRANSIENT ){ + int nAlloc = nByte; + if( flags&MEM_Term ){ + nAlloc += (enc==SQLITE_UTF8?1:2); + } + if( nByte>iLimit ){ + return SQLITE_TOOBIG; + } + testcase( nAlloc==0 ); + testcase( nAlloc==31 ); + testcase( nAlloc==32 ); + if( sqlite3VdbeMemClearAndResize(pMem, MAX(nAlloc,32)) ){ + return SQLITE_NOMEM; + } + memcpy(pMem->z, z, nAlloc); + }else if( xDel==SQLITE_DYNAMIC ){ + sqlite3VdbeMemRelease(pMem); + pMem->zMalloc = pMem->z = (char *)z; + pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc); + }else{ + sqlite3VdbeMemRelease(pMem); + pMem->z = (char *)z; + pMem->xDel = xDel; + flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn); + } + + pMem->n = nByte; + pMem->flags = flags; + pMem->enc = (enc==0 ? SQLITE_UTF8 : enc); + +#ifndef SQLITE_OMIT_UTF16 + if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){ + return SQLITE_NOMEM; + } +#endif + + if( nByte>iLimit ){ + return SQLITE_TOOBIG; + } + + return SQLITE_OK; +} + +/* +** Move data out of a btree key or data field and into a Mem structure. +** The data or key is taken from the entry that pCur is currently pointing +** to. offset and amt determine what portion of the data or key to retrieve. +** key is true to get the key or false to get data. The result is written +** into the pMem element. +** +** The pMem object must have been initialized. This routine will use +** pMem->zMalloc to hold the content from the btree, if possible. New +** pMem->zMalloc space will be allocated if necessary. The calling routine +** is responsible for making sure that the pMem object is eventually +** destroyed. +** +** If this routine fails for any reason (malloc returns NULL or unable +** to read from the disk) then the pMem is left in an inconsistent state. +*/ +static SQLITE_NOINLINE int vdbeMemFromBtreeResize( + BtCursor *pCur, /* Cursor pointing at record to retrieve. */ + u32 offset, /* Offset from the start of data to return bytes from. */ + u32 amt, /* Number of bytes to return. */ + int key, /* If true, retrieve from the btree key, not data. */ + Mem *pMem /* OUT: Return data in this Mem structure. */ +){ + int rc; + pMem->flags = MEM_Null; + if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+2)) ){ + if( key ){ + rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z); + }else{ + rc = sqlite3BtreeData(pCur, offset, amt, pMem->z); + } + if( rc==SQLITE_OK ){ + pMem->z[amt] = 0; + pMem->z[amt+1] = 0; + pMem->flags = MEM_Blob|MEM_Term; + pMem->n = (int)amt; + }else{ + sqlite3VdbeMemRelease(pMem); + } + } + return rc; +} +SQLITE_PRIVATE int sqlite3VdbeMemFromBtree( + BtCursor *pCur, /* Cursor pointing at record to retrieve. */ + u32 offset, /* Offset from the start of data to return bytes from. */ + u32 amt, /* Number of bytes to return. */ + int key, /* If true, retrieve from the btree key, not data. */ + Mem *pMem /* OUT: Return data in this Mem structure. */ +){ + char *zData; /* Data from the btree layer */ + u32 available = 0; /* Number of bytes available on the local btree page */ + int rc = SQLITE_OK; /* Return code */ + + assert( sqlite3BtreeCursorIsValid(pCur) ); + assert( !VdbeMemDynamic(pMem) ); + + /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert() + ** that both the BtShared and database handle mutexes are held. */ + assert( (pMem->flags & MEM_RowSet)==0 ); + if( key ){ + zData = (char *)sqlite3BtreeKeyFetch(pCur, &available); + }else{ + zData = (char *)sqlite3BtreeDataFetch(pCur, &available); + } + assert( zData!=0 ); + + if( offset+amt<=available ){ + pMem->z = &zData[offset]; + pMem->flags = MEM_Blob|MEM_Ephem; + pMem->n = (int)amt; + }else{ + rc = vdbeMemFromBtreeResize(pCur, offset, amt, key, pMem); + } + + return rc; +} + +/* +** The pVal argument is known to be a value other than NULL. +** Convert it into a string with encoding enc and return a pointer +** to a zero-terminated version of that string. +*/ +static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){ + assert( pVal!=0 ); + assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) ); + assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) ); + assert( (pVal->flags & MEM_RowSet)==0 ); + assert( (pVal->flags & (MEM_Null))==0 ); + if( pVal->flags & (MEM_Blob|MEM_Str) ){ + pVal->flags |= MEM_Str; + if( pVal->flags & MEM_Zero ){ + sqlite3VdbeMemExpandBlob(pVal); + } + if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){ + sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED); + } + if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){ + assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 ); + if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){ + return 0; + } + } + sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */ + }else{ + sqlite3VdbeMemStringify(pVal, enc, 0); + assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) ); + } + assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0 + || pVal->db->mallocFailed ); + if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){ + return pVal->z; + }else{ + return 0; + } +} + +/* This function is only available internally, it is not part of the +** external API. It works in a similar way to sqlite3_value_text(), +** except the data returned is in the encoding specified by the second +** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or +** SQLITE_UTF8. +** +** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED. +** If that is the case, then the result must be aligned on an even byte +** boundary. +*/ +SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){ + if( !pVal ) return 0; + assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) ); + assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) ); + assert( (pVal->flags & MEM_RowSet)==0 ); + if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){ + return pVal->z; + } + if( pVal->flags&MEM_Null ){ + return 0; + } + return valueToText(pVal, enc); +} + +/* +** Create a new sqlite3_value object. +*/ +SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *db){ + Mem *p = sqlite3DbMallocZero(db, sizeof(*p)); + if( p ){ + p->flags = MEM_Null; + p->db = db; + } + return p; +} + +/* +** Context object passed by sqlite3Stat4ProbeSetValue() through to +** valueNew(). See comments above valueNew() for details. +*/ +struct ValueNewStat4Ctx { + Parse *pParse; + Index *pIdx; + UnpackedRecord **ppRec; + int iVal; +}; + +/* +** Allocate and return a pointer to a new sqlite3_value object. If +** the second argument to this function is NULL, the object is allocated +** by calling sqlite3ValueNew(). +** +** Otherwise, if the second argument is non-zero, then this function is +** being called indirectly by sqlite3Stat4ProbeSetValue(). If it has not +** already been allocated, allocate the UnpackedRecord structure that +** that function will return to its caller here. Then return a pointer to +** an sqlite3_value within the UnpackedRecord.a[] array. +*/ +static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + if( p ){ + UnpackedRecord *pRec = p->ppRec[0]; + + if( pRec==0 ){ + Index *pIdx = p->pIdx; /* Index being probed */ + int nByte; /* Bytes of space to allocate */ + int i; /* Counter variable */ + int nCol = pIdx->nColumn; /* Number of index columns including rowid */ + + nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord)); + pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte); + if( pRec ){ + pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx); + if( pRec->pKeyInfo ){ + assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol ); + assert( pRec->pKeyInfo->enc==ENC(db) ); + pRec->aMem = (Mem *)((u8*)pRec + ROUND8(sizeof(UnpackedRecord))); + for(i=0; iaMem[i].flags = MEM_Null; + pRec->aMem[i].db = db; + } + }else{ + sqlite3DbFree(db, pRec); + pRec = 0; + } + } + if( pRec==0 ) return 0; + p->ppRec[0] = pRec; + } + + pRec->nField = p->iVal+1; + return &pRec->aMem[p->iVal]; + } +#else + UNUSED_PARAMETER(p); +#endif /* defined(SQLITE_ENABLE_STAT3_OR_STAT4) */ + return sqlite3ValueNew(db); +} + +/* +** The expression object indicated by the second argument is guaranteed +** to be a scalar SQL function. If +** +** * all function arguments are SQL literals, +** * one of the SQLITE_FUNC_CONSTANT or _SLOCHNG function flags is set, and +** * the SQLITE_FUNC_NEEDCOLL function flag is not set, +** +** then this routine attempts to invoke the SQL function. Assuming no +** error occurs, output parameter (*ppVal) is set to point to a value +** object containing the result before returning SQLITE_OK. +** +** Affinity aff is applied to the result of the function before returning. +** If the result is a text value, the sqlite3_value object uses encoding +** enc. +** +** If the conditions above are not met, this function returns SQLITE_OK +** and sets (*ppVal) to NULL. Or, if an error occurs, (*ppVal) is set to +** NULL and an SQLite error code returned. +*/ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +static int valueFromFunction( + sqlite3 *db, /* The database connection */ + Expr *p, /* The expression to evaluate */ + u8 enc, /* Encoding to use */ + u8 aff, /* Affinity to use */ + sqlite3_value **ppVal, /* Write the new value here */ + struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */ +){ + sqlite3_context ctx; /* Context object for function invocation */ + sqlite3_value **apVal = 0; /* Function arguments */ + int nVal = 0; /* Size of apVal[] array */ + FuncDef *pFunc = 0; /* Function definition */ + sqlite3_value *pVal = 0; /* New value */ + int rc = SQLITE_OK; /* Return code */ + int nName; /* Size of function name in bytes */ + ExprList *pList = 0; /* Function arguments */ + int i; /* Iterator variable */ + + assert( pCtx!=0 ); + assert( (p->flags & EP_TokenOnly)==0 ); + pList = p->x.pList; + if( pList ) nVal = pList->nExpr; + nName = sqlite3Strlen30(p->u.zToken); + pFunc = sqlite3FindFunction(db, p->u.zToken, nName, nVal, enc, 0); + assert( pFunc ); + if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0 + || (pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL) + ){ + return SQLITE_OK; + } + + if( pList ){ + apVal = (sqlite3_value**)sqlite3DbMallocZero(db, sizeof(apVal[0]) * nVal); + if( apVal==0 ){ + rc = SQLITE_NOMEM; + goto value_from_function_out; + } + for(i=0; ia[i].pExpr, enc, aff, &apVal[i]); + if( apVal[i]==0 || rc!=SQLITE_OK ) goto value_from_function_out; + } + } + + pVal = valueNew(db, pCtx); + if( pVal==0 ){ + rc = SQLITE_NOMEM; + goto value_from_function_out; + } + + assert( pCtx->pParse->rc==SQLITE_OK ); + memset(&ctx, 0, sizeof(ctx)); + ctx.pOut = pVal; + ctx.pFunc = pFunc; + pFunc->xFunc(&ctx, nVal, apVal); + if( ctx.isError ){ + rc = ctx.isError; + sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal)); + }else{ + sqlite3ValueApplyAffinity(pVal, aff, SQLITE_UTF8); + assert( rc==SQLITE_OK ); + rc = sqlite3VdbeChangeEncoding(pVal, enc); + if( rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal) ){ + rc = SQLITE_TOOBIG; + pCtx->pParse->nErr++; + } + } + pCtx->pParse->rc = rc; + + value_from_function_out: + if( rc!=SQLITE_OK ){ + pVal = 0; + } + if( apVal ){ + for(i=0; iop)==TK_UPLUS ) pExpr = pExpr->pLeft; + if( NEVER(op==TK_REGISTER) ) op = pExpr->op2; + + /* Compressed expressions only appear when parsing the DEFAULT clause + ** on a table column definition, and hence only when pCtx==0. This + ** check ensures that an EP_TokenOnly expression is never passed down + ** into valueFromFunction(). */ + assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 ); + + if( op==TK_CAST ){ + u8 aff = sqlite3AffinityType(pExpr->u.zToken,0); + rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx); + testcase( rc!=SQLITE_OK ); + if( *ppVal ){ + sqlite3VdbeMemCast(*ppVal, aff, SQLITE_UTF8); + sqlite3ValueApplyAffinity(*ppVal, affinity, SQLITE_UTF8); + } + return rc; + } + + /* Handle negative integers in a single step. This is needed in the + ** case when the value is -9223372036854775808. + */ + if( op==TK_UMINUS + && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){ + pExpr = pExpr->pLeft; + op = pExpr->op; + negInt = -1; + zNeg = "-"; + } + + if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){ + pVal = valueNew(db, pCtx); + if( pVal==0 ) goto no_mem; + if( ExprHasProperty(pExpr, EP_IntValue) ){ + sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt); + }else{ + zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken); + if( zVal==0 ) goto no_mem; + sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC); + } + if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_BLOB ){ + sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8); + }else{ + sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8); + } + if( pVal->flags & (MEM_Int|MEM_Real) ) pVal->flags &= ~MEM_Str; + if( enc!=SQLITE_UTF8 ){ + rc = sqlite3VdbeChangeEncoding(pVal, enc); + } + }else if( op==TK_UMINUS ) { + /* This branch happens for multiple negative signs. Ex: -(-5) */ + if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) + && pVal!=0 + ){ + sqlite3VdbeMemNumerify(pVal); + if( pVal->flags & MEM_Real ){ + pVal->u.r = -pVal->u.r; + }else if( pVal->u.i==SMALLEST_INT64 ){ + pVal->u.r = -(double)SMALLEST_INT64; + MemSetTypeFlag(pVal, MEM_Real); + }else{ + pVal->u.i = -pVal->u.i; + } + sqlite3ValueApplyAffinity(pVal, affinity, enc); + } + }else if( op==TK_NULL ){ + pVal = valueNew(db, pCtx); + if( pVal==0 ) goto no_mem; + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + else if( op==TK_BLOB ){ + int nVal; + assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' ); + assert( pExpr->u.zToken[1]=='\'' ); + pVal = valueNew(db, pCtx); + if( !pVal ) goto no_mem; + zVal = &pExpr->u.zToken[2]; + nVal = sqlite3Strlen30(zVal)-1; + assert( zVal[nVal]=='\'' ); + sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2, + 0, SQLITE_DYNAMIC); + } +#endif + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + else if( op==TK_FUNCTION && pCtx!=0 ){ + rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx); + } +#endif + + *ppVal = pVal; + return rc; + +no_mem: + db->mallocFailed = 1; + sqlite3DbFree(db, zVal); + assert( *ppVal==0 ); +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + if( pCtx==0 ) sqlite3ValueFree(pVal); +#else + assert( pCtx==0 ); sqlite3ValueFree(pVal); +#endif + return SQLITE_NOMEM; +} + +/* +** Create a new sqlite3_value object, containing the value of pExpr. +** +** This only works for very simple expressions that consist of one constant +** token (i.e. "5", "5.1", "'a string'"). If the expression can +** be converted directly into a value, then the value is allocated and +** a pointer written to *ppVal. The caller is responsible for deallocating +** the value by passing it to sqlite3ValueFree() later on. If the expression +** cannot be converted to a value, then *ppVal is set to NULL. +*/ +SQLITE_PRIVATE int sqlite3ValueFromExpr( + sqlite3 *db, /* The database connection */ + Expr *pExpr, /* The expression to evaluate */ + u8 enc, /* Encoding to use */ + u8 affinity, /* Affinity to use */ + sqlite3_value **ppVal /* Write the new value here */ +){ + return valueFromExpr(db, pExpr, enc, affinity, ppVal, 0); +} + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +/* +** The implementation of the sqlite_record() function. This function accepts +** a single argument of any type. The return value is a formatted database +** record (a blob) containing the argument value. +** +** This is used to convert the value stored in the 'sample' column of the +** sqlite_stat3 table to the record format SQLite uses internally. +*/ +static void recordFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const int file_format = 1; + int iSerial; /* Serial type */ + int nSerial; /* Bytes of space for iSerial as varint */ + int nVal; /* Bytes of space required for argv[0] */ + int nRet; + sqlite3 *db; + u8 *aRet; + + UNUSED_PARAMETER( argc ); + iSerial = sqlite3VdbeSerialType(argv[0], file_format); + nSerial = sqlite3VarintLen(iSerial); + nVal = sqlite3VdbeSerialTypeLen(iSerial); + db = sqlite3_context_db_handle(context); + + nRet = 1 + nSerial + nVal; + aRet = sqlite3DbMallocRaw(db, nRet); + if( aRet==0 ){ + sqlite3_result_error_nomem(context); + }else{ + aRet[0] = nSerial+1; + putVarint32(&aRet[1], iSerial); + sqlite3VdbeSerialPut(&aRet[1+nSerial], argv[0], iSerial); + sqlite3_result_blob(context, aRet, nRet, SQLITE_TRANSIENT); + sqlite3DbFree(db, aRet); + } +} + +/* +** Register built-in functions used to help read ANALYZE data. +*/ +SQLITE_PRIVATE void sqlite3AnalyzeFunctions(void){ + static SQLITE_WSD FuncDef aAnalyzeTableFuncs[] = { + FUNCTION(sqlite_record, 1, 0, 0, recordFunc), + }; + int i; + FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions); + FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aAnalyzeTableFuncs); + for(i=0; idb; + + /* Skip over any TK_COLLATE nodes */ + pExpr = sqlite3ExprSkipCollate(pExpr); + + if( !pExpr ){ + pVal = valueNew(db, pAlloc); + if( pVal ){ + sqlite3VdbeMemSetNull((Mem*)pVal); + } + }else if( pExpr->op==TK_VARIABLE + || NEVER(pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE) + ){ + Vdbe *v; + int iBindVar = pExpr->iColumn; + sqlite3VdbeSetVarmask(pParse->pVdbe, iBindVar); + if( (v = pParse->pReprepare)!=0 ){ + pVal = valueNew(db, pAlloc); + if( pVal ){ + rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]); + if( rc==SQLITE_OK ){ + sqlite3ValueApplyAffinity(pVal, affinity, ENC(db)); + } + pVal->db = pParse->db; + } + } + }else{ + rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc); + } + + assert( pVal==0 || pVal->db==db ); + *ppVal = pVal; + return rc; +} + +/* +** This function is used to allocate and populate UnpackedRecord +** structures intended to be compared against sample index keys stored +** in the sqlite_stat4 table. +** +** A single call to this function attempts to populates field iVal (leftmost +** is 0 etc.) of the unpacked record with a value extracted from expression +** pExpr. Extraction of values is possible if: +** +** * (pExpr==0). In this case the value is assumed to be an SQL NULL, +** +** * The expression is a bound variable, and this is a reprepare, or +** +** * The sqlite3ValueFromExpr() function is able to extract a value +** from the expression (i.e. the expression is a literal value). +** +** If a value can be extracted, the affinity passed as the 5th argument +** is applied to it before it is copied into the UnpackedRecord. Output +** parameter *pbOk is set to true if a value is extracted, or false +** otherwise. +** +** When this function is called, *ppRec must either point to an object +** allocated by an earlier call to this function, or must be NULL. If it +** is NULL and a value can be successfully extracted, a new UnpackedRecord +** is allocated (and *ppRec set to point to it) before returning. +** +** Unless an error is encountered, SQLITE_OK is returned. It is not an +** error if a value cannot be extracted from pExpr. If an error does +** occur, an SQLite error code is returned. +*/ +SQLITE_PRIVATE int sqlite3Stat4ProbeSetValue( + Parse *pParse, /* Parse context */ + Index *pIdx, /* Index being probed */ + UnpackedRecord **ppRec, /* IN/OUT: Probe record */ + Expr *pExpr, /* The expression to extract a value from */ + u8 affinity, /* Affinity to use */ + int iVal, /* Array element to populate */ + int *pbOk /* OUT: True if value was extracted */ +){ + int rc; + sqlite3_value *pVal = 0; + struct ValueNewStat4Ctx alloc; + + alloc.pParse = pParse; + alloc.pIdx = pIdx; + alloc.ppRec = ppRec; + alloc.iVal = iVal; + + rc = stat4ValueFromExpr(pParse, pExpr, affinity, &alloc, &pVal); + assert( pVal==0 || pVal->db==pParse->db ); + *pbOk = (pVal!=0); + return rc; +} + +/* +** Attempt to extract a value from expression pExpr using the methods +** as described for sqlite3Stat4ProbeSetValue() above. +** +** If successful, set *ppVal to point to a new value object and return +** SQLITE_OK. If no value can be extracted, but no other error occurs +** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error +** does occur, return an SQLite error code. The final value of *ppVal +** is undefined in this case. +*/ +SQLITE_PRIVATE int sqlite3Stat4ValueFromExpr( + Parse *pParse, /* Parse context */ + Expr *pExpr, /* The expression to extract a value from */ + u8 affinity, /* Affinity to use */ + sqlite3_value **ppVal /* OUT: New value object (or NULL) */ +){ + return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal); +} + +/* +** Extract the iCol-th column from the nRec-byte record in pRec. Write +** the column value into *ppVal. If *ppVal is initially NULL then a new +** sqlite3_value object is allocated. +** +** If *ppVal is initially NULL then the caller is responsible for +** ensuring that the value written into *ppVal is eventually freed. +*/ +SQLITE_PRIVATE int sqlite3Stat4Column( + sqlite3 *db, /* Database handle */ + const void *pRec, /* Pointer to buffer containing record */ + int nRec, /* Size of buffer pRec in bytes */ + int iCol, /* Column to extract */ + sqlite3_value **ppVal /* OUT: Extracted value */ +){ + u32 t; /* a column type code */ + int nHdr; /* Size of the header in the record */ + int iHdr; /* Next unread header byte */ + int iField; /* Next unread data byte */ + int szField; /* Size of the current data field */ + int i; /* Column index */ + u8 *a = (u8*)pRec; /* Typecast byte array */ + Mem *pMem = *ppVal; /* Write result into this Mem object */ + + assert( iCol>0 ); + iHdr = getVarint32(a, nHdr); + if( nHdr>nRec || iHdr>=nHdr ) return SQLITE_CORRUPT_BKPT; + iField = nHdr; + for(i=0; i<=iCol; i++){ + iHdr += getVarint32(&a[iHdr], t); + testcase( iHdr==nHdr ); + testcase( iHdr==nHdr+1 ); + if( iHdr>nHdr ) return SQLITE_CORRUPT_BKPT; + szField = sqlite3VdbeSerialTypeLen(t); + iField += szField; + } + testcase( iField==nRec ); + testcase( iField==nRec+1 ); + if( iField>nRec ) return SQLITE_CORRUPT_BKPT; + if( pMem==0 ){ + pMem = *ppVal = sqlite3ValueNew(db); + if( pMem==0 ) return SQLITE_NOMEM; + } + sqlite3VdbeSerialGet(&a[iField-szField], t, pMem); + pMem->enc = ENC(db); + return SQLITE_OK; +} + +/* +** Unless it is NULL, the argument must be an UnpackedRecord object returned +** by an earlier call to sqlite3Stat4ProbeSetValue(). This call deletes +** the object. +*/ +SQLITE_PRIVATE void sqlite3Stat4ProbeFree(UnpackedRecord *pRec){ + if( pRec ){ + int i; + int nCol = pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField; + Mem *aMem = pRec->aMem; + sqlite3 *db = aMem[0].db; + for(i=0; ipKeyInfo); + sqlite3DbFree(db, pRec); + } +} +#endif /* ifdef SQLITE_ENABLE_STAT4 */ + +/* +** Change the string value of an sqlite3_value object +*/ +SQLITE_PRIVATE void sqlite3ValueSetStr( + sqlite3_value *v, /* Value to be set */ + int n, /* Length of string z */ + const void *z, /* Text of the new string */ + u8 enc, /* Encoding to use */ + void (*xDel)(void*) /* Destructor for the string */ +){ + if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel); +} + +/* +** Free an sqlite3_value object +*/ +SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value *v){ + if( !v ) return; + sqlite3VdbeMemRelease((Mem *)v); + sqlite3DbFree(((Mem*)v)->db, v); +} + +/* +** The sqlite3ValueBytes() routine returns the number of bytes in the +** sqlite3_value object assuming that it uses the encoding "enc". +** The valueBytes() routine is a helper function. +*/ +static SQLITE_NOINLINE int valueBytes(sqlite3_value *pVal, u8 enc){ + return valueToText(pVal, enc)!=0 ? pVal->n : 0; +} +SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){ + Mem *p = (Mem*)pVal; + assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 ); + if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){ + return p->n; + } + if( (p->flags & MEM_Blob)!=0 ){ + if( p->flags & MEM_Zero ){ + return p->n + p->u.nZero; + }else{ + return p->n; + } + } + if( p->flags & MEM_Null ) return 0; + return valueBytes(pVal, enc); +} + +/************** End of vdbemem.c *********************************************/ +/************** Begin file vdbeaux.c *****************************************/ +/* +** 2003 September 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used for creating, destroying, and populating +** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.) +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* +** Create a new virtual database engine. +*/ +SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){ + sqlite3 *db = pParse->db; + Vdbe *p; + p = sqlite3DbMallocZero(db, sizeof(Vdbe) ); + if( p==0 ) return 0; + p->db = db; + if( db->pVdbe ){ + db->pVdbe->pPrev = p; + } + p->pNext = db->pVdbe; + p->pPrev = 0; + db->pVdbe = p; + p->magic = VDBE_MAGIC_INIT; + p->pParse = pParse; + assert( pParse->aLabel==0 ); + assert( pParse->nLabel==0 ); + assert( pParse->nOpAlloc==0 ); + return p; +} + +/* +** Change the error string stored in Vdbe.zErrMsg +*/ +SQLITE_PRIVATE void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){ + va_list ap; + sqlite3DbFree(p->db, p->zErrMsg); + va_start(ap, zFormat); + p->zErrMsg = sqlite3VMPrintf(p->db, zFormat, ap); + va_end(ap); +} + +/* +** Remember the SQL string for a prepared statement. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, int isPrepareV2){ + assert( isPrepareV2==1 || isPrepareV2==0 ); + if( p==0 ) return; +#if defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_ENABLE_SQLLOG) + if( !isPrepareV2 ) return; +#endif + assert( p->zSql==0 ); + p->zSql = sqlite3DbStrNDup(p->db, z, n); + p->isPrepareV2 = (u8)isPrepareV2; +} + +/* +** Return the SQL associated with a prepared statement +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_sql(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe *)pStmt; + return p ? p->zSql : 0; +} + +/* +** Swap all content between two VDBE structures. +*/ +SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){ + Vdbe tmp, *pTmp; + char *zTmp; + tmp = *pA; + *pA = *pB; + *pB = tmp; + pTmp = pA->pNext; + pA->pNext = pB->pNext; + pB->pNext = pTmp; + pTmp = pA->pPrev; + pA->pPrev = pB->pPrev; + pB->pPrev = pTmp; + zTmp = pA->zSql; + pA->zSql = pB->zSql; + pB->zSql = zTmp; + pB->isPrepareV2 = pA->isPrepareV2; +} + +/* +** Resize the Vdbe.aOp array so that it is at least nOp elements larger +** than its current size. nOp is guaranteed to be less than or equal +** to 1024/sizeof(Op). +** +** If an out-of-memory error occurs while resizing the array, return +** SQLITE_NOMEM. In this case Vdbe.aOp and Parse.nOpAlloc remain +** unchanged (this is so that any opcodes already allocated can be +** correctly deallocated along with the rest of the Vdbe). +*/ +static int growOpArray(Vdbe *v, int nOp){ + VdbeOp *pNew; + Parse *p = v->pParse; + + /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force + ** more frequent reallocs and hence provide more opportunities for + ** simulated OOM faults. SQLITE_TEST_REALLOC_STRESS is generally used + ** during testing only. With SQLITE_TEST_REALLOC_STRESS grow the op array + ** by the minimum* amount required until the size reaches 512. Normal + ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current + ** size of the op array or add 1KB of space, whichever is smaller. */ +#ifdef SQLITE_TEST_REALLOC_STRESS + int nNew = (p->nOpAlloc>=512 ? p->nOpAlloc*2 : p->nOpAlloc+nOp); +#else + int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op))); + UNUSED_PARAMETER(nOp); +#endif + + assert( nOp<=(1024/sizeof(Op)) ); + assert( nNew>=(p->nOpAlloc+nOp) ); + pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op)); + if( pNew ){ + p->nOpAlloc = sqlite3DbMallocSize(p->db, pNew)/sizeof(Op); + v->aOp = pNew; + } + return (pNew ? SQLITE_OK : SQLITE_NOMEM); +} + +#ifdef SQLITE_DEBUG +/* This routine is just a convenient place to set a breakpoint that will +** fire after each opcode is inserted and displayed using +** "PRAGMA vdbe_addoptrace=on". +*/ +static void test_addop_breakpoint(void){ + static int n = 0; + n++; +} +#endif + +/* +** Add a new instruction to the list of instructions current in the +** VDBE. Return the address of the new instruction. +** +** Parameters: +** +** p Pointer to the VDBE +** +** op The opcode for this instruction +** +** p1, p2, p3 Operands +** +** Use the sqlite3VdbeResolveLabel() function to fix an address and +** the sqlite3VdbeChangeP4() function to change the value of the P4 +** operand. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){ + int i; + VdbeOp *pOp; + + i = p->nOp; + assert( p->magic==VDBE_MAGIC_INIT ); + assert( op>0 && op<0xff ); + if( p->pParse->nOpAlloc<=i ){ + if( growOpArray(p, 1) ){ + return 1; + } + } + p->nOp++; + pOp = &p->aOp[i]; + pOp->opcode = (u8)op; + pOp->p5 = 0; + pOp->p1 = p1; + pOp->p2 = p2; + pOp->p3 = p3; + pOp->p4.p = 0; + pOp->p4type = P4_NOTUSED; +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + pOp->zComment = 0; +#endif +#ifdef SQLITE_DEBUG + if( p->db->flags & SQLITE_VdbeAddopTrace ){ + int jj, kk; + Parse *pParse = p->pParse; + for(jj=kk=0; jjaColCache + jj; + if( x->iLevel>pParse->iCacheLevel || x->iReg==0 ) continue; + printf(" r[%d]={%d:%d}", x->iReg, x->iTable, x->iColumn); + kk++; + } + if( kk ) printf("\n"); + sqlite3VdbePrintOp(0, i, &p->aOp[i]); + test_addop_breakpoint(); + } +#endif +#ifdef VDBE_PROFILE + pOp->cycles = 0; + pOp->cnt = 0; +#endif +#ifdef SQLITE_VDBE_COVERAGE + pOp->iSrcLine = 0; +#endif + return i; +} +SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){ + return sqlite3VdbeAddOp3(p, op, 0, 0, 0); +} +SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){ + return sqlite3VdbeAddOp3(p, op, p1, 0, 0); +} +SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){ + return sqlite3VdbeAddOp3(p, op, p1, p2, 0); +} + +/* Generate code for an unconditional jump to instruction iDest +*/ +SQLITE_PRIVATE int sqlite3VdbeGoto(Vdbe *p, int iDest){ + return sqlite3VdbeAddOp3(p, OP_Goto, 0, iDest, 0); +} + +/* Generate code to cause the string zStr to be loaded into +** register iDest +*/ +SQLITE_PRIVATE int sqlite3VdbeLoadString(Vdbe *p, int iDest, const char *zStr){ + return sqlite3VdbeAddOp4(p, OP_String8, 0, iDest, 0, zStr, 0); +} + +/* +** Generate code that initializes multiple registers to string or integer +** constants. The registers begin with iDest and increase consecutively. +** One register is initialized for each characgter in zTypes[]. For each +** "s" character in zTypes[], the register is a string if the argument is +** not NULL, or OP_Null if the value is a null pointer. For each "i" character +** in zTypes[], the register is initialized to an integer. +*/ +SQLITE_PRIVATE void sqlite3VdbeMultiLoad(Vdbe *p, int iDest, const char *zTypes, ...){ + va_list ap; + int i; + char c; + va_start(ap, zTypes); + for(i=0; (c = zTypes[i])!=0; i++){ + if( c=='s' ){ + const char *z = va_arg(ap, const char*); + int addr = sqlite3VdbeAddOp2(p, z==0 ? OP_Null : OP_String8, 0, iDest++); + if( z ) sqlite3VdbeChangeP4(p, addr, z, 0); + }else{ + assert( c=='i' ); + sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest++); + } + } + va_end(ap); +} + +/* +** Add an opcode that includes the p4 value as a pointer. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOp4( + Vdbe *p, /* Add the opcode to this VM */ + int op, /* The new opcode */ + int p1, /* The P1 operand */ + int p2, /* The P2 operand */ + int p3, /* The P3 operand */ + const char *zP4, /* The P4 operand */ + int p4type /* P4 operand type */ +){ + int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3); + sqlite3VdbeChangeP4(p, addr, zP4, p4type); + return addr; +} + +/* +** Add an opcode that includes the p4 value with a P4_INT64 or +** P4_REAL type. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8( + Vdbe *p, /* Add the opcode to this VM */ + int op, /* The new opcode */ + int p1, /* The P1 operand */ + int p2, /* The P2 operand */ + int p3, /* The P3 operand */ + const u8 *zP4, /* The P4 operand */ + int p4type /* P4 operand type */ +){ + char *p4copy = sqlite3DbMallocRaw(sqlite3VdbeDb(p), 8); + if( p4copy ) memcpy(p4copy, zP4, 8); + return sqlite3VdbeAddOp4(p, op, p1, p2, p3, p4copy, p4type); +} + +/* +** Add an OP_ParseSchema opcode. This routine is broken out from +** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees +** as having been used. +** +** The zWhere string must have been obtained from sqlite3_malloc(). +** This routine will take ownership of the allocated memory. +*/ +SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){ + int j; + int addr = sqlite3VdbeAddOp3(p, OP_ParseSchema, iDb, 0, 0); + sqlite3VdbeChangeP4(p, addr, zWhere, P4_DYNAMIC); + for(j=0; jdb->nDb; j++) sqlite3VdbeUsesBtree(p, j); +} + +/* +** Add an opcode that includes the p4 value as an integer. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOp4Int( + Vdbe *p, /* Add the opcode to this VM */ + int op, /* The new opcode */ + int p1, /* The P1 operand */ + int p2, /* The P2 operand */ + int p3, /* The P3 operand */ + int p4 /* The P4 operand as an integer */ +){ + int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3); + sqlite3VdbeChangeP4(p, addr, SQLITE_INT_TO_PTR(p4), P4_INT32); + return addr; +} + +/* +** Create a new symbolic label for an instruction that has yet to be +** coded. The symbolic label is really just a negative number. The +** label can be used as the P2 value of an operation. Later, when +** the label is resolved to a specific address, the VDBE will scan +** through its operation list and change all values of P2 which match +** the label into the resolved address. +** +** The VDBE knows that a P2 value is a label because labels are +** always negative and P2 values are suppose to be non-negative. +** Hence, a negative P2 value is a label that has yet to be resolved. +** +** Zero is returned if a malloc() fails. +*/ +SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe *v){ + Parse *p = v->pParse; + int i = p->nLabel++; + assert( v->magic==VDBE_MAGIC_INIT ); + if( (i & (i-1))==0 ){ + p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel, + (i*2+1)*sizeof(p->aLabel[0])); + } + if( p->aLabel ){ + p->aLabel[i] = -1; + } + return -1-i; +} + +/* +** Resolve label "x" to be the address of the next instruction to +** be inserted. The parameter "x" must have been obtained from +** a prior call to sqlite3VdbeMakeLabel(). +*/ +SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *v, int x){ + Parse *p = v->pParse; + int j = -1-x; + assert( v->magic==VDBE_MAGIC_INIT ); + assert( jnLabel ); + assert( j>=0 ); + if( p->aLabel ){ + p->aLabel[j] = v->nOp; + } + p->iFixedOp = v->nOp - 1; +} + +/* +** Mark the VDBE as one that can only be run one time. +*/ +SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe *p){ + p->runOnlyOnce = 1; +} + +#ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */ + +/* +** The following type and function are used to iterate through all opcodes +** in a Vdbe main program and each of the sub-programs (triggers) it may +** invoke directly or indirectly. It should be used as follows: +** +** Op *pOp; +** VdbeOpIter sIter; +** +** memset(&sIter, 0, sizeof(sIter)); +** sIter.v = v; // v is of type Vdbe* +** while( (pOp = opIterNext(&sIter)) ){ +** // Do something with pOp +** } +** sqlite3DbFree(v->db, sIter.apSub); +** +*/ +typedef struct VdbeOpIter VdbeOpIter; +struct VdbeOpIter { + Vdbe *v; /* Vdbe to iterate through the opcodes of */ + SubProgram **apSub; /* Array of subprograms */ + int nSub; /* Number of entries in apSub */ + int iAddr; /* Address of next instruction to return */ + int iSub; /* 0 = main program, 1 = first sub-program etc. */ +}; +static Op *opIterNext(VdbeOpIter *p){ + Vdbe *v = p->v; + Op *pRet = 0; + Op *aOp; + int nOp; + + if( p->iSub<=p->nSub ){ + + if( p->iSub==0 ){ + aOp = v->aOp; + nOp = v->nOp; + }else{ + aOp = p->apSub[p->iSub-1]->aOp; + nOp = p->apSub[p->iSub-1]->nOp; + } + assert( p->iAddriAddr]; + p->iAddr++; + if( p->iAddr==nOp ){ + p->iSub++; + p->iAddr = 0; + } + + if( pRet->p4type==P4_SUBPROGRAM ){ + int nByte = (p->nSub+1)*sizeof(SubProgram*); + int j; + for(j=0; jnSub; j++){ + if( p->apSub[j]==pRet->p4.pProgram ) break; + } + if( j==p->nSub ){ + p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte); + if( !p->apSub ){ + pRet = 0; + }else{ + p->apSub[p->nSub++] = pRet->p4.pProgram; + } + } + } + } + + return pRet; +} + +/* +** Check if the program stored in the VM associated with pParse may +** throw an ABORT exception (causing the statement, but not entire transaction +** to be rolled back). This condition is true if the main program or any +** sub-programs contains any of the following: +** +** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort. +** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort. +** * OP_Destroy +** * OP_VUpdate +** * OP_VRename +** * OP_FkCounter with P2==0 (immediate foreign key constraint) +** * OP_CreateTable and OP_InitCoroutine (for CREATE TABLE AS SELECT ...) +** +** Then check that the value of Parse.mayAbort is true if an +** ABORT may be thrown, or false otherwise. Return true if it does +** match, or false otherwise. This function is intended to be used as +** part of an assert statement in the compiler. Similar to: +** +** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) ); +*/ +SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){ + int hasAbort = 0; + int hasFkCounter = 0; + int hasCreateTable = 0; + int hasInitCoroutine = 0; + Op *pOp; + VdbeOpIter sIter; + memset(&sIter, 0, sizeof(sIter)); + sIter.v = v; + + while( (pOp = opIterNext(&sIter))!=0 ){ + int opcode = pOp->opcode; + if( opcode==OP_Destroy || opcode==OP_VUpdate || opcode==OP_VRename + || ((opcode==OP_Halt || opcode==OP_HaltIfNull) + && ((pOp->p1&0xff)==SQLITE_CONSTRAINT && pOp->p2==OE_Abort)) + ){ + hasAbort = 1; + break; + } + if( opcode==OP_CreateTable ) hasCreateTable = 1; + if( opcode==OP_InitCoroutine ) hasInitCoroutine = 1; +#ifndef SQLITE_OMIT_FOREIGN_KEY + if( opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1 ){ + hasFkCounter = 1; + } +#endif + } + sqlite3DbFree(v->db, sIter.apSub); + + /* Return true if hasAbort==mayAbort. Or if a malloc failure occurred. + ** If malloc failed, then the while() loop above may not have iterated + ** through all opcodes and hasAbort may be set incorrectly. Return + ** true for this case to prevent the assert() in the callers frame + ** from failing. */ + return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter + || (hasCreateTable && hasInitCoroutine) ); +} +#endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */ + +/* +** This routine is called after all opcodes have been inserted. It loops +** through all the opcodes and fixes up some details. +** +** (1) For each jump instruction with a negative P2 value (a label) +** resolve the P2 value to an actual address. +** +** (2) Compute the maximum number of arguments used by any SQL function +** and store that value in *pMaxFuncArgs. +** +** (3) Update the Vdbe.readOnly and Vdbe.bIsReader flags to accurately +** indicate what the prepared statement actually does. +** +** (4) Initialize the p4.xAdvance pointer on opcodes that use it. +** +** (5) Reclaim the memory allocated for storing labels. +*/ +static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){ + int i; + int nMaxArgs = *pMaxFuncArgs; + Op *pOp; + Parse *pParse = p->pParse; + int *aLabel = pParse->aLabel; + p->readOnly = 1; + p->bIsReader = 0; + for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){ + u8 opcode = pOp->opcode; + + /* NOTE: Be sure to update mkopcodeh.awk when adding or removing + ** cases from this switch! */ + switch( opcode ){ + case OP_Transaction: { + if( pOp->p2!=0 ) p->readOnly = 0; + /* fall thru */ + } + case OP_AutoCommit: + case OP_Savepoint: { + p->bIsReader = 1; + break; + } +#ifndef SQLITE_OMIT_WAL + case OP_Checkpoint: +#endif + case OP_Vacuum: + case OP_JournalMode: { + p->readOnly = 0; + p->bIsReader = 1; + break; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + case OP_VUpdate: { + if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2; + break; + } + case OP_VFilter: { + int n; + assert( p->nOp - i >= 3 ); + assert( pOp[-1].opcode==OP_Integer ); + n = pOp[-1].p1; + if( n>nMaxArgs ) nMaxArgs = n; + break; + } +#endif + case OP_Next: + case OP_NextIfOpen: + case OP_SorterNext: { + pOp->p4.xAdvance = sqlite3BtreeNext; + pOp->p4type = P4_ADVANCE; + break; + } + case OP_Prev: + case OP_PrevIfOpen: { + pOp->p4.xAdvance = sqlite3BtreePrevious; + pOp->p4type = P4_ADVANCE; + break; + } + } + + pOp->opflags = sqlite3OpcodeProperty[opcode]; + if( (pOp->opflags & OPFLG_JUMP)!=0 && pOp->p2<0 ){ + assert( -1-pOp->p2nLabel ); + pOp->p2 = aLabel[-1-pOp->p2]; + } + } + sqlite3DbFree(p->db, pParse->aLabel); + pParse->aLabel = 0; + pParse->nLabel = 0; + *pMaxFuncArgs = nMaxArgs; + assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) ); +} + +/* +** Return the address of the next instruction to be inserted. +*/ +SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe *p){ + assert( p->magic==VDBE_MAGIC_INIT ); + return p->nOp; +} + +/* +** This function returns a pointer to the array of opcodes associated with +** the Vdbe passed as the first argument. It is the callers responsibility +** to arrange for the returned array to be eventually freed using the +** vdbeFreeOpArray() function. +** +** Before returning, *pnOp is set to the number of entries in the returned +** array. Also, *pnMaxArg is set to the larger of its current value and +** the number of entries in the Vdbe.apArg[] array required to execute the +** returned program. +*/ +SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg){ + VdbeOp *aOp = p->aOp; + assert( aOp && !p->db->mallocFailed ); + + /* Check that sqlite3VdbeUsesBtree() was not called on this VM */ + assert( DbMaskAllZero(p->btreeMask) ); + + resolveP2Values(p, pnMaxArg); + *pnOp = p->nOp; + p->aOp = 0; + return aOp; +} + +/* +** Add a whole list of operations to the operation stack. Return the +** address of the first operation added. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp, int iLineno){ + int addr, i; + VdbeOp *pOut; + assert( nOp>0 ); + assert( p->magic==VDBE_MAGIC_INIT ); + if( p->nOp + nOp > p->pParse->nOpAlloc && growOpArray(p, nOp) ){ + return 0; + } + addr = p->nOp; + pOut = &p->aOp[addr]; + for(i=0; ip2; + pOut->opcode = aOp->opcode; + pOut->p1 = aOp->p1; + if( p2<0 ){ + assert( sqlite3OpcodeProperty[pOut->opcode] & OPFLG_JUMP ); + pOut->p2 = addr + ADDR(p2); + }else{ + pOut->p2 = p2; + } + pOut->p3 = aOp->p3; + pOut->p4type = P4_NOTUSED; + pOut->p4.p = 0; + pOut->p5 = 0; +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + pOut->zComment = 0; +#endif +#ifdef SQLITE_VDBE_COVERAGE + pOut->iSrcLine = iLineno+i; +#else + (void)iLineno; +#endif +#ifdef SQLITE_DEBUG + if( p->db->flags & SQLITE_VdbeAddopTrace ){ + sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]); + } +#endif + } + p->nOp += nOp; + return addr; +} + +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) +/* +** Add an entry to the array of counters managed by sqlite3_stmt_scanstatus(). +*/ +SQLITE_PRIVATE void sqlite3VdbeScanStatus( + Vdbe *p, /* VM to add scanstatus() to */ + int addrExplain, /* Address of OP_Explain (or 0) */ + int addrLoop, /* Address of loop counter */ + int addrVisit, /* Address of rows visited counter */ + LogEst nEst, /* Estimated number of output rows */ + const char *zName /* Name of table or index being scanned */ +){ + int nByte = (p->nScan+1) * sizeof(ScanStatus); + ScanStatus *aNew; + aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte); + if( aNew ){ + ScanStatus *pNew = &aNew[p->nScan++]; + pNew->addrExplain = addrExplain; + pNew->addrLoop = addrLoop; + pNew->addrVisit = addrVisit; + pNew->nEst = nEst; + pNew->zName = sqlite3DbStrDup(p->db, zName); + p->aScan = aNew; + } +} +#endif + + +/* +** Change the value of the opcode, or P1, P2, P3, or P5 operands +** for a specific instruction. +*/ +SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe *p, u32 addr, u8 iNewOpcode){ + sqlite3VdbeGetOp(p,addr)->opcode = iNewOpcode; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, u32 addr, int val){ + sqlite3VdbeGetOp(p,addr)->p1 = val; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, u32 addr, int val){ + sqlite3VdbeGetOp(p,addr)->p2 = val; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, u32 addr, int val){ + sqlite3VdbeGetOp(p,addr)->p3 = val; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u8 p5){ + sqlite3VdbeGetOp(p,-1)->p5 = p5; +} + +/* +** Change the P2 operand of instruction addr so that it points to +** the address of the next instruction to be coded. +*/ +SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe *p, int addr){ + p->pParse->iFixedOp = p->nOp - 1; + sqlite3VdbeChangeP2(p, addr, p->nOp); +} + + +/* +** If the input FuncDef structure is ephemeral, then free it. If +** the FuncDef is not ephermal, then do nothing. +*/ +static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){ + if( ALWAYS(pDef) && (pDef->funcFlags & SQLITE_FUNC_EPHEM)!=0 ){ + sqlite3DbFree(db, pDef); + } +} + +static void vdbeFreeOpArray(sqlite3 *, Op *, int); + +/* +** Delete a P4 value if necessary. +*/ +static void freeP4(sqlite3 *db, int p4type, void *p4){ + if( p4 ){ + assert( db ); + switch( p4type ){ + case P4_FUNCCTX: { + freeEphemeralFunction(db, ((sqlite3_context*)p4)->pFunc); + /* Fall through into the next case */ + } + case P4_REAL: + case P4_INT64: + case P4_DYNAMIC: + case P4_INTARRAY: { + sqlite3DbFree(db, p4); + break; + } + case P4_KEYINFO: { + if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4); + break; + } + case P4_MPRINTF: { + if( db->pnBytesFreed==0 ) sqlite3_free(p4); + break; + } + case P4_FUNCDEF: { + freeEphemeralFunction(db, (FuncDef*)p4); + break; + } + case P4_MEM: { + if( db->pnBytesFreed==0 ){ + sqlite3ValueFree((sqlite3_value*)p4); + }else{ + Mem *p = (Mem*)p4; + if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc); + sqlite3DbFree(db, p); + } + break; + } + case P4_VTAB : { + if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4); + break; + } + } + } +} + +/* +** Free the space allocated for aOp and any p4 values allocated for the +** opcodes contained within. If aOp is not NULL it is assumed to contain +** nOp entries. +*/ +static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){ + if( aOp ){ + Op *pOp; + for(pOp=aOp; pOp<&aOp[nOp]; pOp++){ + freeP4(db, pOp->p4type, pOp->p4.p); +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + sqlite3DbFree(db, pOp->zComment); +#endif + } + } + sqlite3DbFree(db, aOp); +} + +/* +** Link the SubProgram object passed as the second argument into the linked +** list at Vdbe.pSubProgram. This list is used to delete all sub-program +** objects when the VM is no longer required. +*/ +SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){ + p->pNext = pVdbe->pProgram; + pVdbe->pProgram = p; +} + +/* +** Change the opcode at addr into OP_Noop +*/ +SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){ + if( addrnOp ){ + VdbeOp *pOp = &p->aOp[addr]; + sqlite3 *db = p->db; + freeP4(db, pOp->p4type, pOp->p4.p); + memset(pOp, 0, sizeof(pOp[0])); + pOp->opcode = OP_Noop; + if( addr==p->nOp-1 ) p->nOp--; + } +} + +/* +** If the last opcode is "op" and it is not a jump destination, +** then remove it. Return true if and only if an opcode was removed. +*/ +SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){ + if( (p->nOp-1)>(p->pParse->iFixedOp) && p->aOp[p->nOp-1].opcode==op ){ + sqlite3VdbeChangeToNoop(p, p->nOp-1); + return 1; + }else{ + return 0; + } +} + +/* +** Change the value of the P4 operand for a specific instruction. +** This routine is useful when a large program is loaded from a +** static array using sqlite3VdbeAddOpList but we want to make a +** few minor changes to the program. +** +** If n>=0 then the P4 operand is dynamic, meaning that a copy of +** the string is made into memory obtained from sqlite3_malloc(). +** A value of n==0 means copy bytes of zP4 up to and including the +** first null byte. If n>0 then copy n+1 bytes of zP4. +** +** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points +** to a string or structure that is guaranteed to exist for the lifetime of +** the Vdbe. In these cases we can just copy the pointer. +** +** If addr<0 then change P4 on the most recently inserted instruction. +*/ +SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){ + Op *pOp; + sqlite3 *db; + assert( p!=0 ); + db = p->db; + assert( p->magic==VDBE_MAGIC_INIT ); + if( p->aOp==0 || db->mallocFailed ){ + if( n!=P4_VTAB ){ + freeP4(db, n, (void*)*(char**)&zP4); + } + return; + } + assert( p->nOp>0 ); + assert( addrnOp ); + if( addr<0 ){ + addr = p->nOp - 1; + } + pOp = &p->aOp[addr]; + assert( pOp->p4type==P4_NOTUSED + || pOp->p4type==P4_INT32 + || pOp->p4type==P4_KEYINFO ); + freeP4(db, pOp->p4type, pOp->p4.p); + pOp->p4.p = 0; + if( n==P4_INT32 ){ + /* Note: this cast is safe, because the origin data point was an int + ** that was cast to a (const char *). */ + pOp->p4.i = SQLITE_PTR_TO_INT(zP4); + pOp->p4type = P4_INT32; + }else if( zP4==0 ){ + pOp->p4.p = 0; + pOp->p4type = P4_NOTUSED; + }else if( n==P4_KEYINFO ){ + pOp->p4.p = (void*)zP4; + pOp->p4type = P4_KEYINFO; + }else if( n==P4_VTAB ){ + pOp->p4.p = (void*)zP4; + pOp->p4type = P4_VTAB; + sqlite3VtabLock((VTable *)zP4); + assert( ((VTable *)zP4)->db==p->db ); + }else if( n<0 ){ + pOp->p4.p = (void*)zP4; + pOp->p4type = (signed char)n; + }else{ + if( n==0 ) n = sqlite3Strlen30(zP4); + pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n); + pOp->p4type = P4_DYNAMIC; + } +} + +/* +** Set the P4 on the most recently added opcode to the KeyInfo for the +** index given. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){ + Vdbe *v = pParse->pVdbe; + assert( v!=0 ); + assert( pIdx!=0 ); + sqlite3VdbeChangeP4(v, -1, (char*)sqlite3KeyInfoOfIndex(pParse, pIdx), + P4_KEYINFO); +} + +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +/* +** Change the comment on the most recently coded instruction. Or +** insert a No-op and add the comment to that new instruction. This +** makes the code easier to read during debugging. None of this happens +** in a production build. +*/ +static void vdbeVComment(Vdbe *p, const char *zFormat, va_list ap){ + assert( p->nOp>0 || p->aOp==0 ); + assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed ); + if( p->nOp ){ + assert( p->aOp ); + sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment); + p->aOp[p->nOp-1].zComment = sqlite3VMPrintf(p->db, zFormat, ap); + } +} +SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){ + va_list ap; + if( p ){ + va_start(ap, zFormat); + vdbeVComment(p, zFormat, ap); + va_end(ap); + } +} +SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){ + va_list ap; + if( p ){ + sqlite3VdbeAddOp0(p, OP_Noop); + va_start(ap, zFormat); + vdbeVComment(p, zFormat, ap); + va_end(ap); + } +} +#endif /* NDEBUG */ + +#ifdef SQLITE_VDBE_COVERAGE +/* +** Set the value if the iSrcLine field for the previously coded instruction. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetLineNumber(Vdbe *v, int iLine){ + sqlite3VdbeGetOp(v,-1)->iSrcLine = iLine; +} +#endif /* SQLITE_VDBE_COVERAGE */ + +/* +** Return the opcode for a given address. If the address is -1, then +** return the most recently inserted opcode. +** +** If a memory allocation error has occurred prior to the calling of this +** routine, then a pointer to a dummy VdbeOp will be returned. That opcode +** is readable but not writable, though it is cast to a writable value. +** The return of a dummy opcode allows the call to continue functioning +** after an OOM fault without having to check to see if the return from +** this routine is a valid pointer. But because the dummy.opcode is 0, +** dummy will never be written to. This is verified by code inspection and +** by running with Valgrind. +*/ +SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){ + /* C89 specifies that the constant "dummy" will be initialized to all + ** zeros, which is correct. MSVC generates a warning, nevertheless. */ + static VdbeOp dummy; /* Ignore the MSVC warning about no initializer */ + assert( p->magic==VDBE_MAGIC_INIT ); + if( addr<0 ){ + addr = p->nOp - 1; + } + assert( (addr>=0 && addrnOp) || p->db->mallocFailed ); + if( p->db->mallocFailed ){ + return (VdbeOp*)&dummy; + }else{ + return &p->aOp[addr]; + } +} + +#if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) +/* +** Return an integer value for one of the parameters to the opcode pOp +** determined by character c. +*/ +static int translateP(char c, const Op *pOp){ + if( c=='1' ) return pOp->p1; + if( c=='2' ) return pOp->p2; + if( c=='3' ) return pOp->p3; + if( c=='4' ) return pOp->p4.i; + return pOp->p5; +} + +/* +** Compute a string for the "comment" field of a VDBE opcode listing. +** +** The Synopsis: field in comments in the vdbe.c source file gets converted +** to an extra string that is appended to the sqlite3OpcodeName(). In the +** absence of other comments, this synopsis becomes the comment on the opcode. +** Some translation occurs: +** +** "PX" -> "r[X]" +** "PX@PY" -> "r[X..X+Y-1]" or "r[x]" if y is 0 or 1 +** "PX@PY+1" -> "r[X..X+Y]" or "r[x]" if y is 0 +** "PY..PY" -> "r[X..Y]" or "r[x]" if y<=x +*/ +static int displayComment( + const Op *pOp, /* The opcode to be commented */ + const char *zP4, /* Previously obtained value for P4 */ + char *zTemp, /* Write result here */ + int nTemp /* Space available in zTemp[] */ +){ + const char *zOpName; + const char *zSynopsis; + int nOpName; + int ii, jj; + zOpName = sqlite3OpcodeName(pOp->opcode); + nOpName = sqlite3Strlen30(zOpName); + if( zOpName[nOpName+1] ){ + int seenCom = 0; + char c; + zSynopsis = zOpName += nOpName + 1; + for(ii=jj=0; jjzComment); + seenCom = 1; + }else{ + int v1 = translateP(c, pOp); + int v2; + sqlite3_snprintf(nTemp-jj, zTemp+jj, "%d", v1); + if( strncmp(zSynopsis+ii+1, "@P", 2)==0 ){ + ii += 3; + jj += sqlite3Strlen30(zTemp+jj); + v2 = translateP(zSynopsis[ii], pOp); + if( strncmp(zSynopsis+ii+1,"+1",2)==0 ){ + ii += 2; + v2++; + } + if( v2>1 ){ + sqlite3_snprintf(nTemp-jj, zTemp+jj, "..%d", v1+v2-1); + } + }else if( strncmp(zSynopsis+ii+1, "..P3", 4)==0 && pOp->p3==0 ){ + ii += 4; + } + } + jj += sqlite3Strlen30(zTemp+jj); + }else{ + zTemp[jj++] = c; + } + } + if( !seenCom && jjzComment ){ + sqlite3_snprintf(nTemp-jj, zTemp+jj, "; %s", pOp->zComment); + jj += sqlite3Strlen30(zTemp+jj); + } + if( jjzComment ){ + sqlite3_snprintf(nTemp, zTemp, "%s", pOp->zComment); + jj = sqlite3Strlen30(zTemp); + }else{ + zTemp[0] = 0; + jj = 0; + } + return jj; +} +#endif /* SQLITE_DEBUG */ + + +#if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \ + || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) +/* +** Compute a string that describes the P4 parameter for an opcode. +** Use zTemp for any required temporary buffer space. +*/ +static char *displayP4(Op *pOp, char *zTemp, int nTemp){ + char *zP4 = zTemp; + assert( nTemp>=20 ); + switch( pOp->p4type ){ + case P4_KEYINFO: { + int i, j; + KeyInfo *pKeyInfo = pOp->p4.pKeyInfo; + assert( pKeyInfo->aSortOrder!=0 ); + sqlite3_snprintf(nTemp, zTemp, "k(%d", pKeyInfo->nField); + i = sqlite3Strlen30(zTemp); + for(j=0; jnField; j++){ + CollSeq *pColl = pKeyInfo->aColl[j]; + const char *zColl = pColl ? pColl->zName : "nil"; + int n = sqlite3Strlen30(zColl); + if( n==6 && memcmp(zColl,"BINARY",6)==0 ){ + zColl = "B"; + n = 1; + } + if( i+n>nTemp-7 ){ + memcpy(&zTemp[i],",...",4); + i += 4; + break; + } + zTemp[i++] = ','; + if( pKeyInfo->aSortOrder[j] ){ + zTemp[i++] = '-'; + } + memcpy(&zTemp[i], zColl, n+1); + i += n; + } + zTemp[i++] = ')'; + zTemp[i] = 0; + assert( ip4.pColl; + sqlite3_snprintf(nTemp, zTemp, "(%.20s)", pColl->zName); + break; + } + case P4_FUNCDEF: { + FuncDef *pDef = pOp->p4.pFunc; + sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg); + break; + } +#ifdef SQLITE_DEBUG + case P4_FUNCCTX: { + FuncDef *pDef = pOp->p4.pCtx->pFunc; + sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg); + break; + } +#endif + case P4_INT64: { + sqlite3_snprintf(nTemp, zTemp, "%lld", *pOp->p4.pI64); + break; + } + case P4_INT32: { + sqlite3_snprintf(nTemp, zTemp, "%d", pOp->p4.i); + break; + } + case P4_REAL: { + sqlite3_snprintf(nTemp, zTemp, "%.16g", *pOp->p4.pReal); + break; + } + case P4_MEM: { + Mem *pMem = pOp->p4.pMem; + if( pMem->flags & MEM_Str ){ + zP4 = pMem->z; + }else if( pMem->flags & MEM_Int ){ + sqlite3_snprintf(nTemp, zTemp, "%lld", pMem->u.i); + }else if( pMem->flags & MEM_Real ){ + sqlite3_snprintf(nTemp, zTemp, "%.16g", pMem->u.r); + }else if( pMem->flags & MEM_Null ){ + sqlite3_snprintf(nTemp, zTemp, "NULL"); + }else{ + assert( pMem->flags & MEM_Blob ); + zP4 = "(blob)"; + } + break; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + case P4_VTAB: { + sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab; + sqlite3_snprintf(nTemp, zTemp, "vtab:%p", pVtab); + break; + } +#endif + case P4_INTARRAY: { + sqlite3_snprintf(nTemp, zTemp, "intarray"); + break; + } + case P4_SUBPROGRAM: { + sqlite3_snprintf(nTemp, zTemp, "program"); + break; + } + case P4_ADVANCE: { + zTemp[0] = 0; + break; + } + default: { + zP4 = pOp->p4.z; + if( zP4==0 ){ + zP4 = zTemp; + zTemp[0] = 0; + } + } + } + assert( zP4!=0 ); + return zP4; +} +#endif + +/* +** Declare to the Vdbe that the BTree object at db->aDb[i] is used. +** +** The prepared statements need to know in advance the complete set of +** attached databases that will be use. A mask of these databases +** is maintained in p->btreeMask. The p->lockMask value is the subset of +** p->btreeMask of databases that will require a lock. +*/ +SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){ + assert( i>=0 && idb->nDb && i<(int)sizeof(yDbMask)*8 ); + assert( i<(int)sizeof(p->btreeMask)*8 ); + DbMaskSet(p->btreeMask, i); + if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){ + DbMaskSet(p->lockMask, i); + } +} + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0 +/* +** If SQLite is compiled to support shared-cache mode and to be threadsafe, +** this routine obtains the mutex associated with each BtShared structure +** that may be accessed by the VM passed as an argument. In doing so it also +** sets the BtShared.db member of each of the BtShared structures, ensuring +** that the correct busy-handler callback is invoked if required. +** +** If SQLite is not threadsafe but does support shared-cache mode, then +** sqlite3BtreeEnter() is invoked to set the BtShared.db variables +** of all of BtShared structures accessible via the database handle +** associated with the VM. +** +** If SQLite is not threadsafe and does not support shared-cache mode, this +** function is a no-op. +** +** The p->btreeMask field is a bitmask of all btrees that the prepared +** statement p will ever use. Let N be the number of bits in p->btreeMask +** corresponding to btrees that use shared cache. Then the runtime of +** this routine is N*N. But as N is rarely more than 1, this should not +** be a problem. +*/ +SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){ + int i; + sqlite3 *db; + Db *aDb; + int nDb; + if( DbMaskAllZero(p->lockMask) ) return; /* The common case */ + db = p->db; + aDb = db->aDb; + nDb = db->nDb; + for(i=0; ilockMask,i) && ALWAYS(aDb[i].pBt!=0) ){ + sqlite3BtreeEnter(aDb[i].pBt); + } + } +} +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0 +/* +** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter(). +*/ +static SQLITE_NOINLINE void vdbeLeave(Vdbe *p){ + int i; + sqlite3 *db; + Db *aDb; + int nDb; + db = p->db; + aDb = db->aDb; + nDb = db->nDb; + for(i=0; ilockMask,i) && ALWAYS(aDb[i].pBt!=0) ){ + sqlite3BtreeLeave(aDb[i].pBt); + } + } +} +SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe *p){ + if( DbMaskAllZero(p->lockMask) ) return; /* The common case */ + vdbeLeave(p); +} +#endif + +#if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) +/* +** Print a single opcode. This routine is used for debugging only. +*/ +SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){ + char *zP4; + char zPtr[50]; + char zCom[100]; + static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-13s %.2X %s\n"; + if( pOut==0 ) pOut = stdout; + zP4 = displayP4(pOp, zPtr, sizeof(zPtr)); +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + displayComment(pOp, zP4, zCom, sizeof(zCom)); +#else + zCom[0] = 0; +#endif + /* NB: The sqlite3OpcodeName() function is implemented by code created + ** by the mkopcodeh.awk and mkopcodec.awk scripts which extract the + ** information from the vdbe.c source text */ + fprintf(pOut, zFormat1, pc, + sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5, + zCom + ); + fflush(pOut); +} +#endif + +/* +** Release an array of N Mem elements +*/ +static void releaseMemArray(Mem *p, int N){ + if( p && N ){ + Mem *pEnd = &p[N]; + sqlite3 *db = p->db; + u8 malloc_failed = db->mallocFailed; + if( db->pnBytesFreed ){ + do{ + if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc); + }while( (++p)flags & MEM_Agg ); + testcase( p->flags & MEM_Dyn ); + testcase( p->flags & MEM_Frame ); + testcase( p->flags & MEM_RowSet ); + if( p->flags&(MEM_Agg|MEM_Dyn|MEM_Frame|MEM_RowSet) ){ + sqlite3VdbeMemRelease(p); + }else if( p->szMalloc ){ + sqlite3DbFree(db, p->zMalloc); + p->szMalloc = 0; + } + + p->flags = MEM_Undefined; + }while( (++p)mallocFailed = malloc_failed; + } +} + +/* +** Delete a VdbeFrame object and its contents. VdbeFrame objects are +** allocated by the OP_Program opcode in sqlite3VdbeExec(). +*/ +SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame *p){ + int i; + Mem *aMem = VdbeFrameMem(p); + VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem]; + for(i=0; inChildCsr; i++){ + sqlite3VdbeFreeCursor(p->v, apCsr[i]); + } + releaseMemArray(aMem, p->nChildMem); + sqlite3DbFree(p->v->db, p); +} + +#ifndef SQLITE_OMIT_EXPLAIN +/* +** Give a listing of the program in the virtual machine. +** +** The interface is the same as sqlite3VdbeExec(). But instead of +** running the code, it invokes the callback once for each instruction. +** This feature is used to implement "EXPLAIN". +** +** When p->explain==1, each instruction is listed. When +** p->explain==2, only OP_Explain instructions are listed and these +** are shown in a different format. p->explain==2 is used to implement +** EXPLAIN QUERY PLAN. +** +** When p->explain==1, first the main program is listed, then each of +** the trigger subprograms are listed one by one. +*/ +SQLITE_PRIVATE int sqlite3VdbeList( + Vdbe *p /* The VDBE */ +){ + int nRow; /* Stop when row count reaches this */ + int nSub = 0; /* Number of sub-vdbes seen so far */ + SubProgram **apSub = 0; /* Array of sub-vdbes */ + Mem *pSub = 0; /* Memory cell hold array of subprogs */ + sqlite3 *db = p->db; /* The database connection */ + int i; /* Loop counter */ + int rc = SQLITE_OK; /* Return code */ + Mem *pMem = &p->aMem[1]; /* First Mem of result set */ + + assert( p->explain ); + assert( p->magic==VDBE_MAGIC_RUN ); + assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM ); + + /* Even though this opcode does not use dynamic strings for + ** the result, result columns may become dynamic if the user calls + ** sqlite3_column_text16(), causing a translation to UTF-16 encoding. + */ + releaseMemArray(pMem, 8); + p->pResultSet = 0; + + if( p->rc==SQLITE_NOMEM ){ + /* This happens if a malloc() inside a call to sqlite3_column_text() or + ** sqlite3_column_text16() failed. */ + db->mallocFailed = 1; + return SQLITE_ERROR; + } + + /* When the number of output rows reaches nRow, that means the + ** listing has finished and sqlite3_step() should return SQLITE_DONE. + ** nRow is the sum of the number of rows in the main program, plus + ** the sum of the number of rows in all trigger subprograms encountered + ** so far. The nRow value will increase as new trigger subprograms are + ** encountered, but p->pc will eventually catch up to nRow. + */ + nRow = p->nOp; + if( p->explain==1 ){ + /* The first 8 memory cells are used for the result set. So we will + ** commandeer the 9th cell to use as storage for an array of pointers + ** to trigger subprograms. The VDBE is guaranteed to have at least 9 + ** cells. */ + assert( p->nMem>9 ); + pSub = &p->aMem[9]; + if( pSub->flags&MEM_Blob ){ + /* On the first call to sqlite3_step(), pSub will hold a NULL. It is + ** initialized to a BLOB by the P4_SUBPROGRAM processing logic below */ + nSub = pSub->n/sizeof(Vdbe*); + apSub = (SubProgram **)pSub->z; + } + for(i=0; inOp; + } + } + + do{ + i = p->pc++; + }while( iexplain==2 && p->aOp[i].opcode!=OP_Explain ); + if( i>=nRow ){ + p->rc = SQLITE_OK; + rc = SQLITE_DONE; + }else if( db->u1.isInterrupted ){ + p->rc = SQLITE_INTERRUPT; + rc = SQLITE_ERROR; + sqlite3VdbeError(p, sqlite3ErrStr(p->rc)); + }else{ + char *zP4; + Op *pOp; + if( inOp ){ + /* The output line number is small enough that we are still in the + ** main program. */ + pOp = &p->aOp[i]; + }else{ + /* We are currently listing subprograms. Figure out which one and + ** pick up the appropriate opcode. */ + int j; + i -= p->nOp; + for(j=0; i>=apSub[j]->nOp; j++){ + i -= apSub[j]->nOp; + } + pOp = &apSub[j]->aOp[i]; + } + if( p->explain==1 ){ + pMem->flags = MEM_Int; + pMem->u.i = i; /* Program counter */ + pMem++; + + pMem->flags = MEM_Static|MEM_Str|MEM_Term; + pMem->z = (char*)sqlite3OpcodeName(pOp->opcode); /* Opcode */ + assert( pMem->z!=0 ); + pMem->n = sqlite3Strlen30(pMem->z); + pMem->enc = SQLITE_UTF8; + pMem++; + + /* When an OP_Program opcode is encounter (the only opcode that has + ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms + ** kept in p->aMem[9].z to hold the new program - assuming this subprogram + ** has not already been seen. + */ + if( pOp->p4type==P4_SUBPROGRAM ){ + int nByte = (nSub+1)*sizeof(SubProgram*); + int j; + for(j=0; jp4.pProgram ) break; + } + if( j==nSub && SQLITE_OK==sqlite3VdbeMemGrow(pSub, nByte, nSub!=0) ){ + apSub = (SubProgram **)pSub->z; + apSub[nSub++] = pOp->p4.pProgram; + pSub->flags |= MEM_Blob; + pSub->n = nSub*sizeof(SubProgram*); + } + } + } + + pMem->flags = MEM_Int; + pMem->u.i = pOp->p1; /* P1 */ + pMem++; + + pMem->flags = MEM_Int; + pMem->u.i = pOp->p2; /* P2 */ + pMem++; + + pMem->flags = MEM_Int; + pMem->u.i = pOp->p3; /* P3 */ + pMem++; + + if( sqlite3VdbeMemClearAndResize(pMem, 32) ){ /* P4 */ + assert( p->db->mallocFailed ); + return SQLITE_ERROR; + } + pMem->flags = MEM_Str|MEM_Term; + zP4 = displayP4(pOp, pMem->z, 32); + if( zP4!=pMem->z ){ + sqlite3VdbeMemSetStr(pMem, zP4, -1, SQLITE_UTF8, 0); + }else{ + assert( pMem->z!=0 ); + pMem->n = sqlite3Strlen30(pMem->z); + pMem->enc = SQLITE_UTF8; + } + pMem++; + + if( p->explain==1 ){ + if( sqlite3VdbeMemClearAndResize(pMem, 4) ){ + assert( p->db->mallocFailed ); + return SQLITE_ERROR; + } + pMem->flags = MEM_Str|MEM_Term; + pMem->n = 2; + sqlite3_snprintf(3, pMem->z, "%.2x", pOp->p5); /* P5 */ + pMem->enc = SQLITE_UTF8; + pMem++; + +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + if( sqlite3VdbeMemClearAndResize(pMem, 500) ){ + assert( p->db->mallocFailed ); + return SQLITE_ERROR; + } + pMem->flags = MEM_Str|MEM_Term; + pMem->n = displayComment(pOp, zP4, pMem->z, 500); + pMem->enc = SQLITE_UTF8; +#else + pMem->flags = MEM_Null; /* Comment */ +#endif + } + + p->nResColumn = 8 - 4*(p->explain-1); + p->pResultSet = &p->aMem[1]; + p->rc = SQLITE_OK; + rc = SQLITE_ROW; + } + return rc; +} +#endif /* SQLITE_OMIT_EXPLAIN */ + +#ifdef SQLITE_DEBUG +/* +** Print the SQL that was used to generate a VDBE program. +*/ +SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe *p){ + const char *z = 0; + if( p->zSql ){ + z = p->zSql; + }else if( p->nOp>=1 ){ + const VdbeOp *pOp = &p->aOp[0]; + if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){ + z = pOp->p4.z; + while( sqlite3Isspace(*z) ) z++; + } + } + if( z ) printf("SQL: [%s]\n", z); +} +#endif + +#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) +/* +** Print an IOTRACE message showing SQL content. +*/ +SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){ + int nOp = p->nOp; + VdbeOp *pOp; + if( sqlite3IoTrace==0 ) return; + if( nOp<1 ) return; + pOp = &p->aOp[0]; + if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){ + int i, j; + char z[1000]; + sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z); + for(i=0; sqlite3Isspace(z[i]); i++){} + for(j=0; z[i]; i++){ + if( sqlite3Isspace(z[i]) ){ + if( z[i-1]!=' ' ){ + z[j++] = ' '; + } + }else{ + z[j++] = z[i]; + } + } + z[j] = 0; + sqlite3IoTrace("SQL %s\n", z); + } +} +#endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */ + +/* +** Allocate space from a fixed size buffer and return a pointer to +** that space. If insufficient space is available, return NULL. +** +** The pBuf parameter is the initial value of a pointer which will +** receive the new memory. pBuf is normally NULL. If pBuf is not +** NULL, it means that memory space has already been allocated and that +** this routine should not allocate any new memory. When pBuf is not +** NULL simply return pBuf. Only allocate new memory space when pBuf +** is NULL. +** +** nByte is the number of bytes of space needed. +** +** *ppFrom points to available space and pEnd points to the end of the +** available space. When space is allocated, *ppFrom is advanced past +** the end of the allocated space. +** +** *pnByte is a counter of the number of bytes of space that have failed +** to allocate. If there is insufficient space in *ppFrom to satisfy the +** request, then increment *pnByte by the amount of the request. +*/ +static void *allocSpace( + void *pBuf, /* Where return pointer will be stored */ + int nByte, /* Number of bytes to allocate */ + u8 **ppFrom, /* IN/OUT: Allocate from *ppFrom */ + u8 *pEnd, /* Pointer to 1 byte past the end of *ppFrom buffer */ + int *pnByte /* If allocation cannot be made, increment *pnByte */ +){ + assert( EIGHT_BYTE_ALIGNMENT(*ppFrom) ); + if( pBuf ) return pBuf; + nByte = ROUND8(nByte); + if( &(*ppFrom)[nByte] <= pEnd ){ + pBuf = (void*)*ppFrom; + *ppFrom += nByte; + }else{ + *pnByte += nByte; + } + return pBuf; +} + +/* +** Rewind the VDBE back to the beginning in preparation for +** running it. +*/ +SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){ +#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) + int i; +#endif + assert( p!=0 ); + assert( p->magic==VDBE_MAGIC_INIT ); + + /* There should be at least one opcode. + */ + assert( p->nOp>0 ); + + /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */ + p->magic = VDBE_MAGIC_RUN; + +#ifdef SQLITE_DEBUG + for(i=1; inMem; i++){ + assert( p->aMem[i].db==p->db ); + } +#endif + p->pc = -1; + p->rc = SQLITE_OK; + p->errorAction = OE_Abort; + p->magic = VDBE_MAGIC_RUN; + p->nChange = 0; + p->cacheCtr = 1; + p->minWriteFileFormat = 255; + p->iStatement = 0; + p->nFkConstraint = 0; +#ifdef VDBE_PROFILE + for(i=0; inOp; i++){ + p->aOp[i].cnt = 0; + p->aOp[i].cycles = 0; + } +#endif +} + +/* +** Prepare a virtual machine for execution for the first time after +** creating the virtual machine. This involves things such +** as allocating registers and initializing the program counter. +** After the VDBE has be prepped, it can be executed by one or more +** calls to sqlite3VdbeExec(). +** +** This function may be called exactly once on each virtual machine. +** After this routine is called the VM has been "packaged" and is ready +** to run. After this routine is called, further calls to +** sqlite3VdbeAddOp() functions are prohibited. This routine disconnects +** the Vdbe from the Parse object that helped generate it so that the +** the Vdbe becomes an independent entity and the Parse object can be +** destroyed. +** +** Use the sqlite3VdbeRewind() procedure to restore a virtual machine back +** to its initial state after it has been run. +*/ +SQLITE_PRIVATE void sqlite3VdbeMakeReady( + Vdbe *p, /* The VDBE */ + Parse *pParse /* Parsing context */ +){ + sqlite3 *db; /* The database connection */ + int nVar; /* Number of parameters */ + int nMem; /* Number of VM memory registers */ + int nCursor; /* Number of cursors required */ + int nArg; /* Number of arguments in subprograms */ + int nOnce; /* Number of OP_Once instructions */ + int n; /* Loop counter */ + u8 *zCsr; /* Memory available for allocation */ + u8 *zEnd; /* First byte past allocated memory */ + int nByte; /* How much extra memory is needed */ + + assert( p!=0 ); + assert( p->nOp>0 ); + assert( pParse!=0 ); + assert( p->magic==VDBE_MAGIC_INIT ); + assert( pParse==p->pParse ); + db = p->db; + assert( db->mallocFailed==0 ); + nVar = pParse->nVar; + nMem = pParse->nMem; + nCursor = pParse->nTab; + nArg = pParse->nMaxArg; + nOnce = pParse->nOnce; + if( nOnce==0 ) nOnce = 1; /* Ensure at least one byte in p->aOnceFlag[] */ + + /* For each cursor required, also allocate a memory cell. Memory + ** cells (nMem+1-nCursor)..nMem, inclusive, will never be used by + ** the vdbe program. Instead they are used to allocate space for + ** VdbeCursor/BtCursor structures. The blob of memory associated with + ** cursor 0 is stored in memory cell nMem. Memory cell (nMem-1) + ** stores the blob of memory associated with cursor 1, etc. + ** + ** See also: allocateCursor(). + */ + nMem += nCursor; + + /* Allocate space for memory registers, SQL variables, VDBE cursors and + ** an array to marshal SQL function arguments in. + */ + zCsr = (u8*)&p->aOp[p->nOp]; /* Memory avaliable for allocation */ + zEnd = (u8*)&p->aOp[pParse->nOpAlloc]; /* First byte past end of zCsr[] */ + + resolveP2Values(p, &nArg); + p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort); + if( pParse->explain && nMem<10 ){ + nMem = 10; + } + memset(zCsr, 0, zEnd-zCsr); + zCsr += (zCsr - (u8*)0)&7; + assert( EIGHT_BYTE_ALIGNMENT(zCsr) ); + p->expired = 0; + + /* Memory for registers, parameters, cursor, etc, is allocated in two + ** passes. On the first pass, we try to reuse unused space at the + ** end of the opcode array. If we are unable to satisfy all memory + ** requirements by reusing the opcode array tail, then the second + ** pass will fill in the rest using a fresh allocation. + ** + ** This two-pass approach that reuses as much memory as possible from + ** the leftover space at the end of the opcode array can significantly + ** reduce the amount of memory held by a prepared statement. + */ + do { + nByte = 0; + p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte); + p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte); + p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte); + p->azVar = allocSpace(p->azVar, nVar*sizeof(char*), &zCsr, zEnd, &nByte); + p->apCsr = allocSpace(p->apCsr, nCursor*sizeof(VdbeCursor*), + &zCsr, zEnd, &nByte); + p->aOnceFlag = allocSpace(p->aOnceFlag, nOnce, &zCsr, zEnd, &nByte); +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + p->anExec = allocSpace(p->anExec, p->nOp*sizeof(i64), &zCsr, zEnd, &nByte); +#endif + if( nByte ){ + p->pFree = sqlite3DbMallocZero(db, nByte); + } + zCsr = p->pFree; + zEnd = &zCsr[nByte]; + }while( nByte && !db->mallocFailed ); + + p->nCursor = nCursor; + p->nOnceFlag = nOnce; + if( p->aVar ){ + p->nVar = (ynVar)nVar; + for(n=0; naVar[n].flags = MEM_Null; + p->aVar[n].db = db; + } + } + if( p->azVar && pParse->nzVar>0 ){ + p->nzVar = pParse->nzVar; + memcpy(p->azVar, pParse->azVar, p->nzVar*sizeof(p->azVar[0])); + memset(pParse->azVar, 0, pParse->nzVar*sizeof(pParse->azVar[0])); + } + if( p->aMem ){ + p->aMem--; /* aMem[] goes from 1..nMem */ + p->nMem = nMem; /* not from 0..nMem-1 */ + for(n=1; n<=nMem; n++){ + p->aMem[n].flags = MEM_Undefined; + p->aMem[n].db = db; + } + } + p->explain = pParse->explain; + sqlite3VdbeRewind(p); +} + +/* +** Close a VDBE cursor and release all the resources that cursor +** happens to hold. +*/ +SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){ + if( pCx==0 ){ + return; + } + sqlite3VdbeSorterClose(p->db, pCx); + if( pCx->pBt ){ + sqlite3BtreeClose(pCx->pBt); + /* The pCx->pCursor will be close automatically, if it exists, by + ** the call above. */ + }else if( pCx->pCursor ){ + sqlite3BtreeCloseCursor(pCx->pCursor); + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + else if( pCx->pVtabCursor ){ + sqlite3_vtab_cursor *pVtabCursor = pCx->pVtabCursor; + const sqlite3_module *pModule = pVtabCursor->pVtab->pModule; + assert( pVtabCursor->pVtab->nRef>0 ); + pVtabCursor->pVtab->nRef--; + pModule->xClose(pVtabCursor); + } +#endif +} + +/* +** Close all cursors in the current frame. +*/ +static void closeCursorsInFrame(Vdbe *p){ + if( p->apCsr ){ + int i; + for(i=0; inCursor; i++){ + VdbeCursor *pC = p->apCsr[i]; + if( pC ){ + sqlite3VdbeFreeCursor(p, pC); + p->apCsr[i] = 0; + } + } + } +} + +/* +** Copy the values stored in the VdbeFrame structure to its Vdbe. This +** is used, for example, when a trigger sub-program is halted to restore +** control to the main program. +*/ +SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){ + Vdbe *v = pFrame->v; + closeCursorsInFrame(v); +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + v->anExec = pFrame->anExec; +#endif + v->aOnceFlag = pFrame->aOnceFlag; + v->nOnceFlag = pFrame->nOnceFlag; + v->aOp = pFrame->aOp; + v->nOp = pFrame->nOp; + v->aMem = pFrame->aMem; + v->nMem = pFrame->nMem; + v->apCsr = pFrame->apCsr; + v->nCursor = pFrame->nCursor; + v->db->lastRowid = pFrame->lastRowid; + v->nChange = pFrame->nChange; + v->db->nChange = pFrame->nDbChange; + return pFrame->pc; +} + +/* +** Close all cursors. +** +** Also release any dynamic memory held by the VM in the Vdbe.aMem memory +** cell array. This is necessary as the memory cell array may contain +** pointers to VdbeFrame objects, which may in turn contain pointers to +** open cursors. +*/ +static void closeAllCursors(Vdbe *p){ + if( p->pFrame ){ + VdbeFrame *pFrame; + for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); + sqlite3VdbeFrameRestore(pFrame); + p->pFrame = 0; + p->nFrame = 0; + } + assert( p->nFrame==0 ); + closeCursorsInFrame(p); + if( p->aMem ){ + releaseMemArray(&p->aMem[1], p->nMem); + } + while( p->pDelFrame ){ + VdbeFrame *pDel = p->pDelFrame; + p->pDelFrame = pDel->pParent; + sqlite3VdbeFrameDelete(pDel); + } + + /* Delete any auxdata allocations made by the VM */ + if( p->pAuxData ) sqlite3VdbeDeleteAuxData(p, -1, 0); + assert( p->pAuxData==0 ); +} + +/* +** Clean up the VM after a single run. +*/ +static void Cleanup(Vdbe *p){ + sqlite3 *db = p->db; + +#ifdef SQLITE_DEBUG + /* Execute assert() statements to ensure that the Vdbe.apCsr[] and + ** Vdbe.aMem[] arrays have already been cleaned up. */ + int i; + if( p->apCsr ) for(i=0; inCursor; i++) assert( p->apCsr[i]==0 ); + if( p->aMem ){ + for(i=1; i<=p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined ); + } +#endif + + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = 0; + p->pResultSet = 0; +} + +/* +** Set the number of result columns that will be returned by this SQL +** statement. This is now set at compile time, rather than during +** execution of the vdbe program so that sqlite3_column_count() can +** be called on an SQL statement before sqlite3_step(). +*/ +SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){ + Mem *pColName; + int n; + sqlite3 *db = p->db; + + releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); + sqlite3DbFree(db, p->aColName); + n = nResColumn*COLNAME_N; + p->nResColumn = (u16)nResColumn; + p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n ); + if( p->aColName==0 ) return; + while( n-- > 0 ){ + pColName->flags = MEM_Null; + pColName->db = p->db; + pColName++; + } +} + +/* +** Set the name of the idx'th column to be returned by the SQL statement. +** zName must be a pointer to a nul terminated string. +** +** This call must be made after a call to sqlite3VdbeSetNumCols(). +** +** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC +** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed +** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed. +*/ +SQLITE_PRIVATE int sqlite3VdbeSetColName( + Vdbe *p, /* Vdbe being configured */ + int idx, /* Index of column zName applies to */ + int var, /* One of the COLNAME_* constants */ + const char *zName, /* Pointer to buffer containing name */ + void (*xDel)(void*) /* Memory management strategy for zName */ +){ + int rc; + Mem *pColName; + assert( idxnResColumn ); + assert( vardb->mallocFailed ){ + assert( !zName || xDel!=SQLITE_DYNAMIC ); + return SQLITE_NOMEM; + } + assert( p->aColName!=0 ); + pColName = &(p->aColName[idx+var*p->nResColumn]); + rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel); + assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 ); + return rc; +} + +/* +** A read or write transaction may or may not be active on database handle +** db. If a transaction is active, commit it. If there is a +** write-transaction spanning more than one database file, this routine +** takes care of the master journal trickery. +*/ +static int vdbeCommit(sqlite3 *db, Vdbe *p){ + int i; + int nTrans = 0; /* Number of databases with an active write-transaction */ + int rc = SQLITE_OK; + int needXcommit = 0; + +#ifdef SQLITE_OMIT_VIRTUALTABLE + /* With this option, sqlite3VtabSync() is defined to be simply + ** SQLITE_OK so p is not used. + */ + UNUSED_PARAMETER(p); +#endif + + /* Before doing anything else, call the xSync() callback for any + ** virtual module tables written in this transaction. This has to + ** be done before determining whether a master journal file is + ** required, as an xSync() callback may add an attached database + ** to the transaction. + */ + rc = sqlite3VtabSync(db, p); + + /* This loop determines (a) if the commit hook should be invoked and + ** (b) how many database files have open write transactions, not + ** including the temp database. (b) is important because if more than + ** one database file has an open write transaction, a master journal + ** file is required for an atomic commit. + */ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( sqlite3BtreeIsInTrans(pBt) ){ + needXcommit = 1; + if( i!=1 ) nTrans++; + sqlite3BtreeEnter(pBt); + rc = sqlite3PagerExclusiveLock(sqlite3BtreePager(pBt)); + sqlite3BtreeLeave(pBt); + } + } + if( rc!=SQLITE_OK ){ + return rc; + } + + /* If there are any write-transactions at all, invoke the commit hook */ + if( needXcommit && db->xCommitCallback ){ + rc = db->xCommitCallback(db->pCommitArg); + if( rc ){ + return SQLITE_CONSTRAINT_COMMITHOOK; + } + } + + /* The simple case - no more than one database file (not counting the + ** TEMP database) has a transaction active. There is no need for the + ** master-journal. + ** + ** If the return value of sqlite3BtreeGetFilename() is a zero length + ** string, it means the main database is :memory: or a temp file. In + ** that case we do not support atomic multi-file commits, so use the + ** simple case then too. + */ + if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt)) + || nTrans<=1 + ){ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = sqlite3BtreeCommitPhaseOne(pBt, 0); + } + } + + /* Do the commit only if all databases successfully complete phase 1. + ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an + ** IO error while deleting or truncating a journal file. It is unlikely, + ** but could happen. In this case abandon processing and return the error. + */ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = sqlite3BtreeCommitPhaseTwo(pBt, 0); + } + } + if( rc==SQLITE_OK ){ + sqlite3VtabCommit(db); + } + } + + /* The complex case - There is a multi-file write-transaction active. + ** This requires a master journal file to ensure the transaction is + ** committed atomically. + */ +#ifndef SQLITE_OMIT_DISKIO + else{ + sqlite3_vfs *pVfs = db->pVfs; + int needSync = 0; + char *zMaster = 0; /* File-name for the master journal */ + char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt); + sqlite3_file *pMaster = 0; + i64 offset = 0; + int res; + int retryCount = 0; + int nMainFile; + + /* Select a master journal file name */ + nMainFile = sqlite3Strlen30(zMainFile); + zMaster = sqlite3MPrintf(db, "%s-mjXXXXXX9XXz", zMainFile); + if( zMaster==0 ) return SQLITE_NOMEM; + do { + u32 iRandom; + if( retryCount ){ + if( retryCount>100 ){ + sqlite3_log(SQLITE_FULL, "MJ delete: %s", zMaster); + sqlite3OsDelete(pVfs, zMaster, 0); + break; + }else if( retryCount==1 ){ + sqlite3_log(SQLITE_FULL, "MJ collide: %s", zMaster); + } + } + retryCount++; + sqlite3_randomness(sizeof(iRandom), &iRandom); + sqlite3_snprintf(13, &zMaster[nMainFile], "-mj%06X9%02X", + (iRandom>>8)&0xffffff, iRandom&0xff); + /* The antipenultimate character of the master journal name must + ** be "9" to avoid name collisions when using 8+3 filenames. */ + assert( zMaster[sqlite3Strlen30(zMaster)-3]=='9' ); + sqlite3FileSuffix3(zMainFile, zMaster); + rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res); + }while( rc==SQLITE_OK && res ); + if( rc==SQLITE_OK ){ + /* Open the master journal. */ + rc = sqlite3OsOpenMalloc(pVfs, zMaster, &pMaster, + SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE| + SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_MASTER_JOURNAL, 0 + ); + } + if( rc!=SQLITE_OK ){ + sqlite3DbFree(db, zMaster); + return rc; + } + + /* Write the name of each database file in the transaction into the new + ** master journal file. If an error occurs at this point close + ** and delete the master journal file. All the individual journal files + ** still have 'null' as the master journal pointer, so they will roll + ** back independently if a failure occurs. + */ + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( sqlite3BtreeIsInTrans(pBt) ){ + char const *zFile = sqlite3BtreeGetJournalname(pBt); + if( zFile==0 ){ + continue; /* Ignore TEMP and :memory: databases */ + } + assert( zFile[0]!=0 ); + if( !needSync && !sqlite3BtreeSyncDisabled(pBt) ){ + needSync = 1; + } + rc = sqlite3OsWrite(pMaster, zFile, sqlite3Strlen30(zFile)+1, offset); + offset += sqlite3Strlen30(zFile)+1; + if( rc!=SQLITE_OK ){ + sqlite3OsCloseFree(pMaster); + sqlite3OsDelete(pVfs, zMaster, 0); + sqlite3DbFree(db, zMaster); + return rc; + } + } + } + + /* Sync the master journal file. If the IOCAP_SEQUENTIAL device + ** flag is set this is not required. + */ + if( needSync + && 0==(sqlite3OsDeviceCharacteristics(pMaster)&SQLITE_IOCAP_SEQUENTIAL) + && SQLITE_OK!=(rc = sqlite3OsSync(pMaster, SQLITE_SYNC_NORMAL)) + ){ + sqlite3OsCloseFree(pMaster); + sqlite3OsDelete(pVfs, zMaster, 0); + sqlite3DbFree(db, zMaster); + return rc; + } + + /* Sync all the db files involved in the transaction. The same call + ** sets the master journal pointer in each individual journal. If + ** an error occurs here, do not delete the master journal file. + ** + ** If the error occurs during the first call to + ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the + ** master journal file will be orphaned. But we cannot delete it, + ** in case the master journal file name was written into the journal + ** file before the failure occurred. + */ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = sqlite3BtreeCommitPhaseOne(pBt, zMaster); + } + } + sqlite3OsCloseFree(pMaster); + assert( rc!=SQLITE_BUSY ); + if( rc!=SQLITE_OK ){ + sqlite3DbFree(db, zMaster); + return rc; + } + + /* Delete the master journal file. This commits the transaction. After + ** doing this the directory is synced again before any individual + ** transaction files are deleted. + */ + rc = sqlite3OsDelete(pVfs, zMaster, needSync); + sqlite3DbFree(db, zMaster); + zMaster = 0; + if( rc ){ + return rc; + } + + /* All files and directories have already been synced, so the following + ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and + ** deleting or truncating journals. If something goes wrong while + ** this is happening we don't really care. The integrity of the + ** transaction is already guaranteed, but some stray 'cold' journals + ** may be lying around. Returning an error code won't help matters. + */ + disable_simulated_io_errors(); + sqlite3BeginBenignMalloc(); + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + sqlite3BtreeCommitPhaseTwo(pBt, 1); + } + } + sqlite3EndBenignMalloc(); + enable_simulated_io_errors(); + + sqlite3VtabCommit(db); + } +#endif + + return rc; +} + +/* +** This routine checks that the sqlite3.nVdbeActive count variable +** matches the number of vdbe's in the list sqlite3.pVdbe that are +** currently active. An assertion fails if the two counts do not match. +** This is an internal self-check only - it is not an essential processing +** step. +** +** This is a no-op if NDEBUG is defined. +*/ +#ifndef NDEBUG +static void checkActiveVdbeCnt(sqlite3 *db){ + Vdbe *p; + int cnt = 0; + int nWrite = 0; + int nRead = 0; + p = db->pVdbe; + while( p ){ + if( sqlite3_stmt_busy((sqlite3_stmt*)p) ){ + cnt++; + if( p->readOnly==0 ) nWrite++; + if( p->bIsReader ) nRead++; + } + p = p->pNext; + } + assert( cnt==db->nVdbeActive ); + assert( nWrite==db->nVdbeWrite ); + assert( nRead==db->nVdbeRead ); +} +#else +#define checkActiveVdbeCnt(x) +#endif + +/* +** If the Vdbe passed as the first argument opened a statement-transaction, +** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or +** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement +** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the +** statement transaction is committed. +** +** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned. +** Otherwise SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *p, int eOp){ + sqlite3 *const db = p->db; + int rc = SQLITE_OK; + + /* If p->iStatement is greater than zero, then this Vdbe opened a + ** statement transaction that should be closed here. The only exception + ** is that an IO error may have occurred, causing an emergency rollback. + ** In this case (db->nStatement==0), and there is nothing to do. + */ + if( db->nStatement && p->iStatement ){ + int i; + const int iSavepoint = p->iStatement-1; + + assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE); + assert( db->nStatement>0 ); + assert( p->iStatement==(db->nStatement+db->nSavepoint) ); + + for(i=0; inDb; i++){ + int rc2 = SQLITE_OK; + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + if( eOp==SAVEPOINT_ROLLBACK ){ + rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint); + } + if( rc2==SQLITE_OK ){ + rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint); + } + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + db->nStatement--; + p->iStatement = 0; + + if( rc==SQLITE_OK ){ + if( eOp==SAVEPOINT_ROLLBACK ){ + rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint); + } + if( rc==SQLITE_OK ){ + rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint); + } + } + + /* If the statement transaction is being rolled back, also restore the + ** database handles deferred constraint counter to the value it had when + ** the statement transaction was opened. */ + if( eOp==SAVEPOINT_ROLLBACK ){ + db->nDeferredCons = p->nStmtDefCons; + db->nDeferredImmCons = p->nStmtDefImmCons; + } + } + return rc; +} + +/* +** This function is called when a transaction opened by the database +** handle associated with the VM passed as an argument is about to be +** committed. If there are outstanding deferred foreign key constraint +** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK. +** +** If there are outstanding FK violations and this function returns +** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY +** and write an error message to it. Then return SQLITE_ERROR. +*/ +#ifndef SQLITE_OMIT_FOREIGN_KEY +SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){ + sqlite3 *db = p->db; + if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0) + || (!deferred && p->nFkConstraint>0) + ){ + p->rc = SQLITE_CONSTRAINT_FOREIGNKEY; + p->errorAction = OE_Abort; + sqlite3VdbeError(p, "FOREIGN KEY constraint failed"); + return SQLITE_ERROR; + } + return SQLITE_OK; +} +#endif + +/* +** This routine is called the when a VDBE tries to halt. If the VDBE +** has made changes and is in autocommit mode, then commit those +** changes. If a rollback is needed, then do the rollback. +** +** This routine is the only way to move the state of a VM from +** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. It is harmless to +** call this on a VM that is in the SQLITE_MAGIC_HALT state. +** +** Return an error code. If the commit could not complete because of +** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it +** means the close did not happen and needs to be repeated. +*/ +SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){ + int rc; /* Used to store transient return codes */ + sqlite3 *db = p->db; + + /* This function contains the logic that determines if a statement or + ** transaction will be committed or rolled back as a result of the + ** execution of this virtual machine. + ** + ** If any of the following errors occur: + ** + ** SQLITE_NOMEM + ** SQLITE_IOERR + ** SQLITE_FULL + ** SQLITE_INTERRUPT + ** + ** Then the internal cache might have been left in an inconsistent + ** state. We need to rollback the statement transaction, if there is + ** one, or the complete transaction if there is no statement transaction. + */ + + if( p->db->mallocFailed ){ + p->rc = SQLITE_NOMEM; + } + if( p->aOnceFlag ) memset(p->aOnceFlag, 0, p->nOnceFlag); + closeAllCursors(p); + if( p->magic!=VDBE_MAGIC_RUN ){ + return SQLITE_OK; + } + checkActiveVdbeCnt(db); + + /* No commit or rollback needed if the program never started or if the + ** SQL statement does not read or write a database file. */ + if( p->pc>=0 && p->bIsReader ){ + int mrc; /* Primary error code from p->rc */ + int eStatementOp = 0; + int isSpecialError; /* Set to true if a 'special' error */ + + /* Lock all btrees used by the statement */ + sqlite3VdbeEnter(p); + + /* Check for one of the special errors */ + mrc = p->rc & 0xff; + isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR + || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL; + if( isSpecialError ){ + /* If the query was read-only and the error code is SQLITE_INTERRUPT, + ** no rollback is necessary. Otherwise, at least a savepoint + ** transaction must be rolled back to restore the database to a + ** consistent state. + ** + ** Even if the statement is read-only, it is important to perform + ** a statement or transaction rollback operation. If the error + ** occurred while writing to the journal, sub-journal or database + ** file as part of an effort to free up cache space (see function + ** pagerStress() in pager.c), the rollback is required to restore + ** the pager to a consistent state. + */ + if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){ + if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && p->usesStmtJournal ){ + eStatementOp = SAVEPOINT_ROLLBACK; + }else{ + /* We are forced to roll back the active transaction. Before doing + ** so, abort any other statements this handle currently has active. + */ + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + sqlite3CloseSavepoints(db); + db->autoCommit = 1; + p->nChange = 0; + } + } + } + + /* Check for immediate foreign key violations. */ + if( p->rc==SQLITE_OK ){ + sqlite3VdbeCheckFk(p, 0); + } + + /* If the auto-commit flag is set and this is the only active writer + ** VM, then we do either a commit or rollback of the current transaction. + ** + ** Note: This block also runs if one of the special errors handled + ** above has occurred. + */ + if( !sqlite3VtabInSync(db) + && db->autoCommit + && db->nVdbeWrite==(p->readOnly==0) + ){ + if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){ + rc = sqlite3VdbeCheckFk(p, 1); + if( rc!=SQLITE_OK ){ + if( NEVER(p->readOnly) ){ + sqlite3VdbeLeave(p); + return SQLITE_ERROR; + } + rc = SQLITE_CONSTRAINT_FOREIGNKEY; + }else{ + /* The auto-commit flag is true, the vdbe program was successful + ** or hit an 'OR FAIL' constraint and there are no deferred foreign + ** key constraints to hold up the transaction. This means a commit + ** is required. */ + rc = vdbeCommit(db, p); + } + if( rc==SQLITE_BUSY && p->readOnly ){ + sqlite3VdbeLeave(p); + return SQLITE_BUSY; + }else if( rc!=SQLITE_OK ){ + p->rc = rc; + sqlite3RollbackAll(db, SQLITE_OK); + p->nChange = 0; + }else{ + db->nDeferredCons = 0; + db->nDeferredImmCons = 0; + db->flags &= ~SQLITE_DeferFKs; + sqlite3CommitInternalChanges(db); + } + }else{ + sqlite3RollbackAll(db, SQLITE_OK); + p->nChange = 0; + } + db->nStatement = 0; + }else if( eStatementOp==0 ){ + if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){ + eStatementOp = SAVEPOINT_RELEASE; + }else if( p->errorAction==OE_Abort ){ + eStatementOp = SAVEPOINT_ROLLBACK; + }else{ + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + sqlite3CloseSavepoints(db); + db->autoCommit = 1; + p->nChange = 0; + } + } + + /* If eStatementOp is non-zero, then a statement transaction needs to + ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to + ** do so. If this operation returns an error, and the current statement + ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the + ** current statement error code. + */ + if( eStatementOp ){ + rc = sqlite3VdbeCloseStatement(p, eStatementOp); + if( rc ){ + if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){ + p->rc = rc; + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = 0; + } + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + sqlite3CloseSavepoints(db); + db->autoCommit = 1; + p->nChange = 0; + } + } + + /* If this was an INSERT, UPDATE or DELETE and no statement transaction + ** has been rolled back, update the database connection change-counter. + */ + if( p->changeCntOn ){ + if( eStatementOp!=SAVEPOINT_ROLLBACK ){ + sqlite3VdbeSetChanges(db, p->nChange); + }else{ + sqlite3VdbeSetChanges(db, 0); + } + p->nChange = 0; + } + + /* Release the locks */ + sqlite3VdbeLeave(p); + } + + /* We have successfully halted and closed the VM. Record this fact. */ + if( p->pc>=0 ){ + db->nVdbeActive--; + if( !p->readOnly ) db->nVdbeWrite--; + if( p->bIsReader ) db->nVdbeRead--; + assert( db->nVdbeActive>=db->nVdbeRead ); + assert( db->nVdbeRead>=db->nVdbeWrite ); + assert( db->nVdbeWrite>=0 ); + } + p->magic = VDBE_MAGIC_HALT; + checkActiveVdbeCnt(db); + if( p->db->mallocFailed ){ + p->rc = SQLITE_NOMEM; + } + + /* If the auto-commit flag is set to true, then any locks that were held + ** by connection db have now been released. Call sqlite3ConnectionUnlocked() + ** to invoke any required unlock-notify callbacks. + */ + if( db->autoCommit ){ + sqlite3ConnectionUnlocked(db); + } + + assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 ); + return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK); +} + + +/* +** Each VDBE holds the result of the most recent sqlite3_step() call +** in p->rc. This routine sets that result back to SQLITE_OK. +*/ +SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe *p){ + p->rc = SQLITE_OK; +} + +/* +** Copy the error code and error message belonging to the VDBE passed +** as the first argument to its database handle (so that they will be +** returned by calls to sqlite3_errcode() and sqlite3_errmsg()). +** +** This function does not clear the VDBE error code or message, just +** copies them to the database handle. +*/ +SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){ + sqlite3 *db = p->db; + int rc = p->rc; + if( p->zErrMsg ){ + u8 mallocFailed = db->mallocFailed; + sqlite3BeginBenignMalloc(); + if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db); + sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT); + sqlite3EndBenignMalloc(); + db->mallocFailed = mallocFailed; + db->errCode = rc; + }else{ + sqlite3Error(db, rc); + } + return rc; +} + +#ifdef SQLITE_ENABLE_SQLLOG +/* +** If an SQLITE_CONFIG_SQLLOG hook is registered and the VM has been run, +** invoke it. +*/ +static void vdbeInvokeSqllog(Vdbe *v){ + if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){ + char *zExpanded = sqlite3VdbeExpandSql(v, v->zSql); + assert( v->db->init.busy==0 ); + if( zExpanded ){ + sqlite3GlobalConfig.xSqllog( + sqlite3GlobalConfig.pSqllogArg, v->db, zExpanded, 1 + ); + sqlite3DbFree(v->db, zExpanded); + } + } +} +#else +# define vdbeInvokeSqllog(x) +#endif + +/* +** Clean up a VDBE after execution but do not delete the VDBE just yet. +** Write any error messages into *pzErrMsg. Return the result code. +** +** After this routine is run, the VDBE should be ready to be executed +** again. +** +** To look at it another way, this routine resets the state of the +** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to +** VDBE_MAGIC_INIT. +*/ +SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){ + sqlite3 *db; + db = p->db; + + /* If the VM did not run to completion or if it encountered an + ** error, then it might not have been halted properly. So halt + ** it now. + */ + sqlite3VdbeHalt(p); + + /* If the VDBE has be run even partially, then transfer the error code + ** and error message from the VDBE into the main database structure. But + ** if the VDBE has just been set to run but has not actually executed any + ** instructions yet, leave the main database error information unchanged. + */ + if( p->pc>=0 ){ + vdbeInvokeSqllog(p); + sqlite3VdbeTransferError(p); + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = 0; + if( p->runOnlyOnce ) p->expired = 1; + }else if( p->rc && p->expired ){ + /* The expired flag was set on the VDBE before the first call + ** to sqlite3_step(). For consistency (since sqlite3_step() was + ** called), set the database error in this case as well. + */ + sqlite3ErrorWithMsg(db, p->rc, p->zErrMsg ? "%s" : 0, p->zErrMsg); + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = 0; + } + + /* Reclaim all memory used by the VDBE + */ + Cleanup(p); + + /* Save profiling information from this VDBE run. + */ +#ifdef VDBE_PROFILE + { + FILE *out = fopen("vdbe_profile.out", "a"); + if( out ){ + int i; + fprintf(out, "---- "); + for(i=0; inOp; i++){ + fprintf(out, "%02x", p->aOp[i].opcode); + } + fprintf(out, "\n"); + if( p->zSql ){ + char c, pc = 0; + fprintf(out, "-- "); + for(i=0; (c = p->zSql[i])!=0; i++){ + if( pc=='\n' ) fprintf(out, "-- "); + putc(c, out); + pc = c; + } + if( pc!='\n' ) fprintf(out, "\n"); + } + for(i=0; inOp; i++){ + char zHdr[100]; + sqlite3_snprintf(sizeof(zHdr), zHdr, "%6u %12llu %8llu ", + p->aOp[i].cnt, + p->aOp[i].cycles, + p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0 + ); + fprintf(out, "%s", zHdr); + sqlite3VdbePrintOp(out, i, &p->aOp[i]); + } + fclose(out); + } + } +#endif + p->iCurrentTime = 0; + p->magic = VDBE_MAGIC_INIT; + return p->rc & db->errMask; +} + +/* +** Clean up and delete a VDBE after execution. Return an integer which is +** the result code. Write any error message text into *pzErrMsg. +*/ +SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe *p){ + int rc = SQLITE_OK; + if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){ + rc = sqlite3VdbeReset(p); + assert( (rc & p->db->errMask)==rc ); + } + sqlite3VdbeDelete(p); + return rc; +} + +/* +** If parameter iOp is less than zero, then invoke the destructor for +** all auxiliary data pointers currently cached by the VM passed as +** the first argument. +** +** Or, if iOp is greater than or equal to zero, then the destructor is +** only invoked for those auxiliary data pointers created by the user +** function invoked by the OP_Function opcode at instruction iOp of +** VM pVdbe, and only then if: +** +** * the associated function parameter is the 32nd or later (counting +** from left to right), or +** +** * the corresponding bit in argument mask is clear (where the first +** function parameter corresponds to bit 0 etc.). +*/ +SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(Vdbe *pVdbe, int iOp, int mask){ + AuxData **pp = &pVdbe->pAuxData; + while( *pp ){ + AuxData *pAux = *pp; + if( (iOp<0) + || (pAux->iOp==iOp && (pAux->iArg>31 || !(mask & MASKBIT32(pAux->iArg)))) + ){ + testcase( pAux->iArg==31 ); + if( pAux->xDelete ){ + pAux->xDelete(pAux->pAux); + } + *pp = pAux->pNext; + sqlite3DbFree(pVdbe->db, pAux); + }else{ + pp= &pAux->pNext; + } + } +} + +/* +** Free all memory associated with the Vdbe passed as the second argument, +** except for object itself, which is preserved. +** +** The difference between this function and sqlite3VdbeDelete() is that +** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with +** the database connection and frees the object itself. +*/ +SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){ + SubProgram *pSub, *pNext; + int i; + assert( p->db==0 || p->db==db ); + releaseMemArray(p->aVar, p->nVar); + releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); + for(pSub=p->pProgram; pSub; pSub=pNext){ + pNext = pSub->pNext; + vdbeFreeOpArray(db, pSub->aOp, pSub->nOp); + sqlite3DbFree(db, pSub); + } + for(i=p->nzVar-1; i>=0; i--) sqlite3DbFree(db, p->azVar[i]); + vdbeFreeOpArray(db, p->aOp, p->nOp); + sqlite3DbFree(db, p->aColName); + sqlite3DbFree(db, p->zSql); + sqlite3DbFree(db, p->pFree); +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + for(i=0; inScan; i++){ + sqlite3DbFree(db, p->aScan[i].zName); + } + sqlite3DbFree(db, p->aScan); +#endif +} + +/* +** Delete an entire VDBE. +*/ +SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){ + sqlite3 *db; + + if( NEVER(p==0) ) return; + db = p->db; + assert( sqlite3_mutex_held(db->mutex) ); + sqlite3VdbeClearObject(db, p); + if( p->pPrev ){ + p->pPrev->pNext = p->pNext; + }else{ + assert( db->pVdbe==p ); + db->pVdbe = p->pNext; + } + if( p->pNext ){ + p->pNext->pPrev = p->pPrev; + } + p->magic = VDBE_MAGIC_DEAD; + p->db = 0; + sqlite3DbFree(db, p); +} + +/* +** The cursor "p" has a pending seek operation that has not yet been +** carried out. Seek the cursor now. If an error occurs, return +** the appropriate error code. +*/ +static int SQLITE_NOINLINE handleDeferredMoveto(VdbeCursor *p){ + int res, rc; +#ifdef SQLITE_TEST + extern int sqlite3_search_count; +#endif + assert( p->deferredMoveto ); + assert( p->isTable ); + rc = sqlite3BtreeMovetoUnpacked(p->pCursor, 0, p->movetoTarget, 0, &res); + if( rc ) return rc; + if( res!=0 ) return SQLITE_CORRUPT_BKPT; +#ifdef SQLITE_TEST + sqlite3_search_count++; +#endif + p->deferredMoveto = 0; + p->cacheStatus = CACHE_STALE; + return SQLITE_OK; +} + +/* +** Something has moved cursor "p" out of place. Maybe the row it was +** pointed to was deleted out from under it. Or maybe the btree was +** rebalanced. Whatever the cause, try to restore "p" to the place it +** is supposed to be pointing. If the row was deleted out from under the +** cursor, set the cursor to point to a NULL row. +*/ +static int SQLITE_NOINLINE handleMovedCursor(VdbeCursor *p){ + int isDifferentRow, rc; + assert( p->pCursor!=0 ); + assert( sqlite3BtreeCursorHasMoved(p->pCursor) ); + rc = sqlite3BtreeCursorRestore(p->pCursor, &isDifferentRow); + p->cacheStatus = CACHE_STALE; + if( isDifferentRow ) p->nullRow = 1; + return rc; +} + +/* +** Check to ensure that the cursor is valid. Restore the cursor +** if need be. Return any I/O error from the restore operation. +*/ +SQLITE_PRIVATE int sqlite3VdbeCursorRestore(VdbeCursor *p){ + if( sqlite3BtreeCursorHasMoved(p->pCursor) ){ + return handleMovedCursor(p); + } + return SQLITE_OK; +} + +/* +** Make sure the cursor p is ready to read or write the row to which it +** was last positioned. Return an error code if an OOM fault or I/O error +** prevents us from positioning the cursor to its correct position. +** +** If a MoveTo operation is pending on the given cursor, then do that +** MoveTo now. If no move is pending, check to see if the row has been +** deleted out from under the cursor and if it has, mark the row as +** a NULL row. +** +** If the cursor is already pointing to the correct row and that row has +** not been deleted out from under the cursor, then this routine is a no-op. +*/ +SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor *p){ + if( p->deferredMoveto ){ + return handleDeferredMoveto(p); + } + if( p->pCursor && sqlite3BtreeCursorHasMoved(p->pCursor) ){ + return handleMovedCursor(p); + } + return SQLITE_OK; +} + +/* +** The following functions: +** +** sqlite3VdbeSerialType() +** sqlite3VdbeSerialTypeLen() +** sqlite3VdbeSerialLen() +** sqlite3VdbeSerialPut() +** sqlite3VdbeSerialGet() +** +** encapsulate the code that serializes values for storage in SQLite +** data and index records. Each serialized value consists of a +** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned +** integer, stored as a varint. +** +** In an SQLite index record, the serial type is stored directly before +** the blob of data that it corresponds to. In a table record, all serial +** types are stored at the start of the record, and the blobs of data at +** the end. Hence these functions allow the caller to handle the +** serial-type and data blob separately. +** +** The following table describes the various storage classes for data: +** +** serial type bytes of data type +** -------------- --------------- --------------- +** 0 0 NULL +** 1 1 signed integer +** 2 2 signed integer +** 3 3 signed integer +** 4 4 signed integer +** 5 6 signed integer +** 6 8 signed integer +** 7 8 IEEE float +** 8 0 Integer constant 0 +** 9 0 Integer constant 1 +** 10,11 reserved for expansion +** N>=12 and even (N-12)/2 BLOB +** N>=13 and odd (N-13)/2 text +** +** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions +** of SQLite will not understand those serial types. +*/ + +/* +** Return the serial-type for the value stored in pMem. +*/ +SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){ + int flags = pMem->flags; + u32 n; + + if( flags&MEM_Null ){ + return 0; + } + if( flags&MEM_Int ){ + /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */ +# define MAX_6BYTE ((((i64)0x00008000)<<32)-1) + i64 i = pMem->u.i; + u64 u; + if( i<0 ){ + u = ~i; + }else{ + u = i; + } + if( u<=127 ){ + return ((i&1)==i && file_format>=4) ? 8+(u32)u : 1; + } + if( u<=32767 ) return 2; + if( u<=8388607 ) return 3; + if( u<=2147483647 ) return 4; + if( u<=MAX_6BYTE ) return 5; + return 6; + } + if( flags&MEM_Real ){ + return 7; + } + assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) ); + assert( pMem->n>=0 ); + n = (u32)pMem->n; + if( flags & MEM_Zero ){ + n += pMem->u.nZero; + } + return ((n*2) + 12 + ((flags&MEM_Str)!=0)); +} + +/* +** The sizes for serial types less than 12 +*/ +static const u8 sqlite3SmallTypeSizes[] = { + 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, 0, 0 +}; + +/* +** Return the length of the data corresponding to the supplied serial-type. +*/ +SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32 serial_type){ + if( serial_type>=12 ){ + return (serial_type-12)/2; + }else{ + return sqlite3SmallTypeSizes[serial_type]; + } +} + +/* +** If we are on an architecture with mixed-endian floating +** points (ex: ARM7) then swap the lower 4 bytes with the +** upper 4 bytes. Return the result. +** +** For most architectures, this is a no-op. +** +** (later): It is reported to me that the mixed-endian problem +** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems +** that early versions of GCC stored the two words of a 64-bit +** float in the wrong order. And that error has been propagated +** ever since. The blame is not necessarily with GCC, though. +** GCC might have just copying the problem from a prior compiler. +** I am also told that newer versions of GCC that follow a different +** ABI get the byte order right. +** +** Developers using SQLite on an ARM7 should compile and run their +** application using -DSQLITE_DEBUG=1 at least once. With DEBUG +** enabled, some asserts below will ensure that the byte order of +** floating point values is correct. +** +** (2007-08-30) Frank van Vugt has studied this problem closely +** and has send his findings to the SQLite developers. Frank +** writes that some Linux kernels offer floating point hardware +** emulation that uses only 32-bit mantissas instead of a full +** 48-bits as required by the IEEE standard. (This is the +** CONFIG_FPE_FASTFPE option.) On such systems, floating point +** byte swapping becomes very complicated. To avoid problems, +** the necessary byte swapping is carried out using a 64-bit integer +** rather than a 64-bit float. Frank assures us that the code here +** works for him. We, the developers, have no way to independently +** verify this, but Frank seems to know what he is talking about +** so we trust him. +*/ +#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT +static u64 floatSwap(u64 in){ + union { + u64 r; + u32 i[2]; + } u; + u32 t; + + u.r = in; + t = u.i[0]; + u.i[0] = u.i[1]; + u.i[1] = t; + return u.r; +} +# define swapMixedEndianFloat(X) X = floatSwap(X) +#else +# define swapMixedEndianFloat(X) +#endif + +/* +** Write the serialized data blob for the value stored in pMem into +** buf. It is assumed that the caller has allocated sufficient space. +** Return the number of bytes written. +** +** nBuf is the amount of space left in buf[]. The caller is responsible +** for allocating enough space to buf[] to hold the entire field, exclusive +** of the pMem->u.nZero bytes for a MEM_Zero value. +** +** Return the number of bytes actually written into buf[]. The number +** of bytes in the zero-filled tail is included in the return value only +** if those bytes were zeroed in buf[]. +*/ +SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, Mem *pMem, u32 serial_type){ + u32 len; + + /* Integer and Real */ + if( serial_type<=7 && serial_type>0 ){ + u64 v; + u32 i; + if( serial_type==7 ){ + assert( sizeof(v)==sizeof(pMem->u.r) ); + memcpy(&v, &pMem->u.r, sizeof(v)); + swapMixedEndianFloat(v); + }else{ + v = pMem->u.i; + } + len = i = sqlite3SmallTypeSizes[serial_type]; + assert( i>0 ); + do{ + buf[--i] = (u8)(v&0xFF); + v >>= 8; + }while( i ); + return len; + } + + /* String or blob */ + if( serial_type>=12 ){ + assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0) + == (int)sqlite3VdbeSerialTypeLen(serial_type) ); + len = pMem->n; + memcpy(buf, pMem->z, len); + return len; + } + + /* NULL or constants 0 or 1 */ + return 0; +} + +/* Input "x" is a sequence of unsigned characters that represent a +** big-endian integer. Return the equivalent native integer +*/ +#define ONE_BYTE_INT(x) ((i8)(x)[0]) +#define TWO_BYTE_INT(x) (256*(i8)((x)[0])|(x)[1]) +#define THREE_BYTE_INT(x) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2]) +#define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3]) +#define FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3]) + +/* +** Deserialize the data blob pointed to by buf as serial type serial_type +** and store the result in pMem. Return the number of bytes read. +** +** This function is implemented as two separate routines for performance. +** The few cases that require local variables are broken out into a separate +** routine so that in most cases the overhead of moving the stack pointer +** is avoided. +*/ +static u32 SQLITE_NOINLINE serialGet( + const unsigned char *buf, /* Buffer to deserialize from */ + u32 serial_type, /* Serial type to deserialize */ + Mem *pMem /* Memory cell to write value into */ +){ + u64 x = FOUR_BYTE_UINT(buf); + u32 y = FOUR_BYTE_UINT(buf+4); + x = (x<<32) + y; + if( serial_type==6 ){ + /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit + ** twos-complement integer. */ + pMem->u.i = *(i64*)&x; + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + }else{ + /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit + ** floating point number. */ +#if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT) + /* Verify that integers and floating point values use the same + ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is + ** defined that 64-bit floating point values really are mixed + ** endian. + */ + static const u64 t1 = ((u64)0x3ff00000)<<32; + static const double r1 = 1.0; + u64 t2 = t1; + swapMixedEndianFloat(t2); + assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 ); +#endif + assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 ); + swapMixedEndianFloat(x); + memcpy(&pMem->u.r, &x, sizeof(x)); + pMem->flags = sqlite3IsNaN(pMem->u.r) ? MEM_Null : MEM_Real; + } + return 8; +} +SQLITE_PRIVATE u32 sqlite3VdbeSerialGet( + const unsigned char *buf, /* Buffer to deserialize from */ + u32 serial_type, /* Serial type to deserialize */ + Mem *pMem /* Memory cell to write value into */ +){ + switch( serial_type ){ + case 10: /* Reserved for future use */ + case 11: /* Reserved for future use */ + case 0: { /* Null */ + /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */ + pMem->flags = MEM_Null; + break; + } + case 1: { + /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement + ** integer. */ + pMem->u.i = ONE_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return 1; + } + case 2: { /* 2-byte signed integer */ + /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit + ** twos-complement integer. */ + pMem->u.i = TWO_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return 2; + } + case 3: { /* 3-byte signed integer */ + /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit + ** twos-complement integer. */ + pMem->u.i = THREE_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return 3; + } + case 4: { /* 4-byte signed integer */ + /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit + ** twos-complement integer. */ + pMem->u.i = FOUR_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return 4; + } + case 5: { /* 6-byte signed integer */ + /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit + ** twos-complement integer. */ + pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return 6; + } + case 6: /* 8-byte signed integer */ + case 7: { /* IEEE floating point */ + /* These use local variables, so do them in a separate routine + ** to avoid having to move the frame pointer in the common case */ + return serialGet(buf,serial_type,pMem); + } + case 8: /* Integer 0 */ + case 9: { /* Integer 1 */ + /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */ + /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */ + pMem->u.i = serial_type-8; + pMem->flags = MEM_Int; + return 0; + } + default: { + /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in + ** length. + ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and + ** (N-13)/2 bytes in length. */ + static const u16 aFlag[] = { MEM_Blob|MEM_Ephem, MEM_Str|MEM_Ephem }; + pMem->z = (char *)buf; + pMem->n = (serial_type-12)/2; + pMem->flags = aFlag[serial_type&1]; + return pMem->n; + } + } + return 0; +} +/* +** This routine is used to allocate sufficient space for an UnpackedRecord +** structure large enough to be used with sqlite3VdbeRecordUnpack() if +** the first argument is a pointer to KeyInfo structure pKeyInfo. +** +** The space is either allocated using sqlite3DbMallocRaw() or from within +** the unaligned buffer passed via the second and third arguments (presumably +** stack space). If the former, then *ppFree is set to a pointer that should +** be eventually freed by the caller using sqlite3DbFree(). Or, if the +** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL +** before returning. +** +** If an OOM error occurs, NULL is returned. +*/ +SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord( + KeyInfo *pKeyInfo, /* Description of the record */ + char *pSpace, /* Unaligned space available */ + int szSpace, /* Size of pSpace[] in bytes */ + char **ppFree /* OUT: Caller should free this pointer */ +){ + UnpackedRecord *p; /* Unpacked record to return */ + int nOff; /* Increment pSpace by nOff to align it */ + int nByte; /* Number of bytes required for *p */ + + /* We want to shift the pointer pSpace up such that it is 8-byte aligned. + ** Thus, we need to calculate a value, nOff, between 0 and 7, to shift + ** it by. If pSpace is already 8-byte aligned, nOff should be zero. + */ + nOff = (8 - (SQLITE_PTR_TO_INT(pSpace) & 7)) & 7; + nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1); + if( nByte>szSpace+nOff ){ + p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte); + *ppFree = (char *)p; + if( !p ) return 0; + }else{ + p = (UnpackedRecord*)&pSpace[nOff]; + *ppFree = 0; + } + + p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))]; + assert( pKeyInfo->aSortOrder!=0 ); + p->pKeyInfo = pKeyInfo; + p->nField = pKeyInfo->nField + 1; + return p; +} + +/* +** Given the nKey-byte encoding of a record in pKey[], populate the +** UnpackedRecord structure indicated by the fourth argument with the +** contents of the decoded record. +*/ +SQLITE_PRIVATE void sqlite3VdbeRecordUnpack( + KeyInfo *pKeyInfo, /* Information about the record format */ + int nKey, /* Size of the binary record */ + const void *pKey, /* The binary record */ + UnpackedRecord *p /* Populate this structure before returning. */ +){ + const unsigned char *aKey = (const unsigned char *)pKey; + int d; + u32 idx; /* Offset in aKey[] to read from */ + u16 u; /* Unsigned loop counter */ + u32 szHdr; + Mem *pMem = p->aMem; + + p->default_rc = 0; + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + idx = getVarint32(aKey, szHdr); + d = szHdr; + u = 0; + while( idxenc = pKeyInfo->enc; + pMem->db = pKeyInfo->db; + /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */ + pMem->szMalloc = 0; + d += sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem); + pMem++; + if( (++u)>=p->nField ) break; + } + assert( u<=pKeyInfo->nField + 1 ); + p->nField = u; +} + +#if SQLITE_DEBUG +/* +** This function compares two index or table record keys in the same way +** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(), +** this function deserializes and compares values using the +** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used +** in assert() statements to ensure that the optimized code in +** sqlite3VdbeRecordCompare() returns results with these two primitives. +** +** Return true if the result of comparison is equivalent to desiredResult. +** Return false if there is a disagreement. +*/ +static int vdbeRecordCompareDebug( + int nKey1, const void *pKey1, /* Left key */ + const UnpackedRecord *pPKey2, /* Right key */ + int desiredResult /* Correct answer */ +){ + u32 d1; /* Offset into aKey[] of next data element */ + u32 idx1; /* Offset into aKey[] of next header element */ + u32 szHdr1; /* Number of bytes in header */ + int i = 0; + int rc = 0; + const unsigned char *aKey1 = (const unsigned char *)pKey1; + KeyInfo *pKeyInfo; + Mem mem1; + + pKeyInfo = pPKey2->pKeyInfo; + if( pKeyInfo->db==0 ) return 1; + mem1.enc = pKeyInfo->enc; + mem1.db = pKeyInfo->db; + /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */ + VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */ + + /* Compilers may complain that mem1.u.i is potentially uninitialized. + ** We could initialize it, as shown here, to silence those complaints. + ** But in fact, mem1.u.i will never actually be used uninitialized, and doing + ** the unnecessary initialization has a measurable negative performance + ** impact, since this routine is a very high runner. And so, we choose + ** to ignore the compiler warnings and leave this variable uninitialized. + */ + /* mem1.u.i = 0; // not needed, here to silence compiler warning */ + + idx1 = getVarint32(aKey1, szHdr1); + if( szHdr1>98307 ) return SQLITE_CORRUPT; + d1 = szHdr1; + assert( pKeyInfo->nField+pKeyInfo->nXField>=pPKey2->nField || CORRUPT_DB ); + assert( pKeyInfo->aSortOrder!=0 ); + assert( pKeyInfo->nField>0 ); + assert( idx1<=szHdr1 || CORRUPT_DB ); + do{ + u32 serial_type1; + + /* Read the serial types for the next element in each key. */ + idx1 += getVarint32( aKey1+idx1, serial_type1 ); + + /* Verify that there is enough key space remaining to avoid + ** a buffer overread. The "d1+serial_type1+2" subexpression will + ** always be greater than or equal to the amount of required key space. + ** Use that approximation to avoid the more expensive call to + ** sqlite3VdbeSerialTypeLen() in the common case. + */ + if( d1+serial_type1+2>(u32)nKey1 + && d1+sqlite3VdbeSerialTypeLen(serial_type1)>(u32)nKey1 + ){ + break; + } + + /* Extract the values to be compared. + */ + d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1); + + /* Do the comparison + */ + rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i], pKeyInfo->aColl[i]); + if( rc!=0 ){ + assert( mem1.szMalloc==0 ); /* See comment below */ + if( pKeyInfo->aSortOrder[i] ){ + rc = -rc; /* Invert the result for DESC sort order. */ + } + goto debugCompareEnd; + } + i++; + }while( idx1nField ); + + /* No memory allocation is ever used on mem1. Prove this using + ** the following assert(). If the assert() fails, it indicates a + ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). + */ + assert( mem1.szMalloc==0 ); + + /* rc==0 here means that one of the keys ran out of fields and + ** all the fields up to that point were equal. Return the default_rc + ** value. */ + rc = pPKey2->default_rc; + +debugCompareEnd: + if( desiredResult==0 && rc==0 ) return 1; + if( desiredResult<0 && rc<0 ) return 1; + if( desiredResult>0 && rc>0 ) return 1; + if( CORRUPT_DB ) return 1; + if( pKeyInfo->db->mallocFailed ) return 1; + return 0; +} +#endif + +#if SQLITE_DEBUG +/* +** Count the number of fields (a.k.a. columns) in the record given by +** pKey,nKey. The verify that this count is less than or equal to the +** limit given by pKeyInfo->nField + pKeyInfo->nXField. +** +** If this constraint is not satisfied, it means that the high-speed +** vdbeRecordCompareInt() and vdbeRecordCompareString() routines will +** not work correctly. If this assert() ever fires, it probably means +** that the KeyInfo.nField or KeyInfo.nXField values were computed +** incorrectly. +*/ +static void vdbeAssertFieldCountWithinLimits( + int nKey, const void *pKey, /* The record to verify */ + const KeyInfo *pKeyInfo /* Compare size with this KeyInfo */ +){ + int nField = 0; + u32 szHdr; + u32 idx; + u32 notUsed; + const unsigned char *aKey = (const unsigned char*)pKey; + + if( CORRUPT_DB ) return; + idx = getVarint32(aKey, szHdr); + assert( nKey>=0 ); + assert( szHdr<=(u32)nKey ); + while( idxnField+pKeyInfo->nXField ); +} +#else +# define vdbeAssertFieldCountWithinLimits(A,B,C) +#endif + +/* +** Both *pMem1 and *pMem2 contain string values. Compare the two values +** using the collation sequence pColl. As usual, return a negative , zero +** or positive value if *pMem1 is less than, equal to or greater than +** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);". +*/ +static int vdbeCompareMemString( + const Mem *pMem1, + const Mem *pMem2, + const CollSeq *pColl, + u8 *prcErr /* If an OOM occurs, set to SQLITE_NOMEM */ +){ + if( pMem1->enc==pColl->enc ){ + /* The strings are already in the correct encoding. Call the + ** comparison function directly */ + return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z); + }else{ + int rc; + const void *v1, *v2; + int n1, n2; + Mem c1; + Mem c2; + sqlite3VdbeMemInit(&c1, pMem1->db, MEM_Null); + sqlite3VdbeMemInit(&c2, pMem1->db, MEM_Null); + sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem); + sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem); + v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc); + n1 = v1==0 ? 0 : c1.n; + v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc); + n2 = v2==0 ? 0 : c2.n; + rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2); + sqlite3VdbeMemRelease(&c1); + sqlite3VdbeMemRelease(&c2); + if( (v1==0 || v2==0) && prcErr ) *prcErr = SQLITE_NOMEM; + return rc; + } +} + +/* +** Compare two blobs. Return negative, zero, or positive if the first +** is less than, equal to, or greater than the second, respectively. +** If one blob is a prefix of the other, then the shorter is the lessor. +*/ +static SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem *pB2){ + int c = memcmp(pB1->z, pB2->z, pB1->n>pB2->n ? pB2->n : pB1->n); + if( c ) return c; + return pB1->n - pB2->n; +} + + +/* +** Compare the values contained by the two memory cells, returning +** negative, zero or positive if pMem1 is less than, equal to, or greater +** than pMem2. Sorting order is NULL's first, followed by numbers (integers +** and reals) sorted numerically, followed by text ordered by the collating +** sequence pColl and finally blob's ordered by memcmp(). +** +** Two NULL values are considered equal by this function. +*/ +SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){ + int f1, f2; + int combined_flags; + + f1 = pMem1->flags; + f2 = pMem2->flags; + combined_flags = f1|f2; + assert( (combined_flags & MEM_RowSet)==0 ); + + /* If one value is NULL, it is less than the other. If both values + ** are NULL, return 0. + */ + if( combined_flags&MEM_Null ){ + return (f2&MEM_Null) - (f1&MEM_Null); + } + + /* If one value is a number and the other is not, the number is less. + ** If both are numbers, compare as reals if one is a real, or as integers + ** if both values are integers. + */ + if( combined_flags&(MEM_Int|MEM_Real) ){ + double r1, r2; + if( (f1 & f2 & MEM_Int)!=0 ){ + if( pMem1->u.i < pMem2->u.i ) return -1; + if( pMem1->u.i > pMem2->u.i ) return 1; + return 0; + } + if( (f1&MEM_Real)!=0 ){ + r1 = pMem1->u.r; + }else if( (f1&MEM_Int)!=0 ){ + r1 = (double)pMem1->u.i; + }else{ + return 1; + } + if( (f2&MEM_Real)!=0 ){ + r2 = pMem2->u.r; + }else if( (f2&MEM_Int)!=0 ){ + r2 = (double)pMem2->u.i; + }else{ + return -1; + } + if( r1r2 ) return 1; + return 0; + } + + /* If one value is a string and the other is a blob, the string is less. + ** If both are strings, compare using the collating functions. + */ + if( combined_flags&MEM_Str ){ + if( (f1 & MEM_Str)==0 ){ + return 1; + } + if( (f2 & MEM_Str)==0 ){ + return -1; + } + + assert( pMem1->enc==pMem2->enc ); + assert( pMem1->enc==SQLITE_UTF8 || + pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE ); + + /* The collation sequence must be defined at this point, even if + ** the user deletes the collation sequence after the vdbe program is + ** compiled (this was not always the case). + */ + assert( !pColl || pColl->xCmp ); + + if( pColl ){ + return vdbeCompareMemString(pMem1, pMem2, pColl, 0); + } + /* If a NULL pointer was passed as the collate function, fall through + ** to the blob case and use memcmp(). */ + } + + /* Both values must be blobs. Compare using memcmp(). */ + return sqlite3BlobCompare(pMem1, pMem2); +} + + +/* +** The first argument passed to this function is a serial-type that +** corresponds to an integer - all values between 1 and 9 inclusive +** except 7. The second points to a buffer containing an integer value +** serialized according to serial_type. This function deserializes +** and returns the value. +*/ +static i64 vdbeRecordDecodeInt(u32 serial_type, const u8 *aKey){ + u32 y; + assert( CORRUPT_DB || (serial_type>=1 && serial_type<=9 && serial_type!=7) ); + switch( serial_type ){ + case 0: + case 1: + testcase( aKey[0]&0x80 ); + return ONE_BYTE_INT(aKey); + case 2: + testcase( aKey[0]&0x80 ); + return TWO_BYTE_INT(aKey); + case 3: + testcase( aKey[0]&0x80 ); + return THREE_BYTE_INT(aKey); + case 4: { + testcase( aKey[0]&0x80 ); + y = FOUR_BYTE_UINT(aKey); + return (i64)*(int*)&y; + } + case 5: { + testcase( aKey[0]&0x80 ); + return FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey); + } + case 6: { + u64 x = FOUR_BYTE_UINT(aKey); + testcase( aKey[0]&0x80 ); + x = (x<<32) | FOUR_BYTE_UINT(aKey+4); + return (i64)*(i64*)&x; + } + } + + return (serial_type - 8); +} + +/* +** This function compares the two table rows or index records +** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero +** or positive integer if key1 is less than, equal to or +** greater than key2. The {nKey1, pKey1} key must be a blob +** created by the OP_MakeRecord opcode of the VDBE. The pPKey2 +** key must be a parsed key such as obtained from +** sqlite3VdbeParseRecord. +** +** If argument bSkip is non-zero, it is assumed that the caller has already +** determined that the first fields of the keys are equal. +** +** Key1 and Key2 do not have to contain the same number of fields. If all +** fields that appear in both keys are equal, then pPKey2->default_rc is +** returned. +** +** If database corruption is discovered, set pPKey2->errCode to +** SQLITE_CORRUPT and return 0. If an OOM error is encountered, +** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the +** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db). +*/ +SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2, /* Right key */ + int bSkip /* If true, skip the first field */ +){ + u32 d1; /* Offset into aKey[] of next data element */ + int i; /* Index of next field to compare */ + u32 szHdr1; /* Size of record header in bytes */ + u32 idx1; /* Offset of first type in header */ + int rc = 0; /* Return value */ + Mem *pRhs = pPKey2->aMem; /* Next field of pPKey2 to compare */ + KeyInfo *pKeyInfo = pPKey2->pKeyInfo; + const unsigned char *aKey1 = (const unsigned char *)pKey1; + Mem mem1; + + /* If bSkip is true, then the caller has already determined that the first + ** two elements in the keys are equal. Fix the various stack variables so + ** that this routine begins comparing at the second field. */ + if( bSkip ){ + u32 s1; + idx1 = 1 + getVarint32(&aKey1[1], s1); + szHdr1 = aKey1[0]; + d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1); + i = 1; + pRhs++; + }else{ + idx1 = getVarint32(aKey1, szHdr1); + d1 = szHdr1; + if( d1>(unsigned)nKey1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + } + i = 0; + } + + VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */ + assert( pPKey2->pKeyInfo->nField+pPKey2->pKeyInfo->nXField>=pPKey2->nField + || CORRUPT_DB ); + assert( pPKey2->pKeyInfo->aSortOrder!=0 ); + assert( pPKey2->pKeyInfo->nField>0 ); + assert( idx1<=szHdr1 || CORRUPT_DB ); + do{ + u32 serial_type; + + /* RHS is an integer */ + if( pRhs->flags & MEM_Int ){ + serial_type = aKey1[idx1]; + testcase( serial_type==12 ); + if( serial_type>=10 ){ + rc = +1; + }else if( serial_type==0 ){ + rc = -1; + }else if( serial_type==7 ){ + double rhs = (double)pRhs->u.i; + sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1); + if( mem1.u.rrhs ){ + rc = +1; + } + }else{ + i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]); + i64 rhs = pRhs->u.i; + if( lhsrhs ){ + rc = +1; + } + } + } + + /* RHS is real */ + else if( pRhs->flags & MEM_Real ){ + serial_type = aKey1[idx1]; + if( serial_type>=10 ){ + /* Serial types 12 or greater are strings and blobs (greater than + ** numbers). Types 10 and 11 are currently "reserved for future + ** use", so it doesn't really matter what the results of comparing + ** them to numberic values are. */ + rc = +1; + }else if( serial_type==0 ){ + rc = -1; + }else{ + double rhs = pRhs->u.r; + double lhs; + sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1); + if( serial_type==7 ){ + lhs = mem1.u.r; + }else{ + lhs = (double)mem1.u.i; + } + if( lhsrhs ){ + rc = +1; + } + } + } + + /* RHS is a string */ + else if( pRhs->flags & MEM_Str ){ + getVarint32(&aKey1[idx1], serial_type); + testcase( serial_type==12 ); + if( serial_type<12 ){ + rc = -1; + }else if( !(serial_type & 0x01) ){ + rc = +1; + }else{ + mem1.n = (serial_type - 12) / 2; + testcase( (d1+mem1.n)==(unsigned)nKey1 ); + testcase( (d1+mem1.n+1)==(unsigned)nKey1 ); + if( (d1+mem1.n) > (unsigned)nKey1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + }else if( pKeyInfo->aColl[i] ){ + mem1.enc = pKeyInfo->enc; + mem1.db = pKeyInfo->db; + mem1.flags = MEM_Str; + mem1.z = (char*)&aKey1[d1]; + rc = vdbeCompareMemString( + &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode + ); + }else{ + int nCmp = MIN(mem1.n, pRhs->n); + rc = memcmp(&aKey1[d1], pRhs->z, nCmp); + if( rc==0 ) rc = mem1.n - pRhs->n; + } + } + } + + /* RHS is a blob */ + else if( pRhs->flags & MEM_Blob ){ + getVarint32(&aKey1[idx1], serial_type); + testcase( serial_type==12 ); + if( serial_type<12 || (serial_type & 0x01) ){ + rc = -1; + }else{ + int nStr = (serial_type - 12) / 2; + testcase( (d1+nStr)==(unsigned)nKey1 ); + testcase( (d1+nStr+1)==(unsigned)nKey1 ); + if( (d1+nStr) > (unsigned)nKey1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + }else{ + int nCmp = MIN(nStr, pRhs->n); + rc = memcmp(&aKey1[d1], pRhs->z, nCmp); + if( rc==0 ) rc = nStr - pRhs->n; + } + } + } + + /* RHS is null */ + else{ + serial_type = aKey1[idx1]; + rc = (serial_type!=0); + } + + if( rc!=0 ){ + if( pKeyInfo->aSortOrder[i] ){ + rc = -rc; + } + assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, rc) ); + assert( mem1.szMalloc==0 ); /* See comment below */ + return rc; + } + + i++; + pRhs++; + d1 += sqlite3VdbeSerialTypeLen(serial_type); + idx1 += sqlite3VarintLen(serial_type); + }while( idx1<(unsigned)szHdr1 && inField && d1<=(unsigned)nKey1 ); + + /* No memory allocation is ever used on mem1. Prove this using + ** the following assert(). If the assert() fails, it indicates a + ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). */ + assert( mem1.szMalloc==0 ); + + /* rc==0 here means that one or both of the keys ran out of fields and + ** all the fields up to that point were equal. Return the default_rc + ** value. */ + assert( CORRUPT_DB + || vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, pPKey2->default_rc) + || pKeyInfo->db->mallocFailed + ); + return pPKey2->default_rc; +} +SQLITE_PRIVATE int sqlite3VdbeRecordCompare( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2 /* Right key */ +){ + return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 0); +} + + +/* +** This function is an optimized version of sqlite3VdbeRecordCompare() +** that (a) the first field of pPKey2 is an integer, and (b) the +** size-of-header varint at the start of (pKey1/nKey1) fits in a single +** byte (i.e. is less than 128). +** +** To avoid concerns about buffer overreads, this routine is only used +** on schemas where the maximum valid header size is 63 bytes or less. +*/ +static int vdbeRecordCompareInt( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2 /* Right key */ +){ + const u8 *aKey = &((const u8*)pKey1)[*(const u8*)pKey1 & 0x3F]; + int serial_type = ((const u8*)pKey1)[1]; + int res; + u32 y; + u64 x; + i64 v = pPKey2->aMem[0].u.i; + i64 lhs; + + vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo); + assert( (*(u8*)pKey1)<=0x3F || CORRUPT_DB ); + switch( serial_type ){ + case 1: { /* 1-byte signed integer */ + lhs = ONE_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 2: { /* 2-byte signed integer */ + lhs = TWO_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 3: { /* 3-byte signed integer */ + lhs = THREE_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 4: { /* 4-byte signed integer */ + y = FOUR_BYTE_UINT(aKey); + lhs = (i64)*(int*)&y; + testcase( lhs<0 ); + break; + } + case 5: { /* 6-byte signed integer */ + lhs = FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 6: { /* 8-byte signed integer */ + x = FOUR_BYTE_UINT(aKey); + x = (x<<32) | FOUR_BYTE_UINT(aKey+4); + lhs = *(i64*)&x; + testcase( lhs<0 ); + break; + } + case 8: + lhs = 0; + break; + case 9: + lhs = 1; + break; + + /* This case could be removed without changing the results of running + ** this code. Including it causes gcc to generate a faster switch + ** statement (since the range of switch targets now starts at zero and + ** is contiguous) but does not cause any duplicate code to be generated + ** (as gcc is clever enough to combine the two like cases). Other + ** compilers might be similar. */ + case 0: case 7: + return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2); + + default: + return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2); + } + + if( v>lhs ){ + res = pPKey2->r1; + }else if( vr2; + }else if( pPKey2->nField>1 ){ + /* The first fields of the two keys are equal. Compare the trailing + ** fields. */ + res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1); + }else{ + /* The first fields of the two keys are equal and there are no trailing + ** fields. Return pPKey2->default_rc in this case. */ + res = pPKey2->default_rc; + } + + assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) ); + return res; +} + +/* +** This function is an optimized version of sqlite3VdbeRecordCompare() +** that (a) the first field of pPKey2 is a string, that (b) the first field +** uses the collation sequence BINARY and (c) that the size-of-header varint +** at the start of (pKey1/nKey1) fits in a single byte. +*/ +static int vdbeRecordCompareString( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2 /* Right key */ +){ + const u8 *aKey1 = (const u8*)pKey1; + int serial_type; + int res; + + vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo); + getVarint32(&aKey1[1], serial_type); + if( serial_type<12 ){ + res = pPKey2->r1; /* (pKey1/nKey1) is a number or a null */ + }else if( !(serial_type & 0x01) ){ + res = pPKey2->r2; /* (pKey1/nKey1) is a blob */ + }else{ + int nCmp; + int nStr; + int szHdr = aKey1[0]; + + nStr = (serial_type-12) / 2; + if( (szHdr + nStr) > nKey1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + } + nCmp = MIN( pPKey2->aMem[0].n, nStr ); + res = memcmp(&aKey1[szHdr], pPKey2->aMem[0].z, nCmp); + + if( res==0 ){ + res = nStr - pPKey2->aMem[0].n; + if( res==0 ){ + if( pPKey2->nField>1 ){ + res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1); + }else{ + res = pPKey2->default_rc; + } + }else if( res>0 ){ + res = pPKey2->r2; + }else{ + res = pPKey2->r1; + } + }else if( res>0 ){ + res = pPKey2->r2; + }else{ + res = pPKey2->r1; + } + } + + assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) + || CORRUPT_DB + || pPKey2->pKeyInfo->db->mallocFailed + ); + return res; +} + +/* +** Return a pointer to an sqlite3VdbeRecordCompare() compatible function +** suitable for comparing serialized records to the unpacked record passed +** as the only argument. +*/ +SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){ + /* varintRecordCompareInt() and varintRecordCompareString() both assume + ** that the size-of-header varint that occurs at the start of each record + ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt() + ** also assumes that it is safe to overread a buffer by at least the + ** maximum possible legal header size plus 8 bytes. Because there is + ** guaranteed to be at least 74 (but not 136) bytes of padding following each + ** buffer passed to varintRecordCompareInt() this makes it convenient to + ** limit the size of the header to 64 bytes in cases where the first field + ** is an integer. + ** + ** The easiest way to enforce this limit is to consider only records with + ** 13 fields or less. If the first field is an integer, the maximum legal + ** header size is (12*5 + 1 + 1) bytes. */ + if( (p->pKeyInfo->nField + p->pKeyInfo->nXField)<=13 ){ + int flags = p->aMem[0].flags; + if( p->pKeyInfo->aSortOrder[0] ){ + p->r1 = 1; + p->r2 = -1; + }else{ + p->r1 = -1; + p->r2 = 1; + } + if( (flags & MEM_Int) ){ + return vdbeRecordCompareInt; + } + testcase( flags & MEM_Real ); + testcase( flags & MEM_Null ); + testcase( flags & MEM_Blob ); + if( (flags & (MEM_Real|MEM_Null|MEM_Blob))==0 && p->pKeyInfo->aColl[0]==0 ){ + assert( flags & MEM_Str ); + return vdbeRecordCompareString; + } + } + + return sqlite3VdbeRecordCompare; +} + +/* +** pCur points at an index entry created using the OP_MakeRecord opcode. +** Read the rowid (the last field in the record) and store it in *rowid. +** Return SQLITE_OK if everything works, or an error code otherwise. +** +** pCur might be pointing to text obtained from a corrupt database file. +** So the content cannot be trusted. Do appropriate checks on the content. +*/ +SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){ + i64 nCellKey = 0; + int rc; + u32 szHdr; /* Size of the header */ + u32 typeRowid; /* Serial type of the rowid */ + u32 lenRowid; /* Size of the rowid */ + Mem m, v; + + /* Get the size of the index entry. Only indices entries of less + ** than 2GiB are support - anything large must be database corruption. + ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so + ** this code can safely assume that nCellKey is 32-bits + */ + assert( sqlite3BtreeCursorIsValid(pCur) ); + VVA_ONLY(rc =) sqlite3BtreeKeySize(pCur, &nCellKey); + assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */ + assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey ); + + /* Read in the complete content of the index entry */ + sqlite3VdbeMemInit(&m, db, 0); + rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, 1, &m); + if( rc ){ + return rc; + } + + /* The index entry must begin with a header size */ + (void)getVarint32((u8*)m.z, szHdr); + testcase( szHdr==3 ); + testcase( szHdr==m.n ); + if( unlikely(szHdr<3 || (int)szHdr>m.n) ){ + goto idx_rowid_corruption; + } + + /* The last field of the index should be an integer - the ROWID. + ** Verify that the last entry really is an integer. */ + (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid); + testcase( typeRowid==1 ); + testcase( typeRowid==2 ); + testcase( typeRowid==3 ); + testcase( typeRowid==4 ); + testcase( typeRowid==5 ); + testcase( typeRowid==6 ); + testcase( typeRowid==8 ); + testcase( typeRowid==9 ); + if( unlikely(typeRowid<1 || typeRowid>9 || typeRowid==7) ){ + goto idx_rowid_corruption; + } + lenRowid = sqlite3SmallTypeSizes[typeRowid]; + testcase( (u32)m.n==szHdr+lenRowid ); + if( unlikely((u32)m.npCursor; + Mem m; + + assert( sqlite3BtreeCursorIsValid(pCur) ); + VVA_ONLY(rc =) sqlite3BtreeKeySize(pCur, &nCellKey); + assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */ + /* nCellKey will always be between 0 and 0xffffffff because of the way + ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */ + if( nCellKey<=0 || nCellKey>0x7fffffff ){ + *res = 0; + return SQLITE_CORRUPT_BKPT; + } + sqlite3VdbeMemInit(&m, db, 0); + rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (u32)nCellKey, 1, &m); + if( rc ){ + return rc; + } + *res = sqlite3VdbeRecordCompare(m.n, m.z, pUnpacked); + sqlite3VdbeMemRelease(&m); + return SQLITE_OK; +} + +/* +** This routine sets the value to be returned by subsequent calls to +** sqlite3_changes() on the database handle 'db'. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){ + assert( sqlite3_mutex_held(db->mutex) ); + db->nChange = nChange; + db->nTotalChange += nChange; +} + +/* +** Set a flag in the vdbe to update the change counter when it is finalised +** or reset. +*/ +SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe *v){ + v->changeCntOn = 1; +} + +/* +** Mark every prepared statement associated with a database connection +** as expired. +** +** An expired statement means that recompilation of the statement is +** recommend. Statements expire when things happen that make their +** programs obsolete. Removing user-defined functions or collating +** sequences, or changing an authorization function are the types of +** things that make prepared statements obsolete. +*/ +SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3 *db){ + Vdbe *p; + for(p = db->pVdbe; p; p=p->pNext){ + p->expired = 1; + } +} + +/* +** Return the database associated with the Vdbe. +*/ +SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe *v){ + return v->db; +} + +/* +** Return a pointer to an sqlite3_value structure containing the value bound +** parameter iVar of VM v. Except, if the value is an SQL NULL, return +** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_* +** constants) to the value before returning it. +** +** The returned value must be freed by the caller using sqlite3ValueFree(). +*/ +SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff){ + assert( iVar>0 ); + if( v ){ + Mem *pMem = &v->aVar[iVar-1]; + if( 0==(pMem->flags & MEM_Null) ){ + sqlite3_value *pRet = sqlite3ValueNew(v->db); + if( pRet ){ + sqlite3VdbeMemCopy((Mem *)pRet, pMem); + sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8); + } + return pRet; + } + } + return 0; +} + +/* +** Configure SQL variable iVar so that binding a new value to it signals +** to sqlite3_reoptimize() that re-preparing the statement may result +** in a better query plan. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){ + assert( iVar>0 ); + if( iVar>32 ){ + v->expmask = 0xffffffff; + }else{ + v->expmask |= ((u32)1 << (iVar-1)); + } +} + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored +** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored +** in memory obtained from sqlite3DbMalloc). +*/ +SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){ + sqlite3 *db = p->db; + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg); + sqlite3_free(pVtab->zErrMsg); + pVtab->zErrMsg = 0; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/************** End of vdbeaux.c *********************************************/ +/************** Begin file vdbeapi.c *****************************************/ +/* +** 2004 May 26 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code use to implement APIs that are part of the +** VDBE. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Return TRUE (non-zero) of the statement supplied as an argument needs +** to be recompiled. A statement needs to be recompiled whenever the +** execution environment changes in a way that would alter the program +** that sqlite3_prepare() generates. For example, if new functions or +** collating sequences are registered or if an authorizer function is +** added or changed. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_expired(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe*)pStmt; + return p==0 || p->expired; +} +#endif + +/* +** Check on a Vdbe to make sure it has not been finalized. Log +** an error and return true if it has been finalized (or is otherwise +** invalid). Return false if it is ok. +*/ +static int vdbeSafety(Vdbe *p){ + if( p->db==0 ){ + sqlite3_log(SQLITE_MISUSE, "API called with finalized prepared statement"); + return 1; + }else{ + return 0; + } +} +static int vdbeSafetyNotNull(Vdbe *p){ + if( p==0 ){ + sqlite3_log(SQLITE_MISUSE, "API called with NULL prepared statement"); + return 1; + }else{ + return vdbeSafety(p); + } +} + +#ifndef SQLITE_OMIT_TRACE +/* +** Invoke the profile callback. This routine is only called if we already +** know that the profile callback is defined and needs to be invoked. +*/ +static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){ + sqlite3_int64 iNow; + assert( p->startTime>0 ); + assert( db->xProfile!=0 ); + assert( db->init.busy==0 ); + assert( p->zSql!=0 ); + sqlite3OsCurrentTimeInt64(db->pVfs, &iNow); + db->xProfile(db->pProfileArg, p->zSql, (iNow - p->startTime)*1000000); + p->startTime = 0; +} +/* +** The checkProfileCallback(DB,P) macro checks to see if a profile callback +** is needed, and it invokes the callback if it is needed. +*/ +# define checkProfileCallback(DB,P) \ + if( ((P)->startTime)>0 ){ invokeProfileCallback(DB,P); } +#else +# define checkProfileCallback(DB,P) /*no-op*/ +#endif + +/* +** The following routine destroys a virtual machine that is created by +** the sqlite3_compile() routine. The integer returned is an SQLITE_ +** success/failure code that describes the result of executing the virtual +** machine. +** +** This routine sets the error code and string returned by +** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_finalize(sqlite3_stmt *pStmt){ + int rc; + if( pStmt==0 ){ + /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL + ** pointer is a harmless no-op. */ + rc = SQLITE_OK; + }else{ + Vdbe *v = (Vdbe*)pStmt; + sqlite3 *db = v->db; + if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT; + sqlite3_mutex_enter(db->mutex); + checkProfileCallback(db, v); + rc = sqlite3VdbeFinalize(v); + rc = sqlite3ApiExit(db, rc); + sqlite3LeaveMutexAndCloseZombie(db); + } + return rc; +} + +/* +** Terminate the current execution of an SQL statement and reset it +** back to its starting state so that it can be reused. A success code from +** the prior execution is returned. +** +** This routine sets the error code and string returned by +** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_reset(sqlite3_stmt *pStmt){ + int rc; + if( pStmt==0 ){ + rc = SQLITE_OK; + }else{ + Vdbe *v = (Vdbe*)pStmt; + sqlite3 *db = v->db; + sqlite3_mutex_enter(db->mutex); + checkProfileCallback(db, v); + rc = sqlite3VdbeReset(v); + sqlite3VdbeRewind(v); + assert( (rc & (db->errMask))==rc ); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + } + return rc; +} + +/* +** Set all the parameters in the compiled SQL statement to NULL. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_clear_bindings(sqlite3_stmt *pStmt){ + int i; + int rc = SQLITE_OK; + Vdbe *p = (Vdbe*)pStmt; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex; +#endif + sqlite3_mutex_enter(mutex); + for(i=0; inVar; i++){ + sqlite3VdbeMemRelease(&p->aVar[i]); + p->aVar[i].flags = MEM_Null; + } + if( p->isPrepareV2 && p->expmask ){ + p->expired = 1; + } + sqlite3_mutex_leave(mutex); + return rc; +} + + +/**************************** sqlite3_value_ ******************************* +** The following routines extract information from a Mem or sqlite3_value +** structure. +*/ +SQLITE_API const void *SQLITE_STDCALL sqlite3_value_blob(sqlite3_value *pVal){ + Mem *p = (Mem*)pVal; + if( p->flags & (MEM_Blob|MEM_Str) ){ + if( sqlite3VdbeMemExpandBlob(p)!=SQLITE_OK ){ + assert( p->flags==MEM_Null && p->z==0 ); + return 0; + } + p->flags |= MEM_Blob; + return p->n ? p->z : 0; + }else{ + return sqlite3_value_text(pVal); + } +} +SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes(sqlite3_value *pVal){ + return sqlite3ValueBytes(pVal, SQLITE_UTF8); +} +SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes16(sqlite3_value *pVal){ + return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE); +} +SQLITE_API double SQLITE_STDCALL sqlite3_value_double(sqlite3_value *pVal){ + return sqlite3VdbeRealValue((Mem*)pVal); +} +SQLITE_API int SQLITE_STDCALL sqlite3_value_int(sqlite3_value *pVal){ + return (int)sqlite3VdbeIntValue((Mem*)pVal); +} +SQLITE_API sqlite_int64 SQLITE_STDCALL sqlite3_value_int64(sqlite3_value *pVal){ + return sqlite3VdbeIntValue((Mem*)pVal); +} +SQLITE_API unsigned int SQLITE_STDCALL sqlite3_value_subtype(sqlite3_value *pVal){ + return ((Mem*)pVal)->eSubtype; +} +SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_value_text(sqlite3_value *pVal){ + return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16(sqlite3_value* pVal){ + return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE); +} +SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16be(sqlite3_value *pVal){ + return sqlite3ValueText(pVal, SQLITE_UTF16BE); +} +SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16le(sqlite3_value *pVal){ + return sqlite3ValueText(pVal, SQLITE_UTF16LE); +} +#endif /* SQLITE_OMIT_UTF16 */ +/* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five +** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating +** point number string BLOB NULL +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_value_type(sqlite3_value* pVal){ + static const u8 aType[] = { + SQLITE_BLOB, /* 0x00 */ + SQLITE_NULL, /* 0x01 */ + SQLITE_TEXT, /* 0x02 */ + SQLITE_NULL, /* 0x03 */ + SQLITE_INTEGER, /* 0x04 */ + SQLITE_NULL, /* 0x05 */ + SQLITE_INTEGER, /* 0x06 */ + SQLITE_NULL, /* 0x07 */ + SQLITE_FLOAT, /* 0x08 */ + SQLITE_NULL, /* 0x09 */ + SQLITE_FLOAT, /* 0x0a */ + SQLITE_NULL, /* 0x0b */ + SQLITE_INTEGER, /* 0x0c */ + SQLITE_NULL, /* 0x0d */ + SQLITE_INTEGER, /* 0x0e */ + SQLITE_NULL, /* 0x0f */ + SQLITE_BLOB, /* 0x10 */ + SQLITE_NULL, /* 0x11 */ + SQLITE_TEXT, /* 0x12 */ + SQLITE_NULL, /* 0x13 */ + SQLITE_INTEGER, /* 0x14 */ + SQLITE_NULL, /* 0x15 */ + SQLITE_INTEGER, /* 0x16 */ + SQLITE_NULL, /* 0x17 */ + SQLITE_FLOAT, /* 0x18 */ + SQLITE_NULL, /* 0x19 */ + SQLITE_FLOAT, /* 0x1a */ + SQLITE_NULL, /* 0x1b */ + SQLITE_INTEGER, /* 0x1c */ + SQLITE_NULL, /* 0x1d */ + SQLITE_INTEGER, /* 0x1e */ + SQLITE_NULL, /* 0x1f */ + }; + return aType[pVal->flags&MEM_AffMask]; +} + +/* Make a copy of an sqlite3_value object +*/ +SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_value_dup(const sqlite3_value *pOrig){ + sqlite3_value *pNew; + if( pOrig==0 ) return 0; + pNew = sqlite3_malloc( sizeof(*pNew) ); + if( pNew==0 ) return 0; + memset(pNew, 0, sizeof(*pNew)); + memcpy(pNew, pOrig, MEMCELLSIZE); + pNew->flags &= ~MEM_Dyn; + pNew->db = 0; + if( pNew->flags&(MEM_Str|MEM_Blob) ){ + pNew->flags &= ~(MEM_Static|MEM_Dyn); + pNew->flags |= MEM_Ephem; + if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){ + sqlite3ValueFree(pNew); + pNew = 0; + } + } + return pNew; +} + +/* Destroy an sqlite3_value object previously obtained from +** sqlite3_value_dup(). +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_value_free(sqlite3_value *pOld){ + sqlite3ValueFree(pOld); +} + + +/**************************** sqlite3_result_ ******************************* +** The following routines are used by user-defined functions to specify +** the function result. +** +** The setStrOrError() function calls sqlite3VdbeMemSetStr() to store the +** result as a string or blob but if the string or blob is too large, it +** then sets the error code to SQLITE_TOOBIG +** +** The invokeValueDestructor(P,X) routine invokes destructor function X() +** on value P is not going to be used and need to be destroyed. +*/ +static void setResultStrOrError( + sqlite3_context *pCtx, /* Function context */ + const char *z, /* String pointer */ + int n, /* Bytes in string, or negative */ + u8 enc, /* Encoding of z. 0 for BLOBs */ + void (*xDel)(void*) /* Destructor function */ +){ + if( sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel)==SQLITE_TOOBIG ){ + sqlite3_result_error_toobig(pCtx); + } +} +static int invokeValueDestructor( + const void *p, /* Value to destroy */ + void (*xDel)(void*), /* The destructor */ + sqlite3_context *pCtx /* Set a SQLITE_TOOBIG error if no NULL */ +){ + assert( xDel!=SQLITE_DYNAMIC ); + if( xDel==0 ){ + /* noop */ + }else if( xDel==SQLITE_TRANSIENT ){ + /* noop */ + }else{ + xDel((void*)p); + } + if( pCtx ) sqlite3_result_error_toobig(pCtx); + return SQLITE_TOOBIG; +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_blob( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( n>=0 ); + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, 0, xDel); +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_blob64( + sqlite3_context *pCtx, + const void *z, + sqlite3_uint64 n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + assert( xDel!=SQLITE_DYNAMIC ); + if( n>0x7fffffff ){ + (void)invokeValueDestructor(z, xDel, pCtx); + }else{ + setResultStrOrError(pCtx, z, (int)n, 0, xDel); + } +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_double(sqlite3_context *pCtx, double rVal){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetDouble(pCtx->pOut, rVal); +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + pCtx->isError = SQLITE_ERROR; + pCtx->fErrorOrAux = 1; + sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API void SQLITE_STDCALL sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + pCtx->isError = SQLITE_ERROR; + pCtx->fErrorOrAux = 1; + sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT); +} +#endif +SQLITE_API void SQLITE_STDCALL sqlite3_result_int(sqlite3_context *pCtx, int iVal){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal); +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetInt64(pCtx->pOut, iVal); +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_null(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetNull(pCtx->pOut); +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + pCtx->pOut->eSubtype = eSubtype & 0xff; +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_text( + sqlite3_context *pCtx, + const char *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel); +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_text64( + sqlite3_context *pCtx, + const char *z, + sqlite3_uint64 n, + void (*xDel)(void *), + unsigned char enc +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + assert( xDel!=SQLITE_DYNAMIC ); + if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; + if( n>0x7fffffff ){ + (void)invokeValueDestructor(z, xDel, pCtx); + }else{ + setResultStrOrError(pCtx, z, (int)n, enc, xDel); + } +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API void SQLITE_STDCALL sqlite3_result_text16( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel); +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_text16be( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel); +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_text16le( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel); +} +#endif /* SQLITE_OMIT_UTF16 */ +SQLITE_API void SQLITE_STDCALL sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemCopy(pCtx->pOut, pValue); +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n); +} +SQLITE_API int SQLITE_STDCALL sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){ + Mem *pOut = pCtx->pOut; + assert( sqlite3_mutex_held(pOut->db->mutex) ); + if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){ + return SQLITE_TOOBIG; + } + sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n); + return SQLITE_OK; +} +SQLITE_API void SQLITE_STDCALL sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){ + pCtx->isError = errCode; + pCtx->fErrorOrAux = 1; +#ifdef SQLITE_DEBUG + if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode; +#endif + if( pCtx->pOut->flags & MEM_Null ){ + sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1, + SQLITE_UTF8, SQLITE_STATIC); + } +} + +/* Force an SQLITE_TOOBIG error. */ +SQLITE_API void SQLITE_STDCALL sqlite3_result_error_toobig(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + pCtx->isError = SQLITE_TOOBIG; + pCtx->fErrorOrAux = 1; + sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1, + SQLITE_UTF8, SQLITE_STATIC); +} + +/* An SQLITE_NOMEM error. */ +SQLITE_API void SQLITE_STDCALL sqlite3_result_error_nomem(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetNull(pCtx->pOut); + pCtx->isError = SQLITE_NOMEM; + pCtx->fErrorOrAux = 1; + pCtx->pOut->db->mallocFailed = 1; +} + +/* +** This function is called after a transaction has been committed. It +** invokes callbacks registered with sqlite3_wal_hook() as required. +*/ +static int doWalCallbacks(sqlite3 *db){ + int rc = SQLITE_OK; +#ifndef SQLITE_OMIT_WAL + int i; + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + int nEntry; + sqlite3BtreeEnter(pBt); + nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt)); + sqlite3BtreeLeave(pBt); + if( db->xWalCallback && nEntry>0 && rc==SQLITE_OK ){ + rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zName, nEntry); + } + } + } +#endif + return rc; +} + + +/* +** Execute the statement pStmt, either until a row of data is ready, the +** statement is completely executed or an error occurs. +** +** This routine implements the bulk of the logic behind the sqlite_step() +** API. The only thing omitted is the automatic recompile if a +** schema change has occurred. That detail is handled by the +** outer sqlite3_step() wrapper procedure. +*/ +static int sqlite3Step(Vdbe *p){ + sqlite3 *db; + int rc; + + assert(p); + if( p->magic!=VDBE_MAGIC_RUN ){ + /* We used to require that sqlite3_reset() be called before retrying + ** sqlite3_step() after any error or after SQLITE_DONE. But beginning + ** with version 3.7.0, we changed this so that sqlite3_reset() would + ** be called automatically instead of throwing the SQLITE_MISUSE error. + ** This "automatic-reset" change is not technically an incompatibility, + ** since any application that receives an SQLITE_MISUSE is broken by + ** definition. + ** + ** Nevertheless, some published applications that were originally written + ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE + ** returns, and those were broken by the automatic-reset change. As a + ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the + ** legacy behavior of returning SQLITE_MISUSE for cases where the + ** previous sqlite3_step() returned something other than a SQLITE_LOCKED + ** or SQLITE_BUSY error. + */ +#ifdef SQLITE_OMIT_AUTORESET + if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){ + sqlite3_reset((sqlite3_stmt*)p); + }else{ + return SQLITE_MISUSE_BKPT; + } +#else + sqlite3_reset((sqlite3_stmt*)p); +#endif + } + + /* Check that malloc() has not failed. If it has, return early. */ + db = p->db; + if( db->mallocFailed ){ + p->rc = SQLITE_NOMEM; + return SQLITE_NOMEM; + } + + if( p->pc<=0 && p->expired ){ + p->rc = SQLITE_SCHEMA; + rc = SQLITE_ERROR; + goto end_of_step; + } + if( p->pc<0 ){ + /* If there are no other statements currently running, then + ** reset the interrupt flag. This prevents a call to sqlite3_interrupt + ** from interrupting a statement that has not yet started. + */ + if( db->nVdbeActive==0 ){ + db->u1.isInterrupted = 0; + } + + assert( db->nVdbeWrite>0 || db->autoCommit==0 + || (db->nDeferredCons==0 && db->nDeferredImmCons==0) + ); + +#ifndef SQLITE_OMIT_TRACE + if( db->xProfile && !db->init.busy && p->zSql ){ + sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime); + }else{ + assert( p->startTime==0 ); + } +#endif + + db->nVdbeActive++; + if( p->readOnly==0 ) db->nVdbeWrite++; + if( p->bIsReader ) db->nVdbeRead++; + p->pc = 0; + } +#ifdef SQLITE_DEBUG + p->rcApp = SQLITE_OK; +#endif +#ifndef SQLITE_OMIT_EXPLAIN + if( p->explain ){ + rc = sqlite3VdbeList(p); + }else +#endif /* SQLITE_OMIT_EXPLAIN */ + { + db->nVdbeExec++; + rc = sqlite3VdbeExec(p); + db->nVdbeExec--; + } + +#ifndef SQLITE_OMIT_TRACE + /* If the statement completed successfully, invoke the profile callback */ + if( rc!=SQLITE_ROW ) checkProfileCallback(db, p); +#endif + + if( rc==SQLITE_DONE ){ + assert( p->rc==SQLITE_OK ); + p->rc = doWalCallbacks(db); + if( p->rc!=SQLITE_OK ){ + rc = SQLITE_ERROR; + } + } + + db->errCode = rc; + if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){ + p->rc = SQLITE_NOMEM; + } +end_of_step: + /* At this point local variable rc holds the value that should be + ** returned if this statement was compiled using the legacy + ** sqlite3_prepare() interface. According to the docs, this can only + ** be one of the values in the first assert() below. Variable p->rc + ** contains the value that would be returned if sqlite3_finalize() + ** were called on statement p. + */ + assert( rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR + || (rc&0xff)==SQLITE_BUSY || rc==SQLITE_MISUSE + ); + assert( (p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE) || p->rc==p->rcApp ); + if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){ + /* If this statement was prepared using sqlite3_prepare_v2(), and an + ** error has occurred, then return the error code in p->rc to the + ** caller. Set the error code in the database handle to the same value. + */ + rc = sqlite3VdbeTransferError(p); + } + return (rc&db->errMask); +} + +/* +** This is the top-level implementation of sqlite3_step(). Call +** sqlite3Step() to do most of the work. If a schema error occurs, +** call sqlite3Reprepare() and try again. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_step(sqlite3_stmt *pStmt){ + int rc = SQLITE_OK; /* Result from sqlite3Step() */ + int rc2 = SQLITE_OK; /* Result from sqlite3Reprepare() */ + Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */ + int cnt = 0; /* Counter to prevent infinite loop of reprepares */ + sqlite3 *db; /* The database connection */ + + if( vdbeSafetyNotNull(v) ){ + return SQLITE_MISUSE_BKPT; + } + db = v->db; + sqlite3_mutex_enter(db->mutex); + v->doingRerun = 0; + while( (rc = sqlite3Step(v))==SQLITE_SCHEMA + && cnt++ < SQLITE_MAX_SCHEMA_RETRY ){ + int savedPc = v->pc; + rc2 = rc = sqlite3Reprepare(v); + if( rc!=SQLITE_OK) break; + sqlite3_reset(pStmt); + if( savedPc>=0 ) v->doingRerun = 1; + assert( v->expired==0 ); + } + if( rc2!=SQLITE_OK ){ + /* This case occurs after failing to recompile an sql statement. + ** The error message from the SQL compiler has already been loaded + ** into the database handle. This block copies the error message + ** from the database handle into the statement and sets the statement + ** program counter to 0 to ensure that when the statement is + ** finalized or reset the parser error message is available via + ** sqlite3_errmsg() and sqlite3_errcode(). + */ + const char *zErr = (const char *)sqlite3_value_text(db->pErr); + sqlite3DbFree(db, v->zErrMsg); + if( !db->mallocFailed ){ + v->zErrMsg = sqlite3DbStrDup(db, zErr); + v->rc = rc2; + } else { + v->zErrMsg = 0; + v->rc = rc = SQLITE_NOMEM; + } + } + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + + +/* +** Extract the user data from a sqlite3_context structure and return a +** pointer to it. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_user_data(sqlite3_context *p){ + assert( p && p->pFunc ); + return p->pFunc->pUserData; +} + +/* +** Extract the user data from a sqlite3_context structure and return a +** pointer to it. +** +** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface +** returns a copy of the pointer to the database connection (the 1st +** parameter) of the sqlite3_create_function() and +** sqlite3_create_function16() routines that originally registered the +** application defined function. +*/ +SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_context_db_handle(sqlite3_context *p){ + assert( p && p->pOut ); + return p->pOut->db; +} + +/* +** Return the current time for a statement. If the current time +** is requested more than once within the same run of a single prepared +** statement, the exact same time is returned for each invocation regardless +** of the amount of time that elapses between invocations. In other words, +** the time returned is always the time of the first call. +*/ +SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){ + int rc; +#ifndef SQLITE_ENABLE_STAT3_OR_STAT4 + sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime; + assert( p->pVdbe!=0 ); +#else + sqlite3_int64 iTime = 0; + sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime; +#endif + if( *piTime==0 ){ + rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime); + if( rc ) *piTime = 0; + } + return *piTime; +} + +/* +** The following is the implementation of an SQL function that always +** fails with an error message stating that the function is used in the +** wrong context. The sqlite3_overload_function() API might construct +** SQL function that use this routine so that the functions will exist +** for name resolution but are actually overloaded by the xFindFunction +** method of virtual tables. +*/ +SQLITE_PRIVATE void sqlite3InvalidFunction( + sqlite3_context *context, /* The function calling context */ + int NotUsed, /* Number of arguments to the function */ + sqlite3_value **NotUsed2 /* Value of each argument */ +){ + const char *zName = context->pFunc->zName; + char *zErr; + UNUSED_PARAMETER2(NotUsed, NotUsed2); + zErr = sqlite3_mprintf( + "unable to use function %s in the requested context", zName); + sqlite3_result_error(context, zErr, -1); + sqlite3_free(zErr); +} + +/* +** Create a new aggregate context for p and return a pointer to +** its pMem->z element. +*/ +static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){ + Mem *pMem = p->pMem; + assert( (pMem->flags & MEM_Agg)==0 ); + if( nByte<=0 ){ + sqlite3VdbeMemSetNull(pMem); + pMem->z = 0; + }else{ + sqlite3VdbeMemClearAndResize(pMem, nByte); + pMem->flags = MEM_Agg; + pMem->u.pDef = p->pFunc; + if( pMem->z ){ + memset(pMem->z, 0, nByte); + } + } + return (void*)pMem->z; +} + +/* +** Allocate or return the aggregate context for a user function. A new +** context is allocated on the first call. Subsequent calls return the +** same context that was returned on prior calls. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context *p, int nByte){ + assert( p && p->pFunc && p->pFunc->xStep ); + assert( sqlite3_mutex_held(p->pOut->db->mutex) ); + testcase( nByte<0 ); + if( (p->pMem->flags & MEM_Agg)==0 ){ + return createAggContext(p, nByte); + }else{ + return (void*)p->pMem->z; + } +} + +/* +** Return the auxiliary data pointer, if any, for the iArg'th argument to +** the user-function defined by pCtx. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){ + AuxData *pAuxData; + + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); +#if SQLITE_ENABLE_STAT3_OR_STAT4 + if( pCtx->pVdbe==0 ) return 0; +#else + assert( pCtx->pVdbe!=0 ); +#endif + for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){ + if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break; + } + + return (pAuxData ? pAuxData->pAux : 0); +} + +/* +** Set the auxiliary data pointer and delete function, for the iArg'th +** argument to the user-function defined by pCtx. Any previous value is +** deleted by calling the delete function specified when it was set. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_set_auxdata( + sqlite3_context *pCtx, + int iArg, + void *pAux, + void (*xDelete)(void*) +){ + AuxData *pAuxData; + Vdbe *pVdbe = pCtx->pVdbe; + + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + if( iArg<0 ) goto failed; +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + if( pVdbe==0 ) goto failed; +#else + assert( pVdbe!=0 ); +#endif + + for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){ + if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break; + } + if( pAuxData==0 ){ + pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData)); + if( !pAuxData ) goto failed; + pAuxData->iOp = pCtx->iOp; + pAuxData->iArg = iArg; + pAuxData->pNext = pVdbe->pAuxData; + pVdbe->pAuxData = pAuxData; + if( pCtx->fErrorOrAux==0 ){ + pCtx->isError = 0; + pCtx->fErrorOrAux = 1; + } + }else if( pAuxData->xDelete ){ + pAuxData->xDelete(pAuxData->pAux); + } + + pAuxData->pAux = pAux; + pAuxData->xDelete = xDelete; + return; + +failed: + if( xDelete ){ + xDelete(pAux); + } +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Return the number of times the Step function of an aggregate has been +** called. +** +** This function is deprecated. Do not use it for new code. It is +** provide only to avoid breaking legacy code. New aggregate function +** implementations should keep their own counts within their aggregate +** context. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_aggregate_count(sqlite3_context *p){ + assert( p && p->pMem && p->pFunc && p->pFunc->xStep ); + return p->pMem->n; +} +#endif + +/* +** Return the number of columns in the result set for the statement pStmt. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_column_count(sqlite3_stmt *pStmt){ + Vdbe *pVm = (Vdbe *)pStmt; + return pVm ? pVm->nResColumn : 0; +} + +/* +** Return the number of values available from the current row of the +** currently executing statement pStmt. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_data_count(sqlite3_stmt *pStmt){ + Vdbe *pVm = (Vdbe *)pStmt; + if( pVm==0 || pVm->pResultSet==0 ) return 0; + return pVm->nResColumn; +} + +/* +** Return a pointer to static memory containing an SQL NULL value. +*/ +static const Mem *columnNullValue(void){ + /* Even though the Mem structure contains an element + ** of type i64, on certain architectures (x86) with certain compiler + ** switches (-Os), gcc may align this Mem object on a 4-byte boundary + ** instead of an 8-byte one. This all works fine, except that when + ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s + ** that a Mem structure is located on an 8-byte boundary. To prevent + ** these assert()s from failing, when building with SQLITE_DEBUG defined + ** using gcc, we force nullMem to be 8-byte aligned using the magical + ** __attribute__((aligned(8))) macro. */ + static const Mem nullMem +#if defined(SQLITE_DEBUG) && defined(__GNUC__) + __attribute__((aligned(8))) +#endif + = { + /* .u = */ {0}, + /* .flags = */ (u16)MEM_Null, + /* .enc = */ (u8)0, + /* .eSubtype = */ (u8)0, + /* .n = */ (int)0, + /* .z = */ (char*)0, + /* .zMalloc = */ (char*)0, + /* .szMalloc = */ (int)0, + /* .uTemp = */ (u32)0, + /* .db = */ (sqlite3*)0, + /* .xDel = */ (void(*)(void*))0, +#ifdef SQLITE_DEBUG + /* .pScopyFrom = */ (Mem*)0, + /* .pFiller = */ (void*)0, +#endif + }; + return &nullMem; +} + +/* +** Check to see if column iCol of the given statement is valid. If +** it is, return a pointer to the Mem for the value of that column. +** If iCol is not valid, return a pointer to a Mem which has a value +** of NULL. +*/ +static Mem *columnMem(sqlite3_stmt *pStmt, int i){ + Vdbe *pVm; + Mem *pOut; + + pVm = (Vdbe *)pStmt; + if( pVm && pVm->pResultSet!=0 && inResColumn && i>=0 ){ + sqlite3_mutex_enter(pVm->db->mutex); + pOut = &pVm->pResultSet[i]; + }else{ + if( pVm && ALWAYS(pVm->db) ){ + sqlite3_mutex_enter(pVm->db->mutex); + sqlite3Error(pVm->db, SQLITE_RANGE); + } + pOut = (Mem*)columnNullValue(); + } + return pOut; +} + +/* +** This function is called after invoking an sqlite3_value_XXX function on a +** column value (i.e. a value returned by evaluating an SQL expression in the +** select list of a SELECT statement) that may cause a malloc() failure. If +** malloc() has failed, the threads mallocFailed flag is cleared and the result +** code of statement pStmt set to SQLITE_NOMEM. +** +** Specifically, this is called from within: +** +** sqlite3_column_int() +** sqlite3_column_int64() +** sqlite3_column_text() +** sqlite3_column_text16() +** sqlite3_column_real() +** sqlite3_column_bytes() +** sqlite3_column_bytes16() +** sqiite3_column_blob() +*/ +static void columnMallocFailure(sqlite3_stmt *pStmt) +{ + /* If malloc() failed during an encoding conversion within an + ** sqlite3_column_XXX API, then set the return code of the statement to + ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR + ** and _finalize() will return NOMEM. + */ + Vdbe *p = (Vdbe *)pStmt; + if( p ){ + p->rc = sqlite3ApiExit(p->db, p->rc); + sqlite3_mutex_leave(p->db->mutex); + } +} + +/**************************** sqlite3_column_ ******************************* +** The following routines are used to access elements of the current row +** in the result set. +*/ +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_blob(sqlite3_stmt *pStmt, int i){ + const void *val; + val = sqlite3_value_blob( columnMem(pStmt,i) ); + /* Even though there is no encoding conversion, value_blob() might + ** need to call malloc() to expand the result of a zeroblob() + ** expression. + */ + columnMallocFailure(pStmt); + return val; +} +SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){ + int val = sqlite3_value_bytes( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){ + int val = sqlite3_value_bytes16( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API double SQLITE_STDCALL sqlite3_column_double(sqlite3_stmt *pStmt, int i){ + double val = sqlite3_value_double( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API int SQLITE_STDCALL sqlite3_column_int(sqlite3_stmt *pStmt, int i){ + int val = sqlite3_value_int( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API sqlite_int64 SQLITE_STDCALL sqlite3_column_int64(sqlite3_stmt *pStmt, int i){ + sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_column_text(sqlite3_stmt *pStmt, int i){ + const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_column_value(sqlite3_stmt *pStmt, int i){ + Mem *pOut = columnMem(pStmt, i); + if( pOut->flags&MEM_Static ){ + pOut->flags &= ~MEM_Static; + pOut->flags |= MEM_Ephem; + } + columnMallocFailure(pStmt); + return (sqlite3_value *)pOut; +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_text16(sqlite3_stmt *pStmt, int i){ + const void *val = sqlite3_value_text16( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +#endif /* SQLITE_OMIT_UTF16 */ +SQLITE_API int SQLITE_STDCALL sqlite3_column_type(sqlite3_stmt *pStmt, int i){ + int iType = sqlite3_value_type( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return iType; +} + +/* +** Convert the N-th element of pStmt->pColName[] into a string using +** xFunc() then return that string. If N is out of range, return 0. +** +** There are up to 5 names for each column. useType determines which +** name is returned. Here are the names: +** +** 0 The column name as it should be displayed for output +** 1 The datatype name for the column +** 2 The name of the database that the column derives from +** 3 The name of the table that the column derives from +** 4 The name of the table column that the result column derives from +** +** If the result is not a simple column reference (if it is an expression +** or a constant) then useTypes 2, 3, and 4 return NULL. +*/ +static const void *columnName( + sqlite3_stmt *pStmt, + int N, + const void *(*xFunc)(Mem*), + int useType +){ + const void *ret; + Vdbe *p; + int n; + sqlite3 *db; +#ifdef SQLITE_ENABLE_API_ARMOR + if( pStmt==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + ret = 0; + p = (Vdbe *)pStmt; + db = p->db; + assert( db!=0 ); + n = sqlite3_column_count(pStmt); + if( N=0 ){ + N += useType*n; + sqlite3_mutex_enter(db->mutex); + assert( db->mallocFailed==0 ); + ret = xFunc(&p->aColName[N]); + /* A malloc may have failed inside of the xFunc() call. If this + ** is the case, clear the mallocFailed flag and return NULL. + */ + if( db->mallocFailed ){ + db->mallocFailed = 0; + ret = 0; + } + sqlite3_mutex_leave(db->mutex); + } + return ret; +} + +/* +** Return the name of the Nth column of the result set returned by SQL +** statement pStmt. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_column_name(sqlite3_stmt *pStmt, int N){ + return columnName( + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_name16(sqlite3_stmt *pStmt, int N){ + return columnName( + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME); +} +#endif + +/* +** Constraint: If you have ENABLE_COLUMN_METADATA then you must +** not define OMIT_DECLTYPE. +*/ +#if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA) +# error "Must not define both SQLITE_OMIT_DECLTYPE \ + and SQLITE_ENABLE_COLUMN_METADATA" +#endif + +#ifndef SQLITE_OMIT_DECLTYPE +/* +** Return the column declaration type (if applicable) of the 'i'th column +** of the result set of SQL statement pStmt. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){ + return columnName( + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){ + return columnName( + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE); +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_OMIT_DECLTYPE */ + +#ifdef SQLITE_ENABLE_COLUMN_METADATA +/* +** Return the name of the database from which a result column derives. +** NULL is returned if the result column is an expression or constant or +** anything else which is not an unambiguous reference to a database column. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){ + return columnName( + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){ + return columnName( + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE); +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the name of the table from which a result column derives. +** NULL is returned if the result column is an expression or constant or +** anything else which is not an unambiguous reference to a database column. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){ + return columnName( + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){ + return columnName( + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE); +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the name of the table column from which a result column derives. +** NULL is returned if the result column is an expression or constant or +** anything else which is not an unambiguous reference to a database column. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){ + return columnName( + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *SQLITE_STDCALL sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){ + return columnName( + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN); +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_ENABLE_COLUMN_METADATA */ + + +/******************************* sqlite3_bind_ *************************** +** +** Routines used to attach values to wildcards in a compiled SQL statement. +*/ +/* +** Unbind the value bound to variable i in virtual machine p. This is the +** the same as binding a NULL value to the column. If the "i" parameter is +** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK. +** +** A successful evaluation of this routine acquires the mutex on p. +** the mutex is released if any kind of error occurs. +** +** The error code stored in database p->db is overwritten with the return +** value in any case. +*/ +static int vdbeUnbind(Vdbe *p, int i){ + Mem *pVar; + if( vdbeSafetyNotNull(p) ){ + return SQLITE_MISUSE_BKPT; + } + sqlite3_mutex_enter(p->db->mutex); + if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){ + sqlite3Error(p->db, SQLITE_MISUSE); + sqlite3_mutex_leave(p->db->mutex); + sqlite3_log(SQLITE_MISUSE, + "bind on a busy prepared statement: [%s]", p->zSql); + return SQLITE_MISUSE_BKPT; + } + if( i<1 || i>p->nVar ){ + sqlite3Error(p->db, SQLITE_RANGE); + sqlite3_mutex_leave(p->db->mutex); + return SQLITE_RANGE; + } + i--; + pVar = &p->aVar[i]; + sqlite3VdbeMemRelease(pVar); + pVar->flags = MEM_Null; + sqlite3Error(p->db, SQLITE_OK); + + /* If the bit corresponding to this variable in Vdbe.expmask is set, then + ** binding a new value to this variable invalidates the current query plan. + ** + ** IMPLEMENTATION-OF: R-48440-37595 If the specific value bound to host + ** parameter in the WHERE clause might influence the choice of query plan + ** for a statement, then the statement will be automatically recompiled, + ** as if there had been a schema change, on the first sqlite3_step() call + ** following any change to the bindings of that parameter. + */ + if( p->isPrepareV2 && + ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff) + ){ + p->expired = 1; + } + return SQLITE_OK; +} + +/* +** Bind a text or BLOB value. +*/ +static int bindText( + sqlite3_stmt *pStmt, /* The statement to bind against */ + int i, /* Index of the parameter to bind */ + const void *zData, /* Pointer to the data to be bound */ + int nData, /* Number of bytes of data to be bound */ + void (*xDel)(void*), /* Destructor for the data */ + u8 encoding /* Encoding for the data */ +){ + Vdbe *p = (Vdbe *)pStmt; + Mem *pVar; + int rc; + + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + if( zData!=0 ){ + pVar = &p->aVar[i-1]; + rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel); + if( rc==SQLITE_OK && encoding!=0 ){ + rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db)); + } + sqlite3Error(p->db, rc); + rc = sqlite3ApiExit(p->db, rc); + } + sqlite3_mutex_leave(p->db->mutex); + }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){ + xDel((void*)zData); + } + return rc; +} + + +/* +** Bind a blob value to an SQL statement variable. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob( + sqlite3_stmt *pStmt, + int i, + const void *zData, + int nData, + void (*xDel)(void*) +){ + return bindText(pStmt, i, zData, nData, xDel, 0); +} +SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob64( + sqlite3_stmt *pStmt, + int i, + const void *zData, + sqlite3_uint64 nData, + void (*xDel)(void*) +){ + assert( xDel!=SQLITE_DYNAMIC ); + if( nData>0x7fffffff ){ + return invokeValueDestructor(zData, xDel, 0); + }else{ + return bindText(pStmt, i, zData, (int)nData, xDel, 0); + } +} +SQLITE_API int SQLITE_STDCALL sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue); + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int SQLITE_STDCALL sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){ + return sqlite3_bind_int64(p, i, (i64)iValue); +} +SQLITE_API int SQLITE_STDCALL sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue); + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int SQLITE_STDCALL sqlite3_bind_null(sqlite3_stmt *pStmt, int i){ + int rc; + Vdbe *p = (Vdbe*)pStmt; + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int SQLITE_STDCALL sqlite3_bind_text( + sqlite3_stmt *pStmt, + int i, + const char *zData, + int nData, + void (*xDel)(void*) +){ + return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8); +} +SQLITE_API int SQLITE_STDCALL sqlite3_bind_text64( + sqlite3_stmt *pStmt, + int i, + const char *zData, + sqlite3_uint64 nData, + void (*xDel)(void*), + unsigned char enc +){ + assert( xDel!=SQLITE_DYNAMIC ); + if( nData>0x7fffffff ){ + return invokeValueDestructor(zData, xDel, 0); + }else{ + if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; + return bindText(pStmt, i, zData, (int)nData, xDel, enc); + } +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API int SQLITE_STDCALL sqlite3_bind_text16( + sqlite3_stmt *pStmt, + int i, + const void *zData, + int nData, + void (*xDel)(void*) +){ + return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE); +} +#endif /* SQLITE_OMIT_UTF16 */ +SQLITE_API int SQLITE_STDCALL sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){ + int rc; + switch( sqlite3_value_type((sqlite3_value*)pValue) ){ + case SQLITE_INTEGER: { + rc = sqlite3_bind_int64(pStmt, i, pValue->u.i); + break; + } + case SQLITE_FLOAT: { + rc = sqlite3_bind_double(pStmt, i, pValue->u.r); + break; + } + case SQLITE_BLOB: { + if( pValue->flags & MEM_Zero ){ + rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero); + }else{ + rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT); + } + break; + } + case SQLITE_TEXT: { + rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT, + pValue->enc); + break; + } + default: { + rc = sqlite3_bind_null(pStmt, i); + break; + } + } + return rc; +} +SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + rc = vdbeUnbind(p, i); + if( rc==SQLITE_OK ){ + sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n); + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + sqlite3_mutex_enter(p->db->mutex); + if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){ + rc = SQLITE_TOOBIG; + }else{ + assert( (n & 0x7FFFFFFF)==n ); + rc = sqlite3_bind_zeroblob(pStmt, i, n); + } + rc = sqlite3ApiExit(p->db, rc); + sqlite3_mutex_leave(p->db->mutex); + return rc; +} + +/* +** Return the number of wildcards that can be potentially bound to. +** This routine is added to support DBD::SQLite. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe*)pStmt; + return p ? p->nVar : 0; +} + +/* +** Return the name of a wildcard parameter. Return NULL if the index +** is out of range or if the wildcard is unnamed. +** +** The result is always UTF-8. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){ + Vdbe *p = (Vdbe*)pStmt; + if( p==0 || i<1 || i>p->nzVar ){ + return 0; + } + return p->azVar[i-1]; +} + +/* +** Given a wildcard parameter name, return the index of the variable +** with that name. If there is no variable with the given name, +** return 0. +*/ +SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){ + int i; + if( p==0 ){ + return 0; + } + if( zName ){ + for(i=0; inzVar; i++){ + const char *z = p->azVar[i]; + if( z && strncmp(z,zName,nName)==0 && z[nName]==0 ){ + return i+1; + } + } + } + return 0; +} +SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){ + return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName)); +} + +/* +** Transfer all bindings from the first statement over to the second. +*/ +SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){ + Vdbe *pFrom = (Vdbe*)pFromStmt; + Vdbe *pTo = (Vdbe*)pToStmt; + int i; + assert( pTo->db==pFrom->db ); + assert( pTo->nVar==pFrom->nVar ); + sqlite3_mutex_enter(pTo->db->mutex); + for(i=0; inVar; i++){ + sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]); + } + sqlite3_mutex_leave(pTo->db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Deprecated external interface. Internal/core SQLite code +** should call sqlite3TransferBindings. +** +** It is misuse to call this routine with statements from different +** database connections. But as this is a deprecated interface, we +** will not bother to check for that condition. +** +** If the two statements contain a different number of bindings, then +** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise +** SQLITE_OK is returned. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){ + Vdbe *pFrom = (Vdbe*)pFromStmt; + Vdbe *pTo = (Vdbe*)pToStmt; + if( pFrom->nVar!=pTo->nVar ){ + return SQLITE_ERROR; + } + if( pTo->isPrepareV2 && pTo->expmask ){ + pTo->expired = 1; + } + if( pFrom->isPrepareV2 && pFrom->expmask ){ + pFrom->expired = 1; + } + return sqlite3TransferBindings(pFromStmt, pToStmt); +} +#endif + +/* +** Return the sqlite3* database handle to which the prepared statement given +** in the argument belongs. This is the same database handle that was +** the first argument to the sqlite3_prepare() that was used to create +** the statement in the first place. +*/ +SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_db_handle(sqlite3_stmt *pStmt){ + return pStmt ? ((Vdbe*)pStmt)->db : 0; +} + +/* +** Return true if the prepared statement is guaranteed to not modify the +** database. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_stmt_readonly(sqlite3_stmt *pStmt){ + return pStmt ? ((Vdbe*)pStmt)->readOnly : 1; +} + +/* +** Return true if the prepared statement is in need of being reset. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_stmt_busy(sqlite3_stmt *pStmt){ + Vdbe *v = (Vdbe*)pStmt; + return v!=0 && v->pc>=0 && v->magic==VDBE_MAGIC_RUN; +} + +/* +** Return a pointer to the next prepared statement after pStmt associated +** with database connection pDb. If pStmt is NULL, return the first +** prepared statement for the database connection. Return NULL if there +** are no more. +*/ +SQLITE_API sqlite3_stmt *SQLITE_STDCALL sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){ + sqlite3_stmt *pNext; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(pDb) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(pDb->mutex); + if( pStmt==0 ){ + pNext = (sqlite3_stmt*)pDb->pVdbe; + }else{ + pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext; + } + sqlite3_mutex_leave(pDb->mutex); + return pNext; +} + +/* +** Return the value of a status counter for a prepared statement +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){ + Vdbe *pVdbe = (Vdbe*)pStmt; + u32 v; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !pStmt ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + v = pVdbe->aCounter[op]; + if( resetFlag ) pVdbe->aCounter[op] = 0; + return (int)v; +} + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +/* +** Return status data for a single loop within query pStmt. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_stmt_scanstatus( + sqlite3_stmt *pStmt, /* Prepared statement being queried */ + int idx, /* Index of loop to report on */ + int iScanStatusOp, /* Which metric to return */ + void *pOut /* OUT: Write the answer here */ +){ + Vdbe *p = (Vdbe*)pStmt; + ScanStatus *pScan; + if( idx<0 || idx>=p->nScan ) return 1; + pScan = &p->aScan[idx]; + switch( iScanStatusOp ){ + case SQLITE_SCANSTAT_NLOOP: { + *(sqlite3_int64*)pOut = p->anExec[pScan->addrLoop]; + break; + } + case SQLITE_SCANSTAT_NVISIT: { + *(sqlite3_int64*)pOut = p->anExec[pScan->addrVisit]; + break; + } + case SQLITE_SCANSTAT_EST: { + double r = 1.0; + LogEst x = pScan->nEst; + while( x<100 ){ + x += 10; + r *= 0.5; + } + *(double*)pOut = r*sqlite3LogEstToInt(x); + break; + } + case SQLITE_SCANSTAT_NAME: { + *(const char**)pOut = pScan->zName; + break; + } + case SQLITE_SCANSTAT_EXPLAIN: { + if( pScan->addrExplain ){ + *(const char**)pOut = p->aOp[ pScan->addrExplain ].p4.z; + }else{ + *(const char**)pOut = 0; + } + break; + } + case SQLITE_SCANSTAT_SELECTID: { + if( pScan->addrExplain ){ + *(int*)pOut = p->aOp[ pScan->addrExplain ].p1; + }else{ + *(int*)pOut = -1; + } + break; + } + default: { + return 1; + } + } + return 0; +} + +/* +** Zero all counters associated with the sqlite3_stmt_scanstatus() data. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe*)pStmt; + memset(p->anExec, 0, p->nOp * sizeof(i64)); +} +#endif /* SQLITE_ENABLE_STMT_SCANSTATUS */ + +/************** End of vdbeapi.c *********************************************/ +/************** Begin file vdbetrace.c ***************************************/ +/* +** 2009 November 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code used to insert the values of host parameters +** (aka "wildcards") into the SQL text output by sqlite3_trace(). +** +** The Vdbe parse-tree explainer is also found here. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#ifndef SQLITE_OMIT_TRACE + +/* +** zSql is a zero-terminated string of UTF-8 SQL text. Return the number of +** bytes in this text up to but excluding the first character in +** a host parameter. If the text contains no host parameters, return +** the total number of bytes in the text. +*/ +static int findNextHostParameter(const char *zSql, int *pnToken){ + int tokenType; + int nTotal = 0; + int n; + + *pnToken = 0; + while( zSql[0] ){ + n = sqlite3GetToken((u8*)zSql, &tokenType); + assert( n>0 && tokenType!=TK_ILLEGAL ); + if( tokenType==TK_VARIABLE ){ + *pnToken = n; + break; + } + nTotal += n; + zSql += n; + } + return nTotal; +} + +/* +** This function returns a pointer to a nul-terminated string in memory +** obtained from sqlite3DbMalloc(). If sqlite3.nVdbeExec is 1, then the +** string contains a copy of zRawSql but with host parameters expanded to +** their current bindings. Or, if sqlite3.nVdbeExec is greater than 1, +** then the returned string holds a copy of zRawSql with "-- " prepended +** to each line of text. +** +** If the SQLITE_TRACE_SIZE_LIMIT macro is defined to an integer, then +** then long strings and blobs are truncated to that many bytes. This +** can be used to prevent unreasonably large trace strings when dealing +** with large (multi-megabyte) strings and blobs. +** +** The calling function is responsible for making sure the memory returned +** is eventually freed. +** +** ALGORITHM: Scan the input string looking for host parameters in any of +** these forms: ?, ?N, $A, @A, :A. Take care to avoid text within +** string literals, quoted identifier names, and comments. For text forms, +** the host parameter index is found by scanning the prepared +** statement for the corresponding OP_Variable opcode. Once the host +** parameter index is known, locate the value in p->aVar[]. Then render +** the value as a literal in place of the host parameter name. +*/ +SQLITE_PRIVATE char *sqlite3VdbeExpandSql( + Vdbe *p, /* The prepared statement being evaluated */ + const char *zRawSql /* Raw text of the SQL statement */ +){ + sqlite3 *db; /* The database connection */ + int idx = 0; /* Index of a host parameter */ + int nextIndex = 1; /* Index of next ? host parameter */ + int n; /* Length of a token prefix */ + int nToken; /* Length of the parameter token */ + int i; /* Loop counter */ + Mem *pVar; /* Value of a host parameter */ + StrAccum out; /* Accumulate the output here */ + char zBase[100]; /* Initial working space */ + + db = p->db; + sqlite3StrAccumInit(&out, db, zBase, sizeof(zBase), + db->aLimit[SQLITE_LIMIT_LENGTH]); + if( db->nVdbeExec>1 ){ + while( *zRawSql ){ + const char *zStart = zRawSql; + while( *(zRawSql++)!='\n' && *zRawSql ); + sqlite3StrAccumAppend(&out, "-- ", 3); + assert( (zRawSql - zStart) > 0 ); + sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart)); + } + }else if( p->nVar==0 ){ + sqlite3StrAccumAppend(&out, zRawSql, sqlite3Strlen30(zRawSql)); + }else{ + while( zRawSql[0] ){ + n = findNextHostParameter(zRawSql, &nToken); + assert( n>0 ); + sqlite3StrAccumAppend(&out, zRawSql, n); + zRawSql += n; + assert( zRawSql[0] || nToken==0 ); + if( nToken==0 ) break; + if( zRawSql[0]=='?' ){ + if( nToken>1 ){ + assert( sqlite3Isdigit(zRawSql[1]) ); + sqlite3GetInt32(&zRawSql[1], &idx); + }else{ + idx = nextIndex; + } + }else{ + assert( zRawSql[0]==':' || zRawSql[0]=='$' || + zRawSql[0]=='@' || zRawSql[0]=='#' ); + testcase( zRawSql[0]==':' ); + testcase( zRawSql[0]=='$' ); + testcase( zRawSql[0]=='@' ); + testcase( zRawSql[0]=='#' ); + idx = sqlite3VdbeParameterIndex(p, zRawSql, nToken); + assert( idx>0 ); + } + zRawSql += nToken; + nextIndex = idx + 1; + assert( idx>0 && idx<=p->nVar ); + pVar = &p->aVar[idx-1]; + if( pVar->flags & MEM_Null ){ + sqlite3StrAccumAppend(&out, "NULL", 4); + }else if( pVar->flags & MEM_Int ){ + sqlite3XPrintf(&out, 0, "%lld", pVar->u.i); + }else if( pVar->flags & MEM_Real ){ + sqlite3XPrintf(&out, 0, "%!.15g", pVar->u.r); + }else if( pVar->flags & MEM_Str ){ + int nOut; /* Number of bytes of the string text to include in output */ +#ifndef SQLITE_OMIT_UTF16 + u8 enc = ENC(db); + Mem utf8; + if( enc!=SQLITE_UTF8 ){ + memset(&utf8, 0, sizeof(utf8)); + utf8.db = db; + sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC); + sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8); + pVar = &utf8; + } +#endif + nOut = pVar->n; +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOut>SQLITE_TRACE_SIZE_LIMIT ){ + nOut = SQLITE_TRACE_SIZE_LIMIT; + while( nOutn && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; } + } +#endif + sqlite3XPrintf(&out, 0, "'%.*q'", nOut, pVar->z); +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOutn ){ + sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut); + } +#endif +#ifndef SQLITE_OMIT_UTF16 + if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8); +#endif + }else if( pVar->flags & MEM_Zero ){ + sqlite3XPrintf(&out, 0, "zeroblob(%d)", pVar->u.nZero); + }else{ + int nOut; /* Number of bytes of the blob to include in output */ + assert( pVar->flags & MEM_Blob ); + sqlite3StrAccumAppend(&out, "x'", 2); + nOut = pVar->n; +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOut>SQLITE_TRACE_SIZE_LIMIT ) nOut = SQLITE_TRACE_SIZE_LIMIT; +#endif + for(i=0; iz[i]&0xff); + } + sqlite3StrAccumAppend(&out, "'", 1); +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOutn ){ + sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut); + } +#endif + } + } + } + return sqlite3StrAccumFinish(&out); +} + +#endif /* #ifndef SQLITE_OMIT_TRACE */ + +/************** End of vdbetrace.c *******************************************/ +/************** Begin file vdbe.c ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** The code in this file implements the function that runs the +** bytecode of a prepared statement. +** +** Various scripts scan this source file in order to generate HTML +** documentation, headers files, or other derived files. The formatting +** of the code in this file is, therefore, important. See other comments +** in this file for details. If in doubt, do not deviate from existing +** commenting and indentation practices when changing or adding code. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* +** Invoke this macro on memory cells just prior to changing the +** value of the cell. This macro verifies that shallow copies are +** not misused. A shallow copy of a string or blob just copies a +** pointer to the string or blob, not the content. If the original +** is changed while the copy is still in use, the string or blob might +** be changed out from under the copy. This macro verifies that nothing +** like that ever happens. +*/ +#ifdef SQLITE_DEBUG +# define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M) +#else +# define memAboutToChange(P,M) +#endif + +/* +** The following global variable is incremented every time a cursor +** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes. The test +** procedures use this information to make sure that indices are +** working correctly. This variable has no function other than to +** help verify the correct operation of the library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_search_count = 0; +#endif + +/* +** When this global variable is positive, it gets decremented once before +** each instruction in the VDBE. When it reaches zero, the u1.isInterrupted +** field of the sqlite3 structure is set in order to simulate an interrupt. +** +** This facility is used for testing purposes only. It does not function +** in an ordinary build. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_interrupt_count = 0; +#endif + +/* +** The next global variable is incremented each type the OP_Sort opcode +** is executed. The test procedures use this information to make sure that +** sorting is occurring or not occurring at appropriate times. This variable +** has no function other than to help verify the correct operation of the +** library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_sort_count = 0; +#endif + +/* +** The next global variable records the size of the largest MEM_Blob +** or MEM_Str that has been used by a VDBE opcode. The test procedures +** use this information to make sure that the zero-blob functionality +** is working correctly. This variable has no function other than to +** help verify the correct operation of the library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_max_blobsize = 0; +static void updateMaxBlobsize(Mem *p){ + if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){ + sqlite3_max_blobsize = p->n; + } +} +#endif + +/* +** The next global variable is incremented each time the OP_Found opcode +** is executed. This is used to test whether or not the foreign key +** operation implemented using OP_FkIsZero is working. This variable +** has no function other than to help verify the correct operation of the +** library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_found_count = 0; +#endif + +/* +** Test a register to see if it exceeds the current maximum blob size. +** If it does, record the new maximum blob size. +*/ +#if defined(SQLITE_TEST) && !defined(SQLITE_OMIT_BUILTIN_TEST) +# define UPDATE_MAX_BLOBSIZE(P) updateMaxBlobsize(P) +#else +# define UPDATE_MAX_BLOBSIZE(P) +#endif + +/* +** Invoke the VDBE coverage callback, if that callback is defined. This +** feature is used for test suite validation only and does not appear an +** production builds. +** +** M is an integer, 2 or 3, that indices how many different ways the +** branch can go. It is usually 2. "I" is the direction the branch +** goes. 0 means falls through. 1 means branch is taken. 2 means the +** second alternative branch is taken. +** +** iSrcLine is the source code line (from the __LINE__ macro) that +** generated the VDBE instruction. This instrumentation assumes that all +** source code is in a single file (the amalgamation). Special values 1 +** and 2 for the iSrcLine parameter mean that this particular branch is +** always taken or never taken, respectively. +*/ +#if !defined(SQLITE_VDBE_COVERAGE) +# define VdbeBranchTaken(I,M) +#else +# define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M) + static void vdbeTakeBranch(int iSrcLine, u8 I, u8 M){ + if( iSrcLine<=2 && ALWAYS(iSrcLine>0) ){ + M = iSrcLine; + /* Assert the truth of VdbeCoverageAlwaysTaken() and + ** VdbeCoverageNeverTaken() */ + assert( (M & I)==I ); + }else{ + if( sqlite3GlobalConfig.xVdbeBranch==0 ) return; /*NO_TEST*/ + sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg, + iSrcLine,I,M); + } + } +#endif + +/* +** Convert the given register into a string if it isn't one +** already. Return non-zero if a malloc() fails. +*/ +#define Stringify(P, enc) \ + if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc,0)) \ + { goto no_mem; } + +/* +** An ephemeral string value (signified by the MEM_Ephem flag) contains +** a pointer to a dynamically allocated string where some other entity +** is responsible for deallocating that string. Because the register +** does not control the string, it might be deleted without the register +** knowing it. +** +** This routine converts an ephemeral string into a dynamically allocated +** string that the register itself controls. In other words, it +** converts an MEM_Ephem string into a string with P.z==P.zMalloc. +*/ +#define Deephemeralize(P) \ + if( ((P)->flags&MEM_Ephem)!=0 \ + && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;} + +/* Return true if the cursor was opened using the OP_OpenSorter opcode. */ +#define isSorter(x) ((x)->pSorter!=0) + +/* +** Allocate VdbeCursor number iCur. Return a pointer to it. Return NULL +** if we run out of memory. +*/ +static VdbeCursor *allocateCursor( + Vdbe *p, /* The virtual machine */ + int iCur, /* Index of the new VdbeCursor */ + int nField, /* Number of fields in the table or index */ + int iDb, /* Database the cursor belongs to, or -1 */ + int isBtreeCursor /* True for B-Tree. False for pseudo-table or vtab */ +){ + /* Find the memory cell that will be used to store the blob of memory + ** required for this VdbeCursor structure. It is convenient to use a + ** vdbe memory cell to manage the memory allocation required for a + ** VdbeCursor structure for the following reasons: + ** + ** * Sometimes cursor numbers are used for a couple of different + ** purposes in a vdbe program. The different uses might require + ** different sized allocations. Memory cells provide growable + ** allocations. + ** + ** * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can + ** be freed lazily via the sqlite3_release_memory() API. This + ** minimizes the number of malloc calls made by the system. + ** + ** Memory cells for cursors are allocated at the top of the address + ** space. Memory cell (p->nMem) corresponds to cursor 0. Space for + ** cursor 1 is managed by memory cell (p->nMem-1), etc. + */ + Mem *pMem = &p->aMem[p->nMem-iCur]; + + int nByte; + VdbeCursor *pCx = 0; + nByte = + ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField + + (isBtreeCursor?sqlite3BtreeCursorSize():0); + + assert( iCurnCursor ); + if( p->apCsr[iCur] ){ + sqlite3VdbeFreeCursor(p, p->apCsr[iCur]); + p->apCsr[iCur] = 0; + } + if( SQLITE_OK==sqlite3VdbeMemClearAndResize(pMem, nByte) ){ + p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z; + memset(pCx, 0, sizeof(VdbeCursor)); + pCx->iDb = iDb; + pCx->nField = nField; + pCx->aOffset = &pCx->aType[nField]; + if( isBtreeCursor ){ + pCx->pCursor = (BtCursor*) + &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField]; + sqlite3BtreeCursorZero(pCx->pCursor); + } + } + return pCx; +} + +/* +** Try to convert a value into a numeric representation if we can +** do so without loss of information. In other words, if the string +** looks like a number, convert it into a number. If it does not +** look like a number, leave it alone. +** +** If the bTryForInt flag is true, then extra effort is made to give +** an integer representation. Strings that look like floating point +** values but which have no fractional component (example: '48.00') +** will have a MEM_Int representation when bTryForInt is true. +** +** If bTryForInt is false, then if the input string contains a decimal +** point or exponential notation, the result is only MEM_Real, even +** if there is an exact integer representation of the quantity. +*/ +static void applyNumericAffinity(Mem *pRec, int bTryForInt){ + double rValue; + i64 iValue; + u8 enc = pRec->enc; + assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real))==MEM_Str ); + if( sqlite3AtoF(pRec->z, &rValue, pRec->n, enc)==0 ) return; + if( 0==sqlite3Atoi64(pRec->z, &iValue, pRec->n, enc) ){ + pRec->u.i = iValue; + pRec->flags |= MEM_Int; + }else{ + pRec->u.r = rValue; + pRec->flags |= MEM_Real; + if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec); + } +} + +/* +** Processing is determine by the affinity parameter: +** +** SQLITE_AFF_INTEGER: +** SQLITE_AFF_REAL: +** SQLITE_AFF_NUMERIC: +** Try to convert pRec to an integer representation or a +** floating-point representation if an integer representation +** is not possible. Note that the integer representation is +** always preferred, even if the affinity is REAL, because +** an integer representation is more space efficient on disk. +** +** SQLITE_AFF_TEXT: +** Convert pRec to a text representation. +** +** SQLITE_AFF_BLOB: +** No-op. pRec is unchanged. +*/ +static void applyAffinity( + Mem *pRec, /* The value to apply affinity to */ + char affinity, /* The affinity to be applied */ + u8 enc /* Use this text encoding */ +){ + if( affinity>=SQLITE_AFF_NUMERIC ){ + assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL + || affinity==SQLITE_AFF_NUMERIC ); + if( (pRec->flags & MEM_Int)==0 ){ + if( (pRec->flags & MEM_Real)==0 ){ + if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1); + }else{ + sqlite3VdbeIntegerAffinity(pRec); + } + } + }else if( affinity==SQLITE_AFF_TEXT ){ + /* Only attempt the conversion to TEXT if there is an integer or real + ** representation (blob and NULL do not get converted) but no string + ** representation. + */ + if( 0==(pRec->flags&MEM_Str) && (pRec->flags&(MEM_Real|MEM_Int)) ){ + sqlite3VdbeMemStringify(pRec, enc, 1); + } + pRec->flags &= ~(MEM_Real|MEM_Int); + } +} + +/* +** Try to convert the type of a function argument or a result column +** into a numeric representation. Use either INTEGER or REAL whichever +** is appropriate. But only do the conversion if it is possible without +** loss of information and return the revised type of the argument. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_value_numeric_type(sqlite3_value *pVal){ + int eType = sqlite3_value_type(pVal); + if( eType==SQLITE_TEXT ){ + Mem *pMem = (Mem*)pVal; + applyNumericAffinity(pMem, 0); + eType = sqlite3_value_type(pVal); + } + return eType; +} + +/* +** Exported version of applyAffinity(). This one works on sqlite3_value*, +** not the internal Mem* type. +*/ +SQLITE_PRIVATE void sqlite3ValueApplyAffinity( + sqlite3_value *pVal, + u8 affinity, + u8 enc +){ + applyAffinity((Mem *)pVal, affinity, enc); +} + +/* +** pMem currently only holds a string type (or maybe a BLOB that we can +** interpret as a string if we want to). Compute its corresponding +** numeric type, if has one. Set the pMem->u.r and pMem->u.i fields +** accordingly. +*/ +static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){ + assert( (pMem->flags & (MEM_Int|MEM_Real))==0 ); + assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ); + if( sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc)==0 ){ + return 0; + } + if( sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc)==SQLITE_OK ){ + return MEM_Int; + } + return MEM_Real; +} + +/* +** Return the numeric type for pMem, either MEM_Int or MEM_Real or both or +** none. +** +** Unlike applyNumericAffinity(), this routine does not modify pMem->flags. +** But it does set pMem->u.r and pMem->u.i appropriately. +*/ +static u16 numericType(Mem *pMem){ + if( pMem->flags & (MEM_Int|MEM_Real) ){ + return pMem->flags & (MEM_Int|MEM_Real); + } + if( pMem->flags & (MEM_Str|MEM_Blob) ){ + return computeNumericType(pMem); + } + return 0; +} + +#ifdef SQLITE_DEBUG +/* +** Write a nice string representation of the contents of cell pMem +** into buffer zBuf, length nBuf. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){ + char *zCsr = zBuf; + int f = pMem->flags; + + static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"}; + + if( f&MEM_Blob ){ + int i; + char c; + if( f & MEM_Dyn ){ + c = 'z'; + assert( (f & (MEM_Static|MEM_Ephem))==0 ); + }else if( f & MEM_Static ){ + c = 't'; + assert( (f & (MEM_Dyn|MEM_Ephem))==0 ); + }else if( f & MEM_Ephem ){ + c = 'e'; + assert( (f & (MEM_Static|MEM_Dyn))==0 ); + }else{ + c = 's'; + } + + sqlite3_snprintf(100, zCsr, "%c", c); + zCsr += sqlite3Strlen30(zCsr); + sqlite3_snprintf(100, zCsr, "%d[", pMem->n); + zCsr += sqlite3Strlen30(zCsr); + for(i=0; i<16 && in; i++){ + sqlite3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF)); + zCsr += sqlite3Strlen30(zCsr); + } + for(i=0; i<16 && in; i++){ + char z = pMem->z[i]; + if( z<32 || z>126 ) *zCsr++ = '.'; + else *zCsr++ = z; + } + + sqlite3_snprintf(100, zCsr, "]%s", encnames[pMem->enc]); + zCsr += sqlite3Strlen30(zCsr); + if( f & MEM_Zero ){ + sqlite3_snprintf(100, zCsr,"+%dz",pMem->u.nZero); + zCsr += sqlite3Strlen30(zCsr); + } + *zCsr = '\0'; + }else if( f & MEM_Str ){ + int j, k; + zBuf[0] = ' '; + if( f & MEM_Dyn ){ + zBuf[1] = 'z'; + assert( (f & (MEM_Static|MEM_Ephem))==0 ); + }else if( f & MEM_Static ){ + zBuf[1] = 't'; + assert( (f & (MEM_Dyn|MEM_Ephem))==0 ); + }else if( f & MEM_Ephem ){ + zBuf[1] = 'e'; + assert( (f & (MEM_Static|MEM_Dyn))==0 ); + }else{ + zBuf[1] = 's'; + } + k = 2; + sqlite3_snprintf(100, &zBuf[k], "%d", pMem->n); + k += sqlite3Strlen30(&zBuf[k]); + zBuf[k++] = '['; + for(j=0; j<15 && jn; j++){ + u8 c = pMem->z[j]; + if( c>=0x20 && c<0x7f ){ + zBuf[k++] = c; + }else{ + zBuf[k++] = '.'; + } + } + zBuf[k++] = ']'; + sqlite3_snprintf(100,&zBuf[k], encnames[pMem->enc]); + k += sqlite3Strlen30(&zBuf[k]); + zBuf[k++] = 0; + } +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Print the value of a register for tracing purposes: +*/ +static void memTracePrint(Mem *p){ + if( p->flags & MEM_Undefined ){ + printf(" undefined"); + }else if( p->flags & MEM_Null ){ + printf(" NULL"); + }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){ + printf(" si:%lld", p->u.i); + }else if( p->flags & MEM_Int ){ + printf(" i:%lld", p->u.i); +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( p->flags & MEM_Real ){ + printf(" r:%g", p->u.r); +#endif + }else if( p->flags & MEM_RowSet ){ + printf(" (rowset)"); + }else{ + char zBuf[200]; + sqlite3VdbeMemPrettyPrint(p, zBuf); + printf(" %s", zBuf); + } +} +static void registerTrace(int iReg, Mem *p){ + printf("REG[%d] = ", iReg); + memTracePrint(p); + printf("\n"); +} +#endif + +#ifdef SQLITE_DEBUG +# define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M) +#else +# define REGISTER_TRACE(R,M) +#endif + + +#ifdef VDBE_PROFILE + +/* +** hwtime.h contains inline assembler code for implementing +** high-performance timing routines. +*/ +/************** Include hwtime.h in the middle of vdbe.c *********************/ +/************** Begin file hwtime.h ******************************************/ +/* +** 2008 May 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains inline asm code for retrieving "high-performance" +** counters for x86 class CPUs. +*/ +#ifndef _HWTIME_H_ +#define _HWTIME_H_ + +/* +** The following routine only works on pentium-class (or newer) processors. +** It uses the RDTSC opcode to read the cycle count value out of the +** processor and returns that value. This can be used for high-res +** profiling. +*/ +#if (defined(__GNUC__) || defined(_MSC_VER)) && \ + (defined(i386) || defined(__i386__) || defined(_M_IX86)) + + #if defined(__GNUC__) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned int lo, hi; + __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); + return (sqlite_uint64)hi << 32 | lo; + } + + #elif defined(_MSC_VER) + + __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){ + __asm { + rdtsc + ret ; return value at EDX:EAX + } + } + + #endif + +#elif (defined(__GNUC__) && defined(__x86_64__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long val; + __asm__ __volatile__ ("rdtsc" : "=A" (val)); + return val; + } + +#elif (defined(__GNUC__) && defined(__ppc__)) + + __inline__ sqlite_uint64 sqlite3Hwtime(void){ + unsigned long long retval; + unsigned long junk; + __asm__ __volatile__ ("\n\ + 1: mftbu %1\n\ + mftb %L0\n\ + mftbu %0\n\ + cmpw %0,%1\n\ + bne 1b" + : "=r" (retval), "=r" (junk)); + return retval; + } + +#else + + #error Need implementation of sqlite3Hwtime() for your platform. + + /* + ** To compile without implementing sqlite3Hwtime() for your platform, + ** you can remove the above #error and use the following + ** stub function. You will lose timing support for many + ** of the debugging and testing utilities, but it should at + ** least compile and run. + */ +SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); } + +#endif + +#endif /* !defined(_HWTIME_H_) */ + +/************** End of hwtime.h **********************************************/ +/************** Continuing where we left off in vdbe.c ***********************/ + +#endif + +#ifndef NDEBUG +/* +** This function is only called from within an assert() expression. It +** checks that the sqlite3.nTransaction variable is correctly set to +** the number of non-transaction savepoints currently in the +** linked list starting at sqlite3.pSavepoint. +** +** Usage: +** +** assert( checkSavepointCount(db) ); +*/ +static int checkSavepointCount(sqlite3 *db){ + int n = 0; + Savepoint *p; + for(p=db->pSavepoint; p; p=p->pNext) n++; + assert( n==(db->nSavepoint + db->isTransactionSavepoint) ); + return 1; +} +#endif + +/* +** Return the register of pOp->p2 after first preparing it to be +** overwritten with an integer value. +*/ +static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){ + Mem *pOut; + assert( pOp->p2>0 ); + assert( pOp->p2<=(p->nMem-p->nCursor) ); + pOut = &p->aMem[pOp->p2]; + memAboutToChange(p, pOut); + if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut); + pOut->flags = MEM_Int; + return pOut; +} + + +/* +** Execute as much of a VDBE program as we can. +** This is the core of sqlite3_step(). +*/ +SQLITE_PRIVATE int sqlite3VdbeExec( + Vdbe *p /* The VDBE */ +){ + Op *aOp = p->aOp; /* Copy of p->aOp */ + Op *pOp = aOp; /* Current operation */ +#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) + Op *pOrigOp; /* Value of pOp at the top of the loop */ +#endif + int rc = SQLITE_OK; /* Value to return */ + sqlite3 *db = p->db; /* The database */ + u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */ + u8 encoding = ENC(db); /* The database encoding */ + int iCompare = 0; /* Result of last OP_Compare operation */ + unsigned nVmStep = 0; /* Number of virtual machine steps */ +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + unsigned nProgressLimit = 0;/* Invoke xProgress() when nVmStep reaches this */ +#endif + Mem *aMem = p->aMem; /* Copy of p->aMem */ + Mem *pIn1 = 0; /* 1st input operand */ + Mem *pIn2 = 0; /* 2nd input operand */ + Mem *pIn3 = 0; /* 3rd input operand */ + Mem *pOut = 0; /* Output operand */ + int *aPermute = 0; /* Permutation of columns for OP_Compare */ + i64 lastRowid = db->lastRowid; /* Saved value of the last insert ROWID */ +#ifdef VDBE_PROFILE + u64 start; /* CPU clock count at start of opcode */ +#endif + /*** INSERT STACK UNION HERE ***/ + + assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */ + sqlite3VdbeEnter(p); + if( p->rc==SQLITE_NOMEM ){ + /* This happens if a malloc() inside a call to sqlite3_column_text() or + ** sqlite3_column_text16() failed. */ + goto no_mem; + } + assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY ); + assert( p->bIsReader || p->readOnly!=0 ); + p->rc = SQLITE_OK; + p->iCurrentTime = 0; + assert( p->explain==0 ); + p->pResultSet = 0; + db->busyHandler.nBusy = 0; + if( db->u1.isInterrupted ) goto abort_due_to_interrupt; + sqlite3VdbeIOTraceSql(p); +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + if( db->xProgress ){ + u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP]; + assert( 0 < db->nProgressOps ); + nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps); + } +#endif +#ifdef SQLITE_DEBUG + sqlite3BeginBenignMalloc(); + if( p->pc==0 + && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0 + ){ + int i; + int once = 1; + sqlite3VdbePrintSql(p); + if( p->db->flags & SQLITE_VdbeListing ){ + printf("VDBE Program Listing:\n"); + for(i=0; inOp; i++){ + sqlite3VdbePrintOp(stdout, i, &aOp[i]); + } + } + if( p->db->flags & SQLITE_VdbeEQP ){ + for(i=0; inOp; i++){ + if( aOp[i].opcode==OP_Explain ){ + if( once ) printf("VDBE Query Plan:\n"); + printf("%s\n", aOp[i].p4.z); + once = 0; + } + } + } + if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n"); + } + sqlite3EndBenignMalloc(); +#endif + for(pOp=&aOp[p->pc]; rc==SQLITE_OK; pOp++){ + assert( pOp>=aOp && pOp<&aOp[p->nOp]); + if( db->mallocFailed ) goto no_mem; +#ifdef VDBE_PROFILE + start = sqlite3Hwtime(); +#endif + nVmStep++; +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + if( p->anExec ) p->anExec[(int)(pOp-aOp)]++; +#endif + + /* Only allow tracing if SQLITE_DEBUG is defined. + */ +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_VdbeTrace ){ + sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp); + } +#endif + + + /* Check to see if we need to simulate an interrupt. This only happens + ** if we have a special test build. + */ +#ifdef SQLITE_TEST + if( sqlite3_interrupt_count>0 ){ + sqlite3_interrupt_count--; + if( sqlite3_interrupt_count==0 ){ + sqlite3_interrupt(db); + } + } +#endif + + /* Sanity checking on other operands */ +#ifdef SQLITE_DEBUG + assert( pOp->opflags==sqlite3OpcodeProperty[pOp->opcode] ); + if( (pOp->opflags & OPFLG_IN1)!=0 ){ + assert( pOp->p1>0 ); + assert( pOp->p1<=(p->nMem-p->nCursor) ); + assert( memIsValid(&aMem[pOp->p1]) ); + assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) ); + REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]); + } + if( (pOp->opflags & OPFLG_IN2)!=0 ){ + assert( pOp->p2>0 ); + assert( pOp->p2<=(p->nMem-p->nCursor) ); + assert( memIsValid(&aMem[pOp->p2]) ); + assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) ); + REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]); + } + if( (pOp->opflags & OPFLG_IN3)!=0 ){ + assert( pOp->p3>0 ); + assert( pOp->p3<=(p->nMem-p->nCursor) ); + assert( memIsValid(&aMem[pOp->p3]) ); + assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) ); + REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]); + } + if( (pOp->opflags & OPFLG_OUT2)!=0 ){ + assert( pOp->p2>0 ); + assert( pOp->p2<=(p->nMem-p->nCursor) ); + memAboutToChange(p, &aMem[pOp->p2]); + } + if( (pOp->opflags & OPFLG_OUT3)!=0 ){ + assert( pOp->p3>0 ); + assert( pOp->p3<=(p->nMem-p->nCursor) ); + memAboutToChange(p, &aMem[pOp->p3]); + } +#endif +#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) + pOrigOp = pOp; +#endif + + switch( pOp->opcode ){ + +/***************************************************************************** +** What follows is a massive switch statement where each case implements a +** separate instruction in the virtual machine. If we follow the usual +** indentation conventions, each case should be indented by 6 spaces. But +** that is a lot of wasted space on the left margin. So the code within +** the switch statement will break with convention and be flush-left. Another +** big comment (similar to this one) will mark the point in the code where +** we transition back to normal indentation. +** +** The formatting of each case is important. The makefile for SQLite +** generates two C files "opcodes.h" and "opcodes.c" by scanning this +** file looking for lines that begin with "case OP_". The opcodes.h files +** will be filled with #defines that give unique integer values to each +** opcode and the opcodes.c file is filled with an array of strings where +** each string is the symbolic name for the corresponding opcode. If the +** case statement is followed by a comment of the form "/# same as ... #/" +** that comment is used to determine the particular value of the opcode. +** +** Other keywords in the comment that follows each case are used to +** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[]. +** Keywords include: in1, in2, in3, out2, out3. See +** the mkopcodeh.awk script for additional information. +** +** Documentation about VDBE opcodes is generated by scanning this file +** for lines of that contain "Opcode:". That line and all subsequent +** comment lines are used in the generation of the opcode.html documentation +** file. +** +** SUMMARY: +** +** Formatting is important to scripts that scan this file. +** Do not deviate from the formatting style currently in use. +** +*****************************************************************************/ + +/* Opcode: Goto * P2 * * * +** +** An unconditional jump to address P2. +** The next instruction executed will be +** the one at index P2 from the beginning of +** the program. +** +** The P1 parameter is not actually used by this opcode. However, it +** is sometimes set to 1 instead of 0 as a hint to the command-line shell +** that this Goto is the bottom of a loop and that the lines from P2 down +** to the current line should be indented for EXPLAIN output. +*/ +case OP_Goto: { /* jump */ +jump_to_p2_and_check_for_interrupt: + pOp = &aOp[pOp->p2 - 1]; + + /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev, + ** OP_VNext, OP_RowSetNext, or OP_SorterNext) all jump here upon + ** completion. Check to see if sqlite3_interrupt() has been called + ** or if the progress callback needs to be invoked. + ** + ** This code uses unstructured "goto" statements and does not look clean. + ** But that is not due to sloppy coding habits. The code is written this + ** way for performance, to avoid having to run the interrupt and progress + ** checks on every opcode. This helps sqlite3_step() to run about 1.5% + ** faster according to "valgrind --tool=cachegrind" */ +check_for_interrupt: + if( db->u1.isInterrupted ) goto abort_due_to_interrupt; +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + /* Call the progress callback if it is configured and the required number + ** of VDBE ops have been executed (either since this invocation of + ** sqlite3VdbeExec() or since last time the progress callback was called). + ** If the progress callback returns non-zero, exit the virtual machine with + ** a return code SQLITE_ABORT. + */ + if( db->xProgress!=0 && nVmStep>=nProgressLimit ){ + assert( db->nProgressOps!=0 ); + nProgressLimit = nVmStep + db->nProgressOps - (nVmStep%db->nProgressOps); + if( db->xProgress(db->pProgressArg) ){ + rc = SQLITE_INTERRUPT; + goto vdbe_error_halt; + } + } +#endif + + break; +} + +/* Opcode: Gosub P1 P2 * * * +** +** Write the current address onto register P1 +** and then jump to address P2. +*/ +case OP_Gosub: { /* jump */ + assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) ); + pIn1 = &aMem[pOp->p1]; + assert( VdbeMemDynamic(pIn1)==0 ); + memAboutToChange(p, pIn1); + pIn1->flags = MEM_Int; + pIn1->u.i = (int)(pOp-aOp); + REGISTER_TRACE(pOp->p1, pIn1); + + /* Most jump operations do a goto to this spot in order to update + ** the pOp pointer. */ +jump_to_p2: + pOp = &aOp[pOp->p2 - 1]; + break; +} + +/* Opcode: Return P1 * * * * +** +** Jump to the next instruction after the address in register P1. After +** the jump, register P1 becomes undefined. +*/ +case OP_Return: { /* in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags==MEM_Int ); + pOp = &aOp[pIn1->u.i]; + pIn1->flags = MEM_Undefined; + break; +} + +/* Opcode: InitCoroutine P1 P2 P3 * * +** +** Set up register P1 so that it will Yield to the coroutine +** located at address P3. +** +** If P2!=0 then the coroutine implementation immediately follows +** this opcode. So jump over the coroutine implementation to +** address P2. +** +** See also: EndCoroutine +*/ +case OP_InitCoroutine: { /* jump */ + assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) ); + assert( pOp->p2>=0 && pOp->p2nOp ); + assert( pOp->p3>=0 && pOp->p3nOp ); + pOut = &aMem[pOp->p1]; + assert( !VdbeMemDynamic(pOut) ); + pOut->u.i = pOp->p3 - 1; + pOut->flags = MEM_Int; + if( pOp->p2 ) goto jump_to_p2; + break; +} + +/* Opcode: EndCoroutine P1 * * * * +** +** The instruction at the address in register P1 is a Yield. +** Jump to the P2 parameter of that Yield. +** After the jump, register P1 becomes undefined. +** +** See also: InitCoroutine +*/ +case OP_EndCoroutine: { /* in1 */ + VdbeOp *pCaller; + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags==MEM_Int ); + assert( pIn1->u.i>=0 && pIn1->u.inOp ); + pCaller = &aOp[pIn1->u.i]; + assert( pCaller->opcode==OP_Yield ); + assert( pCaller->p2>=0 && pCaller->p2nOp ); + pOp = &aOp[pCaller->p2 - 1]; + pIn1->flags = MEM_Undefined; + break; +} + +/* Opcode: Yield P1 P2 * * * +** +** Swap the program counter with the value in register P1. This +** has the effect of yielding to a coroutine. +** +** If the coroutine that is launched by this instruction ends with +** Yield or Return then continue to the next instruction. But if +** the coroutine launched by this instruction ends with +** EndCoroutine, then jump to P2 rather than continuing with the +** next instruction. +** +** See also: InitCoroutine +*/ +case OP_Yield: { /* in1, jump */ + int pcDest; + pIn1 = &aMem[pOp->p1]; + assert( VdbeMemDynamic(pIn1)==0 ); + pIn1->flags = MEM_Int; + pcDest = (int)pIn1->u.i; + pIn1->u.i = (int)(pOp - aOp); + REGISTER_TRACE(pOp->p1, pIn1); + pOp = &aOp[pcDest]; + break; +} + +/* Opcode: HaltIfNull P1 P2 P3 P4 P5 +** Synopsis: if r[P3]=null halt +** +** Check the value in register P3. If it is NULL then Halt using +** parameter P1, P2, and P4 as if this were a Halt instruction. If the +** value in register P3 is not NULL, then this routine is a no-op. +** The P5 parameter should be 1. +*/ +case OP_HaltIfNull: { /* in3 */ + pIn3 = &aMem[pOp->p3]; + if( (pIn3->flags & MEM_Null)==0 ) break; + /* Fall through into OP_Halt */ +} + +/* Opcode: Halt P1 P2 * P4 P5 +** +** Exit immediately. All open cursors, etc are closed +** automatically. +** +** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(), +** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0). +** For errors, it can be some other value. If P1!=0 then P2 will determine +** whether or not to rollback the current transaction. Do not rollback +** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort, +** then back out all changes that have occurred during this execution of the +** VDBE, but do not rollback the transaction. +** +** If P4 is not null then it is an error message string. +** +** P5 is a value between 0 and 4, inclusive, that modifies the P4 string. +** +** 0: (no change) +** 1: NOT NULL contraint failed: P4 +** 2: UNIQUE constraint failed: P4 +** 3: CHECK constraint failed: P4 +** 4: FOREIGN KEY constraint failed: P4 +** +** If P5 is not zero and P4 is NULL, then everything after the ":" is +** omitted. +** +** There is an implied "Halt 0 0 0" instruction inserted at the very end of +** every program. So a jump past the last instruction of the program +** is the same as executing Halt. +*/ +case OP_Halt: { + const char *zType; + const char *zLogFmt; + VdbeFrame *pFrame; + int pcx; + + pcx = (int)(pOp - aOp); + if( pOp->p1==SQLITE_OK && p->pFrame ){ + /* Halt the sub-program. Return control to the parent frame. */ + pFrame = p->pFrame; + p->pFrame = pFrame->pParent; + p->nFrame--; + sqlite3VdbeSetChanges(db, p->nChange); + pcx = sqlite3VdbeFrameRestore(pFrame); + lastRowid = db->lastRowid; + if( pOp->p2==OE_Ignore ){ + /* Instruction pcx is the OP_Program that invoked the sub-program + ** currently being halted. If the p2 instruction of this OP_Halt + ** instruction is set to OE_Ignore, then the sub-program is throwing + ** an IGNORE exception. In this case jump to the address specified + ** as the p2 of the calling OP_Program. */ + pcx = p->aOp[pcx].p2-1; + } + aOp = p->aOp; + aMem = p->aMem; + pOp = &aOp[pcx]; + break; + } + p->rc = pOp->p1; + p->errorAction = (u8)pOp->p2; + p->pc = pcx; + if( p->rc ){ + if( pOp->p5 ){ + static const char * const azType[] = { "NOT NULL", "UNIQUE", "CHECK", + "FOREIGN KEY" }; + assert( pOp->p5>=1 && pOp->p5<=4 ); + testcase( pOp->p5==1 ); + testcase( pOp->p5==2 ); + testcase( pOp->p5==3 ); + testcase( pOp->p5==4 ); + zType = azType[pOp->p5-1]; + }else{ + zType = 0; + } + assert( zType!=0 || pOp->p4.z!=0 ); + zLogFmt = "abort at %d in [%s]: %s"; + if( zType && pOp->p4.z ){ + sqlite3VdbeError(p, "%s constraint failed: %s", zType, pOp->p4.z); + }else if( pOp->p4.z ){ + sqlite3VdbeError(p, "%s", pOp->p4.z); + }else{ + sqlite3VdbeError(p, "%s constraint failed", zType); + } + sqlite3_log(pOp->p1, zLogFmt, pcx, p->zSql, p->zErrMsg); + } + rc = sqlite3VdbeHalt(p); + assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR ); + if( rc==SQLITE_BUSY ){ + p->rc = rc = SQLITE_BUSY; + }else{ + assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ); + assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 ); + rc = p->rc ? SQLITE_ERROR : SQLITE_DONE; + } + goto vdbe_return; +} + +/* Opcode: Integer P1 P2 * * * +** Synopsis: r[P2]=P1 +** +** The 32-bit integer value P1 is written into register P2. +*/ +case OP_Integer: { /* out2 */ + pOut = out2Prerelease(p, pOp); + pOut->u.i = pOp->p1; + break; +} + +/* Opcode: Int64 * P2 * P4 * +** Synopsis: r[P2]=P4 +** +** P4 is a pointer to a 64-bit integer value. +** Write that value into register P2. +*/ +case OP_Int64: { /* out2 */ + pOut = out2Prerelease(p, pOp); + assert( pOp->p4.pI64!=0 ); + pOut->u.i = *pOp->p4.pI64; + break; +} + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* Opcode: Real * P2 * P4 * +** Synopsis: r[P2]=P4 +** +** P4 is a pointer to a 64-bit floating point value. +** Write that value into register P2. +*/ +case OP_Real: { /* same as TK_FLOAT, out2 */ + pOut = out2Prerelease(p, pOp); + pOut->flags = MEM_Real; + assert( !sqlite3IsNaN(*pOp->p4.pReal) ); + pOut->u.r = *pOp->p4.pReal; + break; +} +#endif + +/* Opcode: String8 * P2 * P4 * +** Synopsis: r[P2]='P4' +** +** P4 points to a nul terminated UTF-8 string. This opcode is transformed +** into a String opcode before it is executed for the first time. During +** this transformation, the length of string P4 is computed and stored +** as the P1 parameter. +*/ +case OP_String8: { /* same as TK_STRING, out2 */ + assert( pOp->p4.z!=0 ); + pOut = out2Prerelease(p, pOp); + pOp->opcode = OP_String; + pOp->p1 = sqlite3Strlen30(pOp->p4.z); + +#ifndef SQLITE_OMIT_UTF16 + if( encoding!=SQLITE_UTF8 ){ + rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC); + if( rc==SQLITE_TOOBIG ) goto too_big; + if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem; + assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z ); + assert( VdbeMemDynamic(pOut)==0 ); + pOut->szMalloc = 0; + pOut->flags |= MEM_Static; + if( pOp->p4type==P4_DYNAMIC ){ + sqlite3DbFree(db, pOp->p4.z); + } + pOp->p4type = P4_DYNAMIC; + pOp->p4.z = pOut->z; + pOp->p1 = pOut->n; + } +#endif + if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + /* Fall through to the next case, OP_String */ +} + +/* Opcode: String P1 P2 P3 P4 P5 +** Synopsis: r[P2]='P4' (len=P1) +** +** The string value P4 of length P1 (bytes) is stored in register P2. +** +** If P5!=0 and the content of register P3 is greater than zero, then +** the datatype of the register P2 is converted to BLOB. The content is +** the same sequence of bytes, it is merely interpreted as a BLOB instead +** of a string, as if it had been CAST. +*/ +case OP_String: { /* out2 */ + assert( pOp->p4.z!=0 ); + pOut = out2Prerelease(p, pOp); + pOut->flags = MEM_Str|MEM_Static|MEM_Term; + pOut->z = pOp->p4.z; + pOut->n = pOp->p1; + pOut->enc = encoding; + UPDATE_MAX_BLOBSIZE(pOut); + if( pOp->p5 ){ + assert( pOp->p3>0 ); + assert( pOp->p3<=(p->nMem-p->nCursor) ); + pIn3 = &aMem[pOp->p3]; + assert( pIn3->flags & MEM_Int ); + if( pIn3->u.i ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term; + } + break; +} + +/* Opcode: Null P1 P2 P3 * * +** Synopsis: r[P2..P3]=NULL +** +** Write a NULL into registers P2. If P3 greater than P2, then also write +** NULL into register P3 and every register in between P2 and P3. If P3 +** is less than P2 (typically P3 is zero) then only register P2 is +** set to NULL. +** +** If the P1 value is non-zero, then also set the MEM_Cleared flag so that +** NULL values will not compare equal even if SQLITE_NULLEQ is set on +** OP_Ne or OP_Eq. +*/ +case OP_Null: { /* out2 */ + int cnt; + u16 nullFlag; + pOut = out2Prerelease(p, pOp); + cnt = pOp->p3-pOp->p2; + assert( pOp->p3<=(p->nMem-p->nCursor) ); + pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null; + while( cnt>0 ){ + pOut++; + memAboutToChange(p, pOut); + sqlite3VdbeMemSetNull(pOut); + pOut->flags = nullFlag; + cnt--; + } + break; +} + +/* Opcode: SoftNull P1 * * * * +** Synopsis: r[P1]=NULL +** +** Set register P1 to have the value NULL as seen by the OP_MakeRecord +** instruction, but do not free any string or blob memory associated with +** the register, so that if the value was a string or blob that was +** previously copied using OP_SCopy, the copies will continue to be valid. +*/ +case OP_SoftNull: { + assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) ); + pOut = &aMem[pOp->p1]; + pOut->flags = (pOut->flags|MEM_Null)&~MEM_Undefined; + break; +} + +/* Opcode: Blob P1 P2 * P4 * +** Synopsis: r[P2]=P4 (len=P1) +** +** P4 points to a blob of data P1 bytes long. Store this +** blob in register P2. +*/ +case OP_Blob: { /* out2 */ + assert( pOp->p1 <= SQLITE_MAX_LENGTH ); + pOut = out2Prerelease(p, pOp); + sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0); + pOut->enc = encoding; + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Variable P1 P2 * P4 * +** Synopsis: r[P2]=parameter(P1,P4) +** +** Transfer the values of bound parameter P1 into register P2 +** +** If the parameter is named, then its name appears in P4. +** The P4 value is used by sqlite3_bind_parameter_name(). +*/ +case OP_Variable: { /* out2 */ + Mem *pVar; /* Value being transferred */ + + assert( pOp->p1>0 && pOp->p1<=p->nVar ); + assert( pOp->p4.z==0 || pOp->p4.z==p->azVar[pOp->p1-1] ); + pVar = &p->aVar[pOp->p1 - 1]; + if( sqlite3VdbeMemTooBig(pVar) ){ + goto too_big; + } + pOut = out2Prerelease(p, pOp); + sqlite3VdbeMemShallowCopy(pOut, pVar, MEM_Static); + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Move P1 P2 P3 * * +** Synopsis: r[P2@P3]=r[P1@P3] +** +** Move the P3 values in register P1..P1+P3-1 over into +** registers P2..P2+P3-1. Registers P1..P1+P3-1 are +** left holding a NULL. It is an error for register ranges +** P1..P1+P3-1 and P2..P2+P3-1 to overlap. It is an error +** for P3 to be less than 1. +*/ +case OP_Move: { + int n; /* Number of registers left to copy */ + int p1; /* Register to copy from */ + int p2; /* Register to copy to */ + + n = pOp->p3; + p1 = pOp->p1; + p2 = pOp->p2; + assert( n>0 && p1>0 && p2>0 ); + assert( p1+n<=p2 || p2+n<=p1 ); + + pIn1 = &aMem[p1]; + pOut = &aMem[p2]; + do{ + assert( pOut<=&aMem[(p->nMem-p->nCursor)] ); + assert( pIn1<=&aMem[(p->nMem-p->nCursor)] ); + assert( memIsValid(pIn1) ); + memAboutToChange(p, pOut); + sqlite3VdbeMemMove(pOut, pIn1); +#ifdef SQLITE_DEBUG + if( pOut->pScopyFrom>=&aMem[p1] && pOut->pScopyFrompScopyFrom += pOp->p2 - p1; + } +#endif + Deephemeralize(pOut); + REGISTER_TRACE(p2++, pOut); + pIn1++; + pOut++; + }while( --n ); + break; +} + +/* Opcode: Copy P1 P2 P3 * * +** Synopsis: r[P2@P3+1]=r[P1@P3+1] +** +** Make a copy of registers P1..P1+P3 into registers P2..P2+P3. +** +** This instruction makes a deep copy of the value. A duplicate +** is made of any string or blob constant. See also OP_SCopy. +*/ +case OP_Copy: { + int n; + + n = pOp->p3; + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + assert( pOut!=pIn1 ); + while( 1 ){ + sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem); + Deephemeralize(pOut); +#ifdef SQLITE_DEBUG + pOut->pScopyFrom = 0; +#endif + REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut); + if( (n--)==0 ) break; + pOut++; + pIn1++; + } + break; +} + +/* Opcode: SCopy P1 P2 * * * +** Synopsis: r[P2]=r[P1] +** +** Make a shallow copy of register P1 into register P2. +** +** This instruction makes a shallow copy of the value. If the value +** is a string or blob, then the copy is only a pointer to the +** original and hence if the original changes so will the copy. +** Worse, if the original is deallocated, the copy becomes invalid. +** Thus the program must guarantee that the original will not change +** during the lifetime of the copy. Use OP_Copy to make a complete +** copy. +*/ +case OP_SCopy: { /* out2 */ + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + assert( pOut!=pIn1 ); + sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem); +#ifdef SQLITE_DEBUG + if( pOut->pScopyFrom==0 ) pOut->pScopyFrom = pIn1; +#endif + break; +} + +/* Opcode: ResultRow P1 P2 * * * +** Synopsis: output=r[P1@P2] +** +** The registers P1 through P1+P2-1 contain a single row of +** results. This opcode causes the sqlite3_step() call to terminate +** with an SQLITE_ROW return code and it sets up the sqlite3_stmt +** structure to provide access to the r(P1)..r(P1+P2-1) values as +** the result row. +*/ +case OP_ResultRow: { + Mem *pMem; + int i; + assert( p->nResColumn==pOp->p2 ); + assert( pOp->p1>0 ); + assert( pOp->p1+pOp->p2<=(p->nMem-p->nCursor)+1 ); + +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + /* Run the progress counter just before returning. + */ + if( db->xProgress!=0 + && nVmStep>=nProgressLimit + && db->xProgress(db->pProgressArg)!=0 + ){ + rc = SQLITE_INTERRUPT; + goto vdbe_error_halt; + } +#endif + + /* If this statement has violated immediate foreign key constraints, do + ** not return the number of rows modified. And do not RELEASE the statement + ** transaction. It needs to be rolled back. */ + if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){ + assert( db->flags&SQLITE_CountRows ); + assert( p->usesStmtJournal ); + break; + } + + /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then + ** DML statements invoke this opcode to return the number of rows + ** modified to the user. This is the only way that a VM that + ** opens a statement transaction may invoke this opcode. + ** + ** In case this is such a statement, close any statement transaction + ** opened by this VM before returning control to the user. This is to + ** ensure that statement-transactions are always nested, not overlapping. + ** If the open statement-transaction is not closed here, then the user + ** may step another VM that opens its own statement transaction. This + ** may lead to overlapping statement transactions. + ** + ** The statement transaction is never a top-level transaction. Hence + ** the RELEASE call below can never fail. + */ + assert( p->iStatement==0 || db->flags&SQLITE_CountRows ); + rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE); + if( NEVER(rc!=SQLITE_OK) ){ + break; + } + + /* Invalidate all ephemeral cursor row caches */ + p->cacheCtr = (p->cacheCtr + 2)|1; + + /* Make sure the results of the current row are \000 terminated + ** and have an assigned type. The results are de-ephemeralized as + ** a side effect. + */ + pMem = p->pResultSet = &aMem[pOp->p1]; + for(i=0; ip2; i++){ + assert( memIsValid(&pMem[i]) ); + Deephemeralize(&pMem[i]); + assert( (pMem[i].flags & MEM_Ephem)==0 + || (pMem[i].flags & (MEM_Str|MEM_Blob))==0 ); + sqlite3VdbeMemNulTerminate(&pMem[i]); + REGISTER_TRACE(pOp->p1+i, &pMem[i]); + } + if( db->mallocFailed ) goto no_mem; + + /* Return SQLITE_ROW + */ + p->pc = (int)(pOp - aOp) + 1; + rc = SQLITE_ROW; + goto vdbe_return; +} + +/* Opcode: Concat P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]+r[P1] +** +** Add the text in register P1 onto the end of the text in +** register P2 and store the result in register P3. +** If either the P1 or P2 text are NULL then store NULL in P3. +** +** P3 = P2 || P1 +** +** It is illegal for P1 and P3 to be the same register. Sometimes, +** if P3 is the same register as P2, the implementation is able +** to avoid a memcpy(). +*/ +case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */ + i64 nByte; + + pIn1 = &aMem[pOp->p1]; + pIn2 = &aMem[pOp->p2]; + pOut = &aMem[pOp->p3]; + assert( pIn1!=pOut ); + if( (pIn1->flags | pIn2->flags) & MEM_Null ){ + sqlite3VdbeMemSetNull(pOut); + break; + } + if( ExpandBlob(pIn1) || ExpandBlob(pIn2) ) goto no_mem; + Stringify(pIn1, encoding); + Stringify(pIn2, encoding); + nByte = pIn1->n + pIn2->n; + if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){ + goto no_mem; + } + MemSetTypeFlag(pOut, MEM_Str); + if( pOut!=pIn2 ){ + memcpy(pOut->z, pIn2->z, pIn2->n); + } + memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n); + pOut->z[nByte]=0; + pOut->z[nByte+1] = 0; + pOut->flags |= MEM_Term; + pOut->n = (int)nByte; + pOut->enc = encoding; + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Add P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]+r[P2] +** +** Add the value in register P1 to the value in register P2 +** and store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: Multiply P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]*r[P2] +** +** +** Multiply the value in register P1 by the value in register P2 +** and store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: Subtract P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]-r[P1] +** +** Subtract the value in register P1 from the value in register P2 +** and store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: Divide P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]/r[P1] +** +** Divide the value in register P1 by the value in register P2 +** and store the result in register P3 (P3=P2/P1). If the value in +** register P1 is zero, then the result is NULL. If either input is +** NULL, the result is NULL. +*/ +/* Opcode: Remainder P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]%r[P1] +** +** Compute the remainder after integer register P2 is divided by +** register P1 and store the result in register P3. +** If the value in register P1 is zero the result is NULL. +** If either operand is NULL, the result is NULL. +*/ +case OP_Add: /* same as TK_PLUS, in1, in2, out3 */ +case OP_Subtract: /* same as TK_MINUS, in1, in2, out3 */ +case OP_Multiply: /* same as TK_STAR, in1, in2, out3 */ +case OP_Divide: /* same as TK_SLASH, in1, in2, out3 */ +case OP_Remainder: { /* same as TK_REM, in1, in2, out3 */ + char bIntint; /* Started out as two integer operands */ + u16 flags; /* Combined MEM_* flags from both inputs */ + u16 type1; /* Numeric type of left operand */ + u16 type2; /* Numeric type of right operand */ + i64 iA; /* Integer value of left operand */ + i64 iB; /* Integer value of right operand */ + double rA; /* Real value of left operand */ + double rB; /* Real value of right operand */ + + pIn1 = &aMem[pOp->p1]; + type1 = numericType(pIn1); + pIn2 = &aMem[pOp->p2]; + type2 = numericType(pIn2); + pOut = &aMem[pOp->p3]; + flags = pIn1->flags | pIn2->flags; + if( (flags & MEM_Null)!=0 ) goto arithmetic_result_is_null; + if( (type1 & type2 & MEM_Int)!=0 ){ + iA = pIn1->u.i; + iB = pIn2->u.i; + bIntint = 1; + switch( pOp->opcode ){ + case OP_Add: if( sqlite3AddInt64(&iB,iA) ) goto fp_math; break; + case OP_Subtract: if( sqlite3SubInt64(&iB,iA) ) goto fp_math; break; + case OP_Multiply: if( sqlite3MulInt64(&iB,iA) ) goto fp_math; break; + case OP_Divide: { + if( iA==0 ) goto arithmetic_result_is_null; + if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math; + iB /= iA; + break; + } + default: { + if( iA==0 ) goto arithmetic_result_is_null; + if( iA==-1 ) iA = 1; + iB %= iA; + break; + } + } + pOut->u.i = iB; + MemSetTypeFlag(pOut, MEM_Int); + }else{ + bIntint = 0; +fp_math: + rA = sqlite3VdbeRealValue(pIn1); + rB = sqlite3VdbeRealValue(pIn2); + switch( pOp->opcode ){ + case OP_Add: rB += rA; break; + case OP_Subtract: rB -= rA; break; + case OP_Multiply: rB *= rA; break; + case OP_Divide: { + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + if( rA==(double)0 ) goto arithmetic_result_is_null; + rB /= rA; + break; + } + default: { + iA = (i64)rA; + iB = (i64)rB; + if( iA==0 ) goto arithmetic_result_is_null; + if( iA==-1 ) iA = 1; + rB = (double)(iB % iA); + break; + } + } +#ifdef SQLITE_OMIT_FLOATING_POINT + pOut->u.i = rB; + MemSetTypeFlag(pOut, MEM_Int); +#else + if( sqlite3IsNaN(rB) ){ + goto arithmetic_result_is_null; + } + pOut->u.r = rB; + MemSetTypeFlag(pOut, MEM_Real); + if( ((type1|type2)&MEM_Real)==0 && !bIntint ){ + sqlite3VdbeIntegerAffinity(pOut); + } +#endif + } + break; + +arithmetic_result_is_null: + sqlite3VdbeMemSetNull(pOut); + break; +} + +/* Opcode: CollSeq P1 * * P4 +** +** P4 is a pointer to a CollSeq struct. If the next call to a user function +** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will +** be returned. This is used by the built-in min(), max() and nullif() +** functions. +** +** If P1 is not zero, then it is a register that a subsequent min() or +** max() aggregate will set to 1 if the current row is not the minimum or +** maximum. The P1 register is initialized to 0 by this instruction. +** +** The interface used by the implementation of the aforementioned functions +** to retrieve the collation sequence set by this opcode is not available +** publicly. Only built-in functions have access to this feature. +*/ +case OP_CollSeq: { + assert( pOp->p4type==P4_COLLSEQ ); + if( pOp->p1 ){ + sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0); + } + break; +} + +/* Opcode: Function0 P1 P2 P3 P4 P5 +** Synopsis: r[P3]=func(r[P2@P5]) +** +** Invoke a user function (P4 is a pointer to a FuncDef object that +** defines the function) with P5 arguments taken from register P2 and +** successors. The result of the function is stored in register P3. +** Register P3 must not be one of the function inputs. +** +** P1 is a 32-bit bitmask indicating whether or not each argument to the +** function was determined to be constant at compile time. If the first +** argument was constant then bit 0 of P1 is set. This is used to determine +** whether meta data associated with a user function argument using the +** sqlite3_set_auxdata() API may be safely retained until the next +** invocation of this opcode. +** +** See also: Function, AggStep, AggFinal +*/ +/* Opcode: Function P1 P2 P3 P4 P5 +** Synopsis: r[P3]=func(r[P2@P5]) +** +** Invoke a user function (P4 is a pointer to an sqlite3_context object that +** contains a pointer to the function to be run) with P5 arguments taken +** from register P2 and successors. The result of the function is stored +** in register P3. Register P3 must not be one of the function inputs. +** +** P1 is a 32-bit bitmask indicating whether or not each argument to the +** function was determined to be constant at compile time. If the first +** argument was constant then bit 0 of P1 is set. This is used to determine +** whether meta data associated with a user function argument using the +** sqlite3_set_auxdata() API may be safely retained until the next +** invocation of this opcode. +** +** SQL functions are initially coded as OP_Function0 with P4 pointing +** to a FuncDef object. But on first evaluation, the P4 operand is +** automatically converted into an sqlite3_context object and the operation +** changed to this OP_Function opcode. In this way, the initialization of +** the sqlite3_context object occurs only once, rather than once for each +** evaluation of the function. +** +** See also: Function0, AggStep, AggFinal +*/ +case OP_Function0: { + int n; + sqlite3_context *pCtx; + + assert( pOp->p4type==P4_FUNCDEF ); + n = pOp->p5; + assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) ); + assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) ); + assert( pOp->p3p2 || pOp->p3>=pOp->p2+n ); + pCtx = sqlite3DbMallocRaw(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*)); + if( pCtx==0 ) goto no_mem; + pCtx->pOut = 0; + pCtx->pFunc = pOp->p4.pFunc; + pCtx->iOp = (int)(pOp - aOp); + pCtx->pVdbe = p; + pCtx->argc = n; + pOp->p4type = P4_FUNCCTX; + pOp->p4.pCtx = pCtx; + pOp->opcode = OP_Function; + /* Fall through into OP_Function */ +} +case OP_Function: { + int i; + sqlite3_context *pCtx; + + assert( pOp->p4type==P4_FUNCCTX ); + pCtx = pOp->p4.pCtx; + + /* If this function is inside of a trigger, the register array in aMem[] + ** might change from one evaluation to the next. The next block of code + ** checks to see if the register array has changed, and if so it + ** reinitializes the relavant parts of the sqlite3_context object */ + pOut = &aMem[pOp->p3]; + if( pCtx->pOut != pOut ){ + pCtx->pOut = pOut; + for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i]; + } + + memAboutToChange(p, pCtx->pOut); +#ifdef SQLITE_DEBUG + for(i=0; iargc; i++){ + assert( memIsValid(pCtx->argv[i]) ); + REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]); + } +#endif + MemSetTypeFlag(pCtx->pOut, MEM_Null); + pCtx->fErrorOrAux = 0; + db->lastRowid = lastRowid; + (*pCtx->pFunc->xFunc)(pCtx, pCtx->argc, pCtx->argv); /* IMP: R-24505-23230 */ + lastRowid = db->lastRowid; /* Remember rowid changes made by xFunc */ + + /* If the function returned an error, throw an exception */ + if( pCtx->fErrorOrAux ){ + if( pCtx->isError ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut)); + rc = pCtx->isError; + } + sqlite3VdbeDeleteAuxData(p, pCtx->iOp, pOp->p1); + } + + /* Copy the result of the function into register P3 */ + if( pOut->flags & (MEM_Str|MEM_Blob) ){ + sqlite3VdbeChangeEncoding(pCtx->pOut, encoding); + if( sqlite3VdbeMemTooBig(pCtx->pOut) ) goto too_big; + } + + REGISTER_TRACE(pOp->p3, pCtx->pOut); + UPDATE_MAX_BLOBSIZE(pCtx->pOut); + break; +} + +/* Opcode: BitAnd P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]&r[P2] +** +** Take the bit-wise AND of the values in register P1 and P2 and +** store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: BitOr P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]|r[P2] +** +** Take the bit-wise OR of the values in register P1 and P2 and +** store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: ShiftLeft P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]<>r[P1] +** +** Shift the integer value in register P2 to the right by the +** number of bits specified by the integer in register P1. +** Store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +case OP_BitAnd: /* same as TK_BITAND, in1, in2, out3 */ +case OP_BitOr: /* same as TK_BITOR, in1, in2, out3 */ +case OP_ShiftLeft: /* same as TK_LSHIFT, in1, in2, out3 */ +case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */ + i64 iA; + u64 uA; + i64 iB; + u8 op; + + pIn1 = &aMem[pOp->p1]; + pIn2 = &aMem[pOp->p2]; + pOut = &aMem[pOp->p3]; + if( (pIn1->flags | pIn2->flags) & MEM_Null ){ + sqlite3VdbeMemSetNull(pOut); + break; + } + iA = sqlite3VdbeIntValue(pIn2); + iB = sqlite3VdbeIntValue(pIn1); + op = pOp->opcode; + if( op==OP_BitAnd ){ + iA &= iB; + }else if( op==OP_BitOr ){ + iA |= iB; + }else if( iB!=0 ){ + assert( op==OP_ShiftRight || op==OP_ShiftLeft ); + + /* If shifting by a negative amount, shift in the other direction */ + if( iB<0 ){ + assert( OP_ShiftRight==OP_ShiftLeft+1 ); + op = 2*OP_ShiftLeft + 1 - op; + iB = iB>(-64) ? -iB : 64; + } + + if( iB>=64 ){ + iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1; + }else{ + memcpy(&uA, &iA, sizeof(uA)); + if( op==OP_ShiftLeft ){ + uA <<= iB; + }else{ + uA >>= iB; + /* Sign-extend on a right shift of a negative number */ + if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB); + } + memcpy(&iA, &uA, sizeof(iA)); + } + } + pOut->u.i = iA; + MemSetTypeFlag(pOut, MEM_Int); + break; +} + +/* Opcode: AddImm P1 P2 * * * +** Synopsis: r[P1]=r[P1]+P2 +** +** Add the constant P2 to the value in register P1. +** The result is always an integer. +** +** To force any register to be an integer, just add 0. +*/ +case OP_AddImm: { /* in1 */ + pIn1 = &aMem[pOp->p1]; + memAboutToChange(p, pIn1); + sqlite3VdbeMemIntegerify(pIn1); + pIn1->u.i += pOp->p2; + break; +} + +/* Opcode: MustBeInt P1 P2 * * * +** +** Force the value in register P1 to be an integer. If the value +** in P1 is not an integer and cannot be converted into an integer +** without data loss, then jump immediately to P2, or if P2==0 +** raise an SQLITE_MISMATCH exception. +*/ +case OP_MustBeInt: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + if( (pIn1->flags & MEM_Int)==0 ){ + applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding); + VdbeBranchTaken((pIn1->flags&MEM_Int)==0, 2); + if( (pIn1->flags & MEM_Int)==0 ){ + if( pOp->p2==0 ){ + rc = SQLITE_MISMATCH; + goto abort_due_to_error; + }else{ + goto jump_to_p2; + } + } + } + MemSetTypeFlag(pIn1, MEM_Int); + break; +} + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* Opcode: RealAffinity P1 * * * * +** +** If register P1 holds an integer convert it to a real value. +** +** This opcode is used when extracting information from a column that +** has REAL affinity. Such column values may still be stored as +** integers, for space efficiency, but after extraction we want them +** to have only a real value. +*/ +case OP_RealAffinity: { /* in1 */ + pIn1 = &aMem[pOp->p1]; + if( pIn1->flags & MEM_Int ){ + sqlite3VdbeMemRealify(pIn1); + } + break; +} +#endif + +#ifndef SQLITE_OMIT_CAST +/* Opcode: Cast P1 P2 * * * +** Synopsis: affinity(r[P1]) +** +** Force the value in register P1 to be the type defined by P2. +** +**
      +**
    • TEXT +**
    • BLOB +**
    • NUMERIC +**
    • INTEGER +**
    • REAL +**
    +** +** A NULL value is not changed by this routine. It remains NULL. +*/ +case OP_Cast: { /* in1 */ + assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL ); + testcase( pOp->p2==SQLITE_AFF_TEXT ); + testcase( pOp->p2==SQLITE_AFF_BLOB ); + testcase( pOp->p2==SQLITE_AFF_NUMERIC ); + testcase( pOp->p2==SQLITE_AFF_INTEGER ); + testcase( pOp->p2==SQLITE_AFF_REAL ); + pIn1 = &aMem[pOp->p1]; + memAboutToChange(p, pIn1); + rc = ExpandBlob(pIn1); + sqlite3VdbeMemCast(pIn1, pOp->p2, encoding); + UPDATE_MAX_BLOBSIZE(pIn1); + break; +} +#endif /* SQLITE_OMIT_CAST */ + +/* Opcode: Lt P1 P2 P3 P4 P5 +** Synopsis: if r[P1]r[P3] goto P2 +** +** This works just like the Lt opcode except that the jump is taken if +** the content of register P3 is greater than the content of +** register P1. See the Lt opcode for additional information. +*/ +/* Opcode: Ge P1 P2 P3 P4 P5 +** Synopsis: if r[P1]>=r[P3] goto P2 +** +** This works just like the Lt opcode except that the jump is taken if +** the content of register P3 is greater than or equal to the content of +** register P1. See the Lt opcode for additional information. +*/ +case OP_Eq: /* same as TK_EQ, jump, in1, in3 */ +case OP_Ne: /* same as TK_NE, jump, in1, in3 */ +case OP_Lt: /* same as TK_LT, jump, in1, in3 */ +case OP_Le: /* same as TK_LE, jump, in1, in3 */ +case OP_Gt: /* same as TK_GT, jump, in1, in3 */ +case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ + int res; /* Result of the comparison of pIn1 against pIn3 */ + char affinity; /* Affinity to use for comparison */ + u16 flags1; /* Copy of initial value of pIn1->flags */ + u16 flags3; /* Copy of initial value of pIn3->flags */ + + pIn1 = &aMem[pOp->p1]; + pIn3 = &aMem[pOp->p3]; + flags1 = pIn1->flags; + flags3 = pIn3->flags; + if( (flags1 | flags3)&MEM_Null ){ + /* One or both operands are NULL */ + if( pOp->p5 & SQLITE_NULLEQ ){ + /* If SQLITE_NULLEQ is set (which will only happen if the operator is + ** OP_Eq or OP_Ne) then take the jump or not depending on whether + ** or not both operands are null. + */ + assert( pOp->opcode==OP_Eq || pOp->opcode==OP_Ne ); + assert( (flags1 & MEM_Cleared)==0 ); + assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 ); + if( (flags1&MEM_Null)!=0 + && (flags3&MEM_Null)!=0 + && (flags3&MEM_Cleared)==0 + ){ + res = 0; /* Results are equal */ + }else{ + res = 1; /* Results are not equal */ + } + }else{ + /* SQLITE_NULLEQ is clear and at least one operand is NULL, + ** then the result is always NULL. + ** The jump is taken if the SQLITE_JUMPIFNULL bit is set. + */ + if( pOp->p5 & SQLITE_STOREP2 ){ + pOut = &aMem[pOp->p2]; + MemSetTypeFlag(pOut, MEM_Null); + REGISTER_TRACE(pOp->p2, pOut); + }else{ + VdbeBranchTaken(2,3); + if( pOp->p5 & SQLITE_JUMPIFNULL ){ + goto jump_to_p2; + } + } + break; + } + }else{ + /* Neither operand is NULL. Do a comparison. */ + affinity = pOp->p5 & SQLITE_AFF_MASK; + if( affinity>=SQLITE_AFF_NUMERIC ){ + if( (pIn1->flags & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){ + applyNumericAffinity(pIn1,0); + } + if( (pIn3->flags & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){ + applyNumericAffinity(pIn3,0); + } + }else if( affinity==SQLITE_AFF_TEXT ){ + if( (pIn1->flags & MEM_Str)==0 && (pIn1->flags & (MEM_Int|MEM_Real))!=0 ){ + testcase( pIn1->flags & MEM_Int ); + testcase( pIn1->flags & MEM_Real ); + sqlite3VdbeMemStringify(pIn1, encoding, 1); + testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) ); + flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask); + } + if( (pIn3->flags & MEM_Str)==0 && (pIn3->flags & (MEM_Int|MEM_Real))!=0 ){ + testcase( pIn3->flags & MEM_Int ); + testcase( pIn3->flags & MEM_Real ); + sqlite3VdbeMemStringify(pIn3, encoding, 1); + testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) ); + flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask); + } + } + assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 ); + if( pIn1->flags & MEM_Zero ){ + sqlite3VdbeMemExpandBlob(pIn1); + flags1 &= ~MEM_Zero; + } + if( pIn3->flags & MEM_Zero ){ + sqlite3VdbeMemExpandBlob(pIn3); + flags3 &= ~MEM_Zero; + } + if( db->mallocFailed ) goto no_mem; + res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl); + } + switch( pOp->opcode ){ + case OP_Eq: res = res==0; break; + case OP_Ne: res = res!=0; break; + case OP_Lt: res = res<0; break; + case OP_Le: res = res<=0; break; + case OP_Gt: res = res>0; break; + default: res = res>=0; break; + } + + /* Undo any changes made by applyAffinity() to the input registers. */ + assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); + pIn1->flags = flags1; + assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) ); + pIn3->flags = flags3; + + if( pOp->p5 & SQLITE_STOREP2 ){ + pOut = &aMem[pOp->p2]; + memAboutToChange(p, pOut); + MemSetTypeFlag(pOut, MEM_Int); + pOut->u.i = res; + REGISTER_TRACE(pOp->p2, pOut); + }else{ + VdbeBranchTaken(res!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3); + if( res ){ + goto jump_to_p2; + } + } + break; +} + +/* Opcode: Permutation * * * P4 * +** +** Set the permutation used by the OP_Compare operator to be the array +** of integers in P4. +** +** The permutation is only valid until the next OP_Compare that has +** the OPFLAG_PERMUTE bit set in P5. Typically the OP_Permutation should +** occur immediately prior to the OP_Compare. +*/ +case OP_Permutation: { + assert( pOp->p4type==P4_INTARRAY ); + assert( pOp->p4.ai ); + aPermute = pOp->p4.ai; + break; +} + +/* Opcode: Compare P1 P2 P3 P4 P5 +** Synopsis: r[P1@P3] <-> r[P2@P3] +** +** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this +** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of +** the comparison for use by the next OP_Jump instruct. +** +** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is +** determined by the most recent OP_Permutation operator. If the +** OPFLAG_PERMUTE bit is clear, then register are compared in sequential +** order. +** +** P4 is a KeyInfo structure that defines collating sequences and sort +** orders for the comparison. The permutation applies to registers +** only. The KeyInfo elements are used sequentially. +** +** The comparison is a sort comparison, so NULLs compare equal, +** NULLs are less than numbers, numbers are less than strings, +** and strings are less than blobs. +*/ +case OP_Compare: { + int n; + int i; + int p1; + int p2; + const KeyInfo *pKeyInfo; + int idx; + CollSeq *pColl; /* Collating sequence to use on this term */ + int bRev; /* True for DESCENDING sort order */ + + if( (pOp->p5 & OPFLAG_PERMUTE)==0 ) aPermute = 0; + n = pOp->p3; + pKeyInfo = pOp->p4.pKeyInfo; + assert( n>0 ); + assert( pKeyInfo!=0 ); + p1 = pOp->p1; + p2 = pOp->p2; +#if SQLITE_DEBUG + if( aPermute ){ + int k, mx = 0; + for(k=0; kmx ) mx = aPermute[k]; + assert( p1>0 && p1+mx<=(p->nMem-p->nCursor)+1 ); + assert( p2>0 && p2+mx<=(p->nMem-p->nCursor)+1 ); + }else{ + assert( p1>0 && p1+n<=(p->nMem-p->nCursor)+1 ); + assert( p2>0 && p2+n<=(p->nMem-p->nCursor)+1 ); + } +#endif /* SQLITE_DEBUG */ + for(i=0; inField ); + pColl = pKeyInfo->aColl[i]; + bRev = pKeyInfo->aSortOrder[i]; + iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl); + if( iCompare ){ + if( bRev ) iCompare = -iCompare; + break; + } + } + aPermute = 0; + break; +} + +/* Opcode: Jump P1 P2 P3 * * +** +** Jump to the instruction at address P1, P2, or P3 depending on whether +** in the most recent OP_Compare instruction the P1 vector was less than +** equal to, or greater than the P2 vector, respectively. +*/ +case OP_Jump: { /* jump */ + if( iCompare<0 ){ + VdbeBranchTaken(0,3); pOp = &aOp[pOp->p1 - 1]; + }else if( iCompare==0 ){ + VdbeBranchTaken(1,3); pOp = &aOp[pOp->p2 - 1]; + }else{ + VdbeBranchTaken(2,3); pOp = &aOp[pOp->p3 - 1]; + } + break; +} + +/* Opcode: And P1 P2 P3 * * +** Synopsis: r[P3]=(r[P1] && r[P2]) +** +** Take the logical AND of the values in registers P1 and P2 and +** write the result into register P3. +** +** If either P1 or P2 is 0 (false) then the result is 0 even if +** the other input is NULL. A NULL and true or two NULLs give +** a NULL output. +*/ +/* Opcode: Or P1 P2 P3 * * +** Synopsis: r[P3]=(r[P1] || r[P2]) +** +** Take the logical OR of the values in register P1 and P2 and +** store the answer in register P3. +** +** If either P1 or P2 is nonzero (true) then the result is 1 (true) +** even if the other input is NULL. A NULL and false or two NULLs +** give a NULL output. +*/ +case OP_And: /* same as TK_AND, in1, in2, out3 */ +case OP_Or: { /* same as TK_OR, in1, in2, out3 */ + int v1; /* Left operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */ + int v2; /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */ + + pIn1 = &aMem[pOp->p1]; + if( pIn1->flags & MEM_Null ){ + v1 = 2; + }else{ + v1 = sqlite3VdbeIntValue(pIn1)!=0; + } + pIn2 = &aMem[pOp->p2]; + if( pIn2->flags & MEM_Null ){ + v2 = 2; + }else{ + v2 = sqlite3VdbeIntValue(pIn2)!=0; + } + if( pOp->opcode==OP_And ){ + static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 }; + v1 = and_logic[v1*3+v2]; + }else{ + static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 }; + v1 = or_logic[v1*3+v2]; + } + pOut = &aMem[pOp->p3]; + if( v1==2 ){ + MemSetTypeFlag(pOut, MEM_Null); + }else{ + pOut->u.i = v1; + MemSetTypeFlag(pOut, MEM_Int); + } + break; +} + +/* Opcode: Not P1 P2 * * * +** Synopsis: r[P2]= !r[P1] +** +** Interpret the value in register P1 as a boolean value. Store the +** boolean complement in register P2. If the value in register P1 is +** NULL, then a NULL is stored in P2. +*/ +case OP_Not: { /* same as TK_NOT, in1, out2 */ + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + sqlite3VdbeMemSetNull(pOut); + if( (pIn1->flags & MEM_Null)==0 ){ + pOut->flags = MEM_Int; + pOut->u.i = !sqlite3VdbeIntValue(pIn1); + } + break; +} + +/* Opcode: BitNot P1 P2 * * * +** Synopsis: r[P1]= ~r[P1] +** +** Interpret the content of register P1 as an integer. Store the +** ones-complement of the P1 value into register P2. If P1 holds +** a NULL then store a NULL in P2. +*/ +case OP_BitNot: { /* same as TK_BITNOT, in1, out2 */ + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + sqlite3VdbeMemSetNull(pOut); + if( (pIn1->flags & MEM_Null)==0 ){ + pOut->flags = MEM_Int; + pOut->u.i = ~sqlite3VdbeIntValue(pIn1); + } + break; +} + +/* Opcode: Once P1 P2 * * * +** +** Check the "once" flag number P1. If it is set, jump to instruction P2. +** Otherwise, set the flag and fall through to the next instruction. +** In other words, this opcode causes all following opcodes up through P2 +** (but not including P2) to run just once and to be skipped on subsequent +** times through the loop. +** +** All "once" flags are initially cleared whenever a prepared statement +** first begins to run. +*/ +case OP_Once: { /* jump */ + assert( pOp->p1nOnceFlag ); + VdbeBranchTaken(p->aOnceFlag[pOp->p1]!=0, 2); + if( p->aOnceFlag[pOp->p1] ){ + goto jump_to_p2; + }else{ + p->aOnceFlag[pOp->p1] = 1; + } + break; +} + +/* Opcode: If P1 P2 P3 * * +** +** Jump to P2 if the value in register P1 is true. The value +** is considered true if it is numeric and non-zero. If the value +** in P1 is NULL then take the jump if and only if P3 is non-zero. +*/ +/* Opcode: IfNot P1 P2 P3 * * +** +** Jump to P2 if the value in register P1 is False. The value +** is considered false if it has a numeric value of zero. If the value +** in P1 is NULL then take the jump if and only if P3 is non-zero. +*/ +case OP_If: /* jump, in1 */ +case OP_IfNot: { /* jump, in1 */ + int c; + pIn1 = &aMem[pOp->p1]; + if( pIn1->flags & MEM_Null ){ + c = pOp->p3; + }else{ +#ifdef SQLITE_OMIT_FLOATING_POINT + c = sqlite3VdbeIntValue(pIn1)!=0; +#else + c = sqlite3VdbeRealValue(pIn1)!=0.0; +#endif + if( pOp->opcode==OP_IfNot ) c = !c; + } + VdbeBranchTaken(c!=0, 2); + if( c ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: IsNull P1 P2 * * * +** Synopsis: if r[P1]==NULL goto P2 +** +** Jump to P2 if the value in register P1 is NULL. +*/ +case OP_IsNull: { /* same as TK_ISNULL, jump, in1 */ + pIn1 = &aMem[pOp->p1]; + VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2); + if( (pIn1->flags & MEM_Null)!=0 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: NotNull P1 P2 * * * +** Synopsis: if r[P1]!=NULL goto P2 +** +** Jump to P2 if the value in register P1 is not NULL. +*/ +case OP_NotNull: { /* same as TK_NOTNULL, jump, in1 */ + pIn1 = &aMem[pOp->p1]; + VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2); + if( (pIn1->flags & MEM_Null)==0 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: Column P1 P2 P3 P4 P5 +** Synopsis: r[P3]=PX +** +** Interpret the data that cursor P1 points to as a structure built using +** the MakeRecord instruction. (See the MakeRecord opcode for additional +** information about the format of the data.) Extract the P2-th column +** from this record. If there are less that (P2+1) +** values in the record, extract a NULL. +** +** The value extracted is stored in register P3. +** +** If the column contains fewer than P2 fields, then extract a NULL. Or, +** if the P4 argument is a P4_MEM use the value of the P4 argument as +** the result. +** +** If the OPFLAG_CLEARCACHE bit is set on P5 and P1 is a pseudo-table cursor, +** then the cache of the cursor is reset prior to extracting the column. +** The first OP_Column against a pseudo-table after the value of the content +** register has changed should have this bit set. +** +** If the OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG bits are set on P5 when +** the result is guaranteed to only be used as the argument of a length() +** or typeof() function, respectively. The loading of large blobs can be +** skipped for length() and all content loading can be skipped for typeof(). +*/ +case OP_Column: { + i64 payloadSize64; /* Number of bytes in the record */ + int p2; /* column number to retrieve */ + VdbeCursor *pC; /* The VDBE cursor */ + BtCursor *pCrsr; /* The BTree cursor */ + u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */ + int len; /* The length of the serialized data for the column */ + int i; /* Loop counter */ + Mem *pDest; /* Where to write the extracted value */ + Mem sMem; /* For storing the record being decoded */ + const u8 *zData; /* Part of the record being decoded */ + const u8 *zHdr; /* Next unparsed byte of the header */ + const u8 *zEndHdr; /* Pointer to first byte after the header */ + u32 offset; /* Offset into the data */ + u32 szField; /* Number of bytes in the content of a field */ + u32 avail; /* Number of bytes of available data */ + u32 t; /* A type code from the record header */ + u16 fx; /* pDest->flags value */ + Mem *pReg; /* PseudoTable input register */ + + p2 = pOp->p2; + assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) ); + pDest = &aMem[pOp->p3]; + memAboutToChange(p, pDest); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( p2nField ); + aOffset = pC->aOffset; +#ifndef SQLITE_OMIT_VIRTUALTABLE + assert( pC->pVtabCursor==0 ); /* OP_Column never called on virtual table */ +#endif + pCrsr = pC->pCursor; + assert( pCrsr!=0 || pC->pseudoTableReg>0 ); /* pCrsr NULL on PseudoTables */ + assert( pCrsr!=0 || pC->nullRow ); /* pC->nullRow on PseudoTables */ + + /* If the cursor cache is stale, bring it up-to-date */ + rc = sqlite3VdbeCursorMoveto(pC); + if( rc ) goto abort_due_to_error; + if( pC->cacheStatus!=p->cacheCtr ){ + if( pC->nullRow ){ + if( pCrsr==0 ){ + assert( pC->pseudoTableReg>0 ); + pReg = &aMem[pC->pseudoTableReg]; + assert( pReg->flags & MEM_Blob ); + assert( memIsValid(pReg) ); + pC->payloadSize = pC->szRow = avail = pReg->n; + pC->aRow = (u8*)pReg->z; + }else{ + sqlite3VdbeMemSetNull(pDest); + goto op_column_out; + } + }else{ + assert( pCrsr ); + if( pC->isTable==0 ){ + assert( sqlite3BtreeCursorIsValid(pCrsr) ); + VVA_ONLY(rc =) sqlite3BtreeKeySize(pCrsr, &payloadSize64); + assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */ + /* sqlite3BtreeParseCellPtr() uses getVarint32() to extract the + ** payload size, so it is impossible for payloadSize64 to be + ** larger than 32 bits. */ + assert( (payloadSize64 & SQLITE_MAX_U32)==(u64)payloadSize64 ); + pC->aRow = sqlite3BtreeKeyFetch(pCrsr, &avail); + pC->payloadSize = (u32)payloadSize64; + }else{ + assert( sqlite3BtreeCursorIsValid(pCrsr) ); + VVA_ONLY(rc =) sqlite3BtreeDataSize(pCrsr, &pC->payloadSize); + assert( rc==SQLITE_OK ); /* DataSize() cannot fail */ + pC->aRow = sqlite3BtreeDataFetch(pCrsr, &avail); + } + assert( avail<=65536 ); /* Maximum page size is 64KiB */ + if( pC->payloadSize <= (u32)avail ){ + pC->szRow = pC->payloadSize; + }else{ + pC->szRow = avail; + } + if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + } + pC->cacheStatus = p->cacheCtr; + pC->iHdrOffset = getVarint32(pC->aRow, offset); + pC->nHdrParsed = 0; + aOffset[0] = offset; + + /* Make sure a corrupt database has not given us an oversize header. + ** Do this now to avoid an oversize memory allocation. + ** + ** Type entries can be between 1 and 5 bytes each. But 4 and 5 byte + ** types use so much data space that there can only be 4096 and 32 of + ** them, respectively. So the maximum header length results from a + ** 3-byte type for each of the maximum of 32768 columns plus three + ** extra bytes for the header length itself. 32768*3 + 3 = 98307. + */ + if( offset > 98307 || offset > pC->payloadSize ){ + rc = SQLITE_CORRUPT_BKPT; + goto op_column_error; + } + + if( availaRow does not have to hold the entire row, but it does at least + ** need to cover the header of the record. If pC->aRow does not contain + ** the complete header, then set it to zero, forcing the header to be + ** dynamically allocated. */ + pC->aRow = 0; + pC->szRow = 0; + } + + /* The following goto is an optimization. It can be omitted and + ** everything will still work. But OP_Column is measurably faster + ** by skipping the subsequent conditional, which is always true. + */ + assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */ + goto op_column_read_header; + } + + /* Make sure at least the first p2+1 entries of the header have been + ** parsed and valid information is in aOffset[] and pC->aType[]. + */ + if( pC->nHdrParsed<=p2 ){ + /* If there is more header available for parsing in the record, try + ** to extract additional fields up through the p2+1-th field + */ + op_column_read_header: + if( pC->iHdrOffsetaRow==0 ){ + memset(&sMem, 0, sizeof(sMem)); + rc = sqlite3VdbeMemFromBtree(pCrsr, 0, aOffset[0], + !pC->isTable, &sMem); + if( rc!=SQLITE_OK ){ + goto op_column_error; + } + zData = (u8*)sMem.z; + }else{ + zData = pC->aRow; + } + + /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */ + i = pC->nHdrParsed; + offset = aOffset[i]; + zHdr = zData + pC->iHdrOffset; + zEndHdr = zData + aOffset[0]; + assert( i<=p2 && zHdraType[i] = t; + szField = sqlite3VdbeSerialTypeLen(t); + offset += szField; + if( offsetnHdrParsed = i; + pC->iHdrOffset = (u32)(zHdr - zData); + if( pC->aRow==0 ){ + sqlite3VdbeMemRelease(&sMem); + sMem.flags = MEM_Null; + } + + /* The record is corrupt if any of the following are true: + ** (1) the bytes of the header extend past the declared header size + ** (zHdr>zEndHdr) + ** (2) the entire header was used but not all data was used + ** (zHdr==zEndHdr && offset!=pC->payloadSize) + ** (3) the end of the data extends beyond the end of the record. + ** (offset > pC->payloadSize) + */ + if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset!=pC->payloadSize)) + || (offset > pC->payloadSize) + ){ + rc = SQLITE_CORRUPT_BKPT; + goto op_column_error; + } + } + + /* If after trying to extract new entries from the header, nHdrParsed is + ** still not up to p2, that means that the record has fewer than p2 + ** columns. So the result will be either the default value or a NULL. + */ + if( pC->nHdrParsed<=p2 ){ + if( pOp->p4type==P4_MEM ){ + sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static); + }else{ + sqlite3VdbeMemSetNull(pDest); + } + goto op_column_out; + } + } + + /* Extract the content for the p2+1-th column. Control can only + ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are + ** all valid. + */ + assert( p2nHdrParsed ); + assert( rc==SQLITE_OK ); + assert( sqlite3VdbeCheckMemInvariants(pDest) ); + if( VdbeMemDynamic(pDest) ) sqlite3VdbeMemSetNull(pDest); + t = pC->aType[p2]; + if( pC->szRow>=aOffset[p2+1] ){ + /* This is the common case where the desired content fits on the original + ** page - where the content is not on an overflow page */ + sqlite3VdbeSerialGet(pC->aRow+aOffset[p2], t, pDest); + }else{ + /* This branch happens only when content is on overflow pages */ + if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0 + && ((t>=12 && (t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0)) + || (len = sqlite3VdbeSerialTypeLen(t))==0 + ){ + /* Content is irrelevant for + ** 1. the typeof() function, + ** 2. the length(X) function if X is a blob, and + ** 3. if the content length is zero. + ** So we might as well use bogus content rather than reading + ** content from disk. NULL will work for the value for strings + ** and blobs and whatever is in the payloadSize64 variable + ** will work for everything else. */ + sqlite3VdbeSerialGet(t<=13 ? (u8*)&payloadSize64 : 0, t, pDest); + }else{ + rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, !pC->isTable, + pDest); + if( rc!=SQLITE_OK ){ + goto op_column_error; + } + sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest); + pDest->flags &= ~MEM_Ephem; + } + } + pDest->enc = encoding; + +op_column_out: + /* If the column value is an ephemeral string, go ahead and persist + ** that string in case the cursor moves before the column value is + ** used. The following code does the equivalent of Deephemeralize() + ** but does it faster. */ + if( (pDest->flags & MEM_Ephem)!=0 && pDest->z ){ + fx = pDest->flags & (MEM_Str|MEM_Blob); + assert( fx!=0 ); + zData = (const u8*)pDest->z; + len = pDest->n; + if( sqlite3VdbeMemClearAndResize(pDest, len+2) ) goto no_mem; + memcpy(pDest->z, zData, len); + pDest->z[len] = 0; + pDest->z[len+1] = 0; + pDest->flags = fx|MEM_Term; + } +op_column_error: + UPDATE_MAX_BLOBSIZE(pDest); + REGISTER_TRACE(pOp->p3, pDest); + break; +} + +/* Opcode: Affinity P1 P2 * P4 * +** Synopsis: affinity(r[P1@P2]) +** +** Apply affinities to a range of P2 registers starting with P1. +** +** P4 is a string that is P2 characters long. The nth character of the +** string indicates the column affinity that should be used for the nth +** memory cell in the range. +*/ +case OP_Affinity: { + const char *zAffinity; /* The affinity to be applied */ + char cAff; /* A single character of affinity */ + + zAffinity = pOp->p4.z; + assert( zAffinity!=0 ); + assert( zAffinity[pOp->p2]==0 ); + pIn1 = &aMem[pOp->p1]; + while( (cAff = *(zAffinity++))!=0 ){ + assert( pIn1 <= &p->aMem[(p->nMem-p->nCursor)] ); + assert( memIsValid(pIn1) ); + applyAffinity(pIn1, cAff, encoding); + pIn1++; + } + break; +} + +/* Opcode: MakeRecord P1 P2 P3 P4 * +** Synopsis: r[P3]=mkrec(r[P1@P2]) +** +** Convert P2 registers beginning with P1 into the [record format] +** use as a data record in a database table or as a key +** in an index. The OP_Column opcode can decode the record later. +** +** P4 may be a string that is P2 characters long. The nth character of the +** string indicates the column affinity that should be used for the nth +** field of the index key. +** +** The mapping from character to affinity is given by the SQLITE_AFF_ +** macros defined in sqliteInt.h. +** +** If P4 is NULL then all index fields have the affinity BLOB. +*/ +case OP_MakeRecord: { + u8 *zNewRecord; /* A buffer to hold the data for the new record */ + Mem *pRec; /* The new record */ + u64 nData; /* Number of bytes of data space */ + int nHdr; /* Number of bytes of header space */ + i64 nByte; /* Data space required for this record */ + i64 nZero; /* Number of zero bytes at the end of the record */ + int nVarint; /* Number of bytes in a varint */ + u32 serial_type; /* Type field */ + Mem *pData0; /* First field to be combined into the record */ + Mem *pLast; /* Last field of the record */ + int nField; /* Number of fields in the record */ + char *zAffinity; /* The affinity string for the record */ + int file_format; /* File format to use for encoding */ + int i; /* Space used in zNewRecord[] header */ + int j; /* Space used in zNewRecord[] content */ + int len; /* Length of a field */ + + /* Assuming the record contains N fields, the record format looks + ** like this: + ** + ** ------------------------------------------------------------------------ + ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | + ** ------------------------------------------------------------------------ + ** + ** Data(0) is taken from register P1. Data(1) comes from register P1+1 + ** and so forth. + ** + ** Each type field is a varint representing the serial type of the + ** corresponding data element (see sqlite3VdbeSerialType()). The + ** hdr-size field is also a varint which is the offset from the beginning + ** of the record to data0. + */ + nData = 0; /* Number of bytes of data space */ + nHdr = 0; /* Number of bytes of header space */ + nZero = 0; /* Number of zero bytes at the end of the record */ + nField = pOp->p1; + zAffinity = pOp->p4.z; + assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem-p->nCursor)+1 ); + pData0 = &aMem[nField]; + nField = pOp->p2; + pLast = &pData0[nField-1]; + file_format = p->minWriteFileFormat; + + /* Identify the output register */ + assert( pOp->p3p1 || pOp->p3>=pOp->p1+pOp->p2 ); + pOut = &aMem[pOp->p3]; + memAboutToChange(p, pOut); + + /* Apply the requested affinity to all inputs + */ + assert( pData0<=pLast ); + if( zAffinity ){ + pRec = pData0; + do{ + applyAffinity(pRec++, *(zAffinity++), encoding); + assert( zAffinity[0]==0 || pRec<=pLast ); + }while( zAffinity[0] ); + } + + /* Loop through the elements that will make up the record to figure + ** out how much space is required for the new record. + */ + pRec = pLast; + do{ + assert( memIsValid(pRec) ); + pRec->uTemp = serial_type = sqlite3VdbeSerialType(pRec, file_format); + len = sqlite3VdbeSerialTypeLen(serial_type); + if( pRec->flags & MEM_Zero ){ + if( nData ){ + if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem; + }else{ + nZero += pRec->u.nZero; + len -= pRec->u.nZero; + } + } + nData += len; + testcase( serial_type==127 ); + testcase( serial_type==128 ); + nHdr += serial_type<=127 ? 1 : sqlite3VarintLen(serial_type); + }while( (--pRec)>=pData0 ); + + /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint + ** which determines the total number of bytes in the header. The varint + ** value is the size of the header in bytes including the size varint + ** itself. */ + testcase( nHdr==126 ); + testcase( nHdr==127 ); + if( nHdr<=126 ){ + /* The common case */ + nHdr += 1; + }else{ + /* Rare case of a really large header */ + nVarint = sqlite3VarintLen(nHdr); + nHdr += nVarint; + if( nVarintdb->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + + /* Make sure the output register has a buffer large enough to store + ** the new record. The output register (pOp->p3) is not allowed to + ** be one of the input registers (because the following call to + ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used). + */ + if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){ + goto no_mem; + } + zNewRecord = (u8 *)pOut->z; + + /* Write the record */ + i = putVarint32(zNewRecord, nHdr); + j = nHdr; + assert( pData0<=pLast ); + pRec = pData0; + do{ + serial_type = pRec->uTemp; + /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more + ** additional varints, one per column. */ + i += putVarint32(&zNewRecord[i], serial_type); /* serial type */ + /* EVIDENCE-OF: R-64536-51728 The values for each column in the record + ** immediately follow the header. */ + j += sqlite3VdbeSerialPut(&zNewRecord[j], pRec, serial_type); /* content */ + }while( (++pRec)<=pLast ); + assert( i==nHdr ); + assert( j==nByte ); + + assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) ); + pOut->n = (int)nByte; + pOut->flags = MEM_Blob; + if( nZero ){ + pOut->u.nZero = nZero; + pOut->flags |= MEM_Zero; + } + pOut->enc = SQLITE_UTF8; /* In case the blob is ever converted to text */ + REGISTER_TRACE(pOp->p3, pOut); + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Count P1 P2 * * * +** Synopsis: r[P2]=count() +** +** Store the number of entries (an integer value) in the table or index +** opened by cursor P1 in register P2 +*/ +#ifndef SQLITE_OMIT_BTREECOUNT +case OP_Count: { /* out2 */ + i64 nEntry; + BtCursor *pCrsr; + + pCrsr = p->apCsr[pOp->p1]->pCursor; + assert( pCrsr ); + nEntry = 0; /* Not needed. Only used to silence a warning. */ + rc = sqlite3BtreeCount(pCrsr, &nEntry); + pOut = out2Prerelease(p, pOp); + pOut->u.i = nEntry; + break; +} +#endif + +/* Opcode: Savepoint P1 * * P4 * +** +** Open, release or rollback the savepoint named by parameter P4, depending +** on the value of P1. To open a new savepoint, P1==0. To release (commit) an +** existing savepoint, P1==1, or to rollback an existing savepoint P1==2. +*/ +case OP_Savepoint: { + int p1; /* Value of P1 operand */ + char *zName; /* Name of savepoint */ + int nName; + Savepoint *pNew; + Savepoint *pSavepoint; + Savepoint *pTmp; + int iSavepoint; + int ii; + + p1 = pOp->p1; + zName = pOp->p4.z; + + /* Assert that the p1 parameter is valid. Also that if there is no open + ** transaction, then there cannot be any savepoints. + */ + assert( db->pSavepoint==0 || db->autoCommit==0 ); + assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK ); + assert( db->pSavepoint || db->isTransactionSavepoint==0 ); + assert( checkSavepointCount(db) ); + assert( p->bIsReader ); + + if( p1==SAVEPOINT_BEGIN ){ + if( db->nVdbeWrite>0 ){ + /* A new savepoint cannot be created if there are active write + ** statements (i.e. open read/write incremental blob handles). + */ + sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress"); + rc = SQLITE_BUSY; + }else{ + nName = sqlite3Strlen30(zName); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* This call is Ok even if this savepoint is actually a transaction + ** savepoint (and therefore should not prompt xSavepoint()) callbacks. + ** If this is a transaction savepoint being opened, it is guaranteed + ** that the db->aVTrans[] array is empty. */ + assert( db->autoCommit==0 || db->nVTrans==0 ); + rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, + db->nStatement+db->nSavepoint); + if( rc!=SQLITE_OK ) goto abort_due_to_error; +#endif + + /* Create a new savepoint structure. */ + pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+nName+1); + if( pNew ){ + pNew->zName = (char *)&pNew[1]; + memcpy(pNew->zName, zName, nName+1); + + /* If there is no open transaction, then mark this as a special + ** "transaction savepoint". */ + if( db->autoCommit ){ + db->autoCommit = 0; + db->isTransactionSavepoint = 1; + }else{ + db->nSavepoint++; + } + + /* Link the new savepoint into the database handle's list. */ + pNew->pNext = db->pSavepoint; + db->pSavepoint = pNew; + pNew->nDeferredCons = db->nDeferredCons; + pNew->nDeferredImmCons = db->nDeferredImmCons; + } + } + }else{ + iSavepoint = 0; + + /* Find the named savepoint. If there is no such savepoint, then an + ** an error is returned to the user. */ + for( + pSavepoint = db->pSavepoint; + pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName); + pSavepoint = pSavepoint->pNext + ){ + iSavepoint++; + } + if( !pSavepoint ){ + sqlite3VdbeError(p, "no such savepoint: %s", zName); + rc = SQLITE_ERROR; + }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){ + /* It is not possible to release (commit) a savepoint if there are + ** active write statements. + */ + sqlite3VdbeError(p, "cannot release savepoint - " + "SQL statements in progress"); + rc = SQLITE_BUSY; + }else{ + + /* Determine whether or not this is a transaction savepoint. If so, + ** and this is a RELEASE command, then the current transaction + ** is committed. + */ + int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint; + if( isTransaction && p1==SAVEPOINT_RELEASE ){ + if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){ + goto vdbe_return; + } + db->autoCommit = 1; + if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){ + p->pc = (int)(pOp - aOp); + db->autoCommit = 0; + p->rc = rc = SQLITE_BUSY; + goto vdbe_return; + } + db->isTransactionSavepoint = 0; + rc = p->rc; + }else{ + int isSchemaChange; + iSavepoint = db->nSavepoint - iSavepoint - 1; + if( p1==SAVEPOINT_ROLLBACK ){ + isSchemaChange = (db->flags & SQLITE_InternChanges)!=0; + for(ii=0; iinDb; ii++){ + rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt, + SQLITE_ABORT_ROLLBACK, + isSchemaChange==0); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + } + }else{ + isSchemaChange = 0; + } + for(ii=0; iinDb; ii++){ + rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + } + if( isSchemaChange ){ + sqlite3ExpirePreparedStatements(db); + sqlite3ResetAllSchemasOfConnection(db); + db->flags = (db->flags | SQLITE_InternChanges); + } + } + + /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all + ** savepoints nested inside of the savepoint being operated on. */ + while( db->pSavepoint!=pSavepoint ){ + pTmp = db->pSavepoint; + db->pSavepoint = pTmp->pNext; + sqlite3DbFree(db, pTmp); + db->nSavepoint--; + } + + /* If it is a RELEASE, then destroy the savepoint being operated on + ** too. If it is a ROLLBACK TO, then set the number of deferred + ** constraint violations present in the database to the value stored + ** when the savepoint was created. */ + if( p1==SAVEPOINT_RELEASE ){ + assert( pSavepoint==db->pSavepoint ); + db->pSavepoint = pSavepoint->pNext; + sqlite3DbFree(db, pSavepoint); + if( !isTransaction ){ + db->nSavepoint--; + } + }else{ + db->nDeferredCons = pSavepoint->nDeferredCons; + db->nDeferredImmCons = pSavepoint->nDeferredImmCons; + } + + if( !isTransaction || p1==SAVEPOINT_ROLLBACK ){ + rc = sqlite3VtabSavepoint(db, p1, iSavepoint); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + } + } + } + + break; +} + +/* Opcode: AutoCommit P1 P2 * * * +** +** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll +** back any currently active btree transactions. If there are any active +** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if +** there are active writing VMs or active VMs that use shared cache. +** +** This instruction causes the VM to halt. +*/ +case OP_AutoCommit: { + int desiredAutoCommit; + int iRollback; + int turnOnAC; + + desiredAutoCommit = pOp->p1; + iRollback = pOp->p2; + turnOnAC = desiredAutoCommit && !db->autoCommit; + assert( desiredAutoCommit==1 || desiredAutoCommit==0 ); + assert( desiredAutoCommit==1 || iRollback==0 ); + assert( db->nVdbeActive>0 ); /* At least this one VM is active */ + assert( p->bIsReader ); + + if( turnOnAC && !iRollback && db->nVdbeWrite>0 ){ + /* If this instruction implements a COMMIT and other VMs are writing + ** return an error indicating that the other VMs must complete first. + */ + sqlite3VdbeError(p, "cannot commit transaction - " + "SQL statements in progress"); + rc = SQLITE_BUSY; + }else if( desiredAutoCommit!=db->autoCommit ){ + if( iRollback ){ + assert( desiredAutoCommit==1 ); + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + db->autoCommit = 1; + }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){ + goto vdbe_return; + }else{ + db->autoCommit = (u8)desiredAutoCommit; + } + if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){ + p->pc = (int)(pOp - aOp); + db->autoCommit = (u8)(1-desiredAutoCommit); + p->rc = rc = SQLITE_BUSY; + goto vdbe_return; + } + assert( db->nStatement==0 ); + sqlite3CloseSavepoints(db); + if( p->rc==SQLITE_OK ){ + rc = SQLITE_DONE; + }else{ + rc = SQLITE_ERROR; + } + goto vdbe_return; + }else{ + sqlite3VdbeError(p, + (!desiredAutoCommit)?"cannot start a transaction within a transaction":( + (iRollback)?"cannot rollback - no transaction is active": + "cannot commit - no transaction is active")); + + rc = SQLITE_ERROR; + } + break; +} + +/* Opcode: Transaction P1 P2 P3 P4 P5 +** +** Begin a transaction on database P1 if a transaction is not already +** active. +** If P2 is non-zero, then a write-transaction is started, or if a +** read-transaction is already active, it is upgraded to a write-transaction. +** If P2 is zero, then a read-transaction is started. +** +** P1 is the index of the database file on which the transaction is +** started. Index 0 is the main database file and index 1 is the +** file used for temporary tables. Indices of 2 or more are used for +** attached databases. +** +** If a write-transaction is started and the Vdbe.usesStmtJournal flag is +** true (this flag is set if the Vdbe may modify more than one row and may +** throw an ABORT exception), a statement transaction may also be opened. +** More specifically, a statement transaction is opened iff the database +** connection is currently not in autocommit mode, or if there are other +** active statements. A statement transaction allows the changes made by this +** VDBE to be rolled back after an error without having to roll back the +** entire transaction. If no error is encountered, the statement transaction +** will automatically commit when the VDBE halts. +** +** If P5!=0 then this opcode also checks the schema cookie against P3 +** and the schema generation counter against P4. +** The cookie changes its value whenever the database schema changes. +** This operation is used to detect when that the cookie has changed +** and that the current process needs to reread the schema. If the schema +** cookie in P3 differs from the schema cookie in the database header or +** if the schema generation counter in P4 differs from the current +** generation counter, then an SQLITE_SCHEMA error is raised and execution +** halts. The sqlite3_step() wrapper function might then reprepare the +** statement and rerun it from the beginning. +*/ +case OP_Transaction: { + Btree *pBt; + int iMeta; + int iGen; + + assert( p->bIsReader ); + assert( p->readOnly==0 || pOp->p2==0 ); + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){ + rc = SQLITE_READONLY; + goto abort_due_to_error; + } + pBt = db->aDb[pOp->p1].pBt; + + if( pBt ){ + rc = sqlite3BtreeBeginTrans(pBt, pOp->p2); + testcase( rc==SQLITE_BUSY_SNAPSHOT ); + testcase( rc==SQLITE_BUSY_RECOVERY ); + if( (rc&0xff)==SQLITE_BUSY ){ + p->pc = (int)(pOp - aOp); + p->rc = rc; + goto vdbe_return; + } + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + + if( pOp->p2 && p->usesStmtJournal + && (db->autoCommit==0 || db->nVdbeRead>1) + ){ + assert( sqlite3BtreeIsInTrans(pBt) ); + if( p->iStatement==0 ){ + assert( db->nStatement>=0 && db->nSavepoint>=0 ); + db->nStatement++; + p->iStatement = db->nSavepoint + db->nStatement; + } + + rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeBeginStmt(pBt, p->iStatement); + } + + /* Store the current value of the database handles deferred constraint + ** counter. If the statement transaction needs to be rolled back, + ** the value of this counter needs to be restored too. */ + p->nStmtDefCons = db->nDeferredCons; + p->nStmtDefImmCons = db->nDeferredImmCons; + } + + /* Gather the schema version number for checking: + ** IMPLEMENTATION-OF: R-32195-19465 The schema version is used by SQLite + ** each time a query is executed to ensure that the internal cache of the + ** schema used when compiling the SQL query matches the schema of the + ** database against which the compiled query is actually executed. + */ + sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&iMeta); + iGen = db->aDb[pOp->p1].pSchema->iGeneration; + }else{ + iGen = iMeta = 0; + } + assert( pOp->p5==0 || pOp->p4type==P4_INT32 ); + if( pOp->p5 && (iMeta!=pOp->p3 || iGen!=pOp->p4.i) ){ + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed"); + /* If the schema-cookie from the database file matches the cookie + ** stored with the in-memory representation of the schema, do + ** not reload the schema from the database file. + ** + ** If virtual-tables are in use, this is not just an optimization. + ** Often, v-tables store their data in other SQLite tables, which + ** are queried from within xNext() and other v-table methods using + ** prepared queries. If such a query is out-of-date, we do not want to + ** discard the database schema, as the user code implementing the + ** v-table would have to be ready for the sqlite3_vtab structure itself + ** to be invalidated whenever sqlite3_step() is called from within + ** a v-table method. + */ + if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){ + sqlite3ResetOneSchema(db, pOp->p1); + } + p->expired = 1; + rc = SQLITE_SCHEMA; + } + break; +} + +/* Opcode: ReadCookie P1 P2 P3 * * +** +** Read cookie number P3 from database P1 and write it into register P2. +** P3==1 is the schema version. P3==2 is the database format. +** P3==3 is the recommended pager cache size, and so forth. P1==0 is +** the main database file and P1==1 is the database file used to store +** temporary tables. +** +** There must be a read-lock on the database (either a transaction +** must be started or there must be an open cursor) before +** executing this instruction. +*/ +case OP_ReadCookie: { /* out2 */ + int iMeta; + int iDb; + int iCookie; + + assert( p->bIsReader ); + iDb = pOp->p1; + iCookie = pOp->p3; + assert( pOp->p3=0 && iDbnDb ); + assert( db->aDb[iDb].pBt!=0 ); + assert( DbMaskTest(p->btreeMask, iDb) ); + + sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta); + pOut = out2Prerelease(p, pOp); + pOut->u.i = iMeta; + break; +} + +/* Opcode: SetCookie P1 P2 P3 * * +** +** Write the content of register P3 (interpreted as an integer) +** into cookie number P2 of database P1. P2==1 is the schema version. +** P2==2 is the database format. P2==3 is the recommended pager cache +** size, and so forth. P1==0 is the main database file and P1==1 is the +** database file used to store temporary tables. +** +** A transaction must be started before executing this opcode. +*/ +case OP_SetCookie: { /* in3 */ + Db *pDb; + assert( pOp->p2p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + assert( p->readOnly==0 ); + pDb = &db->aDb[pOp->p1]; + assert( pDb->pBt!=0 ); + assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) ); + pIn3 = &aMem[pOp->p3]; + sqlite3VdbeMemIntegerify(pIn3); + /* See note about index shifting on OP_ReadCookie */ + rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, (int)pIn3->u.i); + if( pOp->p2==BTREE_SCHEMA_VERSION ){ + /* When the schema cookie changes, record the new cookie internally */ + pDb->pSchema->schema_cookie = (int)pIn3->u.i; + db->flags |= SQLITE_InternChanges; + }else if( pOp->p2==BTREE_FILE_FORMAT ){ + /* Record changes in the file format */ + pDb->pSchema->file_format = (u8)pIn3->u.i; + } + if( pOp->p1==1 ){ + /* Invalidate all prepared statements whenever the TEMP database + ** schema is changed. Ticket #1644 */ + sqlite3ExpirePreparedStatements(db); + p->expired = 0; + } + break; +} + +/* Opcode: OpenRead P1 P2 P3 P4 P5 +** Synopsis: root=P2 iDb=P3 +** +** Open a read-only cursor for the database table whose root page is +** P2 in a database file. The database file is determined by P3. +** P3==0 means the main database, P3==1 means the database used for +** temporary tables, and P3>1 means used the corresponding attached +** database. Give the new cursor an identifier of P1. The P1 +** values need not be contiguous but all P1 values should be small integers. +** It is an error for P1 to be negative. +** +** If P5!=0 then use the content of register P2 as the root page, not +** the value of P2 itself. +** +** There will be a read lock on the database whenever there is an +** open cursor. If the database was unlocked prior to this instruction +** then a read lock is acquired as part of this instruction. A read +** lock allows other processes to read the database but prohibits +** any other process from modifying the database. The read lock is +** released when all cursors are closed. If this instruction attempts +** to get a read lock but fails, the script terminates with an +** SQLITE_BUSY error code. +** +** The P4 value may be either an integer (P4_INT32) or a pointer to +** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo +** structure, then said structure defines the content and collating +** sequence of the index being opened. Otherwise, if P4 is an integer +** value, it is set to the number of columns in the table. +** +** See also: OpenWrite, ReopenIdx +*/ +/* Opcode: ReopenIdx P1 P2 P3 P4 P5 +** Synopsis: root=P2 iDb=P3 +** +** The ReopenIdx opcode works exactly like ReadOpen except that it first +** checks to see if the cursor on P1 is already open with a root page +** number of P2 and if it is this opcode becomes a no-op. In other words, +** if the cursor is already open, do not reopen it. +** +** The ReopenIdx opcode may only be used with P5==0 and with P4 being +** a P4_KEYINFO object. Furthermore, the P3 value must be the same as +** every other ReopenIdx or OpenRead for the same cursor number. +** +** See the OpenRead opcode documentation for additional information. +*/ +/* Opcode: OpenWrite P1 P2 P3 P4 P5 +** Synopsis: root=P2 iDb=P3 +** +** Open a read/write cursor named P1 on the table or index whose root +** page is P2. Or if P5!=0 use the content of register P2 to find the +** root page. +** +** The P4 value may be either an integer (P4_INT32) or a pointer to +** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo +** structure, then said structure defines the content and collating +** sequence of the index being opened. Otherwise, if P4 is an integer +** value, it is set to the number of columns in the table, or to the +** largest index of any column of the table that is actually used. +** +** This instruction works just like OpenRead except that it opens the cursor +** in read/write mode. For a given table, there can be one or more read-only +** cursors or a single read/write cursor but not both. +** +** See also OpenRead. +*/ +case OP_ReopenIdx: { + int nField; + KeyInfo *pKeyInfo; + int p2; + int iDb; + int wrFlag; + Btree *pX; + VdbeCursor *pCur; + Db *pDb; + + assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ ); + assert( pOp->p4type==P4_KEYINFO ); + pCur = p->apCsr[pOp->p1]; + if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){ + assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */ + goto open_cursor_set_hints; + } + /* If the cursor is not currently open or is open on a different + ** index, then fall through into OP_OpenRead to force a reopen */ +case OP_OpenRead: +case OP_OpenWrite: + + assert( (pOp->p5&(OPFLAG_P2ISREG|OPFLAG_BULKCSR|OPFLAG_SEEKEQ))==pOp->p5 ); + assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ ); + assert( p->bIsReader ); + assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx + || p->readOnly==0 ); + + if( p->expired ){ + rc = SQLITE_ABORT_ROLLBACK; + break; + } + + nField = 0; + pKeyInfo = 0; + p2 = pOp->p2; + iDb = pOp->p3; + assert( iDb>=0 && iDbnDb ); + assert( DbMaskTest(p->btreeMask, iDb) ); + pDb = &db->aDb[iDb]; + pX = pDb->pBt; + assert( pX!=0 ); + if( pOp->opcode==OP_OpenWrite ){ + wrFlag = 1; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( pDb->pSchema->file_format < p->minWriteFileFormat ){ + p->minWriteFileFormat = pDb->pSchema->file_format; + } + }else{ + wrFlag = 0; + } + if( pOp->p5 & OPFLAG_P2ISREG ){ + assert( p2>0 ); + assert( p2<=(p->nMem-p->nCursor) ); + pIn2 = &aMem[p2]; + assert( memIsValid(pIn2) ); + assert( (pIn2->flags & MEM_Int)!=0 ); + sqlite3VdbeMemIntegerify(pIn2); + p2 = (int)pIn2->u.i; + /* The p2 value always comes from a prior OP_CreateTable opcode and + ** that opcode will always set the p2 value to 2 or more or else fail. + ** If there were a failure, the prepared statement would have halted + ** before reaching this instruction. */ + if( NEVER(p2<2) ) { + rc = SQLITE_CORRUPT_BKPT; + goto abort_due_to_error; + } + } + if( pOp->p4type==P4_KEYINFO ){ + pKeyInfo = pOp->p4.pKeyInfo; + assert( pKeyInfo->enc==ENC(db) ); + assert( pKeyInfo->db==db ); + nField = pKeyInfo->nField+pKeyInfo->nXField; + }else if( pOp->p4type==P4_INT32 ){ + nField = pOp->p4.i; + } + assert( pOp->p1>=0 ); + assert( nField>=0 ); + testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */ + pCur = allocateCursor(p, pOp->p1, nField, iDb, 1); + if( pCur==0 ) goto no_mem; + pCur->nullRow = 1; + pCur->isOrdered = 1; + pCur->pgnoRoot = p2; + rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->pCursor); + pCur->pKeyInfo = pKeyInfo; + /* Set the VdbeCursor.isTable variable. Previous versions of + ** SQLite used to check if the root-page flags were sane at this point + ** and report database corruption if they were not, but this check has + ** since moved into the btree layer. */ + pCur->isTable = pOp->p4type!=P4_KEYINFO; + +open_cursor_set_hints: + assert( OPFLAG_BULKCSR==BTREE_BULKLOAD ); + assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ ); + sqlite3BtreeCursorHints(pCur->pCursor, + (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ))); + break; +} + +/* Opcode: OpenEphemeral P1 P2 * P4 P5 +** Synopsis: nColumn=P2 +** +** Open a new cursor P1 to a transient table. +** The cursor is always opened read/write even if +** the main database is read-only. The ephemeral +** table is deleted automatically when the cursor is closed. +** +** P2 is the number of columns in the ephemeral table. +** The cursor points to a BTree table if P4==0 and to a BTree index +** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure +** that defines the format of keys in the index. +** +** The P5 parameter can be a mask of the BTREE_* flags defined +** in btree.h. These flags control aspects of the operation of +** the btree. The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are +** added automatically. +*/ +/* Opcode: OpenAutoindex P1 P2 * P4 * +** Synopsis: nColumn=P2 +** +** This opcode works the same as OP_OpenEphemeral. It has a +** different name to distinguish its use. Tables created using +** by this opcode will be used for automatically created transient +** indices in joins. +*/ +case OP_OpenAutoindex: +case OP_OpenEphemeral: { + VdbeCursor *pCx; + KeyInfo *pKeyInfo; + + static const int vfsFlags = + SQLITE_OPEN_READWRITE | + SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | + SQLITE_OPEN_DELETEONCLOSE | + SQLITE_OPEN_TRANSIENT_DB; + assert( pOp->p1>=0 ); + assert( pOp->p2>=0 ); + pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1); + if( pCx==0 ) goto no_mem; + pCx->nullRow = 1; + pCx->isEphemeral = 1; + rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBt, + BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, vfsFlags); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeBeginTrans(pCx->pBt, 1); + } + if( rc==SQLITE_OK ){ + /* If a transient index is required, create it by calling + ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before + ** opening it. If a transient table is required, just use the + ** automatically created table with root-page 1 (an BLOB_INTKEY table). + */ + if( (pKeyInfo = pOp->p4.pKeyInfo)!=0 ){ + int pgno; + assert( pOp->p4type==P4_KEYINFO ); + rc = sqlite3BtreeCreateTable(pCx->pBt, &pgno, BTREE_BLOBKEY | pOp->p5); + if( rc==SQLITE_OK ){ + assert( pgno==MASTER_ROOT+1 ); + assert( pKeyInfo->db==db ); + assert( pKeyInfo->enc==ENC(db) ); + pCx->pKeyInfo = pKeyInfo; + rc = sqlite3BtreeCursor(pCx->pBt, pgno, 1, pKeyInfo, pCx->pCursor); + } + pCx->isTable = 0; + }else{ + rc = sqlite3BtreeCursor(pCx->pBt, MASTER_ROOT, 1, 0, pCx->pCursor); + pCx->isTable = 1; + } + } + pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED); + break; +} + +/* Opcode: SorterOpen P1 P2 P3 P4 * +** +** This opcode works like OP_OpenEphemeral except that it opens +** a transient index that is specifically designed to sort large +** tables using an external merge-sort algorithm. +** +** If argument P3 is non-zero, then it indicates that the sorter may +** assume that a stable sort considering the first P3 fields of each +** key is sufficient to produce the required results. +*/ +case OP_SorterOpen: { + VdbeCursor *pCx; + + assert( pOp->p1>=0 ); + assert( pOp->p2>=0 ); + pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1); + if( pCx==0 ) goto no_mem; + pCx->pKeyInfo = pOp->p4.pKeyInfo; + assert( pCx->pKeyInfo->db==db ); + assert( pCx->pKeyInfo->enc==ENC(db) ); + rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx); + break; +} + +/* Opcode: SequenceTest P1 P2 * * * +** Synopsis: if( cursor[P1].ctr++ ) pc = P2 +** +** P1 is a sorter cursor. If the sequence counter is currently zero, jump +** to P2. Regardless of whether or not the jump is taken, increment the +** the sequence value. +*/ +case OP_SequenceTest: { + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC->pSorter ); + if( (pC->seqCount++)==0 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: OpenPseudo P1 P2 P3 * * +** Synopsis: P3 columns in r[P2] +** +** Open a new cursor that points to a fake table that contains a single +** row of data. The content of that one row is the content of memory +** register P2. In other words, cursor P1 becomes an alias for the +** MEM_Blob content contained in register P2. +** +** A pseudo-table created by this opcode is used to hold a single +** row output from the sorter so that the row can be decomposed into +** individual columns using the OP_Column opcode. The OP_Column opcode +** is the only cursor opcode that works with a pseudo-table. +** +** P3 is the number of fields in the records that will be stored by +** the pseudo-table. +*/ +case OP_OpenPseudo: { + VdbeCursor *pCx; + + assert( pOp->p1>=0 ); + assert( pOp->p3>=0 ); + pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, 0); + if( pCx==0 ) goto no_mem; + pCx->nullRow = 1; + pCx->pseudoTableReg = pOp->p2; + pCx->isTable = 1; + assert( pOp->p5==0 ); + break; +} + +/* Opcode: Close P1 * * * * +** +** Close a cursor previously opened as P1. If P1 is not +** currently open, this instruction is a no-op. +*/ +case OP_Close: { + assert( pOp->p1>=0 && pOp->p1nCursor ); + sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]); + p->apCsr[pOp->p1] = 0; + break; +} + +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK +/* Opcode: ColumnsUsed P1 * * P4 * +** +** This opcode (which only exists if SQLite was compiled with +** SQLITE_ENABLE_COLUMN_USED_MASK) identifies which columns of the +** table or index for cursor P1 are used. P4 is a 64-bit integer +** (P4_INT64) in which the first 63 bits are one for each of the +** first 63 columns of the table or index that are actually used +** by the cursor. The high-order bit is set if any column after +** the 64th is used. +*/ +case OP_ColumnsUsed: { + VdbeCursor *pC; + pC = p->apCsr[pOp->p1]; + assert( pC->pCursor ); + pC->maskUsed = *(u64*)pOp->p4.pI64; + break; +} +#endif + +/* Opcode: SeekGE P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as the key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the smallest entry that +** is greater than or equal to the key value. If there are no records +** greater than or equal to the key and P2 is not zero, then jump to P2. +** +** This opcode leaves the cursor configured to move in forward order, +** from the beginning toward the end. In other words, the cursor is +** configured to use Next, not Prev. +** +** See also: Found, NotFound, SeekLt, SeekGt, SeekLe +*/ +/* Opcode: SeekGT P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as a key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the smallest entry that +** is greater than the key value. If there are no records greater than +** the key and P2 is not zero, then jump to P2. +** +** This opcode leaves the cursor configured to move in forward order, +** from the beginning toward the end. In other words, the cursor is +** configured to use Next, not Prev. +** +** See also: Found, NotFound, SeekLt, SeekGe, SeekLe +*/ +/* Opcode: SeekLT P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as a key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the largest entry that +** is less than the key value. If there are no records less than +** the key and P2 is not zero, then jump to P2. +** +** This opcode leaves the cursor configured to move in reverse order, +** from the end toward the beginning. In other words, the cursor is +** configured to use Prev, not Next. +** +** See also: Found, NotFound, SeekGt, SeekGe, SeekLe +*/ +/* Opcode: SeekLE P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as a key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the largest entry that +** is less than or equal to the key value. If there are no records +** less than or equal to the key and P2 is not zero, then jump to P2. +** +** This opcode leaves the cursor configured to move in reverse order, +** from the end toward the beginning. In other words, the cursor is +** configured to use Prev, not Next. +** +** See also: Found, NotFound, SeekGt, SeekGe, SeekLt +*/ +case OP_SeekLT: /* jump, in3 */ +case OP_SeekLE: /* jump, in3 */ +case OP_SeekGE: /* jump, in3 */ +case OP_SeekGT: { /* jump, in3 */ + int res; + int oc; + VdbeCursor *pC; + UnpackedRecord r; + int nField; + i64 iKey; /* The rowid we are to seek to */ + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p2!=0 ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->pseudoTableReg==0 ); + assert( OP_SeekLE == OP_SeekLT+1 ); + assert( OP_SeekGE == OP_SeekLT+2 ); + assert( OP_SeekGT == OP_SeekLT+3 ); + assert( pC->isOrdered ); + assert( pC->pCursor!=0 ); + oc = pOp->opcode; + pC->nullRow = 0; +#ifdef SQLITE_DEBUG + pC->seekOp = pOp->opcode; +#endif + + /* For a cursor with the BTREE_SEEK_EQ hint, only the OP_SeekGE and + ** OP_SeekLE opcodes are allowed, and these must be immediately followed + ** by an OP_IdxGT or OP_IdxLT opcode, respectively, with the same key. + */ +#ifdef SQLITE_DEBUG + if( sqlite3BtreeCursorHasHint(pC->pCursor, BTREE_SEEK_EQ) ){ + assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE ); + assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT ); + assert( pOp[1].p1==pOp[0].p1 ); + assert( pOp[1].p2==pOp[0].p2 ); + assert( pOp[1].p3==pOp[0].p3 ); + assert( pOp[1].p4.i==pOp[0].p4.i ); + } +#endif + + if( pC->isTable ){ + /* The input value in P3 might be of any type: integer, real, string, + ** blob, or NULL. But it needs to be an integer before we can do + ** the seek, so convert it. */ + pIn3 = &aMem[pOp->p3]; + if( (pIn3->flags & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){ + applyNumericAffinity(pIn3, 0); + } + iKey = sqlite3VdbeIntValue(pIn3); + + /* If the P3 value could not be converted into an integer without + ** loss of information, then special processing is required... */ + if( (pIn3->flags & MEM_Int)==0 ){ + if( (pIn3->flags & MEM_Real)==0 ){ + /* If the P3 value cannot be converted into any kind of a number, + ** then the seek is not possible, so jump to P2 */ + VdbeBranchTaken(1,2); goto jump_to_p2; + break; + } + + /* If the approximation iKey is larger than the actual real search + ** term, substitute >= for > and < for <=. e.g. if the search term + ** is 4.9 and the integer approximation 5: + ** + ** (x > 4.9) -> (x >= 5) + ** (x <= 4.9) -> (x < 5) + */ + if( pIn3->u.r<(double)iKey ){ + assert( OP_SeekGE==(OP_SeekGT-1) ); + assert( OP_SeekLT==(OP_SeekLE-1) ); + assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) ); + if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--; + } + + /* If the approximation iKey is smaller than the actual real search + ** term, substitute <= for < and > for >=. */ + else if( pIn3->u.r>(double)iKey ){ + assert( OP_SeekLE==(OP_SeekLT+1) ); + assert( OP_SeekGT==(OP_SeekGE+1) ); + assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) ); + if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++; + } + } + rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, 0, (u64)iKey, 0, &res); + pC->movetoTarget = iKey; /* Used by OP_Delete */ + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + }else{ + nField = pOp->p4.i; + assert( pOp->p4type==P4_INT32 ); + assert( nField>0 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)nField; + + /* The next line of code computes as follows, only faster: + ** if( oc==OP_SeekGT || oc==OP_SeekLE ){ + ** r.default_rc = -1; + ** }else{ + ** r.default_rc = +1; + ** } + */ + r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1); + assert( oc!=OP_SeekGT || r.default_rc==-1 ); + assert( oc!=OP_SeekLE || r.default_rc==-1 ); + assert( oc!=OP_SeekGE || r.default_rc==+1 ); + assert( oc!=OP_SeekLT || r.default_rc==+1 ); + + r.aMem = &aMem[pOp->p3]; +#ifdef SQLITE_DEBUG + { int i; for(i=0; ipCursor, &r, 0, 0, &res); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + } + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; +#ifdef SQLITE_TEST + sqlite3_search_count++; +#endif + if( oc>=OP_SeekGE ){ assert( oc==OP_SeekGE || oc==OP_SeekGT ); + if( res<0 || (res==0 && oc==OP_SeekGT) ){ + res = 0; + rc = sqlite3BtreeNext(pC->pCursor, &res); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + }else{ + res = 0; + } + }else{ + assert( oc==OP_SeekLT || oc==OP_SeekLE ); + if( res>0 || (res==0 && oc==OP_SeekLT) ){ + res = 0; + rc = sqlite3BtreePrevious(pC->pCursor, &res); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + }else{ + /* res might be negative because the table is empty. Check to + ** see if this is the case. + */ + res = sqlite3BtreeEof(pC->pCursor); + } + } + assert( pOp->p2>0 ); + VdbeBranchTaken(res!=0,2); + if( res ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: Seek P1 P2 * * * +** Synopsis: intkey=r[P2] +** +** P1 is an open table cursor and P2 is a rowid integer. Arrange +** for P1 to move so that it points to the rowid given by P2. +** +** This is actually a deferred seek. Nothing actually happens until +** the cursor is used to read a record. That way, if no reads +** occur, no unnecessary I/O happens. +*/ +case OP_Seek: { /* in2 */ + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->pCursor!=0 ); + assert( pC->isTable ); + pC->nullRow = 0; + pIn2 = &aMem[pOp->p2]; + pC->movetoTarget = sqlite3VdbeIntValue(pIn2); + pC->deferredMoveto = 1; + break; +} + + +/* Opcode: Found P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If P4==0 then register P3 holds a blob constructed by MakeRecord. If +** P4>0 then register P3 is the first of P4 registers that form an unpacked +** record. +** +** Cursor P1 is on an index btree. If the record identified by P3 and P4 +** is a prefix of any entry in P1 then a jump is made to P2 and +** P1 is left pointing at the matching entry. +** +** This operation leaves the cursor in a state where it can be +** advanced in the forward direction. The Next instruction will work, +** but not the Prev instruction. +** +** See also: NotFound, NoConflict, NotExists. SeekGe +*/ +/* Opcode: NotFound P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If P4==0 then register P3 holds a blob constructed by MakeRecord. If +** P4>0 then register P3 is the first of P4 registers that form an unpacked +** record. +** +** Cursor P1 is on an index btree. If the record identified by P3 and P4 +** is not the prefix of any entry in P1 then a jump is made to P2. If P1 +** does contain an entry whose prefix matches the P3/P4 record then control +** falls through to the next instruction and P1 is left pointing at the +** matching entry. +** +** This operation leaves the cursor in a state where it cannot be +** advanced in either direction. In other words, the Next and Prev +** opcodes do not work after this operation. +** +** See also: Found, NotExists, NoConflict +*/ +/* Opcode: NoConflict P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If P4==0 then register P3 holds a blob constructed by MakeRecord. If +** P4>0 then register P3 is the first of P4 registers that form an unpacked +** record. +** +** Cursor P1 is on an index btree. If the record identified by P3 and P4 +** contains any NULL value, jump immediately to P2. If all terms of the +** record are not-NULL then a check is done to determine if any row in the +** P1 index btree has a matching key prefix. If there are no matches, jump +** immediately to P2. If there is a match, fall through and leave the P1 +** cursor pointing to the matching row. +** +** This opcode is similar to OP_NotFound with the exceptions that the +** branch is always taken if any part of the search key input is NULL. +** +** This operation leaves the cursor in a state where it cannot be +** advanced in either direction. In other words, the Next and Prev +** opcodes do not work after this operation. +** +** See also: NotFound, Found, NotExists +*/ +case OP_NoConflict: /* jump, in3 */ +case OP_NotFound: /* jump, in3 */ +case OP_Found: { /* jump, in3 */ + int alreadyExists; + int takeJump; + int ii; + VdbeCursor *pC; + int res; + char *pFree; + UnpackedRecord *pIdxKey; + UnpackedRecord r; + char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*4 + 7]; + +#ifdef SQLITE_TEST + if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++; +#endif + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p4type==P4_INT32 ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); +#ifdef SQLITE_DEBUG + pC->seekOp = pOp->opcode; +#endif + pIn3 = &aMem[pOp->p3]; + assert( pC->pCursor!=0 ); + assert( pC->isTable==0 ); + pFree = 0; + if( pOp->p4.i>0 ){ + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)pOp->p4.i; + r.aMem = pIn3; + for(ii=0; iip3+ii, &r.aMem[ii]); +#endif + } + pIdxKey = &r; + }else{ + pIdxKey = sqlite3VdbeAllocUnpackedRecord( + pC->pKeyInfo, aTempRec, sizeof(aTempRec), &pFree + ); + if( pIdxKey==0 ) goto no_mem; + assert( pIn3->flags & MEM_Blob ); + ExpandBlob(pIn3); + sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey); + } + pIdxKey->default_rc = 0; + takeJump = 0; + if( pOp->opcode==OP_NoConflict ){ + /* For the OP_NoConflict opcode, take the jump if any of the + ** input fields are NULL, since any key with a NULL will not + ** conflict */ + for(ii=0; iinField; ii++){ + if( pIdxKey->aMem[ii].flags & MEM_Null ){ + takeJump = 1; + break; + } + } + } + rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, pIdxKey, 0, 0, &res); + sqlite3DbFree(db, pFree); + if( rc!=SQLITE_OK ){ + break; + } + pC->seekResult = res; + alreadyExists = (res==0); + pC->nullRow = 1-alreadyExists; + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + if( pOp->opcode==OP_Found ){ + VdbeBranchTaken(alreadyExists!=0,2); + if( alreadyExists ) goto jump_to_p2; + }else{ + VdbeBranchTaken(takeJump||alreadyExists==0,2); + if( takeJump || !alreadyExists ) goto jump_to_p2; + } + break; +} + +/* Opcode: NotExists P1 P2 P3 * * +** Synopsis: intkey=r[P3] +** +** P1 is the index of a cursor open on an SQL table btree (with integer +** keys). P3 is an integer rowid. If P1 does not contain a record with +** rowid P3 then jump immediately to P2. Or, if P2 is 0, raise an +** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then +** leave the cursor pointing at that record and fall through to the next +** instruction. +** +** The OP_NotFound opcode performs the same operation on index btrees +** (with arbitrary multi-value keys). +** +** This opcode leaves the cursor in a state where it cannot be advanced +** in either direction. In other words, the Next and Prev opcodes will +** not work following this opcode. +** +** See also: Found, NotFound, NoConflict +*/ +case OP_NotExists: { /* jump, in3 */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + u64 iKey; + + pIn3 = &aMem[pOp->p3]; + assert( pIn3->flags & MEM_Int ); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); +#ifdef SQLITE_DEBUG + pC->seekOp = 0; +#endif + assert( pC->isTable ); + assert( pC->pseudoTableReg==0 ); + pCrsr = pC->pCursor; + assert( pCrsr!=0 ); + res = 0; + iKey = pIn3->u.i; + rc = sqlite3BtreeMovetoUnpacked(pCrsr, 0, iKey, 0, &res); + assert( rc==SQLITE_OK || res==0 ); + pC->movetoTarget = iKey; /* Used by OP_Delete */ + pC->nullRow = 0; + pC->cacheStatus = CACHE_STALE; + pC->deferredMoveto = 0; + VdbeBranchTaken(res!=0,2); + pC->seekResult = res; + if( res!=0 ){ + assert( rc==SQLITE_OK ); + if( pOp->p2==0 ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + goto jump_to_p2; + } + } + break; +} + +/* Opcode: Sequence P1 P2 * * * +** Synopsis: r[P2]=cursor[P1].ctr++ +** +** Find the next available sequence number for cursor P1. +** Write the sequence number into register P2. +** The sequence number on the cursor is incremented after this +** instruction. +*/ +case OP_Sequence: { /* out2 */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( p->apCsr[pOp->p1]!=0 ); + pOut = out2Prerelease(p, pOp); + pOut->u.i = p->apCsr[pOp->p1]->seqCount++; + break; +} + + +/* Opcode: NewRowid P1 P2 P3 * * +** Synopsis: r[P2]=rowid +** +** Get a new integer record number (a.k.a "rowid") used as the key to a table. +** The record number is not previously used as a key in the database +** table that cursor P1 points to. The new record number is written +** written to register P2. +** +** If P3>0 then P3 is a register in the root frame of this VDBE that holds +** the largest previously generated record number. No new record numbers are +** allowed to be less than this value. When this value reaches its maximum, +** an SQLITE_FULL error is generated. The P3 register is updated with the ' +** generated record number. This P3 mechanism is used to help implement the +** AUTOINCREMENT feature. +*/ +case OP_NewRowid: { /* out2 */ + i64 v; /* The new rowid */ + VdbeCursor *pC; /* Cursor of table to get the new rowid */ + int res; /* Result of an sqlite3BtreeLast() */ + int cnt; /* Counter to limit the number of searches */ + Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */ + VdbeFrame *pFrame; /* Root frame of VDBE */ + + v = 0; + res = 0; + pOut = out2Prerelease(p, pOp); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->pCursor!=0 ); + { + /* The next rowid or record number (different terms for the same + ** thing) is obtained in a two-step algorithm. + ** + ** First we attempt to find the largest existing rowid and add one + ** to that. But if the largest existing rowid is already the maximum + ** positive integer, we have to fall through to the second + ** probabilistic algorithm + ** + ** The second algorithm is to select a rowid at random and see if + ** it already exists in the table. If it does not exist, we have + ** succeeded. If the random rowid does exist, we select a new one + ** and try again, up to 100 times. + */ + assert( pC->isTable ); + +#ifdef SQLITE_32BIT_ROWID +# define MAX_ROWID 0x7fffffff +#else + /* Some compilers complain about constants of the form 0x7fffffffffffffff. + ** Others complain about 0x7ffffffffffffffffLL. The following macro seems + ** to provide the constant while making all compilers happy. + */ +# define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff ) +#endif + + if( !pC->useRandomRowid ){ + rc = sqlite3BtreeLast(pC->pCursor, &res); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + if( res ){ + v = 1; /* IMP: R-61914-48074 */ + }else{ + assert( sqlite3BtreeCursorIsValid(pC->pCursor) ); + rc = sqlite3BtreeKeySize(pC->pCursor, &v); + assert( rc==SQLITE_OK ); /* Cannot fail following BtreeLast() */ + if( v>=MAX_ROWID ){ + pC->useRandomRowid = 1; + }else{ + v++; /* IMP: R-29538-34987 */ + } + } + } + +#ifndef SQLITE_OMIT_AUTOINCREMENT + if( pOp->p3 ){ + /* Assert that P3 is a valid memory cell. */ + assert( pOp->p3>0 ); + if( p->pFrame ){ + for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); + /* Assert that P3 is a valid memory cell. */ + assert( pOp->p3<=pFrame->nMem ); + pMem = &pFrame->aMem[pOp->p3]; + }else{ + /* Assert that P3 is a valid memory cell. */ + assert( pOp->p3<=(p->nMem-p->nCursor) ); + pMem = &aMem[pOp->p3]; + memAboutToChange(p, pMem); + } + assert( memIsValid(pMem) ); + + REGISTER_TRACE(pOp->p3, pMem); + sqlite3VdbeMemIntegerify(pMem); + assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */ + if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){ + rc = SQLITE_FULL; /* IMP: R-12275-61338 */ + goto abort_due_to_error; + } + if( vu.i+1 ){ + v = pMem->u.i + 1; + } + pMem->u.i = v; + } +#endif + if( pC->useRandomRowid ){ + /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the + ** largest possible integer (9223372036854775807) then the database + ** engine starts picking positive candidate ROWIDs at random until + ** it finds one that is not previously used. */ + assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is + ** an AUTOINCREMENT table. */ + cnt = 0; + do{ + sqlite3_randomness(sizeof(v), &v); + v &= (MAX_ROWID>>1); v++; /* Ensure that v is greater than zero */ + }while( ((rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, 0, (u64)v, + 0, &res))==SQLITE_OK) + && (res==0) + && (++cnt<100)); + if( rc==SQLITE_OK && res==0 ){ + rc = SQLITE_FULL; /* IMP: R-38219-53002 */ + goto abort_due_to_error; + } + assert( v>0 ); /* EV: R-40812-03570 */ + } + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + } + pOut->u.i = v; + break; +} + +/* Opcode: Insert P1 P2 P3 P4 P5 +** Synopsis: intkey=r[P3] data=r[P2] +** +** Write an entry into the table of cursor P1. A new entry is +** created if it doesn't already exist or the data for an existing +** entry is overwritten. The data is the value MEM_Blob stored in register +** number P2. The key is stored in register P3. The key must +** be a MEM_Int. +** +** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is +** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set, +** then rowid is stored for subsequent return by the +** sqlite3_last_insert_rowid() function (otherwise it is unmodified). +** +** If the OPFLAG_USESEEKRESULT flag of P5 is set and if the result of +** the last seek operation (OP_NotExists) was a success, then this +** operation will not attempt to find the appropriate row before doing +** the insert but will instead overwrite the row that the cursor is +** currently pointing to. Presumably, the prior OP_NotExists opcode +** has already positioned the cursor correctly. This is an optimization +** that boosts performance by avoiding redundant seeks. +** +** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an +** UPDATE operation. Otherwise (if the flag is clear) then this opcode +** is part of an INSERT operation. The difference is only important to +** the update hook. +** +** Parameter P4 may point to a string containing the table-name, or +** may be NULL. If it is not NULL, then the update-hook +** (sqlite3.xUpdateCallback) is invoked following a successful insert. +** +** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically +** allocated, then ownership of P2 is transferred to the pseudo-cursor +** and register P2 becomes ephemeral. If the cursor is changed, the +** value of register P2 will then change. Make sure this does not +** cause any problems.) +** +** This instruction only works on tables. The equivalent instruction +** for indices is OP_IdxInsert. +*/ +/* Opcode: InsertInt P1 P2 P3 P4 P5 +** Synopsis: intkey=P3 data=r[P2] +** +** This works exactly like OP_Insert except that the key is the +** integer value P3, not the value of the integer stored in register P3. +*/ +case OP_Insert: +case OP_InsertInt: { + Mem *pData; /* MEM cell holding data for the record to be inserted */ + Mem *pKey; /* MEM cell holding key for the record */ + i64 iKey; /* The integer ROWID or key for the record to be inserted */ + VdbeCursor *pC; /* Cursor to table into which insert is written */ + int nZero; /* Number of zero-bytes to append */ + int seekResult; /* Result of prior seek or 0 if no USESEEKRESULT flag */ + const char *zDb; /* database name - used by the update hook */ + const char *zTbl; /* Table name - used by the opdate hook */ + int op; /* Opcode for update hook: SQLITE_UPDATE or SQLITE_INSERT */ + + pData = &aMem[pOp->p2]; + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( memIsValid(pData) ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->pCursor!=0 ); + assert( pC->pseudoTableReg==0 ); + assert( pC->isTable ); + REGISTER_TRACE(pOp->p2, pData); + + if( pOp->opcode==OP_Insert ){ + pKey = &aMem[pOp->p3]; + assert( pKey->flags & MEM_Int ); + assert( memIsValid(pKey) ); + REGISTER_TRACE(pOp->p3, pKey); + iKey = pKey->u.i; + }else{ + assert( pOp->opcode==OP_InsertInt ); + iKey = pOp->p3; + } + + if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++; + if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = lastRowid = iKey; + if( pData->flags & MEM_Null ){ + pData->z = 0; + pData->n = 0; + }else{ + assert( pData->flags & (MEM_Blob|MEM_Str) ); + } + seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0); + if( pData->flags & MEM_Zero ){ + nZero = pData->u.nZero; + }else{ + nZero = 0; + } + rc = sqlite3BtreeInsert(pC->pCursor, 0, iKey, + pData->z, pData->n, nZero, + (pOp->p5 & OPFLAG_APPEND)!=0, seekResult + ); + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + + /* Invoke the update-hook if required. */ + if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){ + zDb = db->aDb[pC->iDb].zName; + zTbl = pOp->p4.z; + op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT); + assert( pC->isTable ); + db->xUpdateCallback(db->pUpdateArg, op, zDb, zTbl, iKey); + assert( pC->iDb>=0 ); + } + break; +} + +/* Opcode: Delete P1 P2 * P4 P5 +** +** Delete the record at which the P1 cursor is currently pointing. +** +** If the P5 parameter is non-zero, the cursor will be left pointing at +** either the next or the previous record in the table. If it is left +** pointing at the next record, then the next Next instruction will be a +** no-op. As a result, in this case it is OK to delete a record from within a +** Next loop. If P5 is zero, then the cursor is left in an undefined state. +** +** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is +** incremented (otherwise not). +** +** P1 must not be pseudo-table. It has to be a real table with +** multiple rows. +** +** If P4 is not NULL, then it is the name of the table that P1 is +** pointing to. The update hook will be invoked, if it exists. +** If P4 is not NULL then the P1 cursor must have been positioned +** using OP_NotFound prior to invoking this opcode. +*/ +case OP_Delete: { + VdbeCursor *pC; + u8 hasUpdateCallback; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */ + assert( pC->deferredMoveto==0 ); + + hasUpdateCallback = db->xUpdateCallback && pOp->p4.z && pC->isTable; + if( pOp->p5 && hasUpdateCallback ){ + sqlite3BtreeKeySize(pC->pCursor, &pC->movetoTarget); + } + +#ifdef SQLITE_DEBUG + /* The seek operation that positioned the cursor prior to OP_Delete will + ** have also set the pC->movetoTarget field to the rowid of the row that + ** is being deleted */ + if( pOp->p4.z && pC->isTable && pOp->p5==0 ){ + i64 iKey = 0; + sqlite3BtreeKeySize(pC->pCursor, &iKey); + assert( pC->movetoTarget==iKey ); + } +#endif + + rc = sqlite3BtreeDelete(pC->pCursor, pOp->p5); + pC->cacheStatus = CACHE_STALE; + + /* Invoke the update-hook if required. */ + if( rc==SQLITE_OK && hasUpdateCallback ){ + db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, + db->aDb[pC->iDb].zName, pOp->p4.z, pC->movetoTarget); + assert( pC->iDb>=0 ); + } + if( pOp->p2 & OPFLAG_NCHANGE ) p->nChange++; + break; +} +/* Opcode: ResetCount * * * * * +** +** The value of the change counter is copied to the database handle +** change counter (returned by subsequent calls to sqlite3_changes()). +** Then the VMs internal change counter resets to 0. +** This is used by trigger programs. +*/ +case OP_ResetCount: { + sqlite3VdbeSetChanges(db, p->nChange); + p->nChange = 0; + break; +} + +/* Opcode: SorterCompare P1 P2 P3 P4 +** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2 +** +** P1 is a sorter cursor. This instruction compares a prefix of the +** record blob in register P3 against a prefix of the entry that +** the sorter cursor currently points to. Only the first P4 fields +** of r[P3] and the sorter record are compared. +** +** If either P3 or the sorter contains a NULL in one of their significant +** fields (not counting the P4 fields at the end which are ignored) then +** the comparison is assumed to be equal. +** +** Fall through to next instruction if the two records compare equal to +** each other. Jump to P2 if they are different. +*/ +case OP_SorterCompare: { + VdbeCursor *pC; + int res; + int nKeyCol; + + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + assert( pOp->p4type==P4_INT32 ); + pIn3 = &aMem[pOp->p3]; + nKeyCol = pOp->p4.i; + res = 0; + rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res); + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + break; +}; + +/* Opcode: SorterData P1 P2 P3 * * +** Synopsis: r[P2]=data +** +** Write into register P2 the current sorter data for sorter cursor P1. +** Then clear the column header cache on cursor P3. +** +** This opcode is normally use to move a record out of the sorter and into +** a register that is the source for a pseudo-table cursor created using +** OpenPseudo. That pseudo-table cursor is the one that is identified by +** parameter P3. Clearing the P3 column cache as part of this opcode saves +** us from having to issue a separate NullRow instruction to clear that cache. +*/ +case OP_SorterData: { + VdbeCursor *pC; + + pOut = &aMem[pOp->p2]; + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + rc = sqlite3VdbeSorterRowkey(pC, pOut); + assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) ); + assert( pOp->p1>=0 && pOp->p1nCursor ); + p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE; + break; +} + +/* Opcode: RowData P1 P2 * * * +** Synopsis: r[P2]=data +** +** Write into register P2 the complete row data for cursor P1. +** There is no interpretation of the data. +** It is just copied onto the P2 register exactly as +** it is found in the database file. +** +** If the P1 cursor must be pointing to a valid row (not a NULL row) +** of a real table, not a pseudo-table. +*/ +/* Opcode: RowKey P1 P2 * * * +** Synopsis: r[P2]=key +** +** Write into register P2 the complete row key for cursor P1. +** There is no interpretation of the data. +** The key is copied onto the P2 register exactly as +** it is found in the database file. +** +** If the P1 cursor must be pointing to a valid row (not a NULL row) +** of a real table, not a pseudo-table. +*/ +case OP_RowKey: +case OP_RowData: { + VdbeCursor *pC; + BtCursor *pCrsr; + u32 n; + i64 n64; + + pOut = &aMem[pOp->p2]; + memAboutToChange(p, pOut); + + /* Note that RowKey and RowData are really exactly the same instruction */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC)==0 ); + assert( pC->isTable || pOp->opcode!=OP_RowData ); + assert( pC->isTable==0 || pOp->opcode==OP_RowData ); + assert( pC!=0 ); + assert( pC->nullRow==0 ); + assert( pC->pseudoTableReg==0 ); + assert( pC->pCursor!=0 ); + pCrsr = pC->pCursor; + + /* The OP_RowKey and OP_RowData opcodes always follow OP_NotExists or + ** OP_Rewind/Op_Next with no intervening instructions that might invalidate + ** the cursor. If this where not the case, on of the following assert()s + ** would fail. Should this ever change (because of changes in the code + ** generator) then the fix would be to insert a call to + ** sqlite3VdbeCursorMoveto(). + */ + assert( pC->deferredMoveto==0 ); + assert( sqlite3BtreeCursorIsValid(pCrsr) ); +#if 0 /* Not required due to the previous to assert() statements */ + rc = sqlite3VdbeCursorMoveto(pC); + if( rc!=SQLITE_OK ) goto abort_due_to_error; +#endif + + if( pC->isTable==0 ){ + assert( !pC->isTable ); + VVA_ONLY(rc =) sqlite3BtreeKeySize(pCrsr, &n64); + assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */ + if( n64>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + n = (u32)n64; + }else{ + VVA_ONLY(rc =) sqlite3BtreeDataSize(pCrsr, &n); + assert( rc==SQLITE_OK ); /* DataSize() cannot fail */ + if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + } + testcase( n==0 ); + if( sqlite3VdbeMemClearAndResize(pOut, MAX(n,32)) ){ + goto no_mem; + } + pOut->n = n; + MemSetTypeFlag(pOut, MEM_Blob); + if( pC->isTable==0 ){ + rc = sqlite3BtreeKey(pCrsr, 0, n, pOut->z); + }else{ + rc = sqlite3BtreeData(pCrsr, 0, n, pOut->z); + } + pOut->enc = SQLITE_UTF8; /* In case the blob is ever cast to text */ + UPDATE_MAX_BLOBSIZE(pOut); + REGISTER_TRACE(pOp->p2, pOut); + break; +} + +/* Opcode: Rowid P1 P2 * * * +** Synopsis: r[P2]=rowid +** +** Store in register P2 an integer which is the key of the table entry that +** P1 is currently point to. +** +** P1 can be either an ordinary table or a virtual table. There used to +** be a separate OP_VRowid opcode for use with virtual tables, but this +** one opcode now works for both table types. +*/ +case OP_Rowid: { /* out2 */ + VdbeCursor *pC; + i64 v; + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + + pOut = out2Prerelease(p, pOp); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->pseudoTableReg==0 || pC->nullRow ); + if( pC->nullRow ){ + pOut->flags = MEM_Null; + break; + }else if( pC->deferredMoveto ){ + v = pC->movetoTarget; +#ifndef SQLITE_OMIT_VIRTUALTABLE + }else if( pC->pVtabCursor ){ + pVtab = pC->pVtabCursor->pVtab; + pModule = pVtab->pModule; + assert( pModule->xRowid ); + rc = pModule->xRowid(pC->pVtabCursor, &v); + sqlite3VtabImportErrmsg(p, pVtab); +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + }else{ + assert( pC->pCursor!=0 ); + rc = sqlite3VdbeCursorRestore(pC); + if( rc ) goto abort_due_to_error; + if( pC->nullRow ){ + pOut->flags = MEM_Null; + break; + } + rc = sqlite3BtreeKeySize(pC->pCursor, &v); + assert( rc==SQLITE_OK ); /* Always so because of CursorRestore() above */ + } + pOut->u.i = v; + break; +} + +/* Opcode: NullRow P1 * * * * +** +** Move the cursor P1 to a null row. Any OP_Column operations +** that occur while the cursor is on the null row will always +** write a NULL. +*/ +case OP_NullRow: { + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + pC->nullRow = 1; + pC->cacheStatus = CACHE_STALE; + if( pC->pCursor ){ + sqlite3BtreeClearCursor(pC->pCursor); + } + break; +} + +/* Opcode: Last P1 P2 P3 * * +** +** The next use of the Rowid or Column or Prev instruction for P1 +** will refer to the last entry in the database table or index. +** If the table or index is empty and P2>0, then jump immediately to P2. +** If P2 is 0 or if the table or index is not empty, fall through +** to the following instruction. +** +** This opcode leaves the cursor configured to move in reverse order, +** from the end toward the beginning. In other words, the cursor is +** configured to use Prev, not Next. +*/ +case OP_Last: { /* jump */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + pCrsr = pC->pCursor; + res = 0; + assert( pCrsr!=0 ); + rc = sqlite3BtreeLast(pCrsr, &res); + pC->nullRow = (u8)res; + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + pC->seekResult = pOp->p3; +#ifdef SQLITE_DEBUG + pC->seekOp = OP_Last; +#endif + if( pOp->p2>0 ){ + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + } + break; +} + + +/* Opcode: Sort P1 P2 * * * +** +** This opcode does exactly the same thing as OP_Rewind except that +** it increments an undocumented global variable used for testing. +** +** Sorting is accomplished by writing records into a sorting index, +** then rewinding that index and playing it back from beginning to +** end. We use the OP_Sort opcode instead of OP_Rewind to do the +** rewinding so that the global variable will be incremented and +** regression tests can determine whether or not the optimizer is +** correctly optimizing out sorts. +*/ +case OP_SorterSort: /* jump */ +case OP_Sort: { /* jump */ +#ifdef SQLITE_TEST + sqlite3_sort_count++; + sqlite3_search_count--; +#endif + p->aCounter[SQLITE_STMTSTATUS_SORT]++; + /* Fall through into OP_Rewind */ +} +/* Opcode: Rewind P1 P2 * * * +** +** The next use of the Rowid or Column or Next instruction for P1 +** will refer to the first entry in the database table or index. +** If the table or index is empty, jump immediately to P2. +** If the table or index is not empty, fall through to the following +** instruction. +** +** This opcode leaves the cursor configured to move in forward order, +** from the beginning toward the end. In other words, the cursor is +** configured to use Next, not Prev. +*/ +case OP_Rewind: { /* jump */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) ); + res = 1; +#ifdef SQLITE_DEBUG + pC->seekOp = OP_Rewind; +#endif + if( isSorter(pC) ){ + rc = sqlite3VdbeSorterRewind(pC, &res); + }else{ + pCrsr = pC->pCursor; + assert( pCrsr ); + rc = sqlite3BtreeFirst(pCrsr, &res); + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + } + pC->nullRow = (u8)res; + assert( pOp->p2>0 && pOp->p2nOp ); + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + break; +} + +/* Opcode: Next P1 P2 P3 P4 P5 +** +** Advance cursor P1 so that it points to the next key/data pair in its +** table or index. If there are no more key/value pairs then fall through +** to the following instruction. But if the cursor advance was successful, +** jump immediately to P2. +** +** The Next opcode is only valid following an SeekGT, SeekGE, or +** OP_Rewind opcode used to position the cursor. Next is not allowed +** to follow SeekLT, SeekLE, or OP_Last. +** +** The P1 cursor must be for a real table, not a pseudo-table. P1 must have +** been opened prior to this opcode or the program will segfault. +** +** The P3 value is a hint to the btree implementation. If P3==1, that +** means P1 is an SQL index and that this instruction could have been +** omitted if that index had been unique. P3 is usually 0. P3 is +** always either 0 or 1. +** +** P4 is always of type P4_ADVANCE. The function pointer points to +** sqlite3BtreeNext(). +** +** If P5 is positive and the jump is taken, then event counter +** number P5-1 in the prepared statement is incremented. +** +** See also: Prev, NextIfOpen +*/ +/* Opcode: NextIfOpen P1 P2 P3 P4 P5 +** +** This opcode works just like Next except that if cursor P1 is not +** open it behaves a no-op. +*/ +/* Opcode: Prev P1 P2 P3 P4 P5 +** +** Back up cursor P1 so that it points to the previous key/data pair in its +** table or index. If there is no previous key/value pairs then fall through +** to the following instruction. But if the cursor backup was successful, +** jump immediately to P2. +** +** +** The Prev opcode is only valid following an SeekLT, SeekLE, or +** OP_Last opcode used to position the cursor. Prev is not allowed +** to follow SeekGT, SeekGE, or OP_Rewind. +** +** The P1 cursor must be for a real table, not a pseudo-table. If P1 is +** not open then the behavior is undefined. +** +** The P3 value is a hint to the btree implementation. If P3==1, that +** means P1 is an SQL index and that this instruction could have been +** omitted if that index had been unique. P3 is usually 0. P3 is +** always either 0 or 1. +** +** P4 is always of type P4_ADVANCE. The function pointer points to +** sqlite3BtreePrevious(). +** +** If P5 is positive and the jump is taken, then event counter +** number P5-1 in the prepared statement is incremented. +*/ +/* Opcode: PrevIfOpen P1 P2 P3 P4 P5 +** +** This opcode works just like Prev except that if cursor P1 is not +** open it behaves a no-op. +*/ +case OP_SorterNext: { /* jump */ + VdbeCursor *pC; + int res; + + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + res = 0; + rc = sqlite3VdbeSorterNext(db, pC, &res); + goto next_tail; +case OP_PrevIfOpen: /* jump */ +case OP_NextIfOpen: /* jump */ + if( p->apCsr[pOp->p1]==0 ) break; + /* Fall through */ +case OP_Prev: /* jump */ +case OP_Next: /* jump */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p5aCounter) ); + pC = p->apCsr[pOp->p1]; + res = pOp->p3; + assert( pC!=0 ); + assert( pC->deferredMoveto==0 ); + assert( pC->pCursor ); + assert( res==0 || (res==1 && pC->isTable==0) ); + testcase( res==1 ); + assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext ); + assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious ); + assert( pOp->opcode!=OP_NextIfOpen || pOp->p4.xAdvance==sqlite3BtreeNext ); + assert( pOp->opcode!=OP_PrevIfOpen || pOp->p4.xAdvance==sqlite3BtreePrevious); + + /* The Next opcode is only used after SeekGT, SeekGE, and Rewind. + ** The Prev opcode is only used after SeekLT, SeekLE, and Last. */ + assert( pOp->opcode!=OP_Next || pOp->opcode!=OP_NextIfOpen + || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE + || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found); + assert( pOp->opcode!=OP_Prev || pOp->opcode!=OP_PrevIfOpen + || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE + || pC->seekOp==OP_Last ); + + rc = pOp->p4.xAdvance(pC->pCursor, &res); +next_tail: + pC->cacheStatus = CACHE_STALE; + VdbeBranchTaken(res==0,2); + if( res==0 ){ + pC->nullRow = 0; + p->aCounter[pOp->p5]++; +#ifdef SQLITE_TEST + sqlite3_search_count++; +#endif + goto jump_to_p2_and_check_for_interrupt; + }else{ + pC->nullRow = 1; + } + goto check_for_interrupt; +} + +/* Opcode: IdxInsert P1 P2 P3 * P5 +** Synopsis: key=r[P2] +** +** Register P2 holds an SQL index key made using the +** MakeRecord instructions. This opcode writes that key +** into the index P1. Data for the entry is nil. +** +** P3 is a flag that provides a hint to the b-tree layer that this +** insert is likely to be an append. +** +** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is +** incremented by this instruction. If the OPFLAG_NCHANGE bit is clear, +** then the change counter is unchanged. +** +** If P5 has the OPFLAG_USESEEKRESULT bit set, then the cursor must have +** just done a seek to the spot where the new entry is to be inserted. +** This flag avoids doing an extra seek. +** +** This instruction only works for indices. The equivalent instruction +** for tables is OP_Insert. +*/ +case OP_SorterInsert: /* in2 */ +case OP_IdxInsert: { /* in2 */ + VdbeCursor *pC; + int nKey; + const char *zKey; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) ); + pIn2 = &aMem[pOp->p2]; + assert( pIn2->flags & MEM_Blob ); + if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++; + assert( pC->pCursor!=0 ); + assert( pC->isTable==0 ); + rc = ExpandBlob(pIn2); + if( rc==SQLITE_OK ){ + if( pOp->opcode==OP_SorterInsert ){ + rc = sqlite3VdbeSorterWrite(pC, pIn2); + }else{ + nKey = pIn2->n; + zKey = pIn2->z; + rc = sqlite3BtreeInsert(pC->pCursor, zKey, nKey, "", 0, 0, pOp->p3, + ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0) + ); + assert( pC->deferredMoveto==0 ); + pC->cacheStatus = CACHE_STALE; + } + } + break; +} + +/* Opcode: IdxDelete P1 P2 P3 * * +** Synopsis: key=r[P2@P3] +** +** The content of P3 registers starting at register P2 form +** an unpacked index key. This opcode removes that entry from the +** index opened by cursor P1. +*/ +case OP_IdxDelete: { + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + UnpackedRecord r; + + assert( pOp->p3>0 ); + assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem-p->nCursor)+1 ); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + pCrsr = pC->pCursor; + assert( pCrsr!=0 ); + assert( pOp->p5==0 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)pOp->p3; + r.default_rc = 0; + r.aMem = &aMem[pOp->p2]; +#ifdef SQLITE_DEBUG + { int i; for(i=0; ideferredMoveto==0 ); + pC->cacheStatus = CACHE_STALE; + break; +} + +/* Opcode: IdxRowid P1 P2 * * * +** Synopsis: r[P2]=rowid +** +** Write into register P2 an integer which is the last entry in the record at +** the end of the index key pointed to by cursor P1. This integer should be +** the rowid of the table entry to which this index entry points. +** +** See also: Rowid, MakeRecord. +*/ +case OP_IdxRowid: { /* out2 */ + BtCursor *pCrsr; + VdbeCursor *pC; + i64 rowid; + + pOut = out2Prerelease(p, pOp); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + pCrsr = pC->pCursor; + assert( pCrsr!=0 ); + pOut->flags = MEM_Null; + assert( pC->isTable==0 ); + assert( pC->deferredMoveto==0 ); + + /* sqlite3VbeCursorRestore() can only fail if the record has been deleted + ** out from under the cursor. That will never happend for an IdxRowid + ** opcode, hence the NEVER() arround the check of the return value. + */ + rc = sqlite3VdbeCursorRestore(pC); + if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error; + + if( !pC->nullRow ){ + rowid = 0; /* Not needed. Only used to silence a warning. */ + rc = sqlite3VdbeIdxRowid(db, pCrsr, &rowid); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + pOut->u.i = rowid; + pOut->flags = MEM_Int; + } + break; +} + +/* Opcode: IdxGE P1 P2 P3 P4 P5 +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY. Compare this key value against the index +** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID +** fields at the end. +** +** If the P1 index entry is greater than or equal to the key value +** then jump to P2. Otherwise fall through to the next instruction. +*/ +/* Opcode: IdxGT P1 P2 P3 P4 P5 +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY. Compare this key value against the index +** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID +** fields at the end. +** +** If the P1 index entry is greater than the key value +** then jump to P2. Otherwise fall through to the next instruction. +*/ +/* Opcode: IdxLT P1 P2 P3 P4 P5 +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY or ROWID. Compare this key value against +** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or +** ROWID on the P1 index. +** +** If the P1 index entry is less than the key value then jump to P2. +** Otherwise fall through to the next instruction. +*/ +/* Opcode: IdxLE P1 P2 P3 P4 P5 +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY or ROWID. Compare this key value against +** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or +** ROWID on the P1 index. +** +** If the P1 index entry is less than or equal to the key value then jump +** to P2. Otherwise fall through to the next instruction. +*/ +case OP_IdxLE: /* jump */ +case OP_IdxGT: /* jump */ +case OP_IdxLT: /* jump */ +case OP_IdxGE: { /* jump */ + VdbeCursor *pC; + int res; + UnpackedRecord r; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->isOrdered ); + assert( pC->pCursor!=0); + assert( pC->deferredMoveto==0 ); + assert( pOp->p5==0 || pOp->p5==1 ); + assert( pOp->p4type==P4_INT32 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)pOp->p4.i; + if( pOp->opcodeopcode==OP_IdxLE || pOp->opcode==OP_IdxGT ); + r.default_rc = -1; + }else{ + assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT ); + r.default_rc = 0; + } + r.aMem = &aMem[pOp->p3]; +#ifdef SQLITE_DEBUG + { int i; for(i=0; iopcode&1)==(OP_IdxLT&1) ){ + assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT ); + res = -res; + }else{ + assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT ); + res++; + } + VdbeBranchTaken(res>0,2); + if( res>0 ) goto jump_to_p2; + break; +} + +/* Opcode: Destroy P1 P2 P3 * * +** +** Delete an entire database table or index whose root page in the database +** file is given by P1. +** +** The table being destroyed is in the main database file if P3==0. If +** P3==1 then the table to be clear is in the auxiliary database file +** that is used to store tables create using CREATE TEMPORARY TABLE. +** +** If AUTOVACUUM is enabled then it is possible that another root page +** might be moved into the newly deleted root page in order to keep all +** root pages contiguous at the beginning of the database. The former +** value of the root page that moved - its value before the move occurred - +** is stored in register P2. If no page +** movement was required (because the table being dropped was already +** the last one in the database) then a zero is stored in register P2. +** If AUTOVACUUM is disabled then a zero is stored in register P2. +** +** See also: Clear +*/ +case OP_Destroy: { /* out2 */ + int iMoved; + int iDb; + + assert( p->readOnly==0 ); + pOut = out2Prerelease(p, pOp); + pOut->flags = MEM_Null; + if( db->nVdbeRead > db->nVDestroy+1 ){ + rc = SQLITE_LOCKED; + p->errorAction = OE_Abort; + }else{ + iDb = pOp->p3; + assert( DbMaskTest(p->btreeMask, iDb) ); + iMoved = 0; /* Not needed. Only to silence a warning. */ + rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved); + pOut->flags = MEM_Int; + pOut->u.i = iMoved; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( rc==SQLITE_OK && iMoved!=0 ){ + sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1); + /* All OP_Destroy operations occur on the same btree */ + assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 ); + resetSchemaOnFault = iDb+1; + } +#endif + } + break; +} + +/* Opcode: Clear P1 P2 P3 +** +** Delete all contents of the database table or index whose root page +** in the database file is given by P1. But, unlike Destroy, do not +** remove the table or index from the database file. +** +** The table being clear is in the main database file if P2==0. If +** P2==1 then the table to be clear is in the auxiliary database file +** that is used to store tables create using CREATE TEMPORARY TABLE. +** +** If the P3 value is non-zero, then the table referred to must be an +** intkey table (an SQL table, not an index). In this case the row change +** count is incremented by the number of rows in the table being cleared. +** If P3 is greater than zero, then the value stored in register P3 is +** also incremented by the number of rows in the table being cleared. +** +** See also: Destroy +*/ +case OP_Clear: { + int nChange; + + nChange = 0; + assert( p->readOnly==0 ); + assert( DbMaskTest(p->btreeMask, pOp->p2) ); + rc = sqlite3BtreeClearTable( + db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &nChange : 0) + ); + if( pOp->p3 ){ + p->nChange += nChange; + if( pOp->p3>0 ){ + assert( memIsValid(&aMem[pOp->p3]) ); + memAboutToChange(p, &aMem[pOp->p3]); + aMem[pOp->p3].u.i += nChange; + } + } + break; +} + +/* Opcode: ResetSorter P1 * * * * +** +** Delete all contents from the ephemeral table or sorter +** that is open on cursor P1. +** +** This opcode only works for cursors used for sorting and +** opened with OP_OpenEphemeral or OP_SorterOpen. +*/ +case OP_ResetSorter: { + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + if( pC->pSorter ){ + sqlite3VdbeSorterReset(db, pC->pSorter); + }else{ + assert( pC->isEphemeral ); + rc = sqlite3BtreeClearTableOfCursor(pC->pCursor); + } + break; +} + +/* Opcode: CreateTable P1 P2 * * * +** Synopsis: r[P2]=root iDb=P1 +** +** Allocate a new table in the main database file if P1==0 or in the +** auxiliary database file if P1==1 or in an attached database if +** P1>1. Write the root page number of the new table into +** register P2 +** +** The difference between a table and an index is this: A table must +** have a 4-byte integer key and can have arbitrary data. An index +** has an arbitrary key but no data. +** +** See also: CreateIndex +*/ +/* Opcode: CreateIndex P1 P2 * * * +** Synopsis: r[P2]=root iDb=P1 +** +** Allocate a new index in the main database file if P1==0 or in the +** auxiliary database file if P1==1 or in an attached database if +** P1>1. Write the root page number of the new table into +** register P2. +** +** See documentation on OP_CreateTable for additional information. +*/ +case OP_CreateIndex: /* out2 */ +case OP_CreateTable: { /* out2 */ + int pgno; + int flags; + Db *pDb; + + pOut = out2Prerelease(p, pOp); + pgno = 0; + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + assert( p->readOnly==0 ); + pDb = &db->aDb[pOp->p1]; + assert( pDb->pBt!=0 ); + if( pOp->opcode==OP_CreateTable ){ + /* flags = BTREE_INTKEY; */ + flags = BTREE_INTKEY; + }else{ + flags = BTREE_BLOBKEY; + } + rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags); + pOut->u.i = pgno; + break; +} + +/* Opcode: ParseSchema P1 * * P4 * +** +** Read and parse all entries from the SQLITE_MASTER table of database P1 +** that match the WHERE clause P4. +** +** This opcode invokes the parser to create a new virtual machine, +** then runs the new virtual machine. It is thus a re-entrant opcode. +*/ +case OP_ParseSchema: { + int iDb; + const char *zMaster; + char *zSql; + InitData initData; + + /* Any prepared statement that invokes this opcode will hold mutexes + ** on every btree. This is a prerequisite for invoking + ** sqlite3InitCallback(). + */ +#ifdef SQLITE_DEBUG + for(iDb=0; iDbnDb; iDb++){ + assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); + } +#endif + + iDb = pOp->p1; + assert( iDb>=0 && iDbnDb ); + assert( DbHasProperty(db, iDb, DB_SchemaLoaded) ); + /* Used to be a conditional */ { + zMaster = SCHEMA_TABLE(iDb); + initData.db = db; + initData.iDb = pOp->p1; + initData.pzErrMsg = &p->zErrMsg; + zSql = sqlite3MPrintf(db, + "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s ORDER BY rowid", + db->aDb[iDb].zName, zMaster, pOp->p4.z); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + assert( db->init.busy==0 ); + db->init.busy = 1; + initData.rc = SQLITE_OK; + assert( !db->mallocFailed ); + rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); + if( rc==SQLITE_OK ) rc = initData.rc; + sqlite3DbFree(db, zSql); + db->init.busy = 0; + } + } + if( rc ) sqlite3ResetAllSchemasOfConnection(db); + if( rc==SQLITE_NOMEM ){ + goto no_mem; + } + break; +} + +#if !defined(SQLITE_OMIT_ANALYZE) +/* Opcode: LoadAnalysis P1 * * * * +** +** Read the sqlite_stat1 table for database P1 and load the content +** of that table into the internal index hash table. This will cause +** the analysis to be used when preparing all subsequent queries. +*/ +case OP_LoadAnalysis: { + assert( pOp->p1>=0 && pOp->p1nDb ); + rc = sqlite3AnalysisLoad(db, pOp->p1); + break; +} +#endif /* !defined(SQLITE_OMIT_ANALYZE) */ + +/* Opcode: DropTable P1 * * P4 * +** +** Remove the internal (in-memory) data structures that describe +** the table named P4 in database P1. This is called after a table +** is dropped from disk (using the Destroy opcode) in order to keep +** the internal representation of the +** schema consistent with what is on disk. +*/ +case OP_DropTable: { + sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z); + break; +} + +/* Opcode: DropIndex P1 * * P4 * +** +** Remove the internal (in-memory) data structures that describe +** the index named P4 in database P1. This is called after an index +** is dropped from disk (using the Destroy opcode) +** in order to keep the internal representation of the +** schema consistent with what is on disk. +*/ +case OP_DropIndex: { + sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z); + break; +} + +/* Opcode: DropTrigger P1 * * P4 * +** +** Remove the internal (in-memory) data structures that describe +** the trigger named P4 in database P1. This is called after a trigger +** is dropped from disk (using the Destroy opcode) in order to keep +** the internal representation of the +** schema consistent with what is on disk. +*/ +case OP_DropTrigger: { + sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z); + break; +} + + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* Opcode: IntegrityCk P1 P2 P3 * P5 +** +** Do an analysis of the currently open database. Store in +** register P1 the text of an error message describing any problems. +** If no problems are found, store a NULL in register P1. +** +** The register P3 contains the maximum number of allowed errors. +** At most reg(P3) errors will be reported. +** In other words, the analysis stops as soon as reg(P1) errors are +** seen. Reg(P1) is updated with the number of errors remaining. +** +** The root page numbers of all tables in the database are integer +** stored in reg(P1), reg(P1+1), reg(P1+2), .... There are P2 tables +** total. +** +** If P5 is not zero, the check is done on the auxiliary database +** file, not the main database file. +** +** This opcode is used to implement the integrity_check pragma. +*/ +case OP_IntegrityCk: { + int nRoot; /* Number of tables to check. (Number of root pages.) */ + int *aRoot; /* Array of rootpage numbers for tables to be checked */ + int j; /* Loop counter */ + int nErr; /* Number of errors reported */ + char *z; /* Text of the error report */ + Mem *pnErr; /* Register keeping track of errors remaining */ + + assert( p->bIsReader ); + nRoot = pOp->p2; + assert( nRoot>0 ); + aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(nRoot+1) ); + if( aRoot==0 ) goto no_mem; + assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) ); + pnErr = &aMem[pOp->p3]; + assert( (pnErr->flags & MEM_Int)!=0 ); + assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 ); + pIn1 = &aMem[pOp->p1]; + for(j=0; jp5nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p5) ); + z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, aRoot, nRoot, + (int)pnErr->u.i, &nErr); + sqlite3DbFree(db, aRoot); + pnErr->u.i -= nErr; + sqlite3VdbeMemSetNull(pIn1); + if( nErr==0 ){ + assert( z==0 ); + }else if( z==0 ){ + goto no_mem; + }else{ + sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free); + } + UPDATE_MAX_BLOBSIZE(pIn1); + sqlite3VdbeChangeEncoding(pIn1, encoding); + break; +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +/* Opcode: RowSetAdd P1 P2 * * * +** Synopsis: rowset(P1)=r[P2] +** +** Insert the integer value held by register P2 into a boolean index +** held in register P1. +** +** An assertion fails if P2 is not an integer. +*/ +case OP_RowSetAdd: { /* in1, in2 */ + pIn1 = &aMem[pOp->p1]; + pIn2 = &aMem[pOp->p2]; + assert( (pIn2->flags & MEM_Int)!=0 ); + if( (pIn1->flags & MEM_RowSet)==0 ){ + sqlite3VdbeMemSetRowSet(pIn1); + if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem; + } + sqlite3RowSetInsert(pIn1->u.pRowSet, pIn2->u.i); + break; +} + +/* Opcode: RowSetRead P1 P2 P3 * * +** Synopsis: r[P3]=rowset(P1) +** +** Extract the smallest value from boolean index P1 and put that value into +** register P3. Or, if boolean index P1 is initially empty, leave P3 +** unchanged and jump to instruction P2. +*/ +case OP_RowSetRead: { /* jump, in1, out3 */ + i64 val; + + pIn1 = &aMem[pOp->p1]; + if( (pIn1->flags & MEM_RowSet)==0 + || sqlite3RowSetNext(pIn1->u.pRowSet, &val)==0 + ){ + /* The boolean index is empty */ + sqlite3VdbeMemSetNull(pIn1); + VdbeBranchTaken(1,2); + goto jump_to_p2_and_check_for_interrupt; + }else{ + /* A value was pulled from the index */ + VdbeBranchTaken(0,2); + sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val); + } + goto check_for_interrupt; +} + +/* Opcode: RowSetTest P1 P2 P3 P4 +** Synopsis: if r[P3] in rowset(P1) goto P2 +** +** Register P3 is assumed to hold a 64-bit integer value. If register P1 +** contains a RowSet object and that RowSet object contains +** the value held in P3, jump to register P2. Otherwise, insert the +** integer in P3 into the RowSet and continue on to the +** next opcode. +** +** The RowSet object is optimized for the case where successive sets +** of integers, where each set contains no duplicates. Each set +** of values is identified by a unique P4 value. The first set +** must have P4==0, the final set P4=-1. P4 must be either -1 or +** non-negative. For non-negative values of P4 only the lower 4 +** bits are significant. +** +** This allows optimizations: (a) when P4==0 there is no need to test +** the rowset object for P3, as it is guaranteed not to contain it, +** (b) when P4==-1 there is no need to insert the value, as it will +** never be tested for, and (c) when a value that is part of set X is +** inserted, there is no need to search to see if the same value was +** previously inserted as part of set X (only if it was previously +** inserted as part of some other set). +*/ +case OP_RowSetTest: { /* jump, in1, in3 */ + int iSet; + int exists; + + pIn1 = &aMem[pOp->p1]; + pIn3 = &aMem[pOp->p3]; + iSet = pOp->p4.i; + assert( pIn3->flags&MEM_Int ); + + /* If there is anything other than a rowset object in memory cell P1, + ** delete it now and initialize P1 with an empty rowset + */ + if( (pIn1->flags & MEM_RowSet)==0 ){ + sqlite3VdbeMemSetRowSet(pIn1); + if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem; + } + + assert( pOp->p4type==P4_INT32 ); + assert( iSet==-1 || iSet>=0 ); + if( iSet ){ + exists = sqlite3RowSetTest(pIn1->u.pRowSet, iSet, pIn3->u.i); + VdbeBranchTaken(exists!=0,2); + if( exists ) goto jump_to_p2; + } + if( iSet>=0 ){ + sqlite3RowSetInsert(pIn1->u.pRowSet, pIn3->u.i); + } + break; +} + + +#ifndef SQLITE_OMIT_TRIGGER + +/* Opcode: Program P1 P2 P3 P4 P5 +** +** Execute the trigger program passed as P4 (type P4_SUBPROGRAM). +** +** P1 contains the address of the memory cell that contains the first memory +** cell in an array of values used as arguments to the sub-program. P2 +** contains the address to jump to if the sub-program throws an IGNORE +** exception using the RAISE() function. Register P3 contains the address +** of a memory cell in this (the parent) VM that is used to allocate the +** memory required by the sub-vdbe at runtime. +** +** P4 is a pointer to the VM containing the trigger program. +** +** If P5 is non-zero, then recursive program invocation is enabled. +*/ +case OP_Program: { /* jump */ + int nMem; /* Number of memory registers for sub-program */ + int nByte; /* Bytes of runtime space required for sub-program */ + Mem *pRt; /* Register to allocate runtime space */ + Mem *pMem; /* Used to iterate through memory cells */ + Mem *pEnd; /* Last memory cell in new array */ + VdbeFrame *pFrame; /* New vdbe frame to execute in */ + SubProgram *pProgram; /* Sub-program to execute */ + void *t; /* Token identifying trigger */ + + pProgram = pOp->p4.pProgram; + pRt = &aMem[pOp->p3]; + assert( pProgram->nOp>0 ); + + /* If the p5 flag is clear, then recursive invocation of triggers is + ** disabled for backwards compatibility (p5 is set if this sub-program + ** is really a trigger, not a foreign key action, and the flag set + ** and cleared by the "PRAGMA recursive_triggers" command is clear). + ** + ** It is recursive invocation of triggers, at the SQL level, that is + ** disabled. In some cases a single trigger may generate more than one + ** SubProgram (if the trigger may be executed with more than one different + ** ON CONFLICT algorithm). SubProgram structures associated with a + ** single trigger all have the same value for the SubProgram.token + ** variable. */ + if( pOp->p5 ){ + t = pProgram->token; + for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent); + if( pFrame ) break; + } + + if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){ + rc = SQLITE_ERROR; + sqlite3VdbeError(p, "too many levels of trigger recursion"); + break; + } + + /* Register pRt is used to store the memory required to save the state + ** of the current program, and the memory required at runtime to execute + ** the trigger program. If this trigger has been fired before, then pRt + ** is already allocated. Otherwise, it must be initialized. */ + if( (pRt->flags&MEM_Frame)==0 ){ + /* SubProgram.nMem is set to the number of memory cells used by the + ** program stored in SubProgram.aOp. As well as these, one memory + ** cell is required for each cursor used by the program. Set local + ** variable nMem (and later, VdbeFrame.nChildMem) to this value. + */ + nMem = pProgram->nMem + pProgram->nCsr; + nByte = ROUND8(sizeof(VdbeFrame)) + + nMem * sizeof(Mem) + + pProgram->nCsr * sizeof(VdbeCursor *) + + pProgram->nOnce * sizeof(u8); + pFrame = sqlite3DbMallocZero(db, nByte); + if( !pFrame ){ + goto no_mem; + } + sqlite3VdbeMemRelease(pRt); + pRt->flags = MEM_Frame; + pRt->u.pFrame = pFrame; + + pFrame->v = p; + pFrame->nChildMem = nMem; + pFrame->nChildCsr = pProgram->nCsr; + pFrame->pc = (int)(pOp - aOp); + pFrame->aMem = p->aMem; + pFrame->nMem = p->nMem; + pFrame->apCsr = p->apCsr; + pFrame->nCursor = p->nCursor; + pFrame->aOp = p->aOp; + pFrame->nOp = p->nOp; + pFrame->token = pProgram->token; + pFrame->aOnceFlag = p->aOnceFlag; + pFrame->nOnceFlag = p->nOnceFlag; +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + pFrame->anExec = p->anExec; +#endif + + pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem]; + for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){ + pMem->flags = MEM_Undefined; + pMem->db = db; + } + }else{ + pFrame = pRt->u.pFrame; + assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem ); + assert( pProgram->nCsr==pFrame->nChildCsr ); + assert( (int)(pOp - aOp)==pFrame->pc ); + } + + p->nFrame++; + pFrame->pParent = p->pFrame; + pFrame->lastRowid = lastRowid; + pFrame->nChange = p->nChange; + pFrame->nDbChange = p->db->nChange; + p->nChange = 0; + p->pFrame = pFrame; + p->aMem = aMem = &VdbeFrameMem(pFrame)[-1]; + p->nMem = pFrame->nChildMem; + p->nCursor = (u16)pFrame->nChildCsr; + p->apCsr = (VdbeCursor **)&aMem[p->nMem+1]; + p->aOp = aOp = pProgram->aOp; + p->nOp = pProgram->nOp; + p->aOnceFlag = (u8 *)&p->apCsr[p->nCursor]; + p->nOnceFlag = pProgram->nOnce; +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + p->anExec = 0; +#endif + pOp = &aOp[-1]; + memset(p->aOnceFlag, 0, p->nOnceFlag); + + break; +} + +/* Opcode: Param P1 P2 * * * +** +** This opcode is only ever present in sub-programs called via the +** OP_Program instruction. Copy a value currently stored in a memory +** cell of the calling (parent) frame to cell P2 in the current frames +** address space. This is used by trigger programs to access the new.* +** and old.* values. +** +** The address of the cell in the parent frame is determined by adding +** the value of the P1 argument to the value of the P1 argument to the +** calling OP_Program instruction. +*/ +case OP_Param: { /* out2 */ + VdbeFrame *pFrame; + Mem *pIn; + pOut = out2Prerelease(p, pOp); + pFrame = p->pFrame; + pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1]; + sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem); + break; +} + +#endif /* #ifndef SQLITE_OMIT_TRIGGER */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY +/* Opcode: FkCounter P1 P2 * * * +** Synopsis: fkctr[P1]+=P2 +** +** Increment a "constraint counter" by P2 (P2 may be negative or positive). +** If P1 is non-zero, the database constraint counter is incremented +** (deferred foreign key constraints). Otherwise, if P1 is zero, the +** statement counter is incremented (immediate foreign key constraints). +*/ +case OP_FkCounter: { + if( db->flags & SQLITE_DeferFKs ){ + db->nDeferredImmCons += pOp->p2; + }else if( pOp->p1 ){ + db->nDeferredCons += pOp->p2; + }else{ + p->nFkConstraint += pOp->p2; + } + break; +} + +/* Opcode: FkIfZero P1 P2 * * * +** Synopsis: if fkctr[P1]==0 goto P2 +** +** This opcode tests if a foreign key constraint-counter is currently zero. +** If so, jump to instruction P2. Otherwise, fall through to the next +** instruction. +** +** If P1 is non-zero, then the jump is taken if the database constraint-counter +** is zero (the one that counts deferred constraint violations). If P1 is +** zero, the jump is taken if the statement constraint-counter is zero +** (immediate foreign key constraint violations). +*/ +case OP_FkIfZero: { /* jump */ + if( pOp->p1 ){ + VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2); + if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2; + }else{ + VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2); + if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2; + } + break; +} +#endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */ + +#ifndef SQLITE_OMIT_AUTOINCREMENT +/* Opcode: MemMax P1 P2 * * * +** Synopsis: r[P1]=max(r[P1],r[P2]) +** +** P1 is a register in the root frame of this VM (the root frame is +** different from the current frame if this instruction is being executed +** within a sub-program). Set the value of register P1 to the maximum of +** its current value and the value in register P2. +** +** This instruction throws an error if the memory cell is not initially +** an integer. +*/ +case OP_MemMax: { /* in2 */ + VdbeFrame *pFrame; + if( p->pFrame ){ + for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); + pIn1 = &pFrame->aMem[pOp->p1]; + }else{ + pIn1 = &aMem[pOp->p1]; + } + assert( memIsValid(pIn1) ); + sqlite3VdbeMemIntegerify(pIn1); + pIn2 = &aMem[pOp->p2]; + sqlite3VdbeMemIntegerify(pIn2); + if( pIn1->u.iu.i){ + pIn1->u.i = pIn2->u.i; + } + break; +} +#endif /* SQLITE_OMIT_AUTOINCREMENT */ + +/* Opcode: IfPos P1 P2 P3 * * +** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 +** +** Register P1 must contain an integer. +** If the value of register P1 is 1 or greater, subtract P3 from the +** value in P1 and jump to P2. +** +** If the initial value of register P1 is less than 1, then the +** value is unchanged and control passes through to the next instruction. +*/ +case OP_IfPos: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + VdbeBranchTaken( pIn1->u.i>0, 2); + if( pIn1->u.i>0 ){ + pIn1->u.i -= pOp->p3; + goto jump_to_p2; + } + break; +} + +/* Opcode: SetIfNotPos P1 P2 P3 * * +** Synopsis: if r[P1]<=0 then r[P2]=P3 +** +** Register P1 must contain an integer. +** If the value of register P1 is not positive (if it is less than 1) then +** set the value of register P2 to be the integer P3. +*/ +case OP_SetIfNotPos: { /* in1, in2 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + if( pIn1->u.i<=0 ){ + pOut = out2Prerelease(p, pOp); + pOut->u.i = pOp->p3; + } + break; +} + +/* Opcode: IfNotZero P1 P2 P3 * * +** Synopsis: if r[P1]!=0 then r[P1]-=P3, goto P2 +** +** Register P1 must contain an integer. If the content of register P1 is +** initially nonzero, then subtract P3 from the value in register P1 and +** jump to P2. If register P1 is initially zero, leave it unchanged +** and fall through. +*/ +case OP_IfNotZero: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + VdbeBranchTaken(pIn1->u.i<0, 2); + if( pIn1->u.i ){ + pIn1->u.i -= pOp->p3; + goto jump_to_p2; + } + break; +} + +/* Opcode: DecrJumpZero P1 P2 * * * +** Synopsis: if (--r[P1])==0 goto P2 +** +** Register P1 must hold an integer. Decrement the value in register P1 +** then jump to P2 if the new value is exactly zero. +*/ +case OP_DecrJumpZero: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + pIn1->u.i--; + VdbeBranchTaken(pIn1->u.i==0, 2); + if( pIn1->u.i==0 ) goto jump_to_p2; + break; +} + + +/* Opcode: JumpZeroIncr P1 P2 * * * +** Synopsis: if (r[P1]++)==0 ) goto P2 +** +** The register P1 must contain an integer. If register P1 is initially +** zero, then jump to P2. Increment register P1 regardless of whether or +** not the jump is taken. +*/ +case OP_JumpZeroIncr: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + VdbeBranchTaken(pIn1->u.i==0, 2); + if( (pIn1->u.i++)==0 ) goto jump_to_p2; + break; +} + +/* Opcode: AggStep0 * P2 P3 P4 P5 +** Synopsis: accum=r[P3] step(r[P2@P5]) +** +** Execute the step function for an aggregate. The +** function has P5 arguments. P4 is a pointer to the FuncDef +** structure that specifies the function. Register P3 is the +** accumulator. +** +** The P5 arguments are taken from register P2 and its +** successors. +*/ +/* Opcode: AggStep * P2 P3 P4 P5 +** Synopsis: accum=r[P3] step(r[P2@P5]) +** +** Execute the step function for an aggregate. The +** function has P5 arguments. P4 is a pointer to an sqlite3_context +** object that is used to run the function. Register P3 is +** as the accumulator. +** +** The P5 arguments are taken from register P2 and its +** successors. +** +** This opcode is initially coded as OP_AggStep0. On first evaluation, +** the FuncDef stored in P4 is converted into an sqlite3_context and +** the opcode is changed. In this way, the initialization of the +** sqlite3_context only happens once, instead of on each call to the +** step function. +*/ +case OP_AggStep0: { + int n; + sqlite3_context *pCtx; + + assert( pOp->p4type==P4_FUNCDEF ); + n = pOp->p5; + assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) ); + assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) ); + assert( pOp->p3p2 || pOp->p3>=pOp->p2+n ); + pCtx = sqlite3DbMallocRaw(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*)); + if( pCtx==0 ) goto no_mem; + pCtx->pMem = 0; + pCtx->pFunc = pOp->p4.pFunc; + pCtx->iOp = (int)(pOp - aOp); + pCtx->pVdbe = p; + pCtx->argc = n; + pOp->p4type = P4_FUNCCTX; + pOp->p4.pCtx = pCtx; + pOp->opcode = OP_AggStep; + /* Fall through into OP_AggStep */ +} +case OP_AggStep: { + int i; + sqlite3_context *pCtx; + Mem *pMem; + Mem t; + + assert( pOp->p4type==P4_FUNCCTX ); + pCtx = pOp->p4.pCtx; + pMem = &aMem[pOp->p3]; + + /* If this function is inside of a trigger, the register array in aMem[] + ** might change from one evaluation to the next. The next block of code + ** checks to see if the register array has changed, and if so it + ** reinitializes the relavant parts of the sqlite3_context object */ + if( pCtx->pMem != pMem ){ + pCtx->pMem = pMem; + for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i]; + } + +#ifdef SQLITE_DEBUG + for(i=0; iargc; i++){ + assert( memIsValid(pCtx->argv[i]) ); + REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]); + } +#endif + + pMem->n++; + sqlite3VdbeMemInit(&t, db, MEM_Null); + pCtx->pOut = &t; + pCtx->fErrorOrAux = 0; + pCtx->skipFlag = 0; + (pCtx->pFunc->xStep)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */ + if( pCtx->fErrorOrAux ){ + if( pCtx->isError ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(&t)); + rc = pCtx->isError; + } + sqlite3VdbeMemRelease(&t); + }else{ + assert( t.flags==MEM_Null ); + } + if( pCtx->skipFlag ){ + assert( pOp[-1].opcode==OP_CollSeq ); + i = pOp[-1].p1; + if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1); + } + break; +} + +/* Opcode: AggFinal P1 P2 * P4 * +** Synopsis: accum=r[P1] N=P2 +** +** Execute the finalizer function for an aggregate. P1 is +** the memory location that is the accumulator for the aggregate. +** +** P2 is the number of arguments that the step function takes and +** P4 is a pointer to the FuncDef for this function. The P2 +** argument is not used by this opcode. It is only there to disambiguate +** functions that can take varying numbers of arguments. The +** P4 argument is only needed for the degenerate case where +** the step function was not previously called. +*/ +case OP_AggFinal: { + Mem *pMem; + assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) ); + pMem = &aMem[pOp->p1]; + assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 ); + rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc); + if( rc ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(pMem)); + } + sqlite3VdbeChangeEncoding(pMem, encoding); + UPDATE_MAX_BLOBSIZE(pMem); + if( sqlite3VdbeMemTooBig(pMem) ){ + goto too_big; + } + break; +} + +#ifndef SQLITE_OMIT_WAL +/* Opcode: Checkpoint P1 P2 P3 * * +** +** Checkpoint database P1. This is a no-op if P1 is not currently in +** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL, +** RESTART, or TRUNCATE. Write 1 or 0 into mem[P3] if the checkpoint returns +** SQLITE_BUSY or not, respectively. Write the number of pages in the +** WAL after the checkpoint into mem[P3+1] and the number of pages +** in the WAL that have been checkpointed after the checkpoint +** completes into mem[P3+2]. However on an error, mem[P3+1] and +** mem[P3+2] are initialized to -1. +*/ +case OP_Checkpoint: { + int i; /* Loop counter */ + int aRes[3]; /* Results */ + Mem *pMem; /* Write results here */ + + assert( p->readOnly==0 ); + aRes[0] = 0; + aRes[1] = aRes[2] = -1; + assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE + || pOp->p2==SQLITE_CHECKPOINT_FULL + || pOp->p2==SQLITE_CHECKPOINT_RESTART + || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE + ); + rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]); + if( rc==SQLITE_BUSY ){ + rc = SQLITE_OK; + aRes[0] = 1; + } + for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){ + sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]); + } + break; +}; +#endif + +#ifndef SQLITE_OMIT_PRAGMA +/* Opcode: JournalMode P1 P2 P3 * * +** +** Change the journal mode of database P1 to P3. P3 must be one of the +** PAGER_JOURNALMODE_XXX values. If changing between the various rollback +** modes (delete, truncate, persist, off and memory), this is a simple +** operation. No IO is required. +** +** If changing into or out of WAL mode the procedure is more complicated. +** +** Write a string containing the final journal-mode to register P2. +*/ +case OP_JournalMode: { /* out2 */ + Btree *pBt; /* Btree to change journal mode of */ + Pager *pPager; /* Pager associated with pBt */ + int eNew; /* New journal mode */ + int eOld; /* The old journal mode */ +#ifndef SQLITE_OMIT_WAL + const char *zFilename; /* Name of database file for pPager */ +#endif + + pOut = out2Prerelease(p, pOp); + eNew = pOp->p3; + assert( eNew==PAGER_JOURNALMODE_DELETE + || eNew==PAGER_JOURNALMODE_TRUNCATE + || eNew==PAGER_JOURNALMODE_PERSIST + || eNew==PAGER_JOURNALMODE_OFF + || eNew==PAGER_JOURNALMODE_MEMORY + || eNew==PAGER_JOURNALMODE_WAL + || eNew==PAGER_JOURNALMODE_QUERY + ); + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( p->readOnly==0 ); + + pBt = db->aDb[pOp->p1].pBt; + pPager = sqlite3BtreePager(pBt); + eOld = sqlite3PagerGetJournalMode(pPager); + if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld; + if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld; + +#ifndef SQLITE_OMIT_WAL + zFilename = sqlite3PagerFilename(pPager, 1); + + /* Do not allow a transition to journal_mode=WAL for a database + ** in temporary storage or if the VFS does not support shared memory + */ + if( eNew==PAGER_JOURNALMODE_WAL + && (sqlite3Strlen30(zFilename)==0 /* Temp file */ + || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */ + ){ + eNew = eOld; + } + + if( (eNew!=eOld) + && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL) + ){ + if( !db->autoCommit || db->nVdbeRead>1 ){ + rc = SQLITE_ERROR; + sqlite3VdbeError(p, + "cannot change %s wal mode from within a transaction", + (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of") + ); + break; + }else{ + + if( eOld==PAGER_JOURNALMODE_WAL ){ + /* If leaving WAL mode, close the log file. If successful, the call + ** to PagerCloseWal() checkpoints and deletes the write-ahead-log + ** file. An EXCLUSIVE lock may still be held on the database file + ** after a successful return. + */ + rc = sqlite3PagerCloseWal(pPager); + if( rc==SQLITE_OK ){ + sqlite3PagerSetJournalMode(pPager, eNew); + } + }else if( eOld==PAGER_JOURNALMODE_MEMORY ){ + /* Cannot transition directly from MEMORY to WAL. Use mode OFF + ** as an intermediate */ + sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF); + } + + /* Open a transaction on the database file. Regardless of the journal + ** mode, this transaction always uses a rollback journal. + */ + assert( sqlite3BtreeIsInTrans(pBt)==0 ); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1)); + } + } + } +#endif /* ifndef SQLITE_OMIT_WAL */ + + if( rc ){ + eNew = eOld; + } + eNew = sqlite3PagerSetJournalMode(pPager, eNew); + + pOut->flags = MEM_Str|MEM_Static|MEM_Term; + pOut->z = (char *)sqlite3JournalModename(eNew); + pOut->n = sqlite3Strlen30(pOut->z); + pOut->enc = SQLITE_UTF8; + sqlite3VdbeChangeEncoding(pOut, encoding); + break; +}; +#endif /* SQLITE_OMIT_PRAGMA */ + +#if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH) +/* Opcode: Vacuum * * * * * +** +** Vacuum the entire database. This opcode will cause other virtual +** machines to be created and run. It may not be called from within +** a transaction. +*/ +case OP_Vacuum: { + assert( p->readOnly==0 ); + rc = sqlite3RunVacuum(&p->zErrMsg, db); + break; +} +#endif + +#if !defined(SQLITE_OMIT_AUTOVACUUM) +/* Opcode: IncrVacuum P1 P2 * * * +** +** Perform a single step of the incremental vacuum procedure on +** the P1 database. If the vacuum has finished, jump to instruction +** P2. Otherwise, fall through to the next instruction. +*/ +case OP_IncrVacuum: { /* jump */ + Btree *pBt; + + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + assert( p->readOnly==0 ); + pBt = db->aDb[pOp->p1].pBt; + rc = sqlite3BtreeIncrVacuum(pBt); + VdbeBranchTaken(rc==SQLITE_DONE,2); + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + goto jump_to_p2; + } + break; +} +#endif + +/* Opcode: Expire P1 * * * * +** +** Cause precompiled statements to expire. When an expired statement +** is executed using sqlite3_step() it will either automatically +** reprepare itself (if it was originally created using sqlite3_prepare_v2()) +** or it will fail with SQLITE_SCHEMA. +** +** If P1 is 0, then all SQL statements become expired. If P1 is non-zero, +** then only the currently executing statement is expired. +*/ +case OP_Expire: { + if( !pOp->p1 ){ + sqlite3ExpirePreparedStatements(db); + }else{ + p->expired = 1; + } + break; +} + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* Opcode: TableLock P1 P2 P3 P4 * +** Synopsis: iDb=P1 root=P2 write=P3 +** +** Obtain a lock on a particular table. This instruction is only used when +** the shared-cache feature is enabled. +** +** P1 is the index of the database in sqlite3.aDb[] of the database +** on which the lock is acquired. A readlock is obtained if P3==0 or +** a write lock if P3==1. +** +** P2 contains the root-page of the table to lock. +** +** P4 contains a pointer to the name of the table being locked. This is only +** used to generate an error message if the lock cannot be obtained. +*/ +case OP_TableLock: { + u8 isWriteLock = (u8)pOp->p3; + if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommitted) ){ + int p1 = pOp->p1; + assert( p1>=0 && p1nDb ); + assert( DbMaskTest(p->btreeMask, p1) ); + assert( isWriteLock==0 || isWriteLock==1 ); + rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock); + if( (rc&0xFF)==SQLITE_LOCKED ){ + const char *z = pOp->p4.z; + sqlite3VdbeError(p, "database table is locked: %s", z); + } + } + break; +} +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VBegin * * * P4 * +** +** P4 may be a pointer to an sqlite3_vtab structure. If so, call the +** xBegin method for that table. +** +** Also, whether or not P4 is set, check that this is not being called from +** within a callback to a virtual table xSync() method. If it is, the error +** code will be set to SQLITE_LOCKED. +*/ +case OP_VBegin: { + VTable *pVTab; + pVTab = pOp->p4.pVtab; + rc = sqlite3VtabBegin(db, pVTab); + if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab); + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VCreate P1 P2 * * * +** +** P2 is a register that holds the name of a virtual table in database +** P1. Call the xCreate method for that table. +*/ +case OP_VCreate: { + Mem sMem; /* For storing the record being decoded */ + const char *zTab; /* Name of the virtual table */ + + memset(&sMem, 0, sizeof(sMem)); + sMem.db = db; + /* Because P2 is always a static string, it is impossible for the + ** sqlite3VdbeMemCopy() to fail */ + assert( (aMem[pOp->p2].flags & MEM_Str)!=0 ); + assert( (aMem[pOp->p2].flags & MEM_Static)!=0 ); + rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]); + assert( rc==SQLITE_OK ); + zTab = (const char*)sqlite3_value_text(&sMem); + assert( zTab || db->mallocFailed ); + if( zTab ){ + rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg); + } + sqlite3VdbeMemRelease(&sMem); + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VDestroy P1 * * P4 * +** +** P4 is the name of a virtual table in database P1. Call the xDestroy method +** of that table. +*/ +case OP_VDestroy: { + db->nVDestroy++; + rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z); + db->nVDestroy--; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VOpen P1 * * P4 * +** +** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. +** P1 is a cursor number. This opcode opens a cursor to the virtual +** table and stores that cursor in P1. +*/ +case OP_VOpen: { + VdbeCursor *pCur; + sqlite3_vtab_cursor *pVtabCursor; + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + + assert( p->bIsReader ); + pCur = 0; + pVtabCursor = 0; + pVtab = pOp->p4.pVtab->pVtab; + if( pVtab==0 || NEVER(pVtab->pModule==0) ){ + rc = SQLITE_LOCKED; + break; + } + pModule = pVtab->pModule; + rc = pModule->xOpen(pVtab, &pVtabCursor); + sqlite3VtabImportErrmsg(p, pVtab); + if( SQLITE_OK==rc ){ + /* Initialize sqlite3_vtab_cursor base class */ + pVtabCursor->pVtab = pVtab; + + /* Initialize vdbe cursor object */ + pCur = allocateCursor(p, pOp->p1, 0, -1, 0); + if( pCur ){ + pCur->pVtabCursor = pVtabCursor; + pVtab->nRef++; + }else{ + assert( db->mallocFailed ); + pModule->xClose(pVtabCursor); + goto no_mem; + } + } + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VFilter P1 P2 P3 P4 * +** Synopsis: iplan=r[P3] zplan='P4' +** +** P1 is a cursor opened using VOpen. P2 is an address to jump to if +** the filtered result set is empty. +** +** P4 is either NULL or a string that was generated by the xBestIndex +** method of the module. The interpretation of the P4 string is left +** to the module implementation. +** +** This opcode invokes the xFilter method on the virtual table specified +** by P1. The integer query plan parameter to xFilter is stored in register +** P3. Register P3+1 stores the argc parameter to be passed to the +** xFilter method. Registers P3+2..P3+1+argc are the argc +** additional parameters which are passed to +** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter. +** +** A jump is made to P2 if the result set after filtering would be empty. +*/ +case OP_VFilter: { /* jump */ + int nArg; + int iQuery; + const sqlite3_module *pModule; + Mem *pQuery; + Mem *pArgc; + sqlite3_vtab_cursor *pVtabCursor; + sqlite3_vtab *pVtab; + VdbeCursor *pCur; + int res; + int i; + Mem **apArg; + + pQuery = &aMem[pOp->p3]; + pArgc = &pQuery[1]; + pCur = p->apCsr[pOp->p1]; + assert( memIsValid(pQuery) ); + REGISTER_TRACE(pOp->p3, pQuery); + assert( pCur->pVtabCursor ); + pVtabCursor = pCur->pVtabCursor; + pVtab = pVtabCursor->pVtab; + pModule = pVtab->pModule; + + /* Grab the index number and argc parameters */ + assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int ); + nArg = (int)pArgc->u.i; + iQuery = (int)pQuery->u.i; + + /* Invoke the xFilter method */ + res = 0; + apArg = p->apArg; + for(i = 0; ixFilter(pVtabCursor, iQuery, pOp->p4.z, nArg, apArg); + sqlite3VtabImportErrmsg(p, pVtab); + if( rc==SQLITE_OK ){ + res = pModule->xEof(pVtabCursor); + } + pCur->nullRow = 0; + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VColumn P1 P2 P3 * * +** Synopsis: r[P3]=vcolumn(P2) +** +** Store the value of the P2-th column of +** the row of the virtual-table that the +** P1 cursor is pointing to into register P3. +*/ +case OP_VColumn: { + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + Mem *pDest; + sqlite3_context sContext; + + VdbeCursor *pCur = p->apCsr[pOp->p1]; + assert( pCur->pVtabCursor ); + assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) ); + pDest = &aMem[pOp->p3]; + memAboutToChange(p, pDest); + if( pCur->nullRow ){ + sqlite3VdbeMemSetNull(pDest); + break; + } + pVtab = pCur->pVtabCursor->pVtab; + pModule = pVtab->pModule; + assert( pModule->xColumn ); + memset(&sContext, 0, sizeof(sContext)); + sContext.pOut = pDest; + MemSetTypeFlag(pDest, MEM_Null); + rc = pModule->xColumn(pCur->pVtabCursor, &sContext, pOp->p2); + sqlite3VtabImportErrmsg(p, pVtab); + if( sContext.isError ){ + rc = sContext.isError; + } + sqlite3VdbeChangeEncoding(pDest, encoding); + REGISTER_TRACE(pOp->p3, pDest); + UPDATE_MAX_BLOBSIZE(pDest); + + if( sqlite3VdbeMemTooBig(pDest) ){ + goto too_big; + } + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VNext P1 P2 * * * +** +** Advance virtual table P1 to the next row in its result set and +** jump to instruction P2. Or, if the virtual table has reached +** the end of its result set, then fall through to the next instruction. +*/ +case OP_VNext: { /* jump */ + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + int res; + VdbeCursor *pCur; + + res = 0; + pCur = p->apCsr[pOp->p1]; + assert( pCur->pVtabCursor ); + if( pCur->nullRow ){ + break; + } + pVtab = pCur->pVtabCursor->pVtab; + pModule = pVtab->pModule; + assert( pModule->xNext ); + + /* Invoke the xNext() method of the module. There is no way for the + ** underlying implementation to return an error if one occurs during + ** xNext(). Instead, if an error occurs, true is returned (indicating that + ** data is available) and the error code returned when xColumn or + ** some other method is next invoked on the save virtual table cursor. + */ + rc = pModule->xNext(pCur->pVtabCursor); + sqlite3VtabImportErrmsg(p, pVtab); + if( rc==SQLITE_OK ){ + res = pModule->xEof(pCur->pVtabCursor); + } + VdbeBranchTaken(!res,2); + if( !res ){ + /* If there is data, jump to P2 */ + goto jump_to_p2_and_check_for_interrupt; + } + goto check_for_interrupt; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VRename P1 * * P4 * +** +** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. +** This opcode invokes the corresponding xRename method. The value +** in register P1 is passed as the zName argument to the xRename method. +*/ +case OP_VRename: { + sqlite3_vtab *pVtab; + Mem *pName; + + pVtab = pOp->p4.pVtab->pVtab; + pName = &aMem[pOp->p1]; + assert( pVtab->pModule->xRename ); + assert( memIsValid(pName) ); + assert( p->readOnly==0 ); + REGISTER_TRACE(pOp->p1, pName); + assert( pName->flags & MEM_Str ); + testcase( pName->enc==SQLITE_UTF8 ); + testcase( pName->enc==SQLITE_UTF16BE ); + testcase( pName->enc==SQLITE_UTF16LE ); + rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8); + if( rc==SQLITE_OK ){ + rc = pVtab->pModule->xRename(pVtab, pName->z); + sqlite3VtabImportErrmsg(p, pVtab); + p->expired = 0; + } + break; +} +#endif + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VUpdate P1 P2 P3 P4 P5 +** Synopsis: data=r[P3@P2] +** +** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. +** This opcode invokes the corresponding xUpdate method. P2 values +** are contiguous memory cells starting at P3 to pass to the xUpdate +** invocation. The value in register (P3+P2-1) corresponds to the +** p2th element of the argv array passed to xUpdate. +** +** The xUpdate method will do a DELETE or an INSERT or both. +** The argv[0] element (which corresponds to memory cell P3) +** is the rowid of a row to delete. If argv[0] is NULL then no +** deletion occurs. The argv[1] element is the rowid of the new +** row. This can be NULL to have the virtual table select the new +** rowid for itself. The subsequent elements in the array are +** the values of columns in the new row. +** +** If P2==1 then no insert is performed. argv[0] is the rowid of +** a row to delete. +** +** P1 is a boolean flag. If it is set to true and the xUpdate call +** is successful, then the value returned by sqlite3_last_insert_rowid() +** is set to the value of the rowid for the row just inserted. +** +** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to +** apply in the case of a constraint failure on an insert or update. +*/ +case OP_VUpdate: { + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + int nArg; + int i; + sqlite_int64 rowid; + Mem **apArg; + Mem *pX; + + assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback + || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace + ); + assert( p->readOnly==0 ); + pVtab = pOp->p4.pVtab->pVtab; + if( pVtab==0 || NEVER(pVtab->pModule==0) ){ + rc = SQLITE_LOCKED; + break; + } + pModule = pVtab->pModule; + nArg = pOp->p2; + assert( pOp->p4type==P4_VTAB ); + if( ALWAYS(pModule->xUpdate) ){ + u8 vtabOnConflict = db->vtabOnConflict; + apArg = p->apArg; + pX = &aMem[pOp->p3]; + for(i=0; ivtabOnConflict = pOp->p5; + rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid); + db->vtabOnConflict = vtabOnConflict; + sqlite3VtabImportErrmsg(p, pVtab); + if( rc==SQLITE_OK && pOp->p1 ){ + assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) ); + db->lastRowid = lastRowid = rowid; + } + if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){ + if( pOp->p5==OE_Ignore ){ + rc = SQLITE_OK; + }else{ + p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5); + } + }else{ + p->nChange++; + } + } + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* Opcode: Pagecount P1 P2 * * * +** +** Write the current number of pages in database P1 to memory cell P2. +*/ +case OP_Pagecount: { /* out2 */ + pOut = out2Prerelease(p, pOp); + pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt); + break; +} +#endif + + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* Opcode: MaxPgcnt P1 P2 P3 * * +** +** Try to set the maximum page count for database P1 to the value in P3. +** Do not let the maximum page count fall below the current page count and +** do not change the maximum page count value if P3==0. +** +** Store the maximum page count after the change in register P2. +*/ +case OP_MaxPgcnt: { /* out2 */ + unsigned int newMax; + Btree *pBt; + + pOut = out2Prerelease(p, pOp); + pBt = db->aDb[pOp->p1].pBt; + newMax = 0; + if( pOp->p3 ){ + newMax = sqlite3BtreeLastPage(pBt); + if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3; + } + pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax); + break; +} +#endif + + +/* Opcode: Init * P2 * P4 * +** Synopsis: Start at P2 +** +** Programs contain a single instance of this opcode as the very first +** opcode. +** +** If tracing is enabled (by the sqlite3_trace()) interface, then +** the UTF-8 string contained in P4 is emitted on the trace callback. +** Or if P4 is blank, use the string returned by sqlite3_sql(). +** +** If P2 is not zero, jump to instruction P2. +*/ +case OP_Init: { /* jump */ + char *zTrace; + char *z; + +#ifndef SQLITE_OMIT_TRACE + if( db->xTrace + && !p->doingRerun + && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 + ){ + z = sqlite3VdbeExpandSql(p, zTrace); + db->xTrace(db->pTraceArg, z); + sqlite3DbFree(db, z); + } +#ifdef SQLITE_USE_FCNTL_TRACE + zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql); + if( zTrace ){ + int i; + for(i=0; inDb; i++){ + if( DbMaskTest(p->btreeMask, i)==0 ) continue; + sqlite3_file_control(db, db->aDb[i].zName, SQLITE_FCNTL_TRACE, zTrace); + } + } +#endif /* SQLITE_USE_FCNTL_TRACE */ +#ifdef SQLITE_DEBUG + if( (db->flags & SQLITE_SqlTrace)!=0 + && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 + ){ + sqlite3DebugPrintf("SQL-trace: %s\n", zTrace); + } +#endif /* SQLITE_DEBUG */ +#endif /* SQLITE_OMIT_TRACE */ + if( pOp->p2 ) goto jump_to_p2; + break; +} + + +/* Opcode: Noop * * * * * +** +** Do nothing. This instruction is often useful as a jump +** destination. +*/ +/* +** The magic Explain opcode are only inserted when explain==2 (which +** is to say when the EXPLAIN QUERY PLAN syntax is used.) +** This opcode records information from the optimizer. It is the +** the same as a no-op. This opcodesnever appears in a real VM program. +*/ +default: { /* This is really OP_Noop and OP_Explain */ + assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain ); + break; +} + +/***************************************************************************** +** The cases of the switch statement above this line should all be indented +** by 6 spaces. But the left-most 6 spaces have been removed to improve the +** readability. From this point on down, the normal indentation rules are +** restored. +*****************************************************************************/ + } + +#ifdef VDBE_PROFILE + { + u64 endTime = sqlite3Hwtime(); + if( endTime>start ) pOrigOp->cycles += endTime - start; + pOrigOp->cnt++; + } +#endif + + /* The following code adds nothing to the actual functionality + ** of the program. It is only here for testing and debugging. + ** On the other hand, it does burn CPU cycles every time through + ** the evaluator loop. So we can leave it out when NDEBUG is defined. + */ +#ifndef NDEBUG + assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] ); + +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_VdbeTrace ){ + if( rc!=0 ) printf("rc=%d\n",rc); + if( pOrigOp->opflags & (OPFLG_OUT2) ){ + registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]); + } + if( pOrigOp->opflags & OPFLG_OUT3 ){ + registerTrace(pOrigOp->p3, &aMem[pOrigOp->p3]); + } + } +#endif /* SQLITE_DEBUG */ +#endif /* NDEBUG */ + } /* The end of the for(;;) loop the loops through opcodes */ + + /* If we reach this point, it means that execution is finished with + ** an error of some kind. + */ +vdbe_error_halt: + assert( rc ); + p->rc = rc; + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(rc, "statement aborts at %d: [%s] %s", + (int)(pOp - aOp), p->zSql, p->zErrMsg); + sqlite3VdbeHalt(p); + if( rc==SQLITE_IOERR_NOMEM ) db->mallocFailed = 1; + rc = SQLITE_ERROR; + if( resetSchemaOnFault>0 ){ + sqlite3ResetOneSchema(db, resetSchemaOnFault-1); + } + + /* This is the only way out of this procedure. We have to + ** release the mutexes on btrees that were acquired at the + ** top. */ +vdbe_return: + db->lastRowid = lastRowid; + testcase( nVmStep>0 ); + p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep; + sqlite3VdbeLeave(p); + return rc; + + /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH + ** is encountered. + */ +too_big: + sqlite3VdbeError(p, "string or blob too big"); + rc = SQLITE_TOOBIG; + goto vdbe_error_halt; + + /* Jump to here if a malloc() fails. + */ +no_mem: + db->mallocFailed = 1; + sqlite3VdbeError(p, "out of memory"); + rc = SQLITE_NOMEM; + goto vdbe_error_halt; + + /* Jump to here for any other kind of fatal error. The "rc" variable + ** should hold the error number. + */ +abort_due_to_error: + assert( p->zErrMsg==0 ); + if( db->mallocFailed ) rc = SQLITE_NOMEM; + if( rc!=SQLITE_IOERR_NOMEM ){ + sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc)); + } + goto vdbe_error_halt; + + /* Jump to here if the sqlite3_interrupt() API sets the interrupt + ** flag. + */ +abort_due_to_interrupt: + assert( db->u1.isInterrupted ); + rc = SQLITE_INTERRUPT; + p->rc = rc; + sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc)); + goto vdbe_error_halt; +} + + +/************** End of vdbe.c ************************************************/ +/************** Begin file vdbeblob.c ****************************************/ +/* +** 2007 May 1 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code used to implement incremental BLOB I/O. +*/ + +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#ifndef SQLITE_OMIT_INCRBLOB + +/* +** Valid sqlite3_blob* handles point to Incrblob structures. +*/ +typedef struct Incrblob Incrblob; +struct Incrblob { + int flags; /* Copy of "flags" passed to sqlite3_blob_open() */ + int nByte; /* Size of open blob, in bytes */ + int iOffset; /* Byte offset of blob in cursor data */ + int iCol; /* Table column this handle is open on */ + BtCursor *pCsr; /* Cursor pointing at blob row */ + sqlite3_stmt *pStmt; /* Statement holding cursor open */ + sqlite3 *db; /* The associated database */ +}; + + +/* +** This function is used by both blob_open() and blob_reopen(). It seeks +** the b-tree cursor associated with blob handle p to point to row iRow. +** If successful, SQLITE_OK is returned and subsequent calls to +** sqlite3_blob_read() or sqlite3_blob_write() access the specified row. +** +** If an error occurs, or if the specified row does not exist or does not +** contain a value of type TEXT or BLOB in the column nominated when the +** blob handle was opened, then an error code is returned and *pzErr may +** be set to point to a buffer containing an error message. It is the +** responsibility of the caller to free the error message buffer using +** sqlite3DbFree(). +** +** If an error does occur, then the b-tree cursor is closed. All subsequent +** calls to sqlite3_blob_read(), blob_write() or blob_reopen() will +** immediately return SQLITE_ABORT. +*/ +static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){ + int rc; /* Error code */ + char *zErr = 0; /* Error message */ + Vdbe *v = (Vdbe *)p->pStmt; + + /* Set the value of the SQL statements only variable to integer iRow. + ** This is done directly instead of using sqlite3_bind_int64() to avoid + ** triggering asserts related to mutexes. + */ + assert( v->aVar[0].flags&MEM_Int ); + v->aVar[0].u.i = iRow; + + rc = sqlite3_step(p->pStmt); + if( rc==SQLITE_ROW ){ + VdbeCursor *pC = v->apCsr[0]; + u32 type = pC->aType[p->iCol]; + if( type<12 ){ + zErr = sqlite3MPrintf(p->db, "cannot open value of type %s", + type==0?"null": type==7?"real": "integer" + ); + rc = SQLITE_ERROR; + sqlite3_finalize(p->pStmt); + p->pStmt = 0; + }else{ + p->iOffset = pC->aType[p->iCol + pC->nField]; + p->nByte = sqlite3VdbeSerialTypeLen(type); + p->pCsr = pC->pCursor; + sqlite3BtreeIncrblobCursor(p->pCsr); + } + } + + if( rc==SQLITE_ROW ){ + rc = SQLITE_OK; + }else if( p->pStmt ){ + rc = sqlite3_finalize(p->pStmt); + p->pStmt = 0; + if( rc==SQLITE_OK ){ + zErr = sqlite3MPrintf(p->db, "no such rowid: %lld", iRow); + rc = SQLITE_ERROR; + }else{ + zErr = sqlite3MPrintf(p->db, "%s", sqlite3_errmsg(p->db)); + } + } + + assert( rc!=SQLITE_OK || zErr==0 ); + assert( rc!=SQLITE_ROW && rc!=SQLITE_DONE ); + + *pzErr = zErr; + return rc; +} + +/* +** Open a blob handle. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_open( + sqlite3* db, /* The database connection */ + const char *zDb, /* The attached database containing the blob */ + const char *zTable, /* The table containing the blob */ + const char *zColumn, /* The column containing the blob */ + sqlite_int64 iRow, /* The row containing the glob */ + int flags, /* True -> read/write access, false -> read-only */ + sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */ +){ + int nAttempt = 0; + int iCol; /* Index of zColumn in row-record */ + + /* This VDBE program seeks a btree cursor to the identified + ** db/table/row entry. The reason for using a vdbe program instead + ** of writing code to use the b-tree layer directly is that the + ** vdbe program will take advantage of the various transaction, + ** locking and error handling infrastructure built into the vdbe. + ** + ** After seeking the cursor, the vdbe executes an OP_ResultRow. + ** Code external to the Vdbe then "borrows" the b-tree cursor and + ** uses it to implement the blob_read(), blob_write() and + ** blob_bytes() functions. + ** + ** The sqlite3_blob_close() function finalizes the vdbe program, + ** which closes the b-tree cursor and (possibly) commits the + ** transaction. + */ + static const int iLn = VDBE_OFFSET_LINENO(4); + static const VdbeOpList openBlob[] = { + /* {OP_Transaction, 0, 0, 0}, // 0: Inserted separately */ + {OP_TableLock, 0, 0, 0}, /* 1: Acquire a read or write lock */ + /* One of the following two instructions is replaced by an OP_Noop. */ + {OP_OpenRead, 0, 0, 0}, /* 2: Open cursor 0 for reading */ + {OP_OpenWrite, 0, 0, 0}, /* 3: Open cursor 0 for read/write */ + {OP_Variable, 1, 1, 1}, /* 4: Push the rowid to the stack */ + {OP_NotExists, 0, 10, 1}, /* 5: Seek the cursor */ + {OP_Column, 0, 0, 1}, /* 6 */ + {OP_ResultRow, 1, 0, 0}, /* 7 */ + {OP_Goto, 0, 4, 0}, /* 8 */ + {OP_Close, 0, 0, 0}, /* 9 */ + {OP_Halt, 0, 0, 0}, /* 10 */ + }; + + int rc = SQLITE_OK; + char *zErr = 0; + Table *pTab; + Parse *pParse = 0; + Incrblob *pBlob = 0; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppBlob==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + *ppBlob = 0; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zTable==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + flags = !!flags; /* flags = (flags ? 1 : 0); */ + + sqlite3_mutex_enter(db->mutex); + + pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob)); + if( !pBlob ) goto blob_open_out; + pParse = sqlite3StackAllocRaw(db, sizeof(*pParse)); + if( !pParse ) goto blob_open_out; + + do { + memset(pParse, 0, sizeof(Parse)); + pParse->db = db; + sqlite3DbFree(db, zErr); + zErr = 0; + + sqlite3BtreeEnterAll(db); + pTab = sqlite3LocateTable(pParse, 0, zTable, zDb); + if( pTab && IsVirtual(pTab) ){ + pTab = 0; + sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable); + } + if( pTab && !HasRowid(pTab) ){ + pTab = 0; + sqlite3ErrorMsg(pParse, "cannot open table without rowid: %s", zTable); + } +#ifndef SQLITE_OMIT_VIEW + if( pTab && pTab->pSelect ){ + pTab = 0; + sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable); + } +#endif + if( !pTab ){ + if( pParse->zErrMsg ){ + sqlite3DbFree(db, zErr); + zErr = pParse->zErrMsg; + pParse->zErrMsg = 0; + } + rc = SQLITE_ERROR; + sqlite3BtreeLeaveAll(db); + goto blob_open_out; + } + + /* Now search pTab for the exact column. */ + for(iCol=0; iColnCol; iCol++) { + if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){ + break; + } + } + if( iCol==pTab->nCol ){ + sqlite3DbFree(db, zErr); + zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn); + rc = SQLITE_ERROR; + sqlite3BtreeLeaveAll(db); + goto blob_open_out; + } + + /* If the value is being opened for writing, check that the + ** column is not indexed, and that it is not part of a foreign key. + ** It is against the rules to open a column to which either of these + ** descriptions applies for writing. */ + if( flags ){ + const char *zFault = 0; + Index *pIdx; +#ifndef SQLITE_OMIT_FOREIGN_KEY + if( db->flags&SQLITE_ForeignKeys ){ + /* Check that the column is not part of an FK child key definition. It + ** is not necessary to check if it is part of a parent key, as parent + ** key columns must be indexed. The check below will pick up this + ** case. */ + FKey *pFKey; + for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + int j; + for(j=0; jnCol; j++){ + if( pFKey->aCol[j].iFrom==iCol ){ + zFault = "foreign key"; + } + } + } + } +#endif + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int j; + for(j=0; jnKeyCol; j++){ + /* FIXME: Be smarter about indexes that use expressions */ + if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){ + zFault = "indexed"; + } + } + } + if( zFault ){ + sqlite3DbFree(db, zErr); + zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault); + rc = SQLITE_ERROR; + sqlite3BtreeLeaveAll(db); + goto blob_open_out; + } + } + + pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(pParse); + assert( pBlob->pStmt || db->mallocFailed ); + if( pBlob->pStmt ){ + Vdbe *v = (Vdbe *)pBlob->pStmt; + int iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + + + sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, flags, + pTab->pSchema->schema_cookie, + pTab->pSchema->iGeneration); + sqlite3VdbeChangeP5(v, 1); + sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn); + + /* Make sure a mutex is held on the table to be accessed */ + sqlite3VdbeUsesBtree(v, iDb); + + /* Configure the OP_TableLock instruction */ +#ifdef SQLITE_OMIT_SHARED_CACHE + sqlite3VdbeChangeToNoop(v, 1); +#else + sqlite3VdbeChangeP1(v, 1, iDb); + sqlite3VdbeChangeP2(v, 1, pTab->tnum); + sqlite3VdbeChangeP3(v, 1, flags); + sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT); +#endif + + /* Remove either the OP_OpenWrite or OpenRead. Set the P2 + ** parameter of the other to pTab->tnum. */ + sqlite3VdbeChangeToNoop(v, 3 - flags); + sqlite3VdbeChangeP2(v, 2 + flags, pTab->tnum); + sqlite3VdbeChangeP3(v, 2 + flags, iDb); + + /* Configure the number of columns. Configure the cursor to + ** think that the table has one more column than it really + ** does. An OP_Column to retrieve this imaginary column will + ** always return an SQL NULL. This is useful because it means + ** we can invoke OP_Column to fill in the vdbe cursors type + ** and offset cache without causing any IO. + */ + sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32); + sqlite3VdbeChangeP2(v, 6, pTab->nCol); + if( !db->mallocFailed ){ + pParse->nVar = 1; + pParse->nMem = 1; + pParse->nTab = 1; + sqlite3VdbeMakeReady(v, pParse); + } + } + + pBlob->flags = flags; + pBlob->iCol = iCol; + pBlob->db = db; + sqlite3BtreeLeaveAll(db); + if( db->mallocFailed ){ + goto blob_open_out; + } + sqlite3_bind_int64(pBlob->pStmt, 1, iRow); + rc = blobSeekToRow(pBlob, iRow, &zErr); + } while( (++nAttempt)mallocFailed==0 ){ + *ppBlob = (sqlite3_blob *)pBlob; + }else{ + if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt); + sqlite3DbFree(db, pBlob); + } + sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr); + sqlite3DbFree(db, zErr); + sqlite3ParserReset(pParse); + sqlite3StackFree(db, pParse); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Close a blob handle that was previously created using +** sqlite3_blob_open(). +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_close(sqlite3_blob *pBlob){ + Incrblob *p = (Incrblob *)pBlob; + int rc; + sqlite3 *db; + + if( p ){ + db = p->db; + sqlite3_mutex_enter(db->mutex); + rc = sqlite3_finalize(p->pStmt); + sqlite3DbFree(db, p); + sqlite3_mutex_leave(db->mutex); + }else{ + rc = SQLITE_OK; + } + return rc; +} + +/* +** Perform a read or write operation on a blob +*/ +static int blobReadWrite( + sqlite3_blob *pBlob, + void *z, + int n, + int iOffset, + int (*xCall)(BtCursor*, u32, u32, void*) +){ + int rc; + Incrblob *p = (Incrblob *)pBlob; + Vdbe *v; + sqlite3 *db; + + if( p==0 ) return SQLITE_MISUSE_BKPT; + db = p->db; + sqlite3_mutex_enter(db->mutex); + v = (Vdbe*)p->pStmt; + + if( n<0 || iOffset<0 || ((sqlite3_int64)iOffset+n)>p->nByte ){ + /* Request is out of range. Return a transient error. */ + rc = SQLITE_ERROR; + }else if( v==0 ){ + /* If there is no statement handle, then the blob-handle has + ** already been invalidated. Return SQLITE_ABORT in this case. + */ + rc = SQLITE_ABORT; + }else{ + /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is + ** returned, clean-up the statement handle. + */ + assert( db == v->db ); + sqlite3BtreeEnterCursor(p->pCsr); + rc = xCall(p->pCsr, iOffset+p->iOffset, n, z); + sqlite3BtreeLeaveCursor(p->pCsr); + if( rc==SQLITE_ABORT ){ + sqlite3VdbeFinalize(v); + p->pStmt = 0; + }else{ + v->rc = rc; + } + } + sqlite3Error(db, rc); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Read data from a blob handle. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){ + return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData); +} + +/* +** Write data to a blob handle. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){ + return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData); +} + +/* +** Query a blob handle for the size of the data. +** +** The Incrblob.nByte field is fixed for the lifetime of the Incrblob +** so no mutex is required for access. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_bytes(sqlite3_blob *pBlob){ + Incrblob *p = (Incrblob *)pBlob; + return (p && p->pStmt) ? p->nByte : 0; +} + +/* +** Move an existing blob handle to point to a different row of the same +** database table. +** +** If an error occurs, or if the specified row does not exist or does not +** contain a blob or text value, then an error code is returned and the +** database handle error code and message set. If this happens, then all +** subsequent calls to sqlite3_blob_xxx() functions (except blob_close()) +** immediately return SQLITE_ABORT. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){ + int rc; + Incrblob *p = (Incrblob *)pBlob; + sqlite3 *db; + + if( p==0 ) return SQLITE_MISUSE_BKPT; + db = p->db; + sqlite3_mutex_enter(db->mutex); + + if( p->pStmt==0 ){ + /* If there is no statement handle, then the blob-handle has + ** already been invalidated. Return SQLITE_ABORT in this case. + */ + rc = SQLITE_ABORT; + }else{ + char *zErr; + rc = blobSeekToRow(p, iRow, &zErr); + if( rc!=SQLITE_OK ){ + sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr); + sqlite3DbFree(db, zErr); + } + assert( rc!=SQLITE_SCHEMA ); + } + + rc = sqlite3ApiExit(db, rc); + assert( rc==SQLITE_OK || p->pStmt==0 ); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#endif /* #ifndef SQLITE_OMIT_INCRBLOB */ + +/************** End of vdbeblob.c ********************************************/ +/************** Begin file vdbesort.c ****************************************/ +/* +** 2011-07-09 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code for the VdbeSorter object, used in concert with +** a VdbeCursor to sort large numbers of keys for CREATE INDEX statements +** or by SELECT statements with ORDER BY clauses that cannot be satisfied +** using indexes and without LIMIT clauses. +** +** The VdbeSorter object implements a multi-threaded external merge sort +** algorithm that is efficient even if the number of elements being sorted +** exceeds the available memory. +** +** Here is the (internal, non-API) interface between this module and the +** rest of the SQLite system: +** +** sqlite3VdbeSorterInit() Create a new VdbeSorter object. +** +** sqlite3VdbeSorterWrite() Add a single new row to the VdbeSorter +** object. The row is a binary blob in the +** OP_MakeRecord format that contains both +** the ORDER BY key columns and result columns +** in the case of a SELECT w/ ORDER BY, or +** the complete record for an index entry +** in the case of a CREATE INDEX. +** +** sqlite3VdbeSorterRewind() Sort all content previously added. +** Position the read cursor on the +** first sorted element. +** +** sqlite3VdbeSorterNext() Advance the read cursor to the next sorted +** element. +** +** sqlite3VdbeSorterRowkey() Return the complete binary blob for the +** row currently under the read cursor. +** +** sqlite3VdbeSorterCompare() Compare the binary blob for the row +** currently under the read cursor against +** another binary blob X and report if +** X is strictly less than the read cursor. +** Used to enforce uniqueness in a +** CREATE UNIQUE INDEX statement. +** +** sqlite3VdbeSorterClose() Close the VdbeSorter object and reclaim +** all resources. +** +** sqlite3VdbeSorterReset() Refurbish the VdbeSorter for reuse. This +** is like Close() followed by Init() only +** much faster. +** +** The interfaces above must be called in a particular order. Write() can +** only occur in between Init()/Reset() and Rewind(). Next(), Rowkey(), and +** Compare() can only occur in between Rewind() and Close()/Reset(). i.e. +** +** Init() +** for each record: Write() +** Rewind() +** Rowkey()/Compare() +** Next() +** Close() +** +** Algorithm: +** +** Records passed to the sorter via calls to Write() are initially held +** unsorted in main memory. Assuming the amount of memory used never exceeds +** a threshold, when Rewind() is called the set of records is sorted using +** an in-memory merge sort. In this case, no temporary files are required +** and subsequent calls to Rowkey(), Next() and Compare() read records +** directly from main memory. +** +** If the amount of space used to store records in main memory exceeds the +** threshold, then the set of records currently in memory are sorted and +** written to a temporary file in "Packed Memory Array" (PMA) format. +** A PMA created at this point is known as a "level-0 PMA". Higher levels +** of PMAs may be created by merging existing PMAs together - for example +** merging two or more level-0 PMAs together creates a level-1 PMA. +** +** The threshold for the amount of main memory to use before flushing +** records to a PMA is roughly the same as the limit configured for the +** page-cache of the main database. Specifically, the threshold is set to +** the value returned by "PRAGMA main.page_size" multipled by +** that returned by "PRAGMA main.cache_size", in bytes. +** +** If the sorter is running in single-threaded mode, then all PMAs generated +** are appended to a single temporary file. Or, if the sorter is running in +** multi-threaded mode then up to (N+1) temporary files may be opened, where +** N is the configured number of worker threads. In this case, instead of +** sorting the records and writing the PMA to a temporary file itself, the +** calling thread usually launches a worker thread to do so. Except, if +** there are already N worker threads running, the main thread does the work +** itself. +** +** The sorter is running in multi-threaded mode if (a) the library was built +** with pre-processor symbol SQLITE_MAX_WORKER_THREADS set to a value greater +** than zero, and (b) worker threads have been enabled at runtime by calling +** "PRAGMA threads=N" with some value of N greater than 0. +** +** When Rewind() is called, any data remaining in memory is flushed to a +** final PMA. So at this point the data is stored in some number of sorted +** PMAs within temporary files on disk. +** +** If there are fewer than SORTER_MAX_MERGE_COUNT PMAs in total and the +** sorter is running in single-threaded mode, then these PMAs are merged +** incrementally as keys are retreived from the sorter by the VDBE. The +** MergeEngine object, described in further detail below, performs this +** merge. +** +** Or, if running in multi-threaded mode, then a background thread is +** launched to merge the existing PMAs. Once the background thread has +** merged T bytes of data into a single sorted PMA, the main thread +** begins reading keys from that PMA while the background thread proceeds +** with merging the next T bytes of data. And so on. +** +** Parameter T is set to half the value of the memory threshold used +** by Write() above to determine when to create a new PMA. +** +** If there are more than SORTER_MAX_MERGE_COUNT PMAs in total when +** Rewind() is called, then a hierarchy of incremental-merges is used. +** First, T bytes of data from the first SORTER_MAX_MERGE_COUNT PMAs on +** disk are merged together. Then T bytes of data from the second set, and +** so on, such that no operation ever merges more than SORTER_MAX_MERGE_COUNT +** PMAs at a time. This done is to improve locality. +** +** If running in multi-threaded mode and there are more than +** SORTER_MAX_MERGE_COUNT PMAs on disk when Rewind() is called, then more +** than one background thread may be created. Specifically, there may be +** one background thread for each temporary file on disk, and one background +** thread to merge the output of each of the others to a single PMA for +** the main thread to read from. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* +** If SQLITE_DEBUG_SORTER_THREADS is defined, this module outputs various +** messages to stderr that may be helpful in understanding the performance +** characteristics of the sorter in multi-threaded mode. +*/ +#if 0 +# define SQLITE_DEBUG_SORTER_THREADS 1 +#endif + +/* +** Hard-coded maximum amount of data to accumulate in memory before flushing +** to a level 0 PMA. The purpose of this limit is to prevent various integer +** overflows. 512MiB. +*/ +#define SQLITE_MAX_PMASZ (1<<29) + +/* +** Private objects used by the sorter +*/ +typedef struct MergeEngine MergeEngine; /* Merge PMAs together */ +typedef struct PmaReader PmaReader; /* Incrementally read one PMA */ +typedef struct PmaWriter PmaWriter; /* Incrementally write one PMA */ +typedef struct SorterRecord SorterRecord; /* A record being sorted */ +typedef struct SortSubtask SortSubtask; /* A sub-task in the sort process */ +typedef struct SorterFile SorterFile; /* Temporary file object wrapper */ +typedef struct SorterList SorterList; /* In-memory list of records */ +typedef struct IncrMerger IncrMerger; /* Read & merge multiple PMAs */ + +/* +** A container for a temp file handle and the current amount of data +** stored in the file. +*/ +struct SorterFile { + sqlite3_file *pFd; /* File handle */ + i64 iEof; /* Bytes of data stored in pFd */ +}; + +/* +** An in-memory list of objects to be sorted. +** +** If aMemory==0 then each object is allocated separately and the objects +** are connected using SorterRecord.u.pNext. If aMemory!=0 then all objects +** are stored in the aMemory[] bulk memory, one right after the other, and +** are connected using SorterRecord.u.iNext. +*/ +struct SorterList { + SorterRecord *pList; /* Linked list of records */ + u8 *aMemory; /* If non-NULL, bulk memory to hold pList */ + int szPMA; /* Size of pList as PMA in bytes */ +}; + +/* +** The MergeEngine object is used to combine two or more smaller PMAs into +** one big PMA using a merge operation. Separate PMAs all need to be +** combined into one big PMA in order to be able to step through the sorted +** records in order. +** +** The aReadr[] array contains a PmaReader object for each of the PMAs being +** merged. An aReadr[] object either points to a valid key or else is at EOF. +** ("EOF" means "End Of File". When aReadr[] is at EOF there is no more data.) +** For the purposes of the paragraphs below, we assume that the array is +** actually N elements in size, where N is the smallest power of 2 greater +** to or equal to the number of PMAs being merged. The extra aReadr[] elements +** are treated as if they are empty (always at EOF). +** +** The aTree[] array is also N elements in size. The value of N is stored in +** the MergeEngine.nTree variable. +** +** The final (N/2) elements of aTree[] contain the results of comparing +** pairs of PMA keys together. Element i contains the result of +** comparing aReadr[2*i-N] and aReadr[2*i-N+1]. Whichever key is smaller, the +** aTree element is set to the index of it. +** +** For the purposes of this comparison, EOF is considered greater than any +** other key value. If the keys are equal (only possible with two EOF +** values), it doesn't matter which index is stored. +** +** The (N/4) elements of aTree[] that precede the final (N/2) described +** above contains the index of the smallest of each block of 4 PmaReaders +** And so on. So that aTree[1] contains the index of the PmaReader that +** currently points to the smallest key value. aTree[0] is unused. +** +** Example: +** +** aReadr[0] -> Banana +** aReadr[1] -> Feijoa +** aReadr[2] -> Elderberry +** aReadr[3] -> Currant +** aReadr[4] -> Grapefruit +** aReadr[5] -> Apple +** aReadr[6] -> Durian +** aReadr[7] -> EOF +** +** aTree[] = { X, 5 0, 5 0, 3, 5, 6 } +** +** The current element is "Apple" (the value of the key indicated by +** PmaReader 5). When the Next() operation is invoked, PmaReader 5 will +** be advanced to the next key in its segment. Say the next key is +** "Eggplant": +** +** aReadr[5] -> Eggplant +** +** The contents of aTree[] are updated first by comparing the new PmaReader +** 5 key to the current key of PmaReader 4 (still "Grapefruit"). The PmaReader +** 5 value is still smaller, so aTree[6] is set to 5. And so on up the tree. +** The value of PmaReader 6 - "Durian" - is now smaller than that of PmaReader +** 5, so aTree[3] is set to 6. Key 0 is smaller than key 6 (Bananafile2. And instead of using a +** background thread to prepare data for the PmaReader, with a single +** threaded IncrMerger the allocate part of pTask->file2 is "refilled" with +** keys from pMerger by the calling thread whenever the PmaReader runs out +** of data. +*/ +struct IncrMerger { + SortSubtask *pTask; /* Task that owns this merger */ + MergeEngine *pMerger; /* Merge engine thread reads data from */ + i64 iStartOff; /* Offset to start writing file at */ + int mxSz; /* Maximum bytes of data to store */ + int bEof; /* Set to true when merge is finished */ + int bUseThread; /* True to use a bg thread for this object */ + SorterFile aFile[2]; /* aFile[0] for reading, [1] for writing */ +}; + +/* +** An instance of this object is used for writing a PMA. +** +** The PMA is written one record at a time. Each record is of an arbitrary +** size. But I/O is more efficient if it occurs in page-sized blocks where +** each block is aligned on a page boundary. This object caches writes to +** the PMA so that aligned, page-size blocks are written. +*/ +struct PmaWriter { + int eFWErr; /* Non-zero if in an error state */ + u8 *aBuffer; /* Pointer to write buffer */ + int nBuffer; /* Size of write buffer in bytes */ + int iBufStart; /* First byte of buffer to write */ + int iBufEnd; /* Last byte of buffer to write */ + i64 iWriteOff; /* Offset of start of buffer in file */ + sqlite3_file *pFd; /* File handle to write to */ +}; + +/* +** This object is the header on a single record while that record is being +** held in memory and prior to being written out as part of a PMA. +** +** How the linked list is connected depends on how memory is being managed +** by this module. If using a separate allocation for each in-memory record +** (VdbeSorter.list.aMemory==0), then the list is always connected using the +** SorterRecord.u.pNext pointers. +** +** Or, if using the single large allocation method (VdbeSorter.list.aMemory!=0), +** then while records are being accumulated the list is linked using the +** SorterRecord.u.iNext offset. This is because the aMemory[] array may +** be sqlite3Realloc()ed while records are being accumulated. Once the VM +** has finished passing records to the sorter, or when the in-memory buffer +** is full, the list is sorted. As part of the sorting process, it is +** converted to use the SorterRecord.u.pNext pointers. See function +** vdbeSorterSort() for details. +*/ +struct SorterRecord { + int nVal; /* Size of the record in bytes */ + union { + SorterRecord *pNext; /* Pointer to next record in list */ + int iNext; /* Offset within aMemory of next record */ + } u; + /* The data for the record immediately follows this header */ +}; + +/* Return a pointer to the buffer containing the record data for SorterRecord +** object p. Should be used as if: +** +** void *SRVAL(SorterRecord *p) { return (void*)&p[1]; } +*/ +#define SRVAL(p) ((void*)((SorterRecord*)(p) + 1)) + + +/* Maximum number of PMAs that a single MergeEngine can merge */ +#define SORTER_MAX_MERGE_COUNT 16 + +static int vdbeIncrSwap(IncrMerger*); +static void vdbeIncrFree(IncrMerger *); + +/* +** Free all memory belonging to the PmaReader object passed as the +** argument. All structure fields are set to zero before returning. +*/ +static void vdbePmaReaderClear(PmaReader *pReadr){ + sqlite3_free(pReadr->aAlloc); + sqlite3_free(pReadr->aBuffer); + if( pReadr->aMap ) sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap); + vdbeIncrFree(pReadr->pIncr); + memset(pReadr, 0, sizeof(PmaReader)); +} + +/* +** Read the next nByte bytes of data from the PMA p. +** If successful, set *ppOut to point to a buffer containing the data +** and return SQLITE_OK. Otherwise, if an error occurs, return an SQLite +** error code. +** +** The buffer returned in *ppOut is only valid until the +** next call to this function. +*/ +static int vdbePmaReadBlob( + PmaReader *p, /* PmaReader from which to take the blob */ + int nByte, /* Bytes of data to read */ + u8 **ppOut /* OUT: Pointer to buffer containing data */ +){ + int iBuf; /* Offset within buffer to read from */ + int nAvail; /* Bytes of data available in buffer */ + + if( p->aMap ){ + *ppOut = &p->aMap[p->iReadOff]; + p->iReadOff += nByte; + return SQLITE_OK; + } + + assert( p->aBuffer ); + + /* If there is no more data to be read from the buffer, read the next + ** p->nBuffer bytes of data from the file into it. Or, if there are less + ** than p->nBuffer bytes remaining in the PMA, read all remaining data. */ + iBuf = p->iReadOff % p->nBuffer; + if( iBuf==0 ){ + int nRead; /* Bytes to read from disk */ + int rc; /* sqlite3OsRead() return code */ + + /* Determine how many bytes of data to read. */ + if( (p->iEof - p->iReadOff) > (i64)p->nBuffer ){ + nRead = p->nBuffer; + }else{ + nRead = (int)(p->iEof - p->iReadOff); + } + assert( nRead>0 ); + + /* Readr data from the file. Return early if an error occurs. */ + rc = sqlite3OsRead(p->pFd, p->aBuffer, nRead, p->iReadOff); + assert( rc!=SQLITE_IOERR_SHORT_READ ); + if( rc!=SQLITE_OK ) return rc; + } + nAvail = p->nBuffer - iBuf; + + if( nByte<=nAvail ){ + /* The requested data is available in the in-memory buffer. In this + ** case there is no need to make a copy of the data, just return a + ** pointer into the buffer to the caller. */ + *ppOut = &p->aBuffer[iBuf]; + p->iReadOff += nByte; + }else{ + /* The requested data is not all available in the in-memory buffer. + ** In this case, allocate space at p->aAlloc[] to copy the requested + ** range into. Then return a copy of pointer p->aAlloc to the caller. */ + int nRem; /* Bytes remaining to copy */ + + /* Extend the p->aAlloc[] allocation if required. */ + if( p->nAllocnAlloc*2); + while( nByte>nNew ) nNew = nNew*2; + aNew = sqlite3Realloc(p->aAlloc, nNew); + if( !aNew ) return SQLITE_NOMEM; + p->nAlloc = nNew; + p->aAlloc = aNew; + } + + /* Copy as much data as is available in the buffer into the start of + ** p->aAlloc[]. */ + memcpy(p->aAlloc, &p->aBuffer[iBuf], nAvail); + p->iReadOff += nAvail; + nRem = nByte - nAvail; + + /* The following loop copies up to p->nBuffer bytes per iteration into + ** the p->aAlloc[] buffer. */ + while( nRem>0 ){ + int rc; /* vdbePmaReadBlob() return code */ + int nCopy; /* Number of bytes to copy */ + u8 *aNext; /* Pointer to buffer to copy data from */ + + nCopy = nRem; + if( nRem>p->nBuffer ) nCopy = p->nBuffer; + rc = vdbePmaReadBlob(p, nCopy, &aNext); + if( rc!=SQLITE_OK ) return rc; + assert( aNext!=p->aAlloc ); + memcpy(&p->aAlloc[nByte - nRem], aNext, nCopy); + nRem -= nCopy; + } + + *ppOut = p->aAlloc; + } + + return SQLITE_OK; +} + +/* +** Read a varint from the stream of data accessed by p. Set *pnOut to +** the value read. +*/ +static int vdbePmaReadVarint(PmaReader *p, u64 *pnOut){ + int iBuf; + + if( p->aMap ){ + p->iReadOff += sqlite3GetVarint(&p->aMap[p->iReadOff], pnOut); + }else{ + iBuf = p->iReadOff % p->nBuffer; + if( iBuf && (p->nBuffer-iBuf)>=9 ){ + p->iReadOff += sqlite3GetVarint(&p->aBuffer[iBuf], pnOut); + }else{ + u8 aVarint[16], *a; + int i = 0, rc; + do{ + rc = vdbePmaReadBlob(p, 1, &a); + if( rc ) return rc; + aVarint[(i++)&0xf] = a[0]; + }while( (a[0]&0x80)!=0 ); + sqlite3GetVarint(aVarint, pnOut); + } + } + + return SQLITE_OK; +} + +/* +** Attempt to memory map file pFile. If successful, set *pp to point to the +** new mapping and return SQLITE_OK. If the mapping is not attempted +** (because the file is too large or the VFS layer is configured not to use +** mmap), return SQLITE_OK and set *pp to NULL. +** +** Or, if an error occurs, return an SQLite error code. The final value of +** *pp is undefined in this case. +*/ +static int vdbeSorterMapFile(SortSubtask *pTask, SorterFile *pFile, u8 **pp){ + int rc = SQLITE_OK; + if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){ + sqlite3_file *pFd = pFile->pFd; + if( pFd->pMethods->iVersion>=3 ){ + rc = sqlite3OsFetch(pFd, 0, (int)pFile->iEof, (void**)pp); + testcase( rc!=SQLITE_OK ); + } + } + return rc; +} + +/* +** Attach PmaReader pReadr to file pFile (if it is not already attached to +** that file) and seek it to offset iOff within the file. Return SQLITE_OK +** if successful, or an SQLite error code if an error occurs. +*/ +static int vdbePmaReaderSeek( + SortSubtask *pTask, /* Task context */ + PmaReader *pReadr, /* Reader whose cursor is to be moved */ + SorterFile *pFile, /* Sorter file to read from */ + i64 iOff /* Offset in pFile */ +){ + int rc = SQLITE_OK; + + assert( pReadr->pIncr==0 || pReadr->pIncr->bEof==0 ); + + if( sqlite3FaultSim(201) ) return SQLITE_IOERR_READ; + if( pReadr->aMap ){ + sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap); + pReadr->aMap = 0; + } + pReadr->iReadOff = iOff; + pReadr->iEof = pFile->iEof; + pReadr->pFd = pFile->pFd; + + rc = vdbeSorterMapFile(pTask, pFile, &pReadr->aMap); + if( rc==SQLITE_OK && pReadr->aMap==0 ){ + int pgsz = pTask->pSorter->pgsz; + int iBuf = pReadr->iReadOff % pgsz; + if( pReadr->aBuffer==0 ){ + pReadr->aBuffer = (u8*)sqlite3Malloc(pgsz); + if( pReadr->aBuffer==0 ) rc = SQLITE_NOMEM; + pReadr->nBuffer = pgsz; + } + if( rc==SQLITE_OK && iBuf ){ + int nRead = pgsz - iBuf; + if( (pReadr->iReadOff + nRead) > pReadr->iEof ){ + nRead = (int)(pReadr->iEof - pReadr->iReadOff); + } + rc = sqlite3OsRead( + pReadr->pFd, &pReadr->aBuffer[iBuf], nRead, pReadr->iReadOff + ); + testcase( rc!=SQLITE_OK ); + } + } + + return rc; +} + +/* +** Advance PmaReader pReadr to the next key in its PMA. Return SQLITE_OK if +** no error occurs, or an SQLite error code if one does. +*/ +static int vdbePmaReaderNext(PmaReader *pReadr){ + int rc = SQLITE_OK; /* Return Code */ + u64 nRec = 0; /* Size of record in bytes */ + + + if( pReadr->iReadOff>=pReadr->iEof ){ + IncrMerger *pIncr = pReadr->pIncr; + int bEof = 1; + if( pIncr ){ + rc = vdbeIncrSwap(pIncr); + if( rc==SQLITE_OK && pIncr->bEof==0 ){ + rc = vdbePmaReaderSeek( + pIncr->pTask, pReadr, &pIncr->aFile[0], pIncr->iStartOff + ); + bEof = 0; + } + } + + if( bEof ){ + /* This is an EOF condition */ + vdbePmaReaderClear(pReadr); + testcase( rc!=SQLITE_OK ); + return rc; + } + } + + if( rc==SQLITE_OK ){ + rc = vdbePmaReadVarint(pReadr, &nRec); + } + if( rc==SQLITE_OK ){ + pReadr->nKey = (int)nRec; + rc = vdbePmaReadBlob(pReadr, (int)nRec, &pReadr->aKey); + testcase( rc!=SQLITE_OK ); + } + + return rc; +} + +/* +** Initialize PmaReader pReadr to scan through the PMA stored in file pFile +** starting at offset iStart and ending at offset iEof-1. This function +** leaves the PmaReader pointing to the first key in the PMA (or EOF if the +** PMA is empty). +** +** If the pnByte parameter is NULL, then it is assumed that the file +** contains a single PMA, and that that PMA omits the initial length varint. +*/ +static int vdbePmaReaderInit( + SortSubtask *pTask, /* Task context */ + SorterFile *pFile, /* Sorter file to read from */ + i64 iStart, /* Start offset in pFile */ + PmaReader *pReadr, /* PmaReader to populate */ + i64 *pnByte /* IN/OUT: Increment this value by PMA size */ +){ + int rc; + + assert( pFile->iEof>iStart ); + assert( pReadr->aAlloc==0 && pReadr->nAlloc==0 ); + assert( pReadr->aBuffer==0 ); + assert( pReadr->aMap==0 ); + + rc = vdbePmaReaderSeek(pTask, pReadr, pFile, iStart); + if( rc==SQLITE_OK ){ + u64 nByte; /* Size of PMA in bytes */ + rc = vdbePmaReadVarint(pReadr, &nByte); + pReadr->iEof = pReadr->iReadOff + nByte; + *pnByte += nByte; + } + + if( rc==SQLITE_OK ){ + rc = vdbePmaReaderNext(pReadr); + } + return rc; +} + +/* +** A version of vdbeSorterCompare() that assumes that it has already been +** determined that the first field of key1 is equal to the first field of +** key2. +*/ +static int vdbeSorterCompareTail( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + UnpackedRecord *r2 = pTask->pUnpacked; + if( *pbKey2Cached==0 ){ + sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2); + *pbKey2Cached = 1; + } + return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, r2, 1); +} + +/* +** Compare key1 (buffer pKey1, size nKey1 bytes) with key2 (buffer pKey2, +** size nKey2 bytes). Use (pTask->pKeyInfo) for the collation sequences +** used by the comparison. Return the result of the comparison. +** +** If IN/OUT parameter *pbKey2Cached is true when this function is called, +** it is assumed that (pTask->pUnpacked) contains the unpacked version +** of key2. If it is false, (pTask->pUnpacked) is populated with the unpacked +** version of key2 and *pbKey2Cached set to true before returning. +** +** If an OOM error is encountered, (pTask->pUnpacked->error_rc) is set +** to SQLITE_NOMEM. +*/ +static int vdbeSorterCompare( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + UnpackedRecord *r2 = pTask->pUnpacked; + if( !*pbKey2Cached ){ + sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2); + *pbKey2Cached = 1; + } + return sqlite3VdbeRecordCompare(nKey1, pKey1, r2); +} + +/* +** A specially optimized version of vdbeSorterCompare() that assumes that +** the first field of each key is a TEXT value and that the collation +** sequence to compare them with is BINARY. +*/ +static int vdbeSorterCompareText( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + const u8 * const p1 = (const u8 * const)pKey1; + const u8 * const p2 = (const u8 * const)pKey2; + const u8 * const v1 = &p1[ p1[0] ]; /* Pointer to value 1 */ + const u8 * const v2 = &p2[ p2[0] ]; /* Pointer to value 2 */ + + int n1; + int n2; + int res; + + getVarint32(&p1[1], n1); n1 = (n1 - 13) / 2; + getVarint32(&p2[1], n2); n2 = (n2 - 13) / 2; + res = memcmp(v1, v2, MIN(n1, n2)); + if( res==0 ){ + res = n1 - n2; + } + + if( res==0 ){ + if( pTask->pSorter->pKeyInfo->nField>1 ){ + res = vdbeSorterCompareTail( + pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2 + ); + } + }else{ + if( pTask->pSorter->pKeyInfo->aSortOrder[0] ){ + res = res * -1; + } + } + + return res; +} + +/* +** A specially optimized version of vdbeSorterCompare() that assumes that +** the first field of each key is an INTEGER value. +*/ +static int vdbeSorterCompareInt( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + const u8 * const p1 = (const u8 * const)pKey1; + const u8 * const p2 = (const u8 * const)pKey2; + const int s1 = p1[1]; /* Left hand serial type */ + const int s2 = p2[1]; /* Right hand serial type */ + const u8 * const v1 = &p1[ p1[0] ]; /* Pointer to value 1 */ + const u8 * const v2 = &p2[ p2[0] ]; /* Pointer to value 2 */ + int res; /* Return value */ + + assert( (s1>0 && s1<7) || s1==8 || s1==9 ); + assert( (s2>0 && s2<7) || s2==8 || s2==9 ); + + if( s1>7 && s2>7 ){ + res = s1 - s2; + }else{ + if( s1==s2 ){ + if( (*v1 ^ *v2) & 0x80 ){ + /* The two values have different signs */ + res = (*v1 & 0x80) ? -1 : +1; + }else{ + /* The two values have the same sign. Compare using memcmp(). */ + static const u8 aLen[] = {0, 1, 2, 3, 4, 6, 8 }; + int i; + res = 0; + for(i=0; i7 ){ + res = +1; + }else if( s1>7 ){ + res = -1; + }else{ + res = s1 - s2; + } + assert( res!=0 ); + + if( res>0 ){ + if( *v1 & 0x80 ) res = -1; + }else{ + if( *v2 & 0x80 ) res = +1; + } + } + } + + if( res==0 ){ + if( pTask->pSorter->pKeyInfo->nField>1 ){ + res = vdbeSorterCompareTail( + pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2 + ); + } + }else if( pTask->pSorter->pKeyInfo->aSortOrder[0] ){ + res = res * -1; + } + + return res; +} + +/* +** Initialize the temporary index cursor just opened as a sorter cursor. +** +** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nField) +** to determine the number of fields that should be compared from the +** records being sorted. However, if the value passed as argument nField +** is non-zero and the sorter is able to guarantee a stable sort, nField +** is used instead. This is used when sorting records for a CREATE INDEX +** statement. In this case, keys are always delivered to the sorter in +** order of the primary key, which happens to be make up the final part +** of the records being sorted. So if the sort is stable, there is never +** any reason to compare PK fields and they can be ignored for a small +** performance boost. +** +** The sorter can guarantee a stable sort when running in single-threaded +** mode, but not in multi-threaded mode. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterInit( + sqlite3 *db, /* Database connection (for malloc()) */ + int nField, /* Number of key fields in each record */ + VdbeCursor *pCsr /* Cursor that holds the new sorter */ +){ + int pgsz; /* Page size of main database */ + int i; /* Used to iterate through aTask[] */ + int mxCache; /* Cache size */ + VdbeSorter *pSorter; /* The new sorter */ + KeyInfo *pKeyInfo; /* Copy of pCsr->pKeyInfo with db==0 */ + int szKeyInfo; /* Size of pCsr->pKeyInfo in bytes */ + int sz; /* Size of pSorter in bytes */ + int rc = SQLITE_OK; +#if SQLITE_MAX_WORKER_THREADS==0 +# define nWorker 0 +#else + int nWorker; +#endif + + /* Initialize the upper limit on the number of worker threads */ +#if SQLITE_MAX_WORKER_THREADS>0 + if( sqlite3TempInMemory(db) || sqlite3GlobalConfig.bCoreMutex==0 ){ + nWorker = 0; + }else{ + nWorker = db->aLimit[SQLITE_LIMIT_WORKER_THREADS]; + } +#endif + + /* Do not allow the total number of threads (main thread + all workers) + ** to exceed the maximum merge count */ +#if SQLITE_MAX_WORKER_THREADS>=SORTER_MAX_MERGE_COUNT + if( nWorker>=SORTER_MAX_MERGE_COUNT ){ + nWorker = SORTER_MAX_MERGE_COUNT-1; + } +#endif + + assert( pCsr->pKeyInfo && pCsr->pBt==0 ); + szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nField-1)*sizeof(CollSeq*); + sz = sizeof(VdbeSorter) + nWorker * sizeof(SortSubtask); + + pSorter = (VdbeSorter*)sqlite3DbMallocZero(db, sz + szKeyInfo); + pCsr->pSorter = pSorter; + if( pSorter==0 ){ + rc = SQLITE_NOMEM; + }else{ + pSorter->pKeyInfo = pKeyInfo = (KeyInfo*)((u8*)pSorter + sz); + memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo); + pKeyInfo->db = 0; + if( nField && nWorker==0 ){ + pKeyInfo->nXField += (pKeyInfo->nField - nField); + pKeyInfo->nField = nField; + } + pSorter->pgsz = pgsz = sqlite3BtreeGetPageSize(db->aDb[0].pBt); + pSorter->nTask = nWorker + 1; + pSorter->iPrev = nWorker-1; + pSorter->bUseThreads = (pSorter->nTask>1); + pSorter->db = db; + for(i=0; inTask; i++){ + SortSubtask *pTask = &pSorter->aTask[i]; + pTask->pSorter = pSorter; + } + + if( !sqlite3TempInMemory(db) ){ + u32 szPma = sqlite3GlobalConfig.szPma; + pSorter->mnPmaSize = szPma * pgsz; + mxCache = db->aDb[0].pSchema->cache_size; + if( mxCache<(int)szPma ) mxCache = (int)szPma; + pSorter->mxPmaSize = MIN((i64)mxCache*pgsz, SQLITE_MAX_PMASZ); + + /* EVIDENCE-OF: R-26747-61719 When the application provides any amount of + ** scratch memory using SQLITE_CONFIG_SCRATCH, SQLite avoids unnecessary + ** large heap allocations. + */ + if( sqlite3GlobalConfig.pScratch==0 ){ + assert( pSorter->iMemory==0 ); + pSorter->nMemory = pgsz; + pSorter->list.aMemory = (u8*)sqlite3Malloc(pgsz); + if( !pSorter->list.aMemory ) rc = SQLITE_NOMEM; + } + } + + if( (pKeyInfo->nField+pKeyInfo->nXField)<13 + && (pKeyInfo->aColl[0]==0 || pKeyInfo->aColl[0]==db->pDfltColl) + ){ + pSorter->typeMask = SORTER_TYPE_INTEGER | SORTER_TYPE_TEXT; + } + } + + return rc; +} +#undef nWorker /* Defined at the top of this function */ + +/* +** Free the list of sorted records starting at pRecord. +*/ +static void vdbeSorterRecordFree(sqlite3 *db, SorterRecord *pRecord){ + SorterRecord *p; + SorterRecord *pNext; + for(p=pRecord; p; p=pNext){ + pNext = p->u.pNext; + sqlite3DbFree(db, p); + } +} + +/* +** Free all resources owned by the object indicated by argument pTask. All +** fields of *pTask are zeroed before returning. +*/ +static void vdbeSortSubtaskCleanup(sqlite3 *db, SortSubtask *pTask){ + sqlite3DbFree(db, pTask->pUnpacked); +#if SQLITE_MAX_WORKER_THREADS>0 + /* pTask->list.aMemory can only be non-zero if it was handed memory + ** from the main thread. That only occurs SQLITE_MAX_WORKER_THREADS>0 */ + if( pTask->list.aMemory ){ + sqlite3_free(pTask->list.aMemory); + }else +#endif + { + assert( pTask->list.aMemory==0 ); + vdbeSorterRecordFree(0, pTask->list.pList); + } + if( pTask->file.pFd ){ + sqlite3OsCloseFree(pTask->file.pFd); + } + if( pTask->file2.pFd ){ + sqlite3OsCloseFree(pTask->file2.pFd); + } + memset(pTask, 0, sizeof(SortSubtask)); +} + +#ifdef SQLITE_DEBUG_SORTER_THREADS +static void vdbeSorterWorkDebug(SortSubtask *pTask, const char *zEvent){ + i64 t; + int iTask = (pTask - pTask->pSorter->aTask); + sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t); + fprintf(stderr, "%lld:%d %s\n", t, iTask, zEvent); +} +static void vdbeSorterRewindDebug(const char *zEvent){ + i64 t; + sqlite3OsCurrentTimeInt64(sqlite3_vfs_find(0), &t); + fprintf(stderr, "%lld:X %s\n", t, zEvent); +} +static void vdbeSorterPopulateDebug( + SortSubtask *pTask, + const char *zEvent +){ + i64 t; + int iTask = (pTask - pTask->pSorter->aTask); + sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t); + fprintf(stderr, "%lld:bg%d %s\n", t, iTask, zEvent); +} +static void vdbeSorterBlockDebug( + SortSubtask *pTask, + int bBlocked, + const char *zEvent +){ + if( bBlocked ){ + i64 t; + sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t); + fprintf(stderr, "%lld:main %s\n", t, zEvent); + } +} +#else +# define vdbeSorterWorkDebug(x,y) +# define vdbeSorterRewindDebug(y) +# define vdbeSorterPopulateDebug(x,y) +# define vdbeSorterBlockDebug(x,y,z) +#endif + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** Join thread pTask->thread. +*/ +static int vdbeSorterJoinThread(SortSubtask *pTask){ + int rc = SQLITE_OK; + if( pTask->pThread ){ +#ifdef SQLITE_DEBUG_SORTER_THREADS + int bDone = pTask->bDone; +#endif + void *pRet = SQLITE_INT_TO_PTR(SQLITE_ERROR); + vdbeSorterBlockDebug(pTask, !bDone, "enter"); + (void)sqlite3ThreadJoin(pTask->pThread, &pRet); + vdbeSorterBlockDebug(pTask, !bDone, "exit"); + rc = SQLITE_PTR_TO_INT(pRet); + assert( pTask->bDone==1 ); + pTask->bDone = 0; + pTask->pThread = 0; + } + return rc; +} + +/* +** Launch a background thread to run xTask(pIn). +*/ +static int vdbeSorterCreateThread( + SortSubtask *pTask, /* Thread will use this task object */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + assert( pTask->pThread==0 && pTask->bDone==0 ); + return sqlite3ThreadCreate(&pTask->pThread, xTask, pIn); +} + +/* +** Join all outstanding threads launched by SorterWrite() to create +** level-0 PMAs. +*/ +static int vdbeSorterJoinAll(VdbeSorter *pSorter, int rcin){ + int rc = rcin; + int i; + + /* This function is always called by the main user thread. + ** + ** If this function is being called after SorterRewind() has been called, + ** it is possible that thread pSorter->aTask[pSorter->nTask-1].pThread + ** is currently attempt to join one of the other threads. To avoid a race + ** condition where this thread also attempts to join the same object, join + ** thread pSorter->aTask[pSorter->nTask-1].pThread first. */ + for(i=pSorter->nTask-1; i>=0; i--){ + SortSubtask *pTask = &pSorter->aTask[i]; + int rc2 = vdbeSorterJoinThread(pTask); + if( rc==SQLITE_OK ) rc = rc2; + } + return rc; +} +#else +# define vdbeSorterJoinAll(x,rcin) (rcin) +# define vdbeSorterJoinThread(pTask) SQLITE_OK +#endif + +/* +** Allocate a new MergeEngine object capable of handling up to +** nReader PmaReader inputs. +** +** nReader is automatically rounded up to the next power of two. +** nReader may not exceed SORTER_MAX_MERGE_COUNT even after rounding up. +*/ +static MergeEngine *vdbeMergeEngineNew(int nReader){ + int N = 2; /* Smallest power of two >= nReader */ + int nByte; /* Total bytes of space to allocate */ + MergeEngine *pNew; /* Pointer to allocated object to return */ + + assert( nReader<=SORTER_MAX_MERGE_COUNT ); + + while( NnTree = N; + pNew->pTask = 0; + pNew->aReadr = (PmaReader*)&pNew[1]; + pNew->aTree = (int*)&pNew->aReadr[N]; + } + return pNew; +} + +/* +** Free the MergeEngine object passed as the only argument. +*/ +static void vdbeMergeEngineFree(MergeEngine *pMerger){ + int i; + if( pMerger ){ + for(i=0; inTree; i++){ + vdbePmaReaderClear(&pMerger->aReadr[i]); + } + } + sqlite3_free(pMerger); +} + +/* +** Free all resources associated with the IncrMerger object indicated by +** the first argument. +*/ +static void vdbeIncrFree(IncrMerger *pIncr){ + if( pIncr ){ +#if SQLITE_MAX_WORKER_THREADS>0 + if( pIncr->bUseThread ){ + vdbeSorterJoinThread(pIncr->pTask); + if( pIncr->aFile[0].pFd ) sqlite3OsCloseFree(pIncr->aFile[0].pFd); + if( pIncr->aFile[1].pFd ) sqlite3OsCloseFree(pIncr->aFile[1].pFd); + } +#endif + vdbeMergeEngineFree(pIncr->pMerger); + sqlite3_free(pIncr); + } +} + +/* +** Reset a sorting cursor back to its original empty state. +*/ +SQLITE_PRIVATE void sqlite3VdbeSorterReset(sqlite3 *db, VdbeSorter *pSorter){ + int i; + (void)vdbeSorterJoinAll(pSorter, SQLITE_OK); + assert( pSorter->bUseThreads || pSorter->pReader==0 ); +#if SQLITE_MAX_WORKER_THREADS>0 + if( pSorter->pReader ){ + vdbePmaReaderClear(pSorter->pReader); + sqlite3DbFree(db, pSorter->pReader); + pSorter->pReader = 0; + } +#endif + vdbeMergeEngineFree(pSorter->pMerger); + pSorter->pMerger = 0; + for(i=0; inTask; i++){ + SortSubtask *pTask = &pSorter->aTask[i]; + vdbeSortSubtaskCleanup(db, pTask); + pTask->pSorter = pSorter; + } + if( pSorter->list.aMemory==0 ){ + vdbeSorterRecordFree(0, pSorter->list.pList); + } + pSorter->list.pList = 0; + pSorter->list.szPMA = 0; + pSorter->bUsePMA = 0; + pSorter->iMemory = 0; + pSorter->mxKeysize = 0; + sqlite3DbFree(db, pSorter->pUnpacked); + pSorter->pUnpacked = 0; +} + +/* +** Free any cursor components allocated by sqlite3VdbeSorterXXX routines. +*/ +SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *db, VdbeCursor *pCsr){ + VdbeSorter *pSorter = pCsr->pSorter; + if( pSorter ){ + sqlite3VdbeSorterReset(db, pSorter); + sqlite3_free(pSorter->list.aMemory); + sqlite3DbFree(db, pSorter); + pCsr->pSorter = 0; + } +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** The first argument is a file-handle open on a temporary file. The file +** is guaranteed to be nByte bytes or smaller in size. This function +** attempts to extend the file to nByte bytes in size and to ensure that +** the VFS has memory mapped it. +** +** Whether or not the file does end up memory mapped of course depends on +** the specific VFS implementation. +*/ +static void vdbeSorterExtendFile(sqlite3 *db, sqlite3_file *pFd, i64 nByte){ + if( nByte<=(i64)(db->nMaxSorterMmap) && pFd->pMethods->iVersion>=3 ){ + void *p = 0; + int chunksize = 4*1024; + sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_CHUNK_SIZE, &chunksize); + sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_SIZE_HINT, &nByte); + sqlite3OsFetch(pFd, 0, (int)nByte, &p); + sqlite3OsUnfetch(pFd, 0, p); + } +} +#else +# define vdbeSorterExtendFile(x,y,z) +#endif + +/* +** Allocate space for a file-handle and open a temporary file. If successful, +** set *ppFd to point to the malloc'd file-handle and return SQLITE_OK. +** Otherwise, set *ppFd to 0 and return an SQLite error code. +*/ +static int vdbeSorterOpenTempFile( + sqlite3 *db, /* Database handle doing sort */ + i64 nExtend, /* Attempt to extend file to this size */ + sqlite3_file **ppFd +){ + int rc; + if( sqlite3FaultSim(202) ) return SQLITE_IOERR_ACCESS; + rc = sqlite3OsOpenMalloc(db->pVfs, 0, ppFd, + SQLITE_OPEN_TEMP_JOURNAL | + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE, &rc + ); + if( rc==SQLITE_OK ){ + i64 max = SQLITE_MAX_MMAP_SIZE; + sqlite3OsFileControlHint(*ppFd, SQLITE_FCNTL_MMAP_SIZE, (void*)&max); + if( nExtend>0 ){ + vdbeSorterExtendFile(db, *ppFd, nExtend); + } + } + return rc; +} + +/* +** If it has not already been allocated, allocate the UnpackedRecord +** structure at pTask->pUnpacked. Return SQLITE_OK if successful (or +** if no allocation was required), or SQLITE_NOMEM otherwise. +*/ +static int vdbeSortAllocUnpacked(SortSubtask *pTask){ + if( pTask->pUnpacked==0 ){ + char *pFree; + pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord( + pTask->pSorter->pKeyInfo, 0, 0, &pFree + ); + assert( pTask->pUnpacked==(UnpackedRecord*)pFree ); + if( pFree==0 ) return SQLITE_NOMEM; + pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nField; + pTask->pUnpacked->errCode = 0; + } + return SQLITE_OK; +} + + +/* +** Merge the two sorted lists p1 and p2 into a single list. +** Set *ppOut to the head of the new list. +*/ +static void vdbeSorterMerge( + SortSubtask *pTask, /* Calling thread context */ + SorterRecord *p1, /* First list to merge */ + SorterRecord *p2, /* Second list to merge */ + SorterRecord **ppOut /* OUT: Head of merged list */ +){ + SorterRecord *pFinal = 0; + SorterRecord **pp = &pFinal; + int bCached = 0; + + while( p1 && p2 ){ + int res; + res = pTask->xCompare( + pTask, &bCached, SRVAL(p1), p1->nVal, SRVAL(p2), p2->nVal + ); + + if( res<=0 ){ + *pp = p1; + pp = &p1->u.pNext; + p1 = p1->u.pNext; + }else{ + *pp = p2; + pp = &p2->u.pNext; + p2 = p2->u.pNext; + bCached = 0; + } + } + *pp = p1 ? p1 : p2; + *ppOut = pFinal; +} + +/* +** Return the SorterCompare function to compare values collected by the +** sorter object passed as the only argument. +*/ +static SorterCompare vdbeSorterGetCompare(VdbeSorter *p){ + if( p->typeMask==SORTER_TYPE_INTEGER ){ + return vdbeSorterCompareInt; + }else if( p->typeMask==SORTER_TYPE_TEXT ){ + return vdbeSorterCompareText; + } + return vdbeSorterCompare; +} + +/* +** Sort the linked list of records headed at pTask->pList. Return +** SQLITE_OK if successful, or an SQLite error code (i.e. SQLITE_NOMEM) if +** an error occurs. +*/ +static int vdbeSorterSort(SortSubtask *pTask, SorterList *pList){ + int i; + SorterRecord **aSlot; + SorterRecord *p; + int rc; + + rc = vdbeSortAllocUnpacked(pTask); + if( rc!=SQLITE_OK ) return rc; + + p = pList->pList; + pTask->xCompare = vdbeSorterGetCompare(pTask->pSorter); + + aSlot = (SorterRecord **)sqlite3MallocZero(64 * sizeof(SorterRecord *)); + if( !aSlot ){ + return SQLITE_NOMEM; + } + + while( p ){ + SorterRecord *pNext; + if( pList->aMemory ){ + if( (u8*)p==pList->aMemory ){ + pNext = 0; + }else{ + assert( p->u.iNextaMemory) ); + pNext = (SorterRecord*)&pList->aMemory[p->u.iNext]; + } + }else{ + pNext = p->u.pNext; + } + + p->u.pNext = 0; + for(i=0; aSlot[i]; i++){ + vdbeSorterMerge(pTask, p, aSlot[i], &p); + aSlot[i] = 0; + } + aSlot[i] = p; + p = pNext; + } + + p = 0; + for(i=0; i<64; i++){ + vdbeSorterMerge(pTask, p, aSlot[i], &p); + } + pList->pList = p; + + sqlite3_free(aSlot); + assert( pTask->pUnpacked->errCode==SQLITE_OK + || pTask->pUnpacked->errCode==SQLITE_NOMEM + ); + return pTask->pUnpacked->errCode; +} + +/* +** Initialize a PMA-writer object. +*/ +static void vdbePmaWriterInit( + sqlite3_file *pFd, /* File handle to write to */ + PmaWriter *p, /* Object to populate */ + int nBuf, /* Buffer size */ + i64 iStart /* Offset of pFd to begin writing at */ +){ + memset(p, 0, sizeof(PmaWriter)); + p->aBuffer = (u8*)sqlite3Malloc(nBuf); + if( !p->aBuffer ){ + p->eFWErr = SQLITE_NOMEM; + }else{ + p->iBufEnd = p->iBufStart = (iStart % nBuf); + p->iWriteOff = iStart - p->iBufStart; + p->nBuffer = nBuf; + p->pFd = pFd; + } +} + +/* +** Write nData bytes of data to the PMA. Return SQLITE_OK +** if successful, or an SQLite error code if an error occurs. +*/ +static void vdbePmaWriteBlob(PmaWriter *p, u8 *pData, int nData){ + int nRem = nData; + while( nRem>0 && p->eFWErr==0 ){ + int nCopy = nRem; + if( nCopy>(p->nBuffer - p->iBufEnd) ){ + nCopy = p->nBuffer - p->iBufEnd; + } + + memcpy(&p->aBuffer[p->iBufEnd], &pData[nData-nRem], nCopy); + p->iBufEnd += nCopy; + if( p->iBufEnd==p->nBuffer ){ + p->eFWErr = sqlite3OsWrite(p->pFd, + &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart, + p->iWriteOff + p->iBufStart + ); + p->iBufStart = p->iBufEnd = 0; + p->iWriteOff += p->nBuffer; + } + assert( p->iBufEndnBuffer ); + + nRem -= nCopy; + } +} + +/* +** Flush any buffered data to disk and clean up the PMA-writer object. +** The results of using the PMA-writer after this call are undefined. +** Return SQLITE_OK if flushing the buffered data succeeds or is not +** required. Otherwise, return an SQLite error code. +** +** Before returning, set *piEof to the offset immediately following the +** last byte written to the file. +*/ +static int vdbePmaWriterFinish(PmaWriter *p, i64 *piEof){ + int rc; + if( p->eFWErr==0 && ALWAYS(p->aBuffer) && p->iBufEnd>p->iBufStart ){ + p->eFWErr = sqlite3OsWrite(p->pFd, + &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart, + p->iWriteOff + p->iBufStart + ); + } + *piEof = (p->iWriteOff + p->iBufEnd); + sqlite3_free(p->aBuffer); + rc = p->eFWErr; + memset(p, 0, sizeof(PmaWriter)); + return rc; +} + +/* +** Write value iVal encoded as a varint to the PMA. Return +** SQLITE_OK if successful, or an SQLite error code if an error occurs. +*/ +static void vdbePmaWriteVarint(PmaWriter *p, u64 iVal){ + int nByte; + u8 aByte[10]; + nByte = sqlite3PutVarint(aByte, iVal); + vdbePmaWriteBlob(p, aByte, nByte); +} + +/* +** Write the current contents of in-memory linked-list pList to a level-0 +** PMA in the temp file belonging to sub-task pTask. Return SQLITE_OK if +** successful, or an SQLite error code otherwise. +** +** The format of a PMA is: +** +** * A varint. This varint contains the total number of bytes of content +** in the PMA (not including the varint itself). +** +** * One or more records packed end-to-end in order of ascending keys. +** Each record consists of a varint followed by a blob of data (the +** key). The varint is the number of bytes in the blob of data. +*/ +static int vdbeSorterListToPMA(SortSubtask *pTask, SorterList *pList){ + sqlite3 *db = pTask->pSorter->db; + int rc = SQLITE_OK; /* Return code */ + PmaWriter writer; /* Object used to write to the file */ + +#ifdef SQLITE_DEBUG + /* Set iSz to the expected size of file pTask->file after writing the PMA. + ** This is used by an assert() statement at the end of this function. */ + i64 iSz = pList->szPMA + sqlite3VarintLen(pList->szPMA) + pTask->file.iEof; +#endif + + vdbeSorterWorkDebug(pTask, "enter"); + memset(&writer, 0, sizeof(PmaWriter)); + assert( pList->szPMA>0 ); + + /* If the first temporary PMA file has not been opened, open it now. */ + if( pTask->file.pFd==0 ){ + rc = vdbeSorterOpenTempFile(db, 0, &pTask->file.pFd); + assert( rc!=SQLITE_OK || pTask->file.pFd ); + assert( pTask->file.iEof==0 ); + assert( pTask->nPMA==0 ); + } + + /* Try to get the file to memory map */ + if( rc==SQLITE_OK ){ + vdbeSorterExtendFile(db, pTask->file.pFd, pTask->file.iEof+pList->szPMA+9); + } + + /* Sort the list */ + if( rc==SQLITE_OK ){ + rc = vdbeSorterSort(pTask, pList); + } + + if( rc==SQLITE_OK ){ + SorterRecord *p; + SorterRecord *pNext = 0; + + vdbePmaWriterInit(pTask->file.pFd, &writer, pTask->pSorter->pgsz, + pTask->file.iEof); + pTask->nPMA++; + vdbePmaWriteVarint(&writer, pList->szPMA); + for(p=pList->pList; p; p=pNext){ + pNext = p->u.pNext; + vdbePmaWriteVarint(&writer, p->nVal); + vdbePmaWriteBlob(&writer, SRVAL(p), p->nVal); + if( pList->aMemory==0 ) sqlite3_free(p); + } + pList->pList = p; + rc = vdbePmaWriterFinish(&writer, &pTask->file.iEof); + } + + vdbeSorterWorkDebug(pTask, "exit"); + assert( rc!=SQLITE_OK || pList->pList==0 ); + assert( rc!=SQLITE_OK || pTask->file.iEof==iSz ); + return rc; +} + +/* +** Advance the MergeEngine to its next entry. +** Set *pbEof to true there is no next entry because +** the MergeEngine has reached the end of all its inputs. +** +** Return SQLITE_OK if successful or an error code if an error occurs. +*/ +static int vdbeMergeEngineStep( + MergeEngine *pMerger, /* The merge engine to advance to the next row */ + int *pbEof /* Set TRUE at EOF. Set false for more content */ +){ + int rc; + int iPrev = pMerger->aTree[1];/* Index of PmaReader to advance */ + SortSubtask *pTask = pMerger->pTask; + + /* Advance the current PmaReader */ + rc = vdbePmaReaderNext(&pMerger->aReadr[iPrev]); + + /* Update contents of aTree[] */ + if( rc==SQLITE_OK ){ + int i; /* Index of aTree[] to recalculate */ + PmaReader *pReadr1; /* First PmaReader to compare */ + PmaReader *pReadr2; /* Second PmaReader to compare */ + int bCached = 0; + + /* Find the first two PmaReaders to compare. The one that was just + ** advanced (iPrev) and the one next to it in the array. */ + pReadr1 = &pMerger->aReadr[(iPrev & 0xFFFE)]; + pReadr2 = &pMerger->aReadr[(iPrev | 0x0001)]; + + for(i=(pMerger->nTree+iPrev)/2; i>0; i=i/2){ + /* Compare pReadr1 and pReadr2. Store the result in variable iRes. */ + int iRes; + if( pReadr1->pFd==0 ){ + iRes = +1; + }else if( pReadr2->pFd==0 ){ + iRes = -1; + }else{ + iRes = pTask->xCompare(pTask, &bCached, + pReadr1->aKey, pReadr1->nKey, pReadr2->aKey, pReadr2->nKey + ); + } + + /* If pReadr1 contained the smaller value, set aTree[i] to its index. + ** Then set pReadr2 to the next PmaReader to compare to pReadr1. In this + ** case there is no cache of pReadr2 in pTask->pUnpacked, so set + ** pKey2 to point to the record belonging to pReadr2. + ** + ** Alternatively, if pReadr2 contains the smaller of the two values, + ** set aTree[i] to its index and update pReadr1. If vdbeSorterCompare() + ** was actually called above, then pTask->pUnpacked now contains + ** a value equivalent to pReadr2. So set pKey2 to NULL to prevent + ** vdbeSorterCompare() from decoding pReadr2 again. + ** + ** If the two values were equal, then the value from the oldest + ** PMA should be considered smaller. The VdbeSorter.aReadr[] array + ** is sorted from oldest to newest, so pReadr1 contains older values + ** than pReadr2 iff (pReadr1aTree[i] = (int)(pReadr1 - pMerger->aReadr); + pReadr2 = &pMerger->aReadr[ pMerger->aTree[i ^ 0x0001] ]; + bCached = 0; + }else{ + if( pReadr1->pFd ) bCached = 0; + pMerger->aTree[i] = (int)(pReadr2 - pMerger->aReadr); + pReadr1 = &pMerger->aReadr[ pMerger->aTree[i ^ 0x0001] ]; + } + } + *pbEof = (pMerger->aReadr[pMerger->aTree[1]].pFd==0); + } + + return (rc==SQLITE_OK ? pTask->pUnpacked->errCode : rc); +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** The main routine for background threads that write level-0 PMAs. +*/ +static void *vdbeSorterFlushThread(void *pCtx){ + SortSubtask *pTask = (SortSubtask*)pCtx; + int rc; /* Return code */ + assert( pTask->bDone==0 ); + rc = vdbeSorterListToPMA(pTask, &pTask->list); + pTask->bDone = 1; + return SQLITE_INT_TO_PTR(rc); +} +#endif /* SQLITE_MAX_WORKER_THREADS>0 */ + +/* +** Flush the current contents of VdbeSorter.list to a new PMA, possibly +** using a background thread. +*/ +static int vdbeSorterFlushPMA(VdbeSorter *pSorter){ +#if SQLITE_MAX_WORKER_THREADS==0 + pSorter->bUsePMA = 1; + return vdbeSorterListToPMA(&pSorter->aTask[0], &pSorter->list); +#else + int rc = SQLITE_OK; + int i; + SortSubtask *pTask = 0; /* Thread context used to create new PMA */ + int nWorker = (pSorter->nTask-1); + + /* Set the flag to indicate that at least one PMA has been written. + ** Or will be, anyhow. */ + pSorter->bUsePMA = 1; + + /* Select a sub-task to sort and flush the current list of in-memory + ** records to disk. If the sorter is running in multi-threaded mode, + ** round-robin between the first (pSorter->nTask-1) tasks. Except, if + ** the background thread from a sub-tasks previous turn is still running, + ** skip it. If the first (pSorter->nTask-1) sub-tasks are all still busy, + ** fall back to using the final sub-task. The first (pSorter->nTask-1) + ** sub-tasks are prefered as they use background threads - the final + ** sub-task uses the main thread. */ + for(i=0; iiPrev + i + 1) % nWorker; + pTask = &pSorter->aTask[iTest]; + if( pTask->bDone ){ + rc = vdbeSorterJoinThread(pTask); + } + if( rc!=SQLITE_OK || pTask->pThread==0 ) break; + } + + if( rc==SQLITE_OK ){ + if( i==nWorker ){ + /* Use the foreground thread for this operation */ + rc = vdbeSorterListToPMA(&pSorter->aTask[nWorker], &pSorter->list); + }else{ + /* Launch a background thread for this operation */ + u8 *aMem = pTask->list.aMemory; + void *pCtx = (void*)pTask; + + assert( pTask->pThread==0 && pTask->bDone==0 ); + assert( pTask->list.pList==0 ); + assert( pTask->list.aMemory==0 || pSorter->list.aMemory!=0 ); + + pSorter->iPrev = (u8)(pTask - pSorter->aTask); + pTask->list = pSorter->list; + pSorter->list.pList = 0; + pSorter->list.szPMA = 0; + if( aMem ){ + pSorter->list.aMemory = aMem; + pSorter->nMemory = sqlite3MallocSize(aMem); + }else if( pSorter->list.aMemory ){ + pSorter->list.aMemory = sqlite3Malloc(pSorter->nMemory); + if( !pSorter->list.aMemory ) return SQLITE_NOMEM; + } + + rc = vdbeSorterCreateThread(pTask, vdbeSorterFlushThread, pCtx); + } + } + + return rc; +#endif /* SQLITE_MAX_WORKER_THREADS!=0 */ +} + +/* +** Add a record to the sorter. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterWrite( + const VdbeCursor *pCsr, /* Sorter cursor */ + Mem *pVal /* Memory cell containing record */ +){ + VdbeSorter *pSorter = pCsr->pSorter; + int rc = SQLITE_OK; /* Return Code */ + SorterRecord *pNew; /* New list element */ + + int bFlush; /* True to flush contents of memory to PMA */ + int nReq; /* Bytes of memory required */ + int nPMA; /* Bytes of PMA space required */ + int t; /* serial type of first record field */ + + getVarint32((const u8*)&pVal->z[1], t); + if( t>0 && t<10 && t!=7 ){ + pSorter->typeMask &= SORTER_TYPE_INTEGER; + }else if( t>10 && (t & 0x01) ){ + pSorter->typeMask &= SORTER_TYPE_TEXT; + }else{ + pSorter->typeMask = 0; + } + + assert( pSorter ); + + /* Figure out whether or not the current contents of memory should be + ** flushed to a PMA before continuing. If so, do so. + ** + ** If using the single large allocation mode (pSorter->aMemory!=0), then + ** flush the contents of memory to a new PMA if (a) at least one value is + ** already in memory and (b) the new value will not fit in memory. + ** + ** Or, if using separate allocations for each record, flush the contents + ** of memory to a PMA if either of the following are true: + ** + ** * The total memory allocated for the in-memory list is greater + ** than (page-size * cache-size), or + ** + ** * The total memory allocated for the in-memory list is greater + ** than (page-size * 10) and sqlite3HeapNearlyFull() returns true. + */ + nReq = pVal->n + sizeof(SorterRecord); + nPMA = pVal->n + sqlite3VarintLen(pVal->n); + if( pSorter->mxPmaSize ){ + if( pSorter->list.aMemory ){ + bFlush = pSorter->iMemory && (pSorter->iMemory+nReq) > pSorter->mxPmaSize; + }else{ + bFlush = ( + (pSorter->list.szPMA > pSorter->mxPmaSize) + || (pSorter->list.szPMA > pSorter->mnPmaSize && sqlite3HeapNearlyFull()) + ); + } + if( bFlush ){ + rc = vdbeSorterFlushPMA(pSorter); + pSorter->list.szPMA = 0; + pSorter->iMemory = 0; + assert( rc!=SQLITE_OK || pSorter->list.pList==0 ); + } + } + + pSorter->list.szPMA += nPMA; + if( nPMA>pSorter->mxKeysize ){ + pSorter->mxKeysize = nPMA; + } + + if( pSorter->list.aMemory ){ + int nMin = pSorter->iMemory + nReq; + + if( nMin>pSorter->nMemory ){ + u8 *aNew; + int nNew = pSorter->nMemory * 2; + while( nNew < nMin ) nNew = nNew*2; + if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize; + if( nNew < nMin ) nNew = nMin; + + aNew = sqlite3Realloc(pSorter->list.aMemory, nNew); + if( !aNew ) return SQLITE_NOMEM; + pSorter->list.pList = (SorterRecord*)( + aNew + ((u8*)pSorter->list.pList - pSorter->list.aMemory) + ); + pSorter->list.aMemory = aNew; + pSorter->nMemory = nNew; + } + + pNew = (SorterRecord*)&pSorter->list.aMemory[pSorter->iMemory]; + pSorter->iMemory += ROUND8(nReq); + pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory); + }else{ + pNew = (SorterRecord *)sqlite3Malloc(nReq); + if( pNew==0 ){ + return SQLITE_NOMEM; + } + pNew->u.pNext = pSorter->list.pList; + } + + memcpy(SRVAL(pNew), pVal->z, pVal->n); + pNew->nVal = pVal->n; + pSorter->list.pList = pNew; + + return rc; +} + +/* +** Read keys from pIncr->pMerger and populate pIncr->aFile[1]. The format +** of the data stored in aFile[1] is the same as that used by regular PMAs, +** except that the number-of-bytes varint is omitted from the start. +*/ +static int vdbeIncrPopulate(IncrMerger *pIncr){ + int rc = SQLITE_OK; + int rc2; + i64 iStart = pIncr->iStartOff; + SorterFile *pOut = &pIncr->aFile[1]; + SortSubtask *pTask = pIncr->pTask; + MergeEngine *pMerger = pIncr->pMerger; + PmaWriter writer; + assert( pIncr->bEof==0 ); + + vdbeSorterPopulateDebug(pTask, "enter"); + + vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart); + while( rc==SQLITE_OK ){ + int dummy; + PmaReader *pReader = &pMerger->aReadr[ pMerger->aTree[1] ]; + int nKey = pReader->nKey; + i64 iEof = writer.iWriteOff + writer.iBufEnd; + + /* Check if the output file is full or if the input has been exhausted. + ** In either case exit the loop. */ + if( pReader->pFd==0 ) break; + if( (iEof + nKey + sqlite3VarintLen(nKey))>(iStart + pIncr->mxSz) ) break; + + /* Write the next key to the output. */ + vdbePmaWriteVarint(&writer, nKey); + vdbePmaWriteBlob(&writer, pReader->aKey, nKey); + assert( pIncr->pMerger->pTask==pTask ); + rc = vdbeMergeEngineStep(pIncr->pMerger, &dummy); + } + + rc2 = vdbePmaWriterFinish(&writer, &pOut->iEof); + if( rc==SQLITE_OK ) rc = rc2; + vdbeSorterPopulateDebug(pTask, "exit"); + return rc; +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** The main routine for background threads that populate aFile[1] of +** multi-threaded IncrMerger objects. +*/ +static void *vdbeIncrPopulateThread(void *pCtx){ + IncrMerger *pIncr = (IncrMerger*)pCtx; + void *pRet = SQLITE_INT_TO_PTR( vdbeIncrPopulate(pIncr) ); + pIncr->pTask->bDone = 1; + return pRet; +} + +/* +** Launch a background thread to populate aFile[1] of pIncr. +*/ +static int vdbeIncrBgPopulate(IncrMerger *pIncr){ + void *p = (void*)pIncr; + assert( pIncr->bUseThread ); + return vdbeSorterCreateThread(pIncr->pTask, vdbeIncrPopulateThread, p); +} +#endif + +/* +** This function is called when the PmaReader corresponding to pIncr has +** finished reading the contents of aFile[0]. Its purpose is to "refill" +** aFile[0] such that the PmaReader should start rereading it from the +** beginning. +** +** For single-threaded objects, this is accomplished by literally reading +** keys from pIncr->pMerger and repopulating aFile[0]. +** +** For multi-threaded objects, all that is required is to wait until the +** background thread is finished (if it is not already) and then swap +** aFile[0] and aFile[1] in place. If the contents of pMerger have not +** been exhausted, this function also launches a new background thread +** to populate the new aFile[1]. +** +** SQLITE_OK is returned on success, or an SQLite error code otherwise. +*/ +static int vdbeIncrSwap(IncrMerger *pIncr){ + int rc = SQLITE_OK; + +#if SQLITE_MAX_WORKER_THREADS>0 + if( pIncr->bUseThread ){ + rc = vdbeSorterJoinThread(pIncr->pTask); + + if( rc==SQLITE_OK ){ + SorterFile f0 = pIncr->aFile[0]; + pIncr->aFile[0] = pIncr->aFile[1]; + pIncr->aFile[1] = f0; + } + + if( rc==SQLITE_OK ){ + if( pIncr->aFile[0].iEof==pIncr->iStartOff ){ + pIncr->bEof = 1; + }else{ + rc = vdbeIncrBgPopulate(pIncr); + } + } + }else +#endif + { + rc = vdbeIncrPopulate(pIncr); + pIncr->aFile[0] = pIncr->aFile[1]; + if( pIncr->aFile[0].iEof==pIncr->iStartOff ){ + pIncr->bEof = 1; + } + } + + return rc; +} + +/* +** Allocate and return a new IncrMerger object to read data from pMerger. +** +** If an OOM condition is encountered, return NULL. In this case free the +** pMerger argument before returning. +*/ +static int vdbeIncrMergerNew( + SortSubtask *pTask, /* The thread that will be using the new IncrMerger */ + MergeEngine *pMerger, /* The MergeEngine that the IncrMerger will control */ + IncrMerger **ppOut /* Write the new IncrMerger here */ +){ + int rc = SQLITE_OK; + IncrMerger *pIncr = *ppOut = (IncrMerger*) + (sqlite3FaultSim(100) ? 0 : sqlite3MallocZero(sizeof(*pIncr))); + if( pIncr ){ + pIncr->pMerger = pMerger; + pIncr->pTask = pTask; + pIncr->mxSz = MAX(pTask->pSorter->mxKeysize+9,pTask->pSorter->mxPmaSize/2); + pTask->file2.iEof += pIncr->mxSz; + }else{ + vdbeMergeEngineFree(pMerger); + rc = SQLITE_NOMEM; + } + return rc; +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** Set the "use-threads" flag on object pIncr. +*/ +static void vdbeIncrMergerSetThreads(IncrMerger *pIncr){ + pIncr->bUseThread = 1; + pIncr->pTask->file2.iEof -= pIncr->mxSz; +} +#endif /* SQLITE_MAX_WORKER_THREADS>0 */ + + + +/* +** Recompute pMerger->aTree[iOut] by comparing the next keys on the +** two PmaReaders that feed that entry. Neither of the PmaReaders +** are advanced. This routine merely does the comparison. +*/ +static void vdbeMergeEngineCompare( + MergeEngine *pMerger, /* Merge engine containing PmaReaders to compare */ + int iOut /* Store the result in pMerger->aTree[iOut] */ +){ + int i1; + int i2; + int iRes; + PmaReader *p1; + PmaReader *p2; + + assert( iOutnTree && iOut>0 ); + + if( iOut>=(pMerger->nTree/2) ){ + i1 = (iOut - pMerger->nTree/2) * 2; + i2 = i1 + 1; + }else{ + i1 = pMerger->aTree[iOut*2]; + i2 = pMerger->aTree[iOut*2+1]; + } + + p1 = &pMerger->aReadr[i1]; + p2 = &pMerger->aReadr[i2]; + + if( p1->pFd==0 ){ + iRes = i2; + }else if( p2->pFd==0 ){ + iRes = i1; + }else{ + SortSubtask *pTask = pMerger->pTask; + int bCached = 0; + int res; + assert( pTask->pUnpacked!=0 ); /* from vdbeSortSubtaskMain() */ + res = pTask->xCompare( + pTask, &bCached, p1->aKey, p1->nKey, p2->aKey, p2->nKey + ); + if( res<=0 ){ + iRes = i1; + }else{ + iRes = i2; + } + } + + pMerger->aTree[iOut] = iRes; +} + +/* +** Allowed values for the eMode parameter to vdbeMergeEngineInit() +** and vdbePmaReaderIncrMergeInit(). +** +** Only INCRINIT_NORMAL is valid in single-threaded builds (when +** SQLITE_MAX_WORKER_THREADS==0). The other values are only used +** when there exists one or more separate worker threads. +*/ +#define INCRINIT_NORMAL 0 +#define INCRINIT_TASK 1 +#define INCRINIT_ROOT 2 + +/* +** Forward reference required as the vdbeIncrMergeInit() and +** vdbePmaReaderIncrInit() routines are called mutually recursively when +** building a merge tree. +*/ +static int vdbePmaReaderIncrInit(PmaReader *pReadr, int eMode); + +/* +** Initialize the MergeEngine object passed as the second argument. Once this +** function returns, the first key of merged data may be read from the +** MergeEngine object in the usual fashion. +** +** If argument eMode is INCRINIT_ROOT, then it is assumed that any IncrMerge +** objects attached to the PmaReader objects that the merger reads from have +** already been populated, but that they have not yet populated aFile[0] and +** set the PmaReader objects up to read from it. In this case all that is +** required is to call vdbePmaReaderNext() on each PmaReader to point it at +** its first key. +** +** Otherwise, if eMode is any value other than INCRINIT_ROOT, then use +** vdbePmaReaderIncrMergeInit() to initialize each PmaReader that feeds data +** to pMerger. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int vdbeMergeEngineInit( + SortSubtask *pTask, /* Thread that will run pMerger */ + MergeEngine *pMerger, /* MergeEngine to initialize */ + int eMode /* One of the INCRINIT_XXX constants */ +){ + int rc = SQLITE_OK; /* Return code */ + int i; /* For looping over PmaReader objects */ + int nTree = pMerger->nTree; + + /* eMode is always INCRINIT_NORMAL in single-threaded mode */ + assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL ); + + /* Verify that the MergeEngine is assigned to a single thread */ + assert( pMerger->pTask==0 ); + pMerger->pTask = pTask; + + for(i=0; i0 && eMode==INCRINIT_ROOT ){ + /* PmaReaders should be normally initialized in order, as if they are + ** reading from the same temp file this makes for more linear file IO. + ** However, in the INCRINIT_ROOT case, if PmaReader aReadr[nTask-1] is + ** in use it will block the vdbePmaReaderNext() call while it uses + ** the main thread to fill its buffer. So calling PmaReaderNext() + ** on this PmaReader before any of the multi-threaded PmaReaders takes + ** better advantage of multi-processor hardware. */ + rc = vdbePmaReaderNext(&pMerger->aReadr[nTree-i-1]); + }else{ + rc = vdbePmaReaderIncrInit(&pMerger->aReadr[i], INCRINIT_NORMAL); + } + if( rc!=SQLITE_OK ) return rc; + } + + for(i=pMerger->nTree-1; i>0; i--){ + vdbeMergeEngineCompare(pMerger, i); + } + return pTask->pUnpacked->errCode; +} + +/* +** The PmaReader passed as the first argument is guaranteed to be an +** incremental-reader (pReadr->pIncr!=0). This function serves to open +** and/or initialize the temp file related fields of the IncrMerge +** object at (pReadr->pIncr). +** +** If argument eMode is set to INCRINIT_NORMAL, then all PmaReaders +** in the sub-tree headed by pReadr are also initialized. Data is then +** loaded into the buffers belonging to pReadr and it is set to point to +** the first key in its range. +** +** If argument eMode is set to INCRINIT_TASK, then pReadr is guaranteed +** to be a multi-threaded PmaReader and this function is being called in a +** background thread. In this case all PmaReaders in the sub-tree are +** initialized as for INCRINIT_NORMAL and the aFile[1] buffer belonging to +** pReadr is populated. However, pReadr itself is not set up to point +** to its first key. A call to vdbePmaReaderNext() is still required to do +** that. +** +** The reason this function does not call vdbePmaReaderNext() immediately +** in the INCRINIT_TASK case is that vdbePmaReaderNext() assumes that it has +** to block on thread (pTask->thread) before accessing aFile[1]. But, since +** this entire function is being run by thread (pTask->thread), that will +** lead to the current background thread attempting to join itself. +** +** Finally, if argument eMode is set to INCRINIT_ROOT, it may be assumed +** that pReadr->pIncr is a multi-threaded IncrMerge objects, and that all +** child-trees have already been initialized using IncrInit(INCRINIT_TASK). +** In this case vdbePmaReaderNext() is called on all child PmaReaders and +** the current PmaReader set to point to the first key in its range. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int vdbePmaReaderIncrMergeInit(PmaReader *pReadr, int eMode){ + int rc = SQLITE_OK; + IncrMerger *pIncr = pReadr->pIncr; + SortSubtask *pTask = pIncr->pTask; + sqlite3 *db = pTask->pSorter->db; + + /* eMode is always INCRINIT_NORMAL in single-threaded mode */ + assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL ); + + rc = vdbeMergeEngineInit(pTask, pIncr->pMerger, eMode); + + /* Set up the required files for pIncr. A multi-theaded IncrMerge object + ** requires two temp files to itself, whereas a single-threaded object + ** only requires a region of pTask->file2. */ + if( rc==SQLITE_OK ){ + int mxSz = pIncr->mxSz; +#if SQLITE_MAX_WORKER_THREADS>0 + if( pIncr->bUseThread ){ + rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[0].pFd); + if( rc==SQLITE_OK ){ + rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[1].pFd); + } + }else +#endif + /*if( !pIncr->bUseThread )*/{ + if( pTask->file2.pFd==0 ){ + assert( pTask->file2.iEof>0 ); + rc = vdbeSorterOpenTempFile(db, pTask->file2.iEof, &pTask->file2.pFd); + pTask->file2.iEof = 0; + } + if( rc==SQLITE_OK ){ + pIncr->aFile[1].pFd = pTask->file2.pFd; + pIncr->iStartOff = pTask->file2.iEof; + pTask->file2.iEof += mxSz; + } + } + } + +#if SQLITE_MAX_WORKER_THREADS>0 + if( rc==SQLITE_OK && pIncr->bUseThread ){ + /* Use the current thread to populate aFile[1], even though this + ** PmaReader is multi-threaded. If this is an INCRINIT_TASK object, + ** then this function is already running in background thread + ** pIncr->pTask->thread. + ** + ** If this is the INCRINIT_ROOT object, then it is running in the + ** main VDBE thread. But that is Ok, as that thread cannot return + ** control to the VDBE or proceed with anything useful until the + ** first results are ready from this merger object anyway. + */ + assert( eMode==INCRINIT_ROOT || eMode==INCRINIT_TASK ); + rc = vdbeIncrPopulate(pIncr); + } +#endif + + if( rc==SQLITE_OK && (SQLITE_MAX_WORKER_THREADS==0 || eMode!=INCRINIT_TASK) ){ + rc = vdbePmaReaderNext(pReadr); + } + + return rc; +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** The main routine for vdbePmaReaderIncrMergeInit() operations run in +** background threads. +*/ +static void *vdbePmaReaderBgIncrInit(void *pCtx){ + PmaReader *pReader = (PmaReader*)pCtx; + void *pRet = SQLITE_INT_TO_PTR( + vdbePmaReaderIncrMergeInit(pReader,INCRINIT_TASK) + ); + pReader->pIncr->pTask->bDone = 1; + return pRet; +} +#endif + +/* +** If the PmaReader passed as the first argument is not an incremental-reader +** (if pReadr->pIncr==0), then this function is a no-op. Otherwise, it invokes +** the vdbePmaReaderIncrMergeInit() function with the parameters passed to +** this routine to initialize the incremental merge. +** +** If the IncrMerger object is multi-threaded (IncrMerger.bUseThread==1), +** then a background thread is launched to call vdbePmaReaderIncrMergeInit(). +** Or, if the IncrMerger is single threaded, the same function is called +** using the current thread. +*/ +static int vdbePmaReaderIncrInit(PmaReader *pReadr, int eMode){ + IncrMerger *pIncr = pReadr->pIncr; /* Incremental merger */ + int rc = SQLITE_OK; /* Return code */ + if( pIncr ){ +#if SQLITE_MAX_WORKER_THREADS>0 + assert( pIncr->bUseThread==0 || eMode==INCRINIT_TASK ); + if( pIncr->bUseThread ){ + void *pCtx = (void*)pReadr; + rc = vdbeSorterCreateThread(pIncr->pTask, vdbePmaReaderBgIncrInit, pCtx); + }else +#endif + { + rc = vdbePmaReaderIncrMergeInit(pReadr, eMode); + } + } + return rc; +} + +/* +** Allocate a new MergeEngine object to merge the contents of nPMA level-0 +** PMAs from pTask->file. If no error occurs, set *ppOut to point to +** the new object and return SQLITE_OK. Or, if an error does occur, set *ppOut +** to NULL and return an SQLite error code. +** +** When this function is called, *piOffset is set to the offset of the +** first PMA to read from pTask->file. Assuming no error occurs, it is +** set to the offset immediately following the last byte of the last +** PMA before returning. If an error does occur, then the final value of +** *piOffset is undefined. +*/ +static int vdbeMergeEngineLevel0( + SortSubtask *pTask, /* Sorter task to read from */ + int nPMA, /* Number of PMAs to read */ + i64 *piOffset, /* IN/OUT: Readr offset in pTask->file */ + MergeEngine **ppOut /* OUT: New merge-engine */ +){ + MergeEngine *pNew; /* Merge engine to return */ + i64 iOff = *piOffset; + int i; + int rc = SQLITE_OK; + + *ppOut = pNew = vdbeMergeEngineNew(nPMA); + if( pNew==0 ) rc = SQLITE_NOMEM; + + for(i=0; iaReadr[i]; + rc = vdbePmaReaderInit(pTask, &pTask->file, iOff, pReadr, &nDummy); + iOff = pReadr->iEof; + } + + if( rc!=SQLITE_OK ){ + vdbeMergeEngineFree(pNew); + *ppOut = 0; + } + *piOffset = iOff; + return rc; +} + +/* +** Return the depth of a tree comprising nPMA PMAs, assuming a fanout of +** SORTER_MAX_MERGE_COUNT. The returned value does not include leaf nodes. +** +** i.e. +** +** nPMA<=16 -> TreeDepth() == 0 +** nPMA<=256 -> TreeDepth() == 1 +** nPMA<=65536 -> TreeDepth() == 2 +*/ +static int vdbeSorterTreeDepth(int nPMA){ + int nDepth = 0; + i64 nDiv = SORTER_MAX_MERGE_COUNT; + while( nDiv < (i64)nPMA ){ + nDiv = nDiv * SORTER_MAX_MERGE_COUNT; + nDepth++; + } + return nDepth; +} + +/* +** pRoot is the root of an incremental merge-tree with depth nDepth (according +** to vdbeSorterTreeDepth()). pLeaf is the iSeq'th leaf to be added to the +** tree, counting from zero. This function adds pLeaf to the tree. +** +** If successful, SQLITE_OK is returned. If an error occurs, an SQLite error +** code is returned and pLeaf is freed. +*/ +static int vdbeSorterAddToTree( + SortSubtask *pTask, /* Task context */ + int nDepth, /* Depth of tree according to TreeDepth() */ + int iSeq, /* Sequence number of leaf within tree */ + MergeEngine *pRoot, /* Root of tree */ + MergeEngine *pLeaf /* Leaf to add to tree */ +){ + int rc = SQLITE_OK; + int nDiv = 1; + int i; + MergeEngine *p = pRoot; + IncrMerger *pIncr; + + rc = vdbeIncrMergerNew(pTask, pLeaf, &pIncr); + + for(i=1; iaReadr[iIter]; + + if( pReadr->pIncr==0 ){ + MergeEngine *pNew = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT); + if( pNew==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = vdbeIncrMergerNew(pTask, pNew, &pReadr->pIncr); + } + } + if( rc==SQLITE_OK ){ + p = pReadr->pIncr->pMerger; + nDiv = nDiv / SORTER_MAX_MERGE_COUNT; + } + } + + if( rc==SQLITE_OK ){ + p->aReadr[iSeq % SORTER_MAX_MERGE_COUNT].pIncr = pIncr; + }else{ + vdbeIncrFree(pIncr); + } + return rc; +} + +/* +** This function is called as part of a SorterRewind() operation on a sorter +** that has already written two or more level-0 PMAs to one or more temp +** files. It builds a tree of MergeEngine/IncrMerger/PmaReader objects that +** can be used to incrementally merge all PMAs on disk. +** +** If successful, SQLITE_OK is returned and *ppOut set to point to the +** MergeEngine object at the root of the tree before returning. Or, if an +** error occurs, an SQLite error code is returned and the final value +** of *ppOut is undefined. +*/ +static int vdbeSorterMergeTreeBuild( + VdbeSorter *pSorter, /* The VDBE cursor that implements the sort */ + MergeEngine **ppOut /* Write the MergeEngine here */ +){ + MergeEngine *pMain = 0; + int rc = SQLITE_OK; + int iTask; + +#if SQLITE_MAX_WORKER_THREADS>0 + /* If the sorter uses more than one task, then create the top-level + ** MergeEngine here. This MergeEngine will read data from exactly + ** one PmaReader per sub-task. */ + assert( pSorter->bUseThreads || pSorter->nTask==1 ); + if( pSorter->nTask>1 ){ + pMain = vdbeMergeEngineNew(pSorter->nTask); + if( pMain==0 ) rc = SQLITE_NOMEM; + } +#endif + + for(iTask=0; rc==SQLITE_OK && iTasknTask; iTask++){ + SortSubtask *pTask = &pSorter->aTask[iTask]; + assert( pTask->nPMA>0 || SQLITE_MAX_WORKER_THREADS>0 ); + if( SQLITE_MAX_WORKER_THREADS==0 || pTask->nPMA ){ + MergeEngine *pRoot = 0; /* Root node of tree for this task */ + int nDepth = vdbeSorterTreeDepth(pTask->nPMA); + i64 iReadOff = 0; + + if( pTask->nPMA<=SORTER_MAX_MERGE_COUNT ){ + rc = vdbeMergeEngineLevel0(pTask, pTask->nPMA, &iReadOff, &pRoot); + }else{ + int i; + int iSeq = 0; + pRoot = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT); + if( pRoot==0 ) rc = SQLITE_NOMEM; + for(i=0; inPMA && rc==SQLITE_OK; i += SORTER_MAX_MERGE_COUNT){ + MergeEngine *pMerger = 0; /* New level-0 PMA merger */ + int nReader; /* Number of level-0 PMAs to merge */ + + nReader = MIN(pTask->nPMA - i, SORTER_MAX_MERGE_COUNT); + rc = vdbeMergeEngineLevel0(pTask, nReader, &iReadOff, &pMerger); + if( rc==SQLITE_OK ){ + rc = vdbeSorterAddToTree(pTask, nDepth, iSeq++, pRoot, pMerger); + } + } + } + + if( rc==SQLITE_OK ){ +#if SQLITE_MAX_WORKER_THREADS>0 + if( pMain!=0 ){ + rc = vdbeIncrMergerNew(pTask, pRoot, &pMain->aReadr[iTask].pIncr); + }else +#endif + { + assert( pMain==0 ); + pMain = pRoot; + } + }else{ + vdbeMergeEngineFree(pRoot); + } + } + } + + if( rc!=SQLITE_OK ){ + vdbeMergeEngineFree(pMain); + pMain = 0; + } + *ppOut = pMain; + return rc; +} + +/* +** This function is called as part of an sqlite3VdbeSorterRewind() operation +** on a sorter that has written two or more PMAs to temporary files. It sets +** up either VdbeSorter.pMerger (for single threaded sorters) or pReader +** (for multi-threaded sorters) so that it can be used to iterate through +** all records stored in the sorter. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int vdbeSorterSetupMerge(VdbeSorter *pSorter){ + int rc; /* Return code */ + SortSubtask *pTask0 = &pSorter->aTask[0]; + MergeEngine *pMain = 0; +#if SQLITE_MAX_WORKER_THREADS + sqlite3 *db = pTask0->pSorter->db; + int i; + SorterCompare xCompare = vdbeSorterGetCompare(pSorter); + for(i=0; inTask; i++){ + pSorter->aTask[i].xCompare = xCompare; + } +#endif + + rc = vdbeSorterMergeTreeBuild(pSorter, &pMain); + if( rc==SQLITE_OK ){ +#if SQLITE_MAX_WORKER_THREADS + assert( pSorter->bUseThreads==0 || pSorter->nTask>1 ); + if( pSorter->bUseThreads ){ + int iTask; + PmaReader *pReadr = 0; + SortSubtask *pLast = &pSorter->aTask[pSorter->nTask-1]; + rc = vdbeSortAllocUnpacked(pLast); + if( rc==SQLITE_OK ){ + pReadr = (PmaReader*)sqlite3DbMallocZero(db, sizeof(PmaReader)); + pSorter->pReader = pReadr; + if( pReadr==0 ) rc = SQLITE_NOMEM; + } + if( rc==SQLITE_OK ){ + rc = vdbeIncrMergerNew(pLast, pMain, &pReadr->pIncr); + if( rc==SQLITE_OK ){ + vdbeIncrMergerSetThreads(pReadr->pIncr); + for(iTask=0; iTask<(pSorter->nTask-1); iTask++){ + IncrMerger *pIncr; + if( (pIncr = pMain->aReadr[iTask].pIncr) ){ + vdbeIncrMergerSetThreads(pIncr); + assert( pIncr->pTask!=pLast ); + } + } + for(iTask=0; rc==SQLITE_OK && iTasknTask; iTask++){ + /* Check that: + ** + ** a) The incremental merge object is configured to use the + ** right task, and + ** b) If it is using task (nTask-1), it is configured to run + ** in single-threaded mode. This is important, as the + ** root merge (INCRINIT_ROOT) will be using the same task + ** object. + */ + PmaReader *p = &pMain->aReadr[iTask]; + assert( p->pIncr==0 || ( + (p->pIncr->pTask==&pSorter->aTask[iTask]) /* a */ + && (iTask!=pSorter->nTask-1 || p->pIncr->bUseThread==0) /* b */ + )); + rc = vdbePmaReaderIncrInit(p, INCRINIT_TASK); + } + } + pMain = 0; + } + if( rc==SQLITE_OK ){ + rc = vdbePmaReaderIncrMergeInit(pReadr, INCRINIT_ROOT); + } + }else +#endif + { + rc = vdbeMergeEngineInit(pTask0, pMain, INCRINIT_NORMAL); + pSorter->pMerger = pMain; + pMain = 0; + } + } + + if( rc!=SQLITE_OK ){ + vdbeMergeEngineFree(pMain); + } + return rc; +} + + +/* +** Once the sorter has been populated by calls to sqlite3VdbeSorterWrite, +** this function is called to prepare for iterating through the records +** in sorted order. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *pCsr, int *pbEof){ + VdbeSorter *pSorter = pCsr->pSorter; + int rc = SQLITE_OK; /* Return code */ + + assert( pSorter ); + + /* If no data has been written to disk, then do not do so now. Instead, + ** sort the VdbeSorter.pRecord list. The vdbe layer will read data directly + ** from the in-memory list. */ + if( pSorter->bUsePMA==0 ){ + if( pSorter->list.pList ){ + *pbEof = 0; + rc = vdbeSorterSort(&pSorter->aTask[0], &pSorter->list); + }else{ + *pbEof = 1; + } + return rc; + } + + /* Write the current in-memory list to a PMA. When the VdbeSorterWrite() + ** function flushes the contents of memory to disk, it immediately always + ** creates a new list consisting of a single key immediately afterwards. + ** So the list is never empty at this point. */ + assert( pSorter->list.pList ); + rc = vdbeSorterFlushPMA(pSorter); + + /* Join all threads */ + rc = vdbeSorterJoinAll(pSorter, rc); + + vdbeSorterRewindDebug("rewind"); + + /* Assuming no errors have occurred, set up a merger structure to + ** incrementally read and merge all remaining PMAs. */ + assert( pSorter->pReader==0 ); + if( rc==SQLITE_OK ){ + rc = vdbeSorterSetupMerge(pSorter); + *pbEof = 0; + } + + vdbeSorterRewindDebug("rewinddone"); + return rc; +} + +/* +** Advance to the next element in the sorter. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *db, const VdbeCursor *pCsr, int *pbEof){ + VdbeSorter *pSorter = pCsr->pSorter; + int rc; /* Return code */ + + assert( pSorter->bUsePMA || (pSorter->pReader==0 && pSorter->pMerger==0) ); + if( pSorter->bUsePMA ){ + assert( pSorter->pReader==0 || pSorter->pMerger==0 ); + assert( pSorter->bUseThreads==0 || pSorter->pReader ); + assert( pSorter->bUseThreads==1 || pSorter->pMerger ); +#if SQLITE_MAX_WORKER_THREADS>0 + if( pSorter->bUseThreads ){ + rc = vdbePmaReaderNext(pSorter->pReader); + *pbEof = (pSorter->pReader->pFd==0); + }else +#endif + /*if( !pSorter->bUseThreads )*/ { + assert( pSorter->pMerger!=0 ); + assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) ); + rc = vdbeMergeEngineStep(pSorter->pMerger, pbEof); + } + }else{ + SorterRecord *pFree = pSorter->list.pList; + pSorter->list.pList = pFree->u.pNext; + pFree->u.pNext = 0; + if( pSorter->list.aMemory==0 ) vdbeSorterRecordFree(db, pFree); + *pbEof = !pSorter->list.pList; + rc = SQLITE_OK; + } + return rc; +} + +/* +** Return a pointer to a buffer owned by the sorter that contains the +** current key. +*/ +static void *vdbeSorterRowkey( + const VdbeSorter *pSorter, /* Sorter object */ + int *pnKey /* OUT: Size of current key in bytes */ +){ + void *pKey; + if( pSorter->bUsePMA ){ + PmaReader *pReader; +#if SQLITE_MAX_WORKER_THREADS>0 + if( pSorter->bUseThreads ){ + pReader = pSorter->pReader; + }else +#endif + /*if( !pSorter->bUseThreads )*/{ + pReader = &pSorter->pMerger->aReadr[pSorter->pMerger->aTree[1]]; + } + *pnKey = pReader->nKey; + pKey = pReader->aKey; + }else{ + *pnKey = pSorter->list.pList->nVal; + pKey = SRVAL(pSorter->list.pList); + } + return pKey; +} + +/* +** Copy the current sorter key into the memory cell pOut. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){ + VdbeSorter *pSorter = pCsr->pSorter; + void *pKey; int nKey; /* Sorter key to copy into pOut */ + + pKey = vdbeSorterRowkey(pSorter, &nKey); + if( sqlite3VdbeMemClearAndResize(pOut, nKey) ){ + return SQLITE_NOMEM; + } + pOut->n = nKey; + MemSetTypeFlag(pOut, MEM_Blob); + memcpy(pOut->z, pKey, nKey); + + return SQLITE_OK; +} + +/* +** Compare the key in memory cell pVal with the key that the sorter cursor +** passed as the first argument currently points to. For the purposes of +** the comparison, ignore the rowid field at the end of each record. +** +** If the sorter cursor key contains any NULL values, consider it to be +** less than pVal. Even if pVal also contains NULL values. +** +** If an error occurs, return an SQLite error code (i.e. SQLITE_NOMEM). +** Otherwise, set *pRes to a negative, zero or positive value if the +** key in pVal is smaller than, equal to or larger than the current sorter +** key. +** +** This routine forms the core of the OP_SorterCompare opcode, which in +** turn is used to verify uniqueness when constructing a UNIQUE INDEX. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterCompare( + const VdbeCursor *pCsr, /* Sorter cursor */ + Mem *pVal, /* Value to compare to current sorter key */ + int nKeyCol, /* Compare this many columns */ + int *pRes /* OUT: Result of comparison */ +){ + VdbeSorter *pSorter = pCsr->pSorter; + UnpackedRecord *r2 = pSorter->pUnpacked; + KeyInfo *pKeyInfo = pCsr->pKeyInfo; + int i; + void *pKey; int nKey; /* Sorter key to compare pVal with */ + + if( r2==0 ){ + char *p; + r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo,0,0,&p); + assert( pSorter->pUnpacked==(UnpackedRecord*)p ); + if( r2==0 ) return SQLITE_NOMEM; + r2->nField = nKeyCol; + } + assert( r2->nField==nKeyCol ); + + pKey = vdbeSorterRowkey(pSorter, &nKey); + sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, r2); + for(i=0; iaMem[i].flags & MEM_Null ){ + *pRes = -1; + return SQLITE_OK; + } + } + + *pRes = sqlite3VdbeRecordCompare(pVal->n, pVal->z, r2); + return SQLITE_OK; +} + +/************** End of vdbesort.c ********************************************/ +/************** Begin file journal.c *****************************************/ +/* +** 2007 August 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file implements a special kind of sqlite3_file object used +** by SQLite to create journal files if the atomic-write optimization +** is enabled. +** +** The distinctive characteristic of this sqlite3_file is that the +** actual on disk file is created lazily. When the file is created, +** the caller specifies a buffer size for an in-memory buffer to +** be used to service read() and write() requests. The actual file +** on disk is not created or populated until either: +** +** 1) The in-memory representation grows too large for the allocated +** buffer, or +** 2) The sqlite3JournalCreate() function is called. +*/ +#ifdef SQLITE_ENABLE_ATOMIC_WRITE +/* #include "sqliteInt.h" */ + + +/* +** A JournalFile object is a subclass of sqlite3_file used by +** as an open file handle for journal files. +*/ +struct JournalFile { + sqlite3_io_methods *pMethod; /* I/O methods on journal files */ + int nBuf; /* Size of zBuf[] in bytes */ + char *zBuf; /* Space to buffer journal writes */ + int iSize; /* Amount of zBuf[] currently used */ + int flags; /* xOpen flags */ + sqlite3_vfs *pVfs; /* The "real" underlying VFS */ + sqlite3_file *pReal; /* The "real" underlying file descriptor */ + const char *zJournal; /* Name of the journal file */ +}; +typedef struct JournalFile JournalFile; + +/* +** If it does not already exists, create and populate the on-disk file +** for JournalFile p. +*/ +static int createFile(JournalFile *p){ + int rc = SQLITE_OK; + if( !p->pReal ){ + sqlite3_file *pReal = (sqlite3_file *)&p[1]; + rc = sqlite3OsOpen(p->pVfs, p->zJournal, pReal, p->flags, 0); + if( rc==SQLITE_OK ){ + p->pReal = pReal; + if( p->iSize>0 ){ + assert(p->iSize<=p->nBuf); + rc = sqlite3OsWrite(p->pReal, p->zBuf, p->iSize, 0); + } + if( rc!=SQLITE_OK ){ + /* If an error occurred while writing to the file, close it before + ** returning. This way, SQLite uses the in-memory journal data to + ** roll back changes made to the internal page-cache before this + ** function was called. */ + sqlite3OsClose(pReal); + p->pReal = 0; + } + } + } + return rc; +} + +/* +** Close the file. +*/ +static int jrnlClose(sqlite3_file *pJfd){ + JournalFile *p = (JournalFile *)pJfd; + if( p->pReal ){ + sqlite3OsClose(p->pReal); + } + sqlite3_free(p->zBuf); + return SQLITE_OK; +} + +/* +** Read data from the file. +*/ +static int jrnlRead( + sqlite3_file *pJfd, /* The journal file from which to read */ + void *zBuf, /* Put the results here */ + int iAmt, /* Number of bytes to read */ + sqlite_int64 iOfst /* Begin reading at this offset */ +){ + int rc = SQLITE_OK; + JournalFile *p = (JournalFile *)pJfd; + if( p->pReal ){ + rc = sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst); + }else if( (iAmt+iOfst)>p->iSize ){ + rc = SQLITE_IOERR_SHORT_READ; + }else{ + memcpy(zBuf, &p->zBuf[iOfst], iAmt); + } + return rc; +} + +/* +** Write data to the file. +*/ +static int jrnlWrite( + sqlite3_file *pJfd, /* The journal file into which to write */ + const void *zBuf, /* Take data to be written from here */ + int iAmt, /* Number of bytes to write */ + sqlite_int64 iOfst /* Begin writing at this offset into the file */ +){ + int rc = SQLITE_OK; + JournalFile *p = (JournalFile *)pJfd; + if( !p->pReal && (iOfst+iAmt)>p->nBuf ){ + rc = createFile(p); + } + if( rc==SQLITE_OK ){ + if( p->pReal ){ + rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst); + }else{ + memcpy(&p->zBuf[iOfst], zBuf, iAmt); + if( p->iSize<(iOfst+iAmt) ){ + p->iSize = (iOfst+iAmt); + } + } + } + return rc; +} + +/* +** Truncate the file. +*/ +static int jrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){ + int rc = SQLITE_OK; + JournalFile *p = (JournalFile *)pJfd; + if( p->pReal ){ + rc = sqlite3OsTruncate(p->pReal, size); + }else if( sizeiSize ){ + p->iSize = size; + } + return rc; +} + +/* +** Sync the file. +*/ +static int jrnlSync(sqlite3_file *pJfd, int flags){ + int rc; + JournalFile *p = (JournalFile *)pJfd; + if( p->pReal ){ + rc = sqlite3OsSync(p->pReal, flags); + }else{ + rc = SQLITE_OK; + } + return rc; +} + +/* +** Query the size of the file in bytes. +*/ +static int jrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){ + int rc = SQLITE_OK; + JournalFile *p = (JournalFile *)pJfd; + if( p->pReal ){ + rc = sqlite3OsFileSize(p->pReal, pSize); + }else{ + *pSize = (sqlite_int64) p->iSize; + } + return rc; +} + +/* +** Table of methods for JournalFile sqlite3_file object. +*/ +static struct sqlite3_io_methods JournalFileMethods = { + 1, /* iVersion */ + jrnlClose, /* xClose */ + jrnlRead, /* xRead */ + jrnlWrite, /* xWrite */ + jrnlTruncate, /* xTruncate */ + jrnlSync, /* xSync */ + jrnlFileSize, /* xFileSize */ + 0, /* xLock */ + 0, /* xUnlock */ + 0, /* xCheckReservedLock */ + 0, /* xFileControl */ + 0, /* xSectorSize */ + 0, /* xDeviceCharacteristics */ + 0, /* xShmMap */ + 0, /* xShmLock */ + 0, /* xShmBarrier */ + 0 /* xShmUnmap */ +}; + +/* +** Open a journal file. +*/ +SQLITE_PRIVATE int sqlite3JournalOpen( + sqlite3_vfs *pVfs, /* The VFS to use for actual file I/O */ + const char *zName, /* Name of the journal file */ + sqlite3_file *pJfd, /* Preallocated, blank file handle */ + int flags, /* Opening flags */ + int nBuf /* Bytes buffered before opening the file */ +){ + JournalFile *p = (JournalFile *)pJfd; + memset(p, 0, sqlite3JournalSize(pVfs)); + if( nBuf>0 ){ + p->zBuf = sqlite3MallocZero(nBuf); + if( !p->zBuf ){ + return SQLITE_NOMEM; + } + }else{ + return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0); + } + p->pMethod = &JournalFileMethods; + p->nBuf = nBuf; + p->flags = flags; + p->zJournal = zName; + p->pVfs = pVfs; + return SQLITE_OK; +} + +/* +** If the argument p points to a JournalFile structure, and the underlying +** file has not yet been created, create it now. +*/ +SQLITE_PRIVATE int sqlite3JournalCreate(sqlite3_file *p){ + if( p->pMethods!=&JournalFileMethods ){ + return SQLITE_OK; + } + return createFile((JournalFile *)p); +} + +/* +** The file-handle passed as the only argument is guaranteed to be an open +** file. It may or may not be of class JournalFile. If the file is a +** JournalFile, and the underlying file on disk has not yet been opened, +** return 0. Otherwise, return 1. +*/ +SQLITE_PRIVATE int sqlite3JournalExists(sqlite3_file *p){ + return (p->pMethods!=&JournalFileMethods || ((JournalFile *)p)->pReal!=0); +} + +/* +** Return the number of bytes required to store a JournalFile that uses vfs +** pVfs to create the underlying on-disk files. +*/ +SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *pVfs){ + return (pVfs->szOsFile+sizeof(JournalFile)); +} +#endif + +/************** End of journal.c *********************************************/ +/************** Begin file memjournal.c **************************************/ +/* +** 2008 October 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code use to implement an in-memory rollback journal. +** The in-memory rollback journal is used to journal transactions for +** ":memory:" databases and when the journal_mode=MEMORY pragma is used. +*/ +/* #include "sqliteInt.h" */ + +/* Forward references to internal structures */ +typedef struct MemJournal MemJournal; +typedef struct FilePoint FilePoint; +typedef struct FileChunk FileChunk; + +/* Space to hold the rollback journal is allocated in increments of +** this many bytes. +** +** The size chosen is a little less than a power of two. That way, +** the FileChunk object will have a size that almost exactly fills +** a power-of-two allocation. This minimizes wasted space in power-of-two +** memory allocators. +*/ +#define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*))) + +/* +** The rollback journal is composed of a linked list of these structures. +*/ +struct FileChunk { + FileChunk *pNext; /* Next chunk in the journal */ + u8 zChunk[JOURNAL_CHUNKSIZE]; /* Content of this chunk */ +}; + +/* +** An instance of this object serves as a cursor into the rollback journal. +** The cursor can be either for reading or writing. +*/ +struct FilePoint { + sqlite3_int64 iOffset; /* Offset from the beginning of the file */ + FileChunk *pChunk; /* Specific chunk into which cursor points */ +}; + +/* +** This subclass is a subclass of sqlite3_file. Each open memory-journal +** is an instance of this class. +*/ +struct MemJournal { + sqlite3_io_methods *pMethod; /* Parent class. MUST BE FIRST */ + FileChunk *pFirst; /* Head of in-memory chunk-list */ + FilePoint endpoint; /* Pointer to the end of the file */ + FilePoint readpoint; /* Pointer to the end of the last xRead() */ +}; + +/* +** Read data from the in-memory journal file. This is the implementation +** of the sqlite3_vfs.xRead method. +*/ +static int memjrnlRead( + sqlite3_file *pJfd, /* The journal file from which to read */ + void *zBuf, /* Put the results here */ + int iAmt, /* Number of bytes to read */ + sqlite_int64 iOfst /* Begin reading at this offset */ +){ + MemJournal *p = (MemJournal *)pJfd; + u8 *zOut = zBuf; + int nRead = iAmt; + int iChunkOffset; + FileChunk *pChunk; + + /* SQLite never tries to read past the end of a rollback journal file */ + assert( iOfst+iAmt<=p->endpoint.iOffset ); + + if( p->readpoint.iOffset!=iOfst || iOfst==0 ){ + sqlite3_int64 iOff = 0; + for(pChunk=p->pFirst; + ALWAYS(pChunk) && (iOff+JOURNAL_CHUNKSIZE)<=iOfst; + pChunk=pChunk->pNext + ){ + iOff += JOURNAL_CHUNKSIZE; + } + }else{ + pChunk = p->readpoint.pChunk; + } + + iChunkOffset = (int)(iOfst%JOURNAL_CHUNKSIZE); + do { + int iSpace = JOURNAL_CHUNKSIZE - iChunkOffset; + int nCopy = MIN(nRead, (JOURNAL_CHUNKSIZE - iChunkOffset)); + memcpy(zOut, &pChunk->zChunk[iChunkOffset], nCopy); + zOut += nCopy; + nRead -= iSpace; + iChunkOffset = 0; + } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 ); + p->readpoint.iOffset = iOfst+iAmt; + p->readpoint.pChunk = pChunk; + + return SQLITE_OK; +} + +/* +** Write data to the file. +*/ +static int memjrnlWrite( + sqlite3_file *pJfd, /* The journal file into which to write */ + const void *zBuf, /* Take data to be written from here */ + int iAmt, /* Number of bytes to write */ + sqlite_int64 iOfst /* Begin writing at this offset into the file */ +){ + MemJournal *p = (MemJournal *)pJfd; + int nWrite = iAmt; + u8 *zWrite = (u8 *)zBuf; + + /* An in-memory journal file should only ever be appended to. Random + ** access writes are not required by sqlite. + */ + assert( iOfst==p->endpoint.iOffset ); + UNUSED_PARAMETER(iOfst); + + while( nWrite>0 ){ + FileChunk *pChunk = p->endpoint.pChunk; + int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE); + int iSpace = MIN(nWrite, JOURNAL_CHUNKSIZE - iChunkOffset); + + if( iChunkOffset==0 ){ + /* New chunk is required to extend the file. */ + FileChunk *pNew = sqlite3_malloc(sizeof(FileChunk)); + if( !pNew ){ + return SQLITE_IOERR_NOMEM; + } + pNew->pNext = 0; + if( pChunk ){ + assert( p->pFirst ); + pChunk->pNext = pNew; + }else{ + assert( !p->pFirst ); + p->pFirst = pNew; + } + p->endpoint.pChunk = pNew; + } + + memcpy(&p->endpoint.pChunk->zChunk[iChunkOffset], zWrite, iSpace); + zWrite += iSpace; + nWrite -= iSpace; + p->endpoint.iOffset += iSpace; + } + + return SQLITE_OK; +} + +/* +** Truncate the file. +*/ +static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){ + MemJournal *p = (MemJournal *)pJfd; + FileChunk *pChunk; + assert(size==0); + UNUSED_PARAMETER(size); + pChunk = p->pFirst; + while( pChunk ){ + FileChunk *pTmp = pChunk; + pChunk = pChunk->pNext; + sqlite3_free(pTmp); + } + sqlite3MemJournalOpen(pJfd); + return SQLITE_OK; +} + +/* +** Close the file. +*/ +static int memjrnlClose(sqlite3_file *pJfd){ + memjrnlTruncate(pJfd, 0); + return SQLITE_OK; +} + + +/* +** Sync the file. +** +** Syncing an in-memory journal is a no-op. And, in fact, this routine +** is never called in a working implementation. This implementation +** exists purely as a contingency, in case some malfunction in some other +** part of SQLite causes Sync to be called by mistake. +*/ +static int memjrnlSync(sqlite3_file *NotUsed, int NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return SQLITE_OK; +} + +/* +** Query the size of the file in bytes. +*/ +static int memjrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){ + MemJournal *p = (MemJournal *)pJfd; + *pSize = (sqlite_int64) p->endpoint.iOffset; + return SQLITE_OK; +} + +/* +** Table of methods for MemJournal sqlite3_file object. +*/ +static const struct sqlite3_io_methods MemJournalMethods = { + 1, /* iVersion */ + memjrnlClose, /* xClose */ + memjrnlRead, /* xRead */ + memjrnlWrite, /* xWrite */ + memjrnlTruncate, /* xTruncate */ + memjrnlSync, /* xSync */ + memjrnlFileSize, /* xFileSize */ + 0, /* xLock */ + 0, /* xUnlock */ + 0, /* xCheckReservedLock */ + 0, /* xFileControl */ + 0, /* xSectorSize */ + 0, /* xDeviceCharacteristics */ + 0, /* xShmMap */ + 0, /* xShmLock */ + 0, /* xShmBarrier */ + 0, /* xShmUnmap */ + 0, /* xFetch */ + 0 /* xUnfetch */ +}; + +/* +** Open a journal file. +*/ +SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *pJfd){ + MemJournal *p = (MemJournal *)pJfd; + assert( EIGHT_BYTE_ALIGNMENT(p) ); + memset(p, 0, sqlite3MemJournalSize()); + p->pMethod = (sqlite3_io_methods*)&MemJournalMethods; +} + +/* +** Return true if the file-handle passed as an argument is +** an in-memory journal +*/ +SQLITE_PRIVATE int sqlite3IsMemJournal(sqlite3_file *pJfd){ + return pJfd->pMethods==&MemJournalMethods; +} + +/* +** Return the number of bytes required to store a MemJournal file descriptor. +*/ +SQLITE_PRIVATE int sqlite3MemJournalSize(void){ + return sizeof(MemJournal); +} + +/************** End of memjournal.c ******************************************/ +/************** Begin file walker.c ******************************************/ +/* +** 2008 August 16 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used for walking the parser tree for +** an SQL statement. +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ + + +/* +** Walk an expression tree. Invoke the callback once for each node +** of the expression, while descending. (In other words, the callback +** is invoked before visiting children.) +** +** The return value from the callback should be one of the WRC_* +** constants to specify how to proceed with the walk. +** +** WRC_Continue Continue descending down the tree. +** +** WRC_Prune Do not descend into child nodes. But allow +** the walk to continue with sibling nodes. +** +** WRC_Abort Do no more callbacks. Unwind the stack and +** return the top-level walk call. +** +** The return value from this routine is WRC_Abort to abandon the tree walk +** and WRC_Continue to continue. +*/ +SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){ + int rc; + if( pExpr==0 ) return WRC_Continue; + testcase( ExprHasProperty(pExpr, EP_TokenOnly) ); + testcase( ExprHasProperty(pExpr, EP_Reduced) ); + rc = pWalker->xExprCallback(pWalker, pExpr); + if( rc==WRC_Continue + && !ExprHasProperty(pExpr,EP_TokenOnly) ){ + if( sqlite3WalkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, pExpr->pRight) ) return WRC_Abort; + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort; + }else{ + if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort; + } + } + return rc & WRC_Abort; +} + +/* +** Call sqlite3WalkExpr() for every expression in list p or until +** an abort request is seen. +*/ +SQLITE_PRIVATE int sqlite3WalkExprList(Walker *pWalker, ExprList *p){ + int i; + struct ExprList_item *pItem; + if( p ){ + for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){ + if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort; + } + } + return WRC_Continue; +} + +/* +** Walk all expressions associated with SELECT statement p. Do +** not invoke the SELECT callback on p, but do (of course) invoke +** any expr callbacks and SELECT callbacks that come from subqueries. +** Return WRC_Abort or WRC_Continue. +*/ +SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){ + if( sqlite3WalkExprList(pWalker, p->pEList) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort; + if( sqlite3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort; + if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, p->pOffset) ) return WRC_Abort; + return WRC_Continue; +} + +/* +** Walk the parse trees associated with all subqueries in the +** FROM clause of SELECT statement p. Do not invoke the select +** callback on p, but do invoke it on each FROM clause subquery +** and on any subqueries further down in the tree. Return +** WRC_Abort or WRC_Continue; +*/ +SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){ + SrcList *pSrc; + int i; + struct SrcList_item *pItem; + + pSrc = p->pSrc; + if( ALWAYS(pSrc) ){ + for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ + if( sqlite3WalkSelect(pWalker, pItem->pSelect) ){ + return WRC_Abort; + } + if( pItem->fg.isTabFunc + && sqlite3WalkExprList(pWalker, pItem->u1.pFuncArg) + ){ + return WRC_Abort; + } + } + } + return WRC_Continue; +} + +/* +** Call sqlite3WalkExpr() for every expression in Select statement p. +** Invoke sqlite3WalkSelect() for subqueries in the FROM clause and +** on the compound select chain, p->pPrior. +** +** If it is not NULL, the xSelectCallback() callback is invoked before +** the walk of the expressions and FROM clause. The xSelectCallback2() +** method, if it is not NULL, is invoked following the walk of the +** expressions and FROM clause. +** +** Return WRC_Continue under normal conditions. Return WRC_Abort if +** there is an abort request. +** +** If the Walker does not have an xSelectCallback() then this routine +** is a no-op returning WRC_Continue. +*/ +SQLITE_PRIVATE int sqlite3WalkSelect(Walker *pWalker, Select *p){ + int rc; + if( p==0 || (pWalker->xSelectCallback==0 && pWalker->xSelectCallback2==0) ){ + return WRC_Continue; + } + rc = WRC_Continue; + pWalker->walkerDepth++; + while( p ){ + if( pWalker->xSelectCallback ){ + rc = pWalker->xSelectCallback(pWalker, p); + if( rc ) break; + } + if( sqlite3WalkSelectExpr(pWalker, p) + || sqlite3WalkSelectFrom(pWalker, p) + ){ + pWalker->walkerDepth--; + return WRC_Abort; + } + if( pWalker->xSelectCallback2 ){ + pWalker->xSelectCallback2(pWalker, p); + } + p = p->pPrior; + } + pWalker->walkerDepth--; + return rc & WRC_Abort; +} + +/************** End of walker.c **********************************************/ +/************** Begin file resolve.c *****************************************/ +/* +** 2008 August 18 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains routines used for walking the parser tree and +** resolve all identifiers by associating them with a particular +** table and column. +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ + +/* +** Walk the expression tree pExpr and increase the aggregate function +** depth (the Expr.op2 field) by N on every TK_AGG_FUNCTION node. +** This needs to occur when copying a TK_AGG_FUNCTION node from an +** outer query into an inner subquery. +** +** incrAggFunctionDepth(pExpr,n) is the main routine. incrAggDepth(..) +** is a helper function - a callback for the tree walker. +*/ +static int incrAggDepth(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n; + return WRC_Continue; +} +static void incrAggFunctionDepth(Expr *pExpr, int N){ + if( N>0 ){ + Walker w; + memset(&w, 0, sizeof(w)); + w.xExprCallback = incrAggDepth; + w.u.n = N; + sqlite3WalkExpr(&w, pExpr); + } +} + +/* +** Turn the pExpr expression into an alias for the iCol-th column of the +** result set in pEList. +** +** If the reference is followed by a COLLATE operator, then make sure +** the COLLATE operator is preserved. For example: +** +** SELECT a+b, c+d FROM t1 ORDER BY 1 COLLATE nocase; +** +** Should be transformed into: +** +** SELECT a+b, c+d FROM t1 ORDER BY (a+b) COLLATE nocase; +** +** The nSubquery parameter specifies how many levels of subquery the +** alias is removed from the original expression. The usual value is +** zero but it might be more if the alias is contained within a subquery +** of the original expression. The Expr.op2 field of TK_AGG_FUNCTION +** structures must be increased by the nSubquery amount. +*/ +static void resolveAlias( + Parse *pParse, /* Parsing context */ + ExprList *pEList, /* A result set */ + int iCol, /* A column in the result set. 0..pEList->nExpr-1 */ + Expr *pExpr, /* Transform this into an alias to the result set */ + const char *zType, /* "GROUP" or "ORDER" or "" */ + int nSubquery /* Number of subqueries that the label is moving */ +){ + Expr *pOrig; /* The iCol-th column of the result set */ + Expr *pDup; /* Copy of pOrig */ + sqlite3 *db; /* The database connection */ + + assert( iCol>=0 && iColnExpr ); + pOrig = pEList->a[iCol].pExpr; + assert( pOrig!=0 ); + db = pParse->db; + pDup = sqlite3ExprDup(db, pOrig, 0); + if( pDup==0 ) return; + if( zType[0]!='G' ) incrAggFunctionDepth(pDup, nSubquery); + if( pExpr->op==TK_COLLATE ){ + pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken); + } + ExprSetProperty(pDup, EP_Alias); + + /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This + ** prevents ExprDelete() from deleting the Expr structure itself, + ** allowing it to be repopulated by the memcpy() on the following line. + ** The pExpr->u.zToken might point into memory that will be freed by the + ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to + ** make a copy of the token before doing the sqlite3DbFree(). + */ + ExprSetProperty(pExpr, EP_Static); + sqlite3ExprDelete(db, pExpr); + memcpy(pExpr, pDup, sizeof(*pExpr)); + if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){ + assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 ); + pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken); + pExpr->flags |= EP_MemToken; + } + sqlite3DbFree(db, pDup); +} + + +/* +** Return TRUE if the name zCol occurs anywhere in the USING clause. +** +** Return FALSE if the USING clause is NULL or if it does not contain +** zCol. +*/ +static int nameInUsingClause(IdList *pUsing, const char *zCol){ + if( pUsing ){ + int k; + for(k=0; knId; k++){ + if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1; + } + } + return 0; +} + +/* +** Subqueries stores the original database, table and column names for their +** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN". +** Check to see if the zSpan given to this routine matches the zDb, zTab, +** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will +** match anything. +*/ +SQLITE_PRIVATE int sqlite3MatchSpanName( + const char *zSpan, + const char *zCol, + const char *zTab, + const char *zDb +){ + int n; + for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){} + if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){ + return 0; + } + zSpan += n+1; + for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){} + if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){ + return 0; + } + zSpan += n+1; + if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){ + return 0; + } + return 1; +} + +/* +** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up +** that name in the set of source tables in pSrcList and make the pExpr +** expression node refer back to that source column. The following changes +** are made to pExpr: +** +** pExpr->iDb Set the index in db->aDb[] of the database X +** (even if X is implied). +** pExpr->iTable Set to the cursor number for the table obtained +** from pSrcList. +** pExpr->pTab Points to the Table structure of X.Y (even if +** X and/or Y are implied.) +** pExpr->iColumn Set to the column number within the table. +** pExpr->op Set to TK_COLUMN. +** pExpr->pLeft Any expression this points to is deleted +** pExpr->pRight Any expression this points to is deleted. +** +** The zDb variable is the name of the database (the "X"). This value may be +** NULL meaning that name is of the form Y.Z or Z. Any available database +** can be used. The zTable variable is the name of the table (the "Y"). This +** value can be NULL if zDb is also NULL. If zTable is NULL it +** means that the form of the name is Z and that columns from any table +** can be used. +** +** If the name cannot be resolved unambiguously, leave an error message +** in pParse and return WRC_Abort. Return WRC_Prune on success. +*/ +static int lookupName( + Parse *pParse, /* The parsing context */ + const char *zDb, /* Name of the database containing table, or NULL */ + const char *zTab, /* Name of table containing column, or NULL */ + const char *zCol, /* Name of the column. */ + NameContext *pNC, /* The name context used to resolve the name */ + Expr *pExpr /* Make this EXPR node point to the selected column */ +){ + int i, j; /* Loop counters */ + int cnt = 0; /* Number of matching column names */ + int cntTab = 0; /* Number of matching table names */ + int nSubquery = 0; /* How many levels of subquery */ + sqlite3 *db = pParse->db; /* The database connection */ + struct SrcList_item *pItem; /* Use for looping over pSrcList items */ + struct SrcList_item *pMatch = 0; /* The matching pSrcList item */ + NameContext *pTopNC = pNC; /* First namecontext in the list */ + Schema *pSchema = 0; /* Schema of the expression */ + int isTrigger = 0; /* True if resolved to a trigger column */ + Table *pTab = 0; /* Table hold the row */ + Column *pCol; /* A column of pTab */ + + assert( pNC ); /* the name context cannot be NULL. */ + assert( zCol ); /* The Z in X.Y.Z cannot be NULL */ + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + + /* Initialize the node to no-match */ + pExpr->iTable = -1; + pExpr->pTab = 0; + ExprSetVVAProperty(pExpr, EP_NoReduce); + + /* Translate the schema name in zDb into a pointer to the corresponding + ** schema. If not found, pSchema will remain NULL and nothing will match + ** resulting in an appropriate error message toward the end of this routine + */ + if( zDb ){ + testcase( pNC->ncFlags & NC_PartIdx ); + testcase( pNC->ncFlags & NC_IsCheck ); + if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){ + /* Silently ignore database qualifiers inside CHECK constraints and + ** partial indices. Do not raise errors because that might break + ** legacy and because it does not hurt anything to just ignore the + ** database name. */ + zDb = 0; + }else{ + for(i=0; inDb; i++){ + assert( db->aDb[i].zName ); + if( sqlite3StrICmp(db->aDb[i].zName,zDb)==0 ){ + pSchema = db->aDb[i].pSchema; + break; + } + } + } + } + + /* Start at the inner-most context and move outward until a match is found */ + while( pNC && cnt==0 ){ + ExprList *pEList; + SrcList *pSrcList = pNC->pSrcList; + + if( pSrcList ){ + for(i=0, pItem=pSrcList->a; inSrc; i++, pItem++){ + pTab = pItem->pTab; + assert( pTab!=0 && pTab->zName!=0 ); + assert( pTab->nCol>0 ); + if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){ + int hit = 0; + pEList = pItem->pSelect->pEList; + for(j=0; jnExpr; j++){ + if( sqlite3MatchSpanName(pEList->a[j].zSpan, zCol, zTab, zDb) ){ + cnt++; + cntTab = 2; + pMatch = pItem; + pExpr->iColumn = j; + hit = 1; + } + } + if( hit || zTab==0 ) continue; + } + if( zDb && pTab->pSchema!=pSchema ){ + continue; + } + if( zTab ){ + const char *zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName; + assert( zTabName!=0 ); + if( sqlite3StrICmp(zTabName, zTab)!=0 ){ + continue; + } + } + if( 0==(cntTab++) ){ + pMatch = pItem; + } + for(j=0, pCol=pTab->aCol; jnCol; j++, pCol++){ + if( sqlite3StrICmp(pCol->zName, zCol)==0 ){ + /* If there has been exactly one prior match and this match + ** is for the right-hand table of a NATURAL JOIN or is in a + ** USING clause, then skip this match. + */ + if( cnt==1 ){ + if( pItem->fg.jointype & JT_NATURAL ) continue; + if( nameInUsingClause(pItem->pUsing, zCol) ) continue; + } + cnt++; + pMatch = pItem; + /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ + pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j; + break; + } + } + } + if( pMatch ){ + pExpr->iTable = pMatch->iCursor; + pExpr->pTab = pMatch->pTab; + /* RIGHT JOIN not (yet) supported */ + assert( (pMatch->fg.jointype & JT_RIGHT)==0 ); + if( (pMatch->fg.jointype & JT_LEFT)!=0 ){ + ExprSetProperty(pExpr, EP_CanBeNull); + } + pSchema = pExpr->pTab->pSchema; + } + } /* if( pSrcList ) */ + +#ifndef SQLITE_OMIT_TRIGGER + /* If we have not already resolved the name, then maybe + ** it is a new.* or old.* trigger argument reference + */ + if( zDb==0 && zTab!=0 && cntTab==0 && pParse->pTriggerTab!=0 ){ + int op = pParse->eTriggerOp; + assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT ); + if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){ + pExpr->iTable = 1; + pTab = pParse->pTriggerTab; + }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){ + pExpr->iTable = 0; + pTab = pParse->pTriggerTab; + }else{ + pTab = 0; + } + + if( pTab ){ + int iCol; + pSchema = pTab->pSchema; + cntTab++; + for(iCol=0, pCol=pTab->aCol; iColnCol; iCol++, pCol++){ + if( sqlite3StrICmp(pCol->zName, zCol)==0 ){ + if( iCol==pTab->iPKey ){ + iCol = -1; + } + break; + } + } + if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){ + /* IMP: R-51414-32910 */ + /* IMP: R-44911-55124 */ + iCol = -1; + } + if( iColnCol ){ + cnt++; + if( iCol<0 ){ + pExpr->affinity = SQLITE_AFF_INTEGER; + }else if( pExpr->iTable==0 ){ + testcase( iCol==31 ); + testcase( iCol==32 ); + pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<iColumn = (i16)iCol; + pExpr->pTab = pTab; + isTrigger = 1; + } + } + } +#endif /* !defined(SQLITE_OMIT_TRIGGER) */ + + /* + ** Perhaps the name is a reference to the ROWID + */ + if( cnt==0 + && cntTab==1 + && pMatch + && (pNC->ncFlags & NC_IdxExpr)==0 + && sqlite3IsRowid(zCol) + && VisibleRowid(pMatch->pTab) + ){ + cnt = 1; + pExpr->iColumn = -1; /* IMP: R-44911-55124 */ + pExpr->affinity = SQLITE_AFF_INTEGER; + } + + /* + ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z + ** might refer to an result-set alias. This happens, for example, when + ** we are resolving names in the WHERE clause of the following command: + ** + ** SELECT a+b AS x FROM table WHERE x<10; + ** + ** In cases like this, replace pExpr with a copy of the expression that + ** forms the result set entry ("a+b" in the example) and return immediately. + ** Note that the expression in the result set should have already been + ** resolved by the time the WHERE clause is resolved. + ** + ** The ability to use an output result-set column in the WHERE, GROUP BY, + ** or HAVING clauses, or as part of a larger expression in the ORDER BY + ** clause is not standard SQL. This is a (goofy) SQLite extension, that + ** is supported for backwards compatibility only. Hence, we issue a warning + ** on sqlite3_log() whenever the capability is used. + */ + if( (pEList = pNC->pEList)!=0 + && zTab==0 + && cnt==0 + ){ + for(j=0; jnExpr; j++){ + char *zAs = pEList->a[j].zName; + if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){ + Expr *pOrig; + assert( pExpr->pLeft==0 && pExpr->pRight==0 ); + assert( pExpr->x.pList==0 ); + assert( pExpr->x.pSelect==0 ); + pOrig = pEList->a[j].pExpr; + if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){ + sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs); + return WRC_Abort; + } + resolveAlias(pParse, pEList, j, pExpr, "", nSubquery); + cnt = 1; + pMatch = 0; + assert( zTab==0 && zDb==0 ); + goto lookupname_end; + } + } + } + + /* Advance to the next name context. The loop will exit when either + ** we have a match (cnt>0) or when we run out of name contexts. + */ + if( cnt==0 ){ + pNC = pNC->pNext; + nSubquery++; + } + } + + /* + ** If X and Y are NULL (in other words if only the column name Z is + ** supplied) and the value of Z is enclosed in double-quotes, then + ** Z is a string literal if it doesn't match any column names. In that + ** case, we need to return right away and not make any changes to + ** pExpr. + ** + ** Because no reference was made to outer contexts, the pNC->nRef + ** fields are not changed in any context. + */ + if( cnt==0 && zTab==0 && ExprHasProperty(pExpr,EP_DblQuoted) ){ + pExpr->op = TK_STRING; + pExpr->pTab = 0; + return WRC_Prune; + } + + /* + ** cnt==0 means there was not match. cnt>1 means there were two or + ** more matches. Either way, we have an error. + */ + if( cnt!=1 ){ + const char *zErr; + zErr = cnt==0 ? "no such column" : "ambiguous column name"; + if( zDb ){ + sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol); + }else if( zTab ){ + sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol); + }else{ + sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol); + } + pParse->checkSchema = 1; + pTopNC->nErr++; + } + + /* If a column from a table in pSrcList is referenced, then record + ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes + ** bit 0 to be set. Column 1 sets bit 1. And so forth. If the + ** column number is greater than the number of bits in the bitmask + ** then set the high-order bit of the bitmask. + */ + if( pExpr->iColumn>=0 && pMatch!=0 ){ + int n = pExpr->iColumn; + testcase( n==BMS-1 ); + if( n>=BMS ){ + n = BMS-1; + } + assert( pMatch->iCursor==pExpr->iTable ); + pMatch->colUsed |= ((Bitmask)1)<pLeft); + pExpr->pLeft = 0; + sqlite3ExprDelete(db, pExpr->pRight); + pExpr->pRight = 0; + pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN); +lookupname_end: + if( cnt==1 ){ + assert( pNC!=0 ); + if( !ExprHasProperty(pExpr, EP_Alias) ){ + sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList); + } + /* Increment the nRef value on all name contexts from TopNC up to + ** the point where the name matched. */ + for(;;){ + assert( pTopNC!=0 ); + pTopNC->nRef++; + if( pTopNC==pNC ) break; + pTopNC = pTopNC->pNext; + } + return WRC_Prune; + } else { + return WRC_Abort; + } +} + +/* +** Allocate and return a pointer to an expression to load the column iCol +** from datasource iSrc in SrcList pSrc. +*/ +SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){ + Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0); + if( p ){ + struct SrcList_item *pItem = &pSrc->a[iSrc]; + p->pTab = pItem->pTab; + p->iTable = pItem->iCursor; + if( p->pTab->iPKey==iCol ){ + p->iColumn = -1; + }else{ + p->iColumn = (ynVar)iCol; + testcase( iCol==BMS ); + testcase( iCol==BMS-1 ); + pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol); + } + ExprSetProperty(p, EP_Resolved); + } + return p; +} + +/* +** Report an error that an expression is not valid for some set of +** pNC->ncFlags values determined by validMask. +*/ +static void notValid( + Parse *pParse, /* Leave error message here */ + NameContext *pNC, /* The name context */ + const char *zMsg, /* Type of error */ + int validMask /* Set of contexts for which prohibited */ +){ + assert( (validMask&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr))==0 ); + if( (pNC->ncFlags & validMask)!=0 ){ + const char *zIn = "partial index WHERE clauses"; + if( pNC->ncFlags & NC_IdxExpr ) zIn = "index expressions"; +#ifndef SQLITE_OMIT_CHECK + else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints"; +#endif + sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn); + } +} + +/* +** Expression p should encode a floating point value between 1.0 and 0.0. +** Return 1024 times this value. Or return -1 if p is not a floating point +** value between 1.0 and 0.0. +*/ +static int exprProbability(Expr *p){ + double r = -1.0; + if( p->op!=TK_FLOAT ) return -1; + sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8); + assert( r>=0.0 ); + if( r>1.0 ) return -1; + return (int)(r*134217728.0); +} + +/* +** This routine is callback for sqlite3WalkExpr(). +** +** Resolve symbolic names into TK_COLUMN operators for the current +** node in the expression tree. Return 0 to continue the search down +** the tree or 2 to abort the tree walk. +** +** This routine also does error checking and name resolution for +** function names. The operator for aggregate functions is changed +** to TK_AGG_FUNCTION. +*/ +static int resolveExprStep(Walker *pWalker, Expr *pExpr){ + NameContext *pNC; + Parse *pParse; + + pNC = pWalker->u.pNC; + assert( pNC!=0 ); + pParse = pNC->pParse; + assert( pParse==pWalker->pParse ); + + if( ExprHasProperty(pExpr, EP_Resolved) ) return WRC_Prune; + ExprSetProperty(pExpr, EP_Resolved); +#ifndef NDEBUG + if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){ + SrcList *pSrcList = pNC->pSrcList; + int i; + for(i=0; ipSrcList->nSrc; i++){ + assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursornTab); + } + } +#endif + switch( pExpr->op ){ + +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) + /* The special operator TK_ROW means use the rowid for the first + ** column in the FROM clause. This is used by the LIMIT and ORDER BY + ** clause processing on UPDATE and DELETE statements. + */ + case TK_ROW: { + SrcList *pSrcList = pNC->pSrcList; + struct SrcList_item *pItem; + assert( pSrcList && pSrcList->nSrc==1 ); + pItem = pSrcList->a; + pExpr->op = TK_COLUMN; + pExpr->pTab = pItem->pTab; + pExpr->iTable = pItem->iCursor; + pExpr->iColumn = -1; + pExpr->affinity = SQLITE_AFF_INTEGER; + break; + } +#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) + && !defined(SQLITE_OMIT_SUBQUERY) */ + + /* A lone identifier is the name of a column. + */ + case TK_ID: { + return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr); + } + + /* A table name and column name: ID.ID + ** Or a database, table and column: ID.ID.ID + */ + case TK_DOT: { + const char *zColumn; + const char *zTable; + const char *zDb; + Expr *pRight; + + /* if( pSrcList==0 ) break; */ + notValid(pParse, pNC, "the \".\" operator", NC_IdxExpr); + /*notValid(pParse, pNC, "the \".\" operator", NC_PartIdx|NC_IsCheck, 1);*/ + pRight = pExpr->pRight; + if( pRight->op==TK_ID ){ + zDb = 0; + zTable = pExpr->pLeft->u.zToken; + zColumn = pRight->u.zToken; + }else{ + assert( pRight->op==TK_DOT ); + zDb = pExpr->pLeft->u.zToken; + zTable = pRight->pLeft->u.zToken; + zColumn = pRight->pRight->u.zToken; + } + return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr); + } + + /* Resolve function names + */ + case TK_FUNCTION: { + ExprList *pList = pExpr->x.pList; /* The argument list */ + int n = pList ? pList->nExpr : 0; /* Number of arguments */ + int no_such_func = 0; /* True if no such function exists */ + int wrong_num_args = 0; /* True if wrong number of arguments */ + int is_agg = 0; /* True if is an aggregate function */ + int auth; /* Authorization to use the function */ + int nId; /* Number of characters in function name */ + const char *zId; /* The function name. */ + FuncDef *pDef; /* Information about the function */ + u8 enc = ENC(pParse->db); /* The database encoding */ + + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + notValid(pParse, pNC, "functions", NC_PartIdx); + zId = pExpr->u.zToken; + nId = sqlite3Strlen30(zId); + pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0); + if( pDef==0 ){ + pDef = sqlite3FindFunction(pParse->db, zId, nId, -2, enc, 0); + if( pDef==0 ){ + no_such_func = 1; + }else{ + wrong_num_args = 1; + } + }else{ + is_agg = pDef->xFunc==0; + if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){ + ExprSetProperty(pExpr, EP_Unlikely|EP_Skip); + if( n==2 ){ + pExpr->iTable = exprProbability(pList->a[1].pExpr); + if( pExpr->iTable<0 ){ + sqlite3ErrorMsg(pParse, + "second argument to likelihood() must be a " + "constant between 0.0 and 1.0"); + pNC->nErr++; + } + }else{ + /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is + ** equivalent to likelihood(X, 0.0625). + ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is + ** short-hand for likelihood(X,0.0625). + ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand + ** for likelihood(X,0.9375). + ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent + ** to likelihood(X,0.9375). */ + /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */ + pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120; + } + } +#ifndef SQLITE_OMIT_AUTHORIZATION + auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0); + if( auth!=SQLITE_OK ){ + if( auth==SQLITE_DENY ){ + sqlite3ErrorMsg(pParse, "not authorized to use function: %s", + pDef->zName); + pNC->nErr++; + } + pExpr->op = TK_NULL; + return WRC_Prune; + } +#endif + if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){ + /* For the purposes of the EP_ConstFunc flag, date and time + ** functions and other functions that change slowly are considered + ** constant because they are constant for the duration of one query */ + ExprSetProperty(pExpr,EP_ConstFunc); + } + if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){ + /* Date/time functions that use 'now', and other functions like + ** sqlite_version() that might change over time cannot be used + ** in an index. */ + notValid(pParse, pNC, "non-deterministic functions", NC_IdxExpr); + } + } + if( is_agg && (pNC->ncFlags & NC_AllowAgg)==0 ){ + sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId); + pNC->nErr++; + is_agg = 0; + }else if( no_such_func && pParse->db->init.busy==0 ){ + sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId); + pNC->nErr++; + }else if( wrong_num_args ){ + sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()", + nId, zId); + pNC->nErr++; + } + if( is_agg ) pNC->ncFlags &= ~NC_AllowAgg; + sqlite3WalkExprList(pWalker, pList); + if( is_agg ){ + NameContext *pNC2 = pNC; + pExpr->op = TK_AGG_FUNCTION; + pExpr->op2 = 0; + while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){ + pExpr->op2++; + pNC2 = pNC2->pNext; + } + assert( pDef!=0 ); + if( pNC2 ){ + assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg ); + testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 ); + pNC2->ncFlags |= NC_HasAgg | (pDef->funcFlags & SQLITE_FUNC_MINMAX); + + } + pNC->ncFlags |= NC_AllowAgg; + } + /* FIX ME: Compute pExpr->affinity based on the expected return + ** type of the function + */ + return WRC_Prune; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: + case TK_EXISTS: testcase( pExpr->op==TK_EXISTS ); +#endif + case TK_IN: { + testcase( pExpr->op==TK_IN ); + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + int nRef = pNC->nRef; + notValid(pParse, pNC, "subqueries", NC_IsCheck|NC_PartIdx|NC_IdxExpr); + sqlite3WalkSelect(pWalker, pExpr->x.pSelect); + assert( pNC->nRef>=nRef ); + if( nRef!=pNC->nRef ){ + ExprSetProperty(pExpr, EP_VarSelect); + } + } + break; + } + case TK_VARIABLE: { + notValid(pParse, pNC, "parameters", NC_IsCheck|NC_PartIdx|NC_IdxExpr); + break; + } + } + return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue; +} + +/* +** pEList is a list of expressions which are really the result set of the +** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause. +** This routine checks to see if pE is a simple identifier which corresponds +** to the AS-name of one of the terms of the expression list. If it is, +** this routine return an integer between 1 and N where N is the number of +** elements in pEList, corresponding to the matching entry. If there is +** no match, or if pE is not a simple identifier, then this routine +** return 0. +** +** pEList has been resolved. pE has not. +*/ +static int resolveAsName( + Parse *pParse, /* Parsing context for error messages */ + ExprList *pEList, /* List of expressions to scan */ + Expr *pE /* Expression we are trying to match */ +){ + int i; /* Loop counter */ + + UNUSED_PARAMETER(pParse); + + if( pE->op==TK_ID ){ + char *zCol = pE->u.zToken; + for(i=0; inExpr; i++){ + char *zAs = pEList->a[i].zName; + if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){ + return i+1; + } + } + } + return 0; +} + +/* +** pE is a pointer to an expression which is a single term in the +** ORDER BY of a compound SELECT. The expression has not been +** name resolved. +** +** At the point this routine is called, we already know that the +** ORDER BY term is not an integer index into the result set. That +** case is handled by the calling routine. +** +** Attempt to match pE against result set columns in the left-most +** SELECT statement. Return the index i of the matching column, +** as an indication to the caller that it should sort by the i-th column. +** The left-most column is 1. In other words, the value returned is the +** same integer value that would be used in the SQL statement to indicate +** the column. +** +** If there is no match, return 0. Return -1 if an error occurs. +*/ +static int resolveOrderByTermToExprList( + Parse *pParse, /* Parsing context for error messages */ + Select *pSelect, /* The SELECT statement with the ORDER BY clause */ + Expr *pE /* The specific ORDER BY term */ +){ + int i; /* Loop counter */ + ExprList *pEList; /* The columns of the result set */ + NameContext nc; /* Name context for resolving pE */ + sqlite3 *db; /* Database connection */ + int rc; /* Return code from subprocedures */ + u8 savedSuppErr; /* Saved value of db->suppressErr */ + + assert( sqlite3ExprIsInteger(pE, &i)==0 ); + pEList = pSelect->pEList; + + /* Resolve all names in the ORDER BY term expression + */ + memset(&nc, 0, sizeof(nc)); + nc.pParse = pParse; + nc.pSrcList = pSelect->pSrc; + nc.pEList = pEList; + nc.ncFlags = NC_AllowAgg; + nc.nErr = 0; + db = pParse->db; + savedSuppErr = db->suppressErr; + db->suppressErr = 1; + rc = sqlite3ResolveExprNames(&nc, pE); + db->suppressErr = savedSuppErr; + if( rc ) return 0; + + /* Try to match the ORDER BY expression against an expression + ** in the result set. Return an 1-based index of the matching + ** result-set entry. + */ + for(i=0; inExpr; i++){ + if( sqlite3ExprCompare(pEList->a[i].pExpr, pE, -1)<2 ){ + return i+1; + } + } + + /* If no match, return 0. */ + return 0; +} + +/* +** Generate an ORDER BY or GROUP BY term out-of-range error. +*/ +static void resolveOutOfRangeError( + Parse *pParse, /* The error context into which to write the error */ + const char *zType, /* "ORDER" or "GROUP" */ + int i, /* The index (1-based) of the term out of range */ + int mx /* Largest permissible value of i */ +){ + sqlite3ErrorMsg(pParse, + "%r %s BY term out of range - should be " + "between 1 and %d", i, zType, mx); +} + +/* +** Analyze the ORDER BY clause in a compound SELECT statement. Modify +** each term of the ORDER BY clause is a constant integer between 1 +** and N where N is the number of columns in the compound SELECT. +** +** ORDER BY terms that are already an integer between 1 and N are +** unmodified. ORDER BY terms that are integers outside the range of +** 1 through N generate an error. ORDER BY terms that are expressions +** are matched against result set expressions of compound SELECT +** beginning with the left-most SELECT and working toward the right. +** At the first match, the ORDER BY expression is transformed into +** the integer column number. +** +** Return the number of errors seen. +*/ +static int resolveCompoundOrderBy( + Parse *pParse, /* Parsing context. Leave error messages here */ + Select *pSelect /* The SELECT statement containing the ORDER BY */ +){ + int i; + ExprList *pOrderBy; + ExprList *pEList; + sqlite3 *db; + int moreToDo = 1; + + pOrderBy = pSelect->pOrderBy; + if( pOrderBy==0 ) return 0; + db = pParse->db; +#if SQLITE_MAX_COLUMN + if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause"); + return 1; + } +#endif + for(i=0; inExpr; i++){ + pOrderBy->a[i].done = 0; + } + pSelect->pNext = 0; + while( pSelect->pPrior ){ + pSelect->pPrior->pNext = pSelect; + pSelect = pSelect->pPrior; + } + while( pSelect && moreToDo ){ + struct ExprList_item *pItem; + moreToDo = 0; + pEList = pSelect->pEList; + assert( pEList!=0 ); + for(i=0, pItem=pOrderBy->a; inExpr; i++, pItem++){ + int iCol = -1; + Expr *pE, *pDup; + if( pItem->done ) continue; + pE = sqlite3ExprSkipCollate(pItem->pExpr); + if( sqlite3ExprIsInteger(pE, &iCol) ){ + if( iCol<=0 || iCol>pEList->nExpr ){ + resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr); + return 1; + } + }else{ + iCol = resolveAsName(pParse, pEList, pE); + if( iCol==0 ){ + pDup = sqlite3ExprDup(db, pE, 0); + if( !db->mallocFailed ){ + assert(pDup); + iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup); + } + sqlite3ExprDelete(db, pDup); + } + } + if( iCol>0 ){ + /* Convert the ORDER BY term into an integer column number iCol, + ** taking care to preserve the COLLATE clause if it exists */ + Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); + if( pNew==0 ) return 1; + pNew->flags |= EP_IntValue; + pNew->u.iValue = iCol; + if( pItem->pExpr==pE ){ + pItem->pExpr = pNew; + }else{ + Expr *pParent = pItem->pExpr; + assert( pParent->op==TK_COLLATE ); + while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft; + assert( pParent->pLeft==pE ); + pParent->pLeft = pNew; + } + sqlite3ExprDelete(db, pE); + pItem->u.x.iOrderByCol = (u16)iCol; + pItem->done = 1; + }else{ + moreToDo = 1; + } + } + pSelect = pSelect->pNext; + } + for(i=0; inExpr; i++){ + if( pOrderBy->a[i].done==0 ){ + sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any " + "column in the result set", i+1); + return 1; + } + } + return 0; +} + +/* +** Check every term in the ORDER BY or GROUP BY clause pOrderBy of +** the SELECT statement pSelect. If any term is reference to a +** result set expression (as determined by the ExprList.a.u.x.iOrderByCol +** field) then convert that term into a copy of the corresponding result set +** column. +** +** If any errors are detected, add an error message to pParse and +** return non-zero. Return zero if no errors are seen. +*/ +SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy( + Parse *pParse, /* Parsing context. Leave error messages here */ + Select *pSelect, /* The SELECT statement containing the clause */ + ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */ + const char *zType /* "ORDER" or "GROUP" */ +){ + int i; + sqlite3 *db = pParse->db; + ExprList *pEList; + struct ExprList_item *pItem; + + if( pOrderBy==0 || pParse->db->mallocFailed ) return 0; +#if SQLITE_MAX_COLUMN + if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType); + return 1; + } +#endif + pEList = pSelect->pEList; + assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */ + for(i=0, pItem=pOrderBy->a; inExpr; i++, pItem++){ + if( pItem->u.x.iOrderByCol ){ + if( pItem->u.x.iOrderByCol>pEList->nExpr ){ + resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr); + return 1; + } + resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr, + zType,0); + } + } + return 0; +} + +/* +** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect. +** The Name context of the SELECT statement is pNC. zType is either +** "ORDER" or "GROUP" depending on which type of clause pOrderBy is. +** +** This routine resolves each term of the clause into an expression. +** If the order-by term is an integer I between 1 and N (where N is the +** number of columns in the result set of the SELECT) then the expression +** in the resolution is a copy of the I-th result-set expression. If +** the order-by term is an identifier that corresponds to the AS-name of +** a result-set expression, then the term resolves to a copy of the +** result-set expression. Otherwise, the expression is resolved in +** the usual way - using sqlite3ResolveExprNames(). +** +** This routine returns the number of errors. If errors occur, then +** an appropriate error message might be left in pParse. (OOM errors +** excepted.) +*/ +static int resolveOrderGroupBy( + NameContext *pNC, /* The name context of the SELECT statement */ + Select *pSelect, /* The SELECT statement holding pOrderBy */ + ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */ + const char *zType /* Either "ORDER" or "GROUP", as appropriate */ +){ + int i, j; /* Loop counters */ + int iCol; /* Column number */ + struct ExprList_item *pItem; /* A term of the ORDER BY clause */ + Parse *pParse; /* Parsing context */ + int nResult; /* Number of terms in the result set */ + + if( pOrderBy==0 ) return 0; + nResult = pSelect->pEList->nExpr; + pParse = pNC->pParse; + for(i=0, pItem=pOrderBy->a; inExpr; i++, pItem++){ + Expr *pE = pItem->pExpr; + Expr *pE2 = sqlite3ExprSkipCollate(pE); + if( zType[0]!='G' ){ + iCol = resolveAsName(pParse, pSelect->pEList, pE2); + if( iCol>0 ){ + /* If an AS-name match is found, mark this ORDER BY column as being + ** a copy of the iCol-th result-set column. The subsequent call to + ** sqlite3ResolveOrderGroupBy() will convert the expression to a + ** copy of the iCol-th result-set expression. */ + pItem->u.x.iOrderByCol = (u16)iCol; + continue; + } + } + if( sqlite3ExprIsInteger(pE2, &iCol) ){ + /* The ORDER BY term is an integer constant. Again, set the column + ** number so that sqlite3ResolveOrderGroupBy() will convert the + ** order-by term to a copy of the result-set expression */ + if( iCol<1 || iCol>0xffff ){ + resolveOutOfRangeError(pParse, zType, i+1, nResult); + return 1; + } + pItem->u.x.iOrderByCol = (u16)iCol; + continue; + } + + /* Otherwise, treat the ORDER BY term as an ordinary expression */ + pItem->u.x.iOrderByCol = 0; + if( sqlite3ResolveExprNames(pNC, pE) ){ + return 1; + } + for(j=0; jpEList->nExpr; j++){ + if( sqlite3ExprCompare(pE, pSelect->pEList->a[j].pExpr, -1)==0 ){ + pItem->u.x.iOrderByCol = j+1; + } + } + } + return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType); +} + +/* +** Resolve names in the SELECT statement p and all of its descendants. +*/ +static int resolveSelectStep(Walker *pWalker, Select *p){ + NameContext *pOuterNC; /* Context that contains this SELECT */ + NameContext sNC; /* Name context of this SELECT */ + int isCompound; /* True if p is a compound select */ + int nCompound; /* Number of compound terms processed so far */ + Parse *pParse; /* Parsing context */ + int i; /* Loop counter */ + ExprList *pGroupBy; /* The GROUP BY clause */ + Select *pLeftmost; /* Left-most of SELECT of a compound */ + sqlite3 *db; /* Database connection */ + + + assert( p!=0 ); + if( p->selFlags & SF_Resolved ){ + return WRC_Prune; + } + pOuterNC = pWalker->u.pNC; + pParse = pWalker->pParse; + db = pParse->db; + + /* Normally sqlite3SelectExpand() will be called first and will have + ** already expanded this SELECT. However, if this is a subquery within + ** an expression, sqlite3ResolveExprNames() will be called without a + ** prior call to sqlite3SelectExpand(). When that happens, let + ** sqlite3SelectPrep() do all of the processing for this SELECT. + ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and + ** this routine in the correct order. + */ + if( (p->selFlags & SF_Expanded)==0 ){ + sqlite3SelectPrep(pParse, p, pOuterNC); + return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune; + } + + isCompound = p->pPrior!=0; + nCompound = 0; + pLeftmost = p; + while( p ){ + assert( (p->selFlags & SF_Expanded)!=0 ); + assert( (p->selFlags & SF_Resolved)==0 ); + p->selFlags |= SF_Resolved; + + /* Resolve the expressions in the LIMIT and OFFSET clauses. These + ** are not allowed to refer to any names, so pass an empty NameContext. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + if( sqlite3ResolveExprNames(&sNC, p->pLimit) || + sqlite3ResolveExprNames(&sNC, p->pOffset) ){ + return WRC_Abort; + } + + /* If the SF_Converted flags is set, then this Select object was + ** was created by the convertCompoundSelectToSubquery() function. + ** In this case the ORDER BY clause (p->pOrderBy) should be resolved + ** as if it were part of the sub-query, not the parent. This block + ** moves the pOrderBy down to the sub-query. It will be moved back + ** after the names have been resolved. */ + if( p->selFlags & SF_Converted ){ + Select *pSub = p->pSrc->a[0].pSelect; + assert( p->pSrc->nSrc==1 && p->pOrderBy ); + assert( pSub->pPrior && pSub->pOrderBy==0 ); + pSub->pOrderBy = p->pOrderBy; + p->pOrderBy = 0; + } + + /* Recursively resolve names in all subqueries + */ + for(i=0; ipSrc->nSrc; i++){ + struct SrcList_item *pItem = &p->pSrc->a[i]; + if( pItem->pSelect ){ + NameContext *pNC; /* Used to iterate name contexts */ + int nRef = 0; /* Refcount for pOuterNC and outer contexts */ + const char *zSavedContext = pParse->zAuthContext; + + /* Count the total number of references to pOuterNC and all of its + ** parent contexts. After resolving references to expressions in + ** pItem->pSelect, check if this value has changed. If so, then + ** SELECT statement pItem->pSelect must be correlated. Set the + ** pItem->fg.isCorrelated flag if this is the case. */ + for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef; + + if( pItem->zName ) pParse->zAuthContext = pItem->zName; + sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC); + pParse->zAuthContext = zSavedContext; + if( pParse->nErr || db->mallocFailed ) return WRC_Abort; + + for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef; + assert( pItem->fg.isCorrelated==0 && nRef<=0 ); + pItem->fg.isCorrelated = (nRef!=0); + } + } + + /* Set up the local name-context to pass to sqlite3ResolveExprNames() to + ** resolve the result-set expression list. + */ + sNC.ncFlags = NC_AllowAgg; + sNC.pSrcList = p->pSrc; + sNC.pNext = pOuterNC; + + /* Resolve names in the result set. */ + if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort; + + /* If there are no aggregate functions in the result-set, and no GROUP BY + ** expression, do not allow aggregates in any of the other expressions. + */ + assert( (p->selFlags & SF_Aggregate)==0 ); + pGroupBy = p->pGroupBy; + if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){ + assert( NC_MinMaxAgg==SF_MinMaxAgg ); + p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg); + }else{ + sNC.ncFlags &= ~NC_AllowAgg; + } + + /* If a HAVING clause is present, then there must be a GROUP BY clause. + */ + if( p->pHaving && !pGroupBy ){ + sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING"); + return WRC_Abort; + } + + /* Add the output column list to the name-context before parsing the + ** other expressions in the SELECT statement. This is so that + ** expressions in the WHERE clause (etc.) can refer to expressions by + ** aliases in the result set. + ** + ** Minor point: If this is the case, then the expression will be + ** re-evaluated for each reference to it. + */ + sNC.pEList = p->pEList; + if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort; + if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort; + + /* Resolve names in table-valued-function arguments */ + for(i=0; ipSrc->nSrc; i++){ + struct SrcList_item *pItem = &p->pSrc->a[i]; + if( pItem->fg.isTabFunc + && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg) + ){ + return WRC_Abort; + } + } + + /* The ORDER BY and GROUP BY clauses may not refer to terms in + ** outer queries + */ + sNC.pNext = 0; + sNC.ncFlags |= NC_AllowAgg; + + /* If this is a converted compound query, move the ORDER BY clause from + ** the sub-query back to the parent query. At this point each term + ** within the ORDER BY clause has been transformed to an integer value. + ** These integers will be replaced by copies of the corresponding result + ** set expressions by the call to resolveOrderGroupBy() below. */ + if( p->selFlags & SF_Converted ){ + Select *pSub = p->pSrc->a[0].pSelect; + p->pOrderBy = pSub->pOrderBy; + pSub->pOrderBy = 0; + } + + /* Process the ORDER BY clause for singleton SELECT statements. + ** The ORDER BY clause for compounds SELECT statements is handled + ** below, after all of the result-sets for all of the elements of + ** the compound have been resolved. + ** + ** If there is an ORDER BY clause on a term of a compound-select other + ** than the right-most term, then that is a syntax error. But the error + ** is not detected until much later, and so we need to go ahead and + ** resolve those symbols on the incorrect ORDER BY for consistency. + */ + if( isCompound<=nCompound /* Defer right-most ORDER BY of a compound */ + && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER") + ){ + return WRC_Abort; + } + if( db->mallocFailed ){ + return WRC_Abort; + } + + /* Resolve the GROUP BY clause. At the same time, make sure + ** the GROUP BY clause does not contain aggregate functions. + */ + if( pGroupBy ){ + struct ExprList_item *pItem; + + if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){ + return WRC_Abort; + } + for(i=0, pItem=pGroupBy->a; inExpr; i++, pItem++){ + if( ExprHasProperty(pItem->pExpr, EP_Agg) ){ + sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in " + "the GROUP BY clause"); + return WRC_Abort; + } + } + } + + /* If this is part of a compound SELECT, check that it has the right + ** number of expressions in the select list. */ + if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){ + sqlite3SelectWrongNumTermsError(pParse, p->pNext); + return WRC_Abort; + } + + /* Advance to the next term of the compound + */ + p = p->pPrior; + nCompound++; + } + + /* Resolve the ORDER BY on a compound SELECT after all terms of + ** the compound have been resolved. + */ + if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){ + return WRC_Abort; + } + + return WRC_Prune; +} + +/* +** This routine walks an expression tree and resolves references to +** table columns and result-set columns. At the same time, do error +** checking on function usage and set a flag if any aggregate functions +** are seen. +** +** To resolve table columns references we look for nodes (or subtrees) of the +** form X.Y.Z or Y.Z or just Z where +** +** X: The name of a database. Ex: "main" or "temp" or +** the symbolic name assigned to an ATTACH-ed database. +** +** Y: The name of a table in a FROM clause. Or in a trigger +** one of the special names "old" or "new". +** +** Z: The name of a column in table Y. +** +** The node at the root of the subtree is modified as follows: +** +** Expr.op Changed to TK_COLUMN +** Expr.pTab Points to the Table object for X.Y +** Expr.iColumn The column index in X.Y. -1 for the rowid. +** Expr.iTable The VDBE cursor number for X.Y +** +** +** To resolve result-set references, look for expression nodes of the +** form Z (with no X and Y prefix) where the Z matches the right-hand +** size of an AS clause in the result-set of a SELECT. The Z expression +** is replaced by a copy of the left-hand side of the result-set expression. +** Table-name and function resolution occurs on the substituted expression +** tree. For example, in: +** +** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x; +** +** The "x" term of the order by is replaced by "a+b" to render: +** +** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b; +** +** Function calls are checked to make sure that the function is +** defined and that the correct number of arguments are specified. +** If the function is an aggregate function, then the NC_HasAgg flag is +** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION. +** If an expression contains aggregate functions then the EP_Agg +** property on the expression is set. +** +** An error message is left in pParse if anything is amiss. The number +** if errors is returned. +*/ +SQLITE_PRIVATE int sqlite3ResolveExprNames( + NameContext *pNC, /* Namespace to resolve expressions in. */ + Expr *pExpr /* The expression to be analyzed. */ +){ + u16 savedHasAgg; + Walker w; + + if( pExpr==0 ) return 0; +#if SQLITE_MAX_EXPR_DEPTH>0 + { + Parse *pParse = pNC->pParse; + if( sqlite3ExprCheckHeight(pParse, pExpr->nHeight+pNC->pParse->nHeight) ){ + return 1; + } + pParse->nHeight += pExpr->nHeight; + } +#endif + savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg); + pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg); + memset(&w, 0, sizeof(w)); + w.xExprCallback = resolveExprStep; + w.xSelectCallback = resolveSelectStep; + w.pParse = pNC->pParse; + w.u.pNC = pNC; + sqlite3WalkExpr(&w, pExpr); +#if SQLITE_MAX_EXPR_DEPTH>0 + pNC->pParse->nHeight -= pExpr->nHeight; +#endif + if( pNC->nErr>0 || w.pParse->nErr>0 ){ + ExprSetProperty(pExpr, EP_Error); + } + if( pNC->ncFlags & NC_HasAgg ){ + ExprSetProperty(pExpr, EP_Agg); + } + pNC->ncFlags |= savedHasAgg; + return ExprHasProperty(pExpr, EP_Error); +} + +/* +** Resolve all names for all expression in an expression list. This is +** just like sqlite3ResolveExprNames() except that it works for an expression +** list rather than a single expression. +*/ +SQLITE_PRIVATE int sqlite3ResolveExprListNames( + NameContext *pNC, /* Namespace to resolve expressions in. */ + ExprList *pList /* The expression list to be analyzed. */ +){ + int i; + assert( pList!=0 ); + for(i=0; inExpr; i++){ + if( sqlite3ResolveExprNames(pNC, pList->a[i].pExpr) ) return WRC_Abort; + } + return WRC_Continue; +} + +/* +** Resolve all names in all expressions of a SELECT and in all +** decendents of the SELECT, including compounds off of p->pPrior, +** subqueries in expressions, and subqueries used as FROM clause +** terms. +** +** See sqlite3ResolveExprNames() for a description of the kinds of +** transformations that occur. +** +** All SELECT statements should have been expanded using +** sqlite3SelectExpand() prior to invoking this routine. +*/ +SQLITE_PRIVATE void sqlite3ResolveSelectNames( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + NameContext *pOuterNC /* Name context for parent SELECT statement */ +){ + Walker w; + + assert( p!=0 ); + memset(&w, 0, sizeof(w)); + w.xExprCallback = resolveExprStep; + w.xSelectCallback = resolveSelectStep; + w.pParse = pParse; + w.u.pNC = pOuterNC; + sqlite3WalkSelect(&w, p); +} + +/* +** Resolve names in expressions that can only reference a single table: +** +** * CHECK constraints +** * WHERE clauses on partial indices +** +** The Expr.iTable value for Expr.op==TK_COLUMN nodes of the expression +** is set to -1 and the Expr.iColumn value is set to the column number. +** +** Any errors cause an error message to be set in pParse. +*/ +SQLITE_PRIVATE void sqlite3ResolveSelfReference( + Parse *pParse, /* Parsing context */ + Table *pTab, /* The table being referenced */ + int type, /* NC_IsCheck or NC_PartIdx or NC_IdxExpr */ + Expr *pExpr, /* Expression to resolve. May be NULL. */ + ExprList *pList /* Expression list to resolve. May be NUL. */ +){ + SrcList sSrc; /* Fake SrcList for pParse->pNewTable */ + NameContext sNC; /* Name context for pParse->pNewTable */ + + assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr ); + memset(&sNC, 0, sizeof(sNC)); + memset(&sSrc, 0, sizeof(sSrc)); + sSrc.nSrc = 1; + sSrc.a[0].zName = pTab->zName; + sSrc.a[0].pTab = pTab; + sSrc.a[0].iCursor = -1; + sNC.pParse = pParse; + sNC.pSrcList = &sSrc; + sNC.ncFlags = type; + if( sqlite3ResolveExprNames(&sNC, pExpr) ) return; + if( pList ) sqlite3ResolveExprListNames(&sNC, pList); +} + +/************** End of resolve.c *********************************************/ +/************** Begin file expr.c ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used for analyzing expressions and +** for generating VDBE code that evaluates expressions in SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* +** Return the 'affinity' of the expression pExpr if any. +** +** If pExpr is a column, a reference to a column via an 'AS' alias, +** or a sub-select with a column as the return value, then the +** affinity of that column is returned. Otherwise, 0x00 is returned, +** indicating no affinity for the expression. +** +** i.e. the WHERE clause expressions in the following statements all +** have an affinity: +** +** CREATE TABLE t1(a); +** SELECT * FROM t1 WHERE a; +** SELECT a AS b FROM t1 WHERE b; +** SELECT * FROM t1 WHERE (select a from t1); +*/ +SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr){ + int op; + pExpr = sqlite3ExprSkipCollate(pExpr); + if( pExpr->flags & EP_Generic ) return 0; + op = pExpr->op; + if( op==TK_SELECT ){ + assert( pExpr->flags&EP_xIsSelect ); + return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr); + } +#ifndef SQLITE_OMIT_CAST + if( op==TK_CAST ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + return sqlite3AffinityType(pExpr->u.zToken, 0); + } +#endif + if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER) + && pExpr->pTab!=0 + ){ + /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally + ** a TK_COLUMN but was previously evaluated and cached in a register */ + int j = pExpr->iColumn; + if( j<0 ) return SQLITE_AFF_INTEGER; + assert( pExpr->pTab && jpTab->nCol ); + return pExpr->pTab->aCol[j].affinity; + } + return pExpr->affinity; +} + +/* +** Set the collating sequence for expression pExpr to be the collating +** sequence named by pToken. Return a pointer to a new Expr node that +** implements the COLLATE operator. +** +** If a memory allocation error occurs, that fact is recorded in pParse->db +** and the pExpr parameter is returned unchanged. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* Add the "COLLATE" clause to this expression */ + const Token *pCollName, /* Name of collating sequence */ + int dequote /* True to dequote pCollName */ +){ + if( pCollName->n>0 ){ + Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote); + if( pNew ){ + pNew->pLeft = pExpr; + pNew->flags |= EP_Collate|EP_Skip; + pExpr = pNew; + } + } + return pExpr; +} +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){ + Token s; + assert( zC!=0 ); + s.z = zC; + s.n = sqlite3Strlen30(s.z); + return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0); +} + +/* +** Skip over any TK_COLLATE operators and any unlikely() +** or likelihood() function at the root of an expression. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){ + while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){ + if( ExprHasProperty(pExpr, EP_Unlikely) ){ + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + assert( pExpr->x.pList->nExpr>0 ); + assert( pExpr->op==TK_FUNCTION ); + pExpr = pExpr->x.pList->a[0].pExpr; + }else{ + assert( pExpr->op==TK_COLLATE ); + pExpr = pExpr->pLeft; + } + } + return pExpr; +} + +/* +** Return the collation sequence for the expression pExpr. If +** there is no defined collating sequence, return NULL. +** +** The collating sequence might be determined by a COLLATE operator +** or by the presence of a column with a defined collating sequence. +** COLLATE operators take first precedence. Left operands take +** precedence over right operands. +*/ +SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){ + sqlite3 *db = pParse->db; + CollSeq *pColl = 0; + Expr *p = pExpr; + while( p ){ + int op = p->op; + if( p->flags & EP_Generic ) break; + if( op==TK_CAST || op==TK_UPLUS ){ + p = p->pLeft; + continue; + } + if( op==TK_COLLATE || (op==TK_REGISTER && p->op2==TK_COLLATE) ){ + pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken); + break; + } + if( (op==TK_AGG_COLUMN || op==TK_COLUMN + || op==TK_REGISTER || op==TK_TRIGGER) + && p->pTab!=0 + ){ + /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally + ** a TK_COLUMN but was previously evaluated and cached in a register */ + int j = p->iColumn; + if( j>=0 ){ + const char *zColl = p->pTab->aCol[j].zColl; + pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0); + } + break; + } + if( p->flags & EP_Collate ){ + if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){ + p = p->pLeft; + }else{ + Expr *pNext = p->pRight; + /* The Expr.x union is never used at the same time as Expr.pRight */ + assert( p->x.pList==0 || p->pRight==0 ); + /* p->flags holds EP_Collate and p->pLeft->flags does not. And + ** p->x.pSelect cannot. So if p->x.pLeft exists, it must hold at + ** least one EP_Collate. Thus the following two ALWAYS. */ + if( p->x.pList!=0 && ALWAYS(!ExprHasProperty(p, EP_xIsSelect)) ){ + int i; + for(i=0; ALWAYS(ix.pList->nExpr); i++){ + if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){ + pNext = p->x.pList->a[i].pExpr; + break; + } + } + } + p = pNext; + } + }else{ + break; + } + } + if( sqlite3CheckCollSeq(pParse, pColl) ){ + pColl = 0; + } + return pColl; +} + +/* +** pExpr is an operand of a comparison operator. aff2 is the +** type affinity of the other operand. This routine returns the +** type affinity that should be used for the comparison operator. +*/ +SQLITE_PRIVATE char sqlite3CompareAffinity(Expr *pExpr, char aff2){ + char aff1 = sqlite3ExprAffinity(pExpr); + if( aff1 && aff2 ){ + /* Both sides of the comparison are columns. If one has numeric + ** affinity, use that. Otherwise use no affinity. + */ + if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){ + return SQLITE_AFF_NUMERIC; + }else{ + return SQLITE_AFF_BLOB; + } + }else if( !aff1 && !aff2 ){ + /* Neither side of the comparison is a column. Compare the + ** results directly. + */ + return SQLITE_AFF_BLOB; + }else{ + /* One side is a column, the other is not. Use the columns affinity. */ + assert( aff1==0 || aff2==0 ); + return (aff1 + aff2); + } +} + +/* +** pExpr is a comparison operator. Return the type affinity that should +** be applied to both operands prior to doing the comparison. +*/ +static char comparisonAffinity(Expr *pExpr){ + char aff; + assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT || + pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE || + pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT ); + assert( pExpr->pLeft ); + aff = sqlite3ExprAffinity(pExpr->pLeft); + if( pExpr->pRight ){ + aff = sqlite3CompareAffinity(pExpr->pRight, aff); + }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff); + }else if( !aff ){ + aff = SQLITE_AFF_BLOB; + } + return aff; +} + +/* +** pExpr is a comparison expression, eg. '=', '<', IN(...) etc. +** idx_affinity is the affinity of an indexed column. Return true +** if the index with affinity idx_affinity may be used to implement +** the comparison in pExpr. +*/ +SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){ + char aff = comparisonAffinity(pExpr); + switch( aff ){ + case SQLITE_AFF_BLOB: + return 1; + case SQLITE_AFF_TEXT: + return idx_affinity==SQLITE_AFF_TEXT; + default: + return sqlite3IsNumericAffinity(idx_affinity); + } +} + +/* +** Return the P5 value that should be used for a binary comparison +** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2. +*/ +static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){ + u8 aff = (char)sqlite3ExprAffinity(pExpr2); + aff = (u8)sqlite3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull; + return aff; +} + +/* +** Return a pointer to the collation sequence that should be used by +** a binary comparison operator comparing pLeft and pRight. +** +** If the left hand expression has a collating sequence type, then it is +** used. Otherwise the collation sequence for the right hand expression +** is used, or the default (BINARY) if neither expression has a collating +** type. +** +** Argument pRight (but not pLeft) may be a null pointer. In this case, +** it is not considered. +*/ +SQLITE_PRIVATE CollSeq *sqlite3BinaryCompareCollSeq( + Parse *pParse, + Expr *pLeft, + Expr *pRight +){ + CollSeq *pColl; + assert( pLeft ); + if( pLeft->flags & EP_Collate ){ + pColl = sqlite3ExprCollSeq(pParse, pLeft); + }else if( pRight && (pRight->flags & EP_Collate)!=0 ){ + pColl = sqlite3ExprCollSeq(pParse, pRight); + }else{ + pColl = sqlite3ExprCollSeq(pParse, pLeft); + if( !pColl ){ + pColl = sqlite3ExprCollSeq(pParse, pRight); + } + } + return pColl; +} + +/* +** Generate code for a comparison operator. +*/ +static int codeCompare( + Parse *pParse, /* The parsing (and code generating) context */ + Expr *pLeft, /* The left operand */ + Expr *pRight, /* The right operand */ + int opcode, /* The comparison opcode */ + int in1, int in2, /* Register holding operands */ + int dest, /* Jump here if true. */ + int jumpIfNull /* If true, jump if either operand is NULL */ +){ + int p5; + int addr; + CollSeq *p4; + + p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight); + p5 = binaryCompareP5(pLeft, pRight, jumpIfNull); + addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1, + (void*)p4, P4_COLLSEQ); + sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5); + return addr; +} + +#if SQLITE_MAX_EXPR_DEPTH>0 +/* +** Check that argument nHeight is less than or equal to the maximum +** expression depth allowed. If it is not, leave an error message in +** pParse. +*/ +SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){ + int rc = SQLITE_OK; + int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH]; + if( nHeight>mxHeight ){ + sqlite3ErrorMsg(pParse, + "Expression tree is too large (maximum depth %d)", mxHeight + ); + rc = SQLITE_ERROR; + } + return rc; +} + +/* The following three functions, heightOfExpr(), heightOfExprList() +** and heightOfSelect(), are used to determine the maximum height +** of any expression tree referenced by the structure passed as the +** first argument. +** +** If this maximum height is greater than the current value pointed +** to by pnHeight, the second parameter, then set *pnHeight to that +** value. +*/ +static void heightOfExpr(Expr *p, int *pnHeight){ + if( p ){ + if( p->nHeight>*pnHeight ){ + *pnHeight = p->nHeight; + } + } +} +static void heightOfExprList(ExprList *p, int *pnHeight){ + if( p ){ + int i; + for(i=0; inExpr; i++){ + heightOfExpr(p->a[i].pExpr, pnHeight); + } + } +} +static void heightOfSelect(Select *p, int *pnHeight){ + if( p ){ + heightOfExpr(p->pWhere, pnHeight); + heightOfExpr(p->pHaving, pnHeight); + heightOfExpr(p->pLimit, pnHeight); + heightOfExpr(p->pOffset, pnHeight); + heightOfExprList(p->pEList, pnHeight); + heightOfExprList(p->pGroupBy, pnHeight); + heightOfExprList(p->pOrderBy, pnHeight); + heightOfSelect(p->pPrior, pnHeight); + } +} + +/* +** Set the Expr.nHeight variable in the structure passed as an +** argument. An expression with no children, Expr.pList or +** Expr.pSelect member has a height of 1. Any other expression +** has a height equal to the maximum height of any other +** referenced Expr plus one. +** +** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags, +** if appropriate. +*/ +static void exprSetHeight(Expr *p){ + int nHeight = 0; + heightOfExpr(p->pLeft, &nHeight); + heightOfExpr(p->pRight, &nHeight); + if( ExprHasProperty(p, EP_xIsSelect) ){ + heightOfSelect(p->x.pSelect, &nHeight); + }else if( p->x.pList ){ + heightOfExprList(p->x.pList, &nHeight); + p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList); + } + p->nHeight = nHeight + 1; +} + +/* +** Set the Expr.nHeight variable using the exprSetHeight() function. If +** the height is greater than the maximum allowed expression depth, +** leave an error in pParse. +** +** Also propagate all EP_Propagate flags from the Expr.x.pList into +** Expr.flags. +*/ +SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){ + if( pParse->nErr ) return; + exprSetHeight(p); + sqlite3ExprCheckHeight(pParse, p->nHeight); +} + +/* +** Return the maximum height of any expression tree referenced +** by the select statement passed as an argument. +*/ +SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *p){ + int nHeight = 0; + heightOfSelect(p, &nHeight); + return nHeight; +} +#else /* ABOVE: Height enforcement enabled. BELOW: Height enforcement off */ +/* +** Propagate all EP_Propagate flags from the Expr.x.pList into +** Expr.flags. +*/ +SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){ + if( p && p->x.pList && !ExprHasProperty(p, EP_xIsSelect) ){ + p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList); + } +} +#define exprSetHeight(y) +#endif /* SQLITE_MAX_EXPR_DEPTH>0 */ + +/* +** This routine is the core allocator for Expr nodes. +** +** Construct a new expression node and return a pointer to it. Memory +** for this node and for the pToken argument is a single allocation +** obtained from sqlite3DbMalloc(). The calling function +** is responsible for making sure the node eventually gets freed. +** +** If dequote is true, then the token (if it exists) is dequoted. +** If dequote is false, no dequoting is performed. The deQuote +** parameter is ignored if pToken is NULL or if the token does not +** appear to be quoted. If the quotes were of the form "..." (double-quotes) +** then the EP_DblQuoted flag is set on the expression node. +** +** Special case: If op==TK_INTEGER and pToken points to a string that +** can be translated into a 32-bit integer, then the token is not +** stored in u.zToken. Instead, the integer values is written +** into u.iValue and the EP_IntValue flag is set. No extra storage +** is allocated to hold the integer text and the dequote flag is ignored. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprAlloc( + sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */ + int op, /* Expression opcode */ + const Token *pToken, /* Token argument. Might be NULL */ + int dequote /* True to dequote */ +){ + Expr *pNew; + int nExtra = 0; + int iValue = 0; + + if( pToken ){ + if( op!=TK_INTEGER || pToken->z==0 + || sqlite3GetInt32(pToken->z, &iValue)==0 ){ + nExtra = pToken->n+1; + assert( iValue>=0 ); + } + } + pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra); + if( pNew ){ + pNew->op = (u8)op; + pNew->iAgg = -1; + if( pToken ){ + if( nExtra==0 ){ + pNew->flags |= EP_IntValue; + pNew->u.iValue = iValue; + }else{ + int c; + pNew->u.zToken = (char*)&pNew[1]; + assert( pToken->z!=0 || pToken->n==0 ); + if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n); + pNew->u.zToken[pToken->n] = 0; + if( dequote && nExtra>=3 + && ((c = pToken->z[0])=='\'' || c=='"' || c=='[' || c=='`') ){ + sqlite3Dequote(pNew->u.zToken); + if( c=='"' ) pNew->flags |= EP_DblQuoted; + } + } + } +#if SQLITE_MAX_EXPR_DEPTH>0 + pNew->nHeight = 1; +#endif + } + return pNew; +} + +/* +** Allocate a new expression node from a zero-terminated token that has +** already been dequoted. +*/ +SQLITE_PRIVATE Expr *sqlite3Expr( + sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */ + int op, /* Expression opcode */ + const char *zToken /* Token argument. Might be NULL */ +){ + Token x; + x.z = zToken; + x.n = zToken ? sqlite3Strlen30(zToken) : 0; + return sqlite3ExprAlloc(db, op, &x, 0); +} + +/* +** Attach subtrees pLeft and pRight to the Expr node pRoot. +** +** If pRoot==NULL that means that a memory allocation error has occurred. +** In that case, delete the subtrees pLeft and pRight. +*/ +SQLITE_PRIVATE void sqlite3ExprAttachSubtrees( + sqlite3 *db, + Expr *pRoot, + Expr *pLeft, + Expr *pRight +){ + if( pRoot==0 ){ + assert( db->mallocFailed ); + sqlite3ExprDelete(db, pLeft); + sqlite3ExprDelete(db, pRight); + }else{ + if( pRight ){ + pRoot->pRight = pRight; + pRoot->flags |= EP_Propagate & pRight->flags; + } + if( pLeft ){ + pRoot->pLeft = pLeft; + pRoot->flags |= EP_Propagate & pLeft->flags; + } + exprSetHeight(pRoot); + } +} + +/* +** Allocate an Expr node which joins as many as two subtrees. +** +** One or both of the subtrees can be NULL. Return a pointer to the new +** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed, +** free the subtrees and return NULL. +*/ +SQLITE_PRIVATE Expr *sqlite3PExpr( + Parse *pParse, /* Parsing context */ + int op, /* Expression opcode */ + Expr *pLeft, /* Left operand */ + Expr *pRight, /* Right operand */ + const Token *pToken /* Argument token */ +){ + Expr *p; + if( op==TK_AND && pLeft && pRight && pParse->nErr==0 ){ + /* Take advantage of short-circuit false optimization for AND */ + p = sqlite3ExprAnd(pParse->db, pLeft, pRight); + }else{ + p = sqlite3ExprAlloc(pParse->db, op, pToken, 1); + sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight); + } + if( p ) { + sqlite3ExprCheckHeight(pParse, p->nHeight); + } + return p; +} + +/* +** If the expression is always either TRUE or FALSE (respectively), +** then return 1. If one cannot determine the truth value of the +** expression at compile-time return 0. +** +** This is an optimization. If is OK to return 0 here even if +** the expression really is always false or false (a false negative). +** But it is a bug to return 1 if the expression might have different +** boolean values in different circumstances (a false positive.) +** +** Note that if the expression is part of conditional for a +** LEFT JOIN, then we cannot determine at compile-time whether or not +** is it true or false, so always return 0. +*/ +static int exprAlwaysTrue(Expr *p){ + int v = 0; + if( ExprHasProperty(p, EP_FromJoin) ) return 0; + if( !sqlite3ExprIsInteger(p, &v) ) return 0; + return v!=0; +} +static int exprAlwaysFalse(Expr *p){ + int v = 0; + if( ExprHasProperty(p, EP_FromJoin) ) return 0; + if( !sqlite3ExprIsInteger(p, &v) ) return 0; + return v==0; +} + +/* +** Join two expressions using an AND operator. If either expression is +** NULL, then just return the other expression. +** +** If one side or the other of the AND is known to be false, then instead +** of returning an AND expression, just return a constant expression with +** a value of false. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){ + if( pLeft==0 ){ + return pRight; + }else if( pRight==0 ){ + return pLeft; + }else if( exprAlwaysFalse(pLeft) || exprAlwaysFalse(pRight) ){ + sqlite3ExprDelete(db, pLeft); + sqlite3ExprDelete(db, pRight); + return sqlite3ExprAlloc(db, TK_INTEGER, &sqlite3IntTokens[0], 0); + }else{ + Expr *pNew = sqlite3ExprAlloc(db, TK_AND, 0, 0); + sqlite3ExprAttachSubtrees(db, pNew, pLeft, pRight); + return pNew; + } +} + +/* +** Construct a new expression node for a function with multiple +** arguments. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){ + Expr *pNew; + sqlite3 *db = pParse->db; + assert( pToken ); + pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1); + if( pNew==0 ){ + sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */ + return 0; + } + pNew->x.pList = pList; + assert( !ExprHasProperty(pNew, EP_xIsSelect) ); + sqlite3ExprSetHeightAndFlags(pParse, pNew); + return pNew; +} + +/* +** Assign a variable number to an expression that encodes a wildcard +** in the original SQL statement. +** +** Wildcards consisting of a single "?" are assigned the next sequential +** variable number. +** +** Wildcards of the form "?nnn" are assigned the number "nnn". We make +** sure "nnn" is not too be to avoid a denial of service attack when +** the SQL statement comes from an external source. +** +** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number +** as the previous instance of the same wildcard. Or if this is the first +** instance of the wildcard, the next sequential variable number is +** assigned. +*/ +SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){ + sqlite3 *db = pParse->db; + const char *z; + + if( pExpr==0 ) return; + assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) ); + z = pExpr->u.zToken; + assert( z!=0 ); + assert( z[0]!=0 ); + if( z[1]==0 ){ + /* Wildcard of the form "?". Assign the next variable number */ + assert( z[0]=='?' ); + pExpr->iColumn = (ynVar)(++pParse->nVar); + }else{ + ynVar x = 0; + u32 n = sqlite3Strlen30(z); + if( z[0]=='?' ){ + /* Wildcard of the form "?nnn". Convert "nnn" to an integer and + ** use it as the variable number */ + i64 i; + int bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8); + pExpr->iColumn = x = (ynVar)i; + testcase( i==0 ); + testcase( i==1 ); + testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 ); + testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ); + if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){ + sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d", + db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]); + x = 0; + } + if( i>pParse->nVar ){ + pParse->nVar = (int)i; + } + }else{ + /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable + ** number as the prior appearance of the same name, or if the name + ** has never appeared before, reuse the same variable number + */ + ynVar i; + for(i=0; inzVar; i++){ + if( pParse->azVar[i] && strcmp(pParse->azVar[i],z)==0 ){ + pExpr->iColumn = x = (ynVar)i+1; + break; + } + } + if( x==0 ) x = pExpr->iColumn = (ynVar)(++pParse->nVar); + } + if( x>0 ){ + if( x>pParse->nzVar ){ + char **a; + a = sqlite3DbRealloc(db, pParse->azVar, x*sizeof(a[0])); + if( a==0 ) return; /* Error reported through db->mallocFailed */ + pParse->azVar = a; + memset(&a[pParse->nzVar], 0, (x-pParse->nzVar)*sizeof(a[0])); + pParse->nzVar = x; + } + if( z[0]!='?' || pParse->azVar[x-1]==0 ){ + sqlite3DbFree(db, pParse->azVar[x-1]); + pParse->azVar[x-1] = sqlite3DbStrNDup(db, z, n); + } + } + } + if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){ + sqlite3ErrorMsg(pParse, "too many SQL variables"); + } +} + +/* +** Recursively delete an expression tree. +*/ +SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){ + if( p==0 ) return; + /* Sanity check: Assert that the IntValue is non-negative if it exists */ + assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 ); + if( !ExprHasProperty(p, EP_TokenOnly) ){ + /* The Expr.x union is never used at the same time as Expr.pRight */ + assert( p->x.pList==0 || p->pRight==0 ); + sqlite3ExprDelete(db, p->pLeft); + sqlite3ExprDelete(db, p->pRight); + if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken); + if( ExprHasProperty(p, EP_xIsSelect) ){ + sqlite3SelectDelete(db, p->x.pSelect); + }else{ + sqlite3ExprListDelete(db, p->x.pList); + } + } + if( !ExprHasProperty(p, EP_Static) ){ + sqlite3DbFree(db, p); + } +} + +/* +** Return the number of bytes allocated for the expression structure +** passed as the first argument. This is always one of EXPR_FULLSIZE, +** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE. +*/ +static int exprStructSize(Expr *p){ + if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE; + if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE; + return EXPR_FULLSIZE; +} + +/* +** The dupedExpr*Size() routines each return the number of bytes required +** to store a copy of an expression or expression tree. They differ in +** how much of the tree is measured. +** +** dupedExprStructSize() Size of only the Expr structure +** dupedExprNodeSize() Size of Expr + space for token +** dupedExprSize() Expr + token + subtree components +** +*************************************************************************** +** +** The dupedExprStructSize() function returns two values OR-ed together: +** (1) the space required for a copy of the Expr structure only and +** (2) the EP_xxx flags that indicate what the structure size should be. +** The return values is always one of: +** +** EXPR_FULLSIZE +** EXPR_REDUCEDSIZE | EP_Reduced +** EXPR_TOKENONLYSIZE | EP_TokenOnly +** +** The size of the structure can be found by masking the return value +** of this routine with 0xfff. The flags can be found by masking the +** return value with EP_Reduced|EP_TokenOnly. +** +** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size +** (unreduced) Expr objects as they or originally constructed by the parser. +** During expression analysis, extra information is computed and moved into +** later parts of teh Expr object and that extra information might get chopped +** off if the expression is reduced. Note also that it does not work to +** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal +** to reduce a pristine expression tree from the parser. The implementation +** of dupedExprStructSize() contain multiple assert() statements that attempt +** to enforce this constraint. +*/ +static int dupedExprStructSize(Expr *p, int flags){ + int nSize; + assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */ + assert( EXPR_FULLSIZE<=0xfff ); + assert( (0xfff & (EP_Reduced|EP_TokenOnly))==0 ); + if( 0==(flags&EXPRDUP_REDUCE) ){ + nSize = EXPR_FULLSIZE; + }else{ + assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) ); + assert( !ExprHasProperty(p, EP_FromJoin) ); + assert( !ExprHasProperty(p, EP_MemToken) ); + assert( !ExprHasProperty(p, EP_NoReduce) ); + if( p->pLeft || p->x.pList ){ + nSize = EXPR_REDUCEDSIZE | EP_Reduced; + }else{ + assert( p->pRight==0 ); + nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly; + } + } + return nSize; +} + +/* +** This function returns the space in bytes required to store the copy +** of the Expr structure and a copy of the Expr.u.zToken string (if that +** string is defined.) +*/ +static int dupedExprNodeSize(Expr *p, int flags){ + int nByte = dupedExprStructSize(p, flags) & 0xfff; + if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){ + nByte += sqlite3Strlen30(p->u.zToken)+1; + } + return ROUND8(nByte); +} + +/* +** Return the number of bytes required to create a duplicate of the +** expression passed as the first argument. The second argument is a +** mask containing EXPRDUP_XXX flags. +** +** The value returned includes space to create a copy of the Expr struct +** itself and the buffer referred to by Expr.u.zToken, if any. +** +** If the EXPRDUP_REDUCE flag is set, then the return value includes +** space to duplicate all Expr nodes in the tree formed by Expr.pLeft +** and Expr.pRight variables (but not for any structures pointed to or +** descended from the Expr.x.pList or Expr.x.pSelect variables). +*/ +static int dupedExprSize(Expr *p, int flags){ + int nByte = 0; + if( p ){ + nByte = dupedExprNodeSize(p, flags); + if( flags&EXPRDUP_REDUCE ){ + nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags); + } + } + return nByte; +} + +/* +** This function is similar to sqlite3ExprDup(), except that if pzBuffer +** is not NULL then *pzBuffer is assumed to point to a buffer large enough +** to store the copy of expression p, the copies of p->u.zToken +** (if applicable), and the copies of the p->pLeft and p->pRight expressions, +** if any. Before returning, *pzBuffer is set to the first byte past the +** portion of the buffer copied into by this function. +*/ +static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){ + Expr *pNew = 0; /* Value to return */ + if( p ){ + const int isReduced = (flags&EXPRDUP_REDUCE); + u8 *zAlloc; + u32 staticFlag = 0; + + assert( pzBuffer==0 || isReduced ); + + /* Figure out where to write the new Expr structure. */ + if( pzBuffer ){ + zAlloc = *pzBuffer; + staticFlag = EP_Static; + }else{ + zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags)); + } + pNew = (Expr *)zAlloc; + + if( pNew ){ + /* Set nNewSize to the size allocated for the structure pointed to + ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or + ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed + ** by the copy of the p->u.zToken string (if any). + */ + const unsigned nStructSize = dupedExprStructSize(p, flags); + const int nNewSize = nStructSize & 0xfff; + int nToken; + if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){ + nToken = sqlite3Strlen30(p->u.zToken) + 1; + }else{ + nToken = 0; + } + if( isReduced ){ + assert( ExprHasProperty(p, EP_Reduced)==0 ); + memcpy(zAlloc, p, nNewSize); + }else{ + int nSize = exprStructSize(p); + memcpy(zAlloc, p, nSize); + memset(&zAlloc[nSize], 0, EXPR_FULLSIZE-nSize); + } + + /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */ + pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static|EP_MemToken); + pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly); + pNew->flags |= staticFlag; + + /* Copy the p->u.zToken string, if any. */ + if( nToken ){ + char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize]; + memcpy(zToken, p->u.zToken, nToken); + } + + if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){ + /* Fill in the pNew->x.pSelect or pNew->x.pList member. */ + if( ExprHasProperty(p, EP_xIsSelect) ){ + pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced); + }else{ + pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced); + } + } + + /* Fill in pNew->pLeft and pNew->pRight. */ + if( ExprHasProperty(pNew, EP_Reduced|EP_TokenOnly) ){ + zAlloc += dupedExprNodeSize(p, flags); + if( ExprHasProperty(pNew, EP_Reduced) ){ + pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc); + pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc); + } + if( pzBuffer ){ + *pzBuffer = zAlloc; + } + }else{ + if( !ExprHasProperty(p, EP_TokenOnly) ){ + pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0); + pNew->pRight = sqlite3ExprDup(db, p->pRight, 0); + } + } + + } + } + return pNew; +} + +/* +** Create and return a deep copy of the object passed as the second +** argument. If an OOM condition is encountered, NULL is returned +** and the db->mallocFailed flag set. +*/ +#ifndef SQLITE_OMIT_CTE +static With *withDup(sqlite3 *db, With *p){ + With *pRet = 0; + if( p ){ + int nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1); + pRet = sqlite3DbMallocZero(db, nByte); + if( pRet ){ + int i; + pRet->nCte = p->nCte; + for(i=0; inCte; i++){ + pRet->a[i].pSelect = sqlite3SelectDup(db, p->a[i].pSelect, 0); + pRet->a[i].pCols = sqlite3ExprListDup(db, p->a[i].pCols, 0); + pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName); + } + } + } + return pRet; +} +#else +# define withDup(x,y) 0 +#endif + +/* +** The following group of routines make deep copies of expressions, +** expression lists, ID lists, and select statements. The copies can +** be deleted (by being passed to their respective ...Delete() routines) +** without effecting the originals. +** +** The expression list, ID, and source lists return by sqlite3ExprListDup(), +** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded +** by subsequent calls to sqlite*ListAppend() routines. +** +** Any tables that the SrcList might point to are not duplicated. +** +** The flags parameter contains a combination of the EXPRDUP_XXX flags. +** If the EXPRDUP_REDUCE flag is set, then the structure returned is a +** truncated version of the usual Expr structure that will be stored as +** part of the in-memory representation of the database schema. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){ + return exprDup(db, p, flags, 0); +} +SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){ + ExprList *pNew; + struct ExprList_item *pItem, *pOldItem; + int i; + if( p==0 ) return 0; + pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) ); + if( pNew==0 ) return 0; + pNew->nExpr = i = p->nExpr; + if( (flags & EXPRDUP_REDUCE)==0 ) for(i=1; inExpr; i+=i){} + pNew->a = pItem = sqlite3DbMallocRaw(db, i*sizeof(p->a[0]) ); + if( pItem==0 ){ + sqlite3DbFree(db, pNew); + return 0; + } + pOldItem = p->a; + for(i=0; inExpr; i++, pItem++, pOldItem++){ + Expr *pOldExpr = pOldItem->pExpr; + pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags); + pItem->zName = sqlite3DbStrDup(db, pOldItem->zName); + pItem->zSpan = sqlite3DbStrDup(db, pOldItem->zSpan); + pItem->sortOrder = pOldItem->sortOrder; + pItem->done = 0; + pItem->bSpanIsTab = pOldItem->bSpanIsTab; + pItem->u = pOldItem->u; + } + return pNew; +} + +/* +** If cursors, triggers, views and subqueries are all omitted from +** the build, then none of the following routines, except for +** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes +** called with a NULL argument. +*/ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \ + || !defined(SQLITE_OMIT_SUBQUERY) +SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){ + SrcList *pNew; + int i; + int nByte; + if( p==0 ) return 0; + nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0); + pNew = sqlite3DbMallocRaw(db, nByte ); + if( pNew==0 ) return 0; + pNew->nSrc = pNew->nAlloc = p->nSrc; + for(i=0; inSrc; i++){ + struct SrcList_item *pNewItem = &pNew->a[i]; + struct SrcList_item *pOldItem = &p->a[i]; + Table *pTab; + pNewItem->pSchema = pOldItem->pSchema; + pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase); + pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); + pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias); + pNewItem->fg = pOldItem->fg; + pNewItem->iCursor = pOldItem->iCursor; + pNewItem->addrFillSub = pOldItem->addrFillSub; + pNewItem->regReturn = pOldItem->regReturn; + if( pNewItem->fg.isIndexedBy ){ + pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy); + } + pNewItem->pIBIndex = pOldItem->pIBIndex; + if( pNewItem->fg.isTabFunc ){ + pNewItem->u1.pFuncArg = + sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags); + } + pTab = pNewItem->pTab = pOldItem->pTab; + if( pTab ){ + pTab->nRef++; + } + pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags); + pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags); + pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing); + pNewItem->colUsed = pOldItem->colUsed; + } + return pNew; +} +SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){ + IdList *pNew; + int i; + if( p==0 ) return 0; + pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) ); + if( pNew==0 ) return 0; + pNew->nId = p->nId; + pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) ); + if( pNew->a==0 ){ + sqlite3DbFree(db, pNew); + return 0; + } + /* Note that because the size of the allocation for p->a[] is not + ** necessarily a power of two, sqlite3IdListAppend() may not be called + ** on the duplicate created by this function. */ + for(i=0; inId; i++){ + struct IdList_item *pNewItem = &pNew->a[i]; + struct IdList_item *pOldItem = &p->a[i]; + pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); + pNewItem->idx = pOldItem->idx; + } + return pNew; +} +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){ + Select *pNew, *pPrior; + if( p==0 ) return 0; + pNew = sqlite3DbMallocRaw(db, sizeof(*p) ); + if( pNew==0 ) return 0; + pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags); + pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags); + pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags); + pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags); + pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags); + pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags); + pNew->op = p->op; + pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags); + if( pPrior ) pPrior->pNext = pNew; + pNew->pNext = 0; + pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags); + pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags); + pNew->iLimit = 0; + pNew->iOffset = 0; + pNew->selFlags = p->selFlags & ~SF_UsesEphemeral; + pNew->addrOpenEphm[0] = -1; + pNew->addrOpenEphm[1] = -1; + pNew->nSelectRow = p->nSelectRow; + pNew->pWith = withDup(db, p->pWith); + sqlite3SelectSetName(pNew, p->zSelName); + return pNew; +} +#else +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){ + assert( p==0 ); + return 0; +} +#endif + + +/* +** Add a new element to the end of an expression list. If pList is +** initially NULL, then create a new expression list. +** +** If a memory allocation error occurs, the entire list is freed and +** NULL is returned. If non-NULL is returned, then it is guaranteed +** that the new entry was successfully appended. +*/ +SQLITE_PRIVATE ExprList *sqlite3ExprListAppend( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to append. Might be NULL */ + Expr *pExpr /* Expression to be appended. Might be NULL */ +){ + sqlite3 *db = pParse->db; + if( pList==0 ){ + pList = sqlite3DbMallocZero(db, sizeof(ExprList) ); + if( pList==0 ){ + goto no_mem; + } + pList->a = sqlite3DbMallocRaw(db, sizeof(pList->a[0])); + if( pList->a==0 ) goto no_mem; + }else if( (pList->nExpr & (pList->nExpr-1))==0 ){ + struct ExprList_item *a; + assert( pList->nExpr>0 ); + a = sqlite3DbRealloc(db, pList->a, pList->nExpr*2*sizeof(pList->a[0])); + if( a==0 ){ + goto no_mem; + } + pList->a = a; + } + assert( pList->a!=0 ); + if( 1 ){ + struct ExprList_item *pItem = &pList->a[pList->nExpr++]; + memset(pItem, 0, sizeof(*pItem)); + pItem->pExpr = pExpr; + } + return pList; + +no_mem: + /* Avoid leaking memory if malloc has failed. */ + sqlite3ExprDelete(db, pExpr); + sqlite3ExprListDelete(db, pList); + return 0; +} + +/* +** Set the sort order for the last element on the given ExprList. +*/ +SQLITE_PRIVATE void sqlite3ExprListSetSortOrder(ExprList *p, int iSortOrder){ + if( p==0 ) return; + assert( SQLITE_SO_UNDEFINED<0 && SQLITE_SO_ASC>=0 && SQLITE_SO_DESC>0 ); + assert( p->nExpr>0 ); + if( iSortOrder<0 ){ + assert( p->a[p->nExpr-1].sortOrder==SQLITE_SO_ASC ); + return; + } + p->a[p->nExpr-1].sortOrder = (u8)iSortOrder; +} + +/* +** Set the ExprList.a[].zName element of the most recently added item +** on the expression list. +** +** pList might be NULL following an OOM error. But pName should never be +** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag +** is set. +*/ +SQLITE_PRIVATE void sqlite3ExprListSetName( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to add the span. */ + Token *pName, /* Name to be added */ + int dequote /* True to cause the name to be dequoted */ +){ + assert( pList!=0 || pParse->db->mallocFailed!=0 ); + if( pList ){ + struct ExprList_item *pItem; + assert( pList->nExpr>0 ); + pItem = &pList->a[pList->nExpr-1]; + assert( pItem->zName==0 ); + pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n); + if( dequote && pItem->zName ) sqlite3Dequote(pItem->zName); + } +} + +/* +** Set the ExprList.a[].zSpan element of the most recently added item +** on the expression list. +** +** pList might be NULL following an OOM error. But pSpan should never be +** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag +** is set. +*/ +SQLITE_PRIVATE void sqlite3ExprListSetSpan( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to add the span. */ + ExprSpan *pSpan /* The span to be added */ +){ + sqlite3 *db = pParse->db; + assert( pList!=0 || db->mallocFailed!=0 ); + if( pList ){ + struct ExprList_item *pItem = &pList->a[pList->nExpr-1]; + assert( pList->nExpr>0 ); + assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr ); + sqlite3DbFree(db, pItem->zSpan); + pItem->zSpan = sqlite3DbStrNDup(db, (char*)pSpan->zStart, + (int)(pSpan->zEnd - pSpan->zStart)); + } +} + +/* +** If the expression list pEList contains more than iLimit elements, +** leave an error message in pParse. +*/ +SQLITE_PRIVATE void sqlite3ExprListCheckLength( + Parse *pParse, + ExprList *pEList, + const char *zObject +){ + int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN]; + testcase( pEList && pEList->nExpr==mx ); + testcase( pEList && pEList->nExpr==mx+1 ); + if( pEList && pEList->nExpr>mx ){ + sqlite3ErrorMsg(pParse, "too many columns in %s", zObject); + } +} + +/* +** Delete an entire expression list. +*/ +SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){ + int i; + struct ExprList_item *pItem; + if( pList==0 ) return; + assert( pList->a!=0 || pList->nExpr==0 ); + for(pItem=pList->a, i=0; inExpr; i++, pItem++){ + sqlite3ExprDelete(db, pItem->pExpr); + sqlite3DbFree(db, pItem->zName); + sqlite3DbFree(db, pItem->zSpan); + } + sqlite3DbFree(db, pList->a); + sqlite3DbFree(db, pList); +} + +/* +** Return the bitwise-OR of all Expr.flags fields in the given +** ExprList. +*/ +SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList *pList){ + int i; + u32 m = 0; + if( pList ){ + for(i=0; inExpr; i++){ + Expr *pExpr = pList->a[i].pExpr; + if( ALWAYS(pExpr) ) m |= pExpr->flags; + } + } + return m; +} + +/* +** These routines are Walker callbacks used to check expressions to +** see if they are "constant" for some definition of constant. The +** Walker.eCode value determines the type of "constant" we are looking +** for. +** +** These callback routines are used to implement the following: +** +** sqlite3ExprIsConstant() pWalker->eCode==1 +** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2 +** sqlite3ExprIsTableConstant() pWalker->eCode==3 +** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5 +** +** In all cases, the callbacks set Walker.eCode=0 and abort if the expression +** is found to not be a constant. +** +** The sqlite3ExprIsConstantOrFunction() is used for evaluating expressions +** in a CREATE TABLE statement. The Walker.eCode value is 5 when parsing +** an existing schema and 4 when processing a new statement. A bound +** parameter raises an error for new statements, but is silently converted +** to NULL for existing schemas. This allows sqlite_master tables that +** contain a bound parameter because they were generated by older versions +** of SQLite to be parsed by newer versions of SQLite without raising a +** malformed schema error. +*/ +static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){ + + /* If pWalker->eCode is 2 then any term of the expression that comes from + ** the ON or USING clauses of a left join disqualifies the expression + ** from being considered constant. */ + if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_FromJoin) ){ + pWalker->eCode = 0; + return WRC_Abort; + } + + switch( pExpr->op ){ + /* Consider functions to be constant if all their arguments are constant + ** and either pWalker->eCode==4 or 5 or the function has the + ** SQLITE_FUNC_CONST flag. */ + case TK_FUNCTION: + if( pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc) ){ + return WRC_Continue; + }else{ + pWalker->eCode = 0; + return WRC_Abort; + } + case TK_ID: + case TK_COLUMN: + case TK_AGG_FUNCTION: + case TK_AGG_COLUMN: + testcase( pExpr->op==TK_ID ); + testcase( pExpr->op==TK_COLUMN ); + testcase( pExpr->op==TK_AGG_FUNCTION ); + testcase( pExpr->op==TK_AGG_COLUMN ); + if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){ + return WRC_Continue; + }else{ + pWalker->eCode = 0; + return WRC_Abort; + } + case TK_VARIABLE: + if( pWalker->eCode==5 ){ + /* Silently convert bound parameters that appear inside of CREATE + ** statements into a NULL when parsing the CREATE statement text out + ** of the sqlite_master table */ + pExpr->op = TK_NULL; + }else if( pWalker->eCode==4 ){ + /* A bound parameter in a CREATE statement that originates from + ** sqlite3_prepare() causes an error */ + pWalker->eCode = 0; + return WRC_Abort; + } + /* Fall through */ + default: + testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */ + testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */ + return WRC_Continue; + } +} +static int selectNodeIsConstant(Walker *pWalker, Select *NotUsed){ + UNUSED_PARAMETER(NotUsed); + pWalker->eCode = 0; + return WRC_Abort; +} +static int exprIsConst(Expr *p, int initFlag, int iCur){ + Walker w; + memset(&w, 0, sizeof(w)); + w.eCode = initFlag; + w.xExprCallback = exprNodeIsConstant; + w.xSelectCallback = selectNodeIsConstant; + w.u.iCur = iCur; + sqlite3WalkExpr(&w, p); + return w.eCode; +} + +/* +** Walk an expression tree. Return non-zero if the expression is constant +** and 0 if it involves variables or function calls. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr *p){ + return exprIsConst(p, 1, 0); +} + +/* +** Walk an expression tree. Return non-zero if the expression is constant +** that does no originate from the ON or USING clauses of a join. +** Return 0 if it involves variables or function calls or terms from +** an ON or USING clause. +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr *p){ + return exprIsConst(p, 2, 0); +} + +/* +** Walk an expression tree. Return non-zero if the expression is constant +** for any single row of the table with cursor iCur. In other words, the +** expression must not refer to any non-deterministic function nor any +** table other than iCur. +*/ +SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){ + return exprIsConst(p, 3, iCur); +} + +/* +** Walk an expression tree. Return non-zero if the expression is constant +** or a function call with constant arguments. Return and 0 if there +** are any variables. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr *p, u8 isInit){ + assert( isInit==0 || isInit==1 ); + return exprIsConst(p, 4+isInit, 0); +} + +/* +** If the expression p codes a constant integer that is small enough +** to fit in a 32-bit integer, return 1 and put the value of the integer +** in *pValue. If the expression is not an integer or if it is too big +** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged. +*/ +SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr *p, int *pValue){ + int rc = 0; + + /* If an expression is an integer literal that fits in a signed 32-bit + ** integer, then the EP_IntValue flag will have already been set */ + assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0 + || sqlite3GetInt32(p->u.zToken, &rc)==0 ); + + if( p->flags & EP_IntValue ){ + *pValue = p->u.iValue; + return 1; + } + switch( p->op ){ + case TK_UPLUS: { + rc = sqlite3ExprIsInteger(p->pLeft, pValue); + break; + } + case TK_UMINUS: { + int v; + if( sqlite3ExprIsInteger(p->pLeft, &v) ){ + assert( v!=(-2147483647-1) ); + *pValue = -v; + rc = 1; + } + break; + } + default: break; + } + return rc; +} + +/* +** Return FALSE if there is no chance that the expression can be NULL. +** +** If the expression might be NULL or if the expression is too complex +** to tell return TRUE. +** +** This routine is used as an optimization, to skip OP_IsNull opcodes +** when we know that a value cannot be NULL. Hence, a false positive +** (returning TRUE when in fact the expression can never be NULL) might +** be a small performance hit but is otherwise harmless. On the other +** hand, a false negative (returning FALSE when the result could be NULL) +** will likely result in an incorrect answer. So when in doubt, return +** TRUE. +*/ +SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){ + u8 op; + while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; } + op = p->op; + if( op==TK_REGISTER ) op = p->op2; + switch( op ){ + case TK_INTEGER: + case TK_STRING: + case TK_FLOAT: + case TK_BLOB: + return 0; + case TK_COLUMN: + assert( p->pTab!=0 ); + return ExprHasProperty(p, EP_CanBeNull) || + (p->iColumn>=0 && p->pTab->aCol[p->iColumn].notNull==0); + default: + return 1; + } +} + +/* +** Return TRUE if the given expression is a constant which would be +** unchanged by OP_Affinity with the affinity given in the second +** argument. +** +** This routine is used to determine if the OP_Affinity operation +** can be omitted. When in doubt return FALSE. A false negative +** is harmless. A false positive, however, can result in the wrong +** answer. +*/ +SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){ + u8 op; + if( aff==SQLITE_AFF_BLOB ) return 1; + while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; } + op = p->op; + if( op==TK_REGISTER ) op = p->op2; + switch( op ){ + case TK_INTEGER: { + return aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC; + } + case TK_FLOAT: { + return aff==SQLITE_AFF_REAL || aff==SQLITE_AFF_NUMERIC; + } + case TK_STRING: { + return aff==SQLITE_AFF_TEXT; + } + case TK_BLOB: { + return 1; + } + case TK_COLUMN: { + assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */ + return p->iColumn<0 + && (aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC); + } + default: { + return 0; + } + } +} + +/* +** Return TRUE if the given string is a row-id column name. +*/ +SQLITE_PRIVATE int sqlite3IsRowid(const char *z){ + if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1; + if( sqlite3StrICmp(z, "ROWID")==0 ) return 1; + if( sqlite3StrICmp(z, "OID")==0 ) return 1; + return 0; +} + +/* +** Return true if we are able to the IN operator optimization on a +** query of the form +** +** x IN (SELECT ...) +** +** Where the SELECT... clause is as specified by the parameter to this +** routine. +** +** The Select object passed in has already been preprocessed and no +** errors have been found. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +static int isCandidateForInOpt(Select *p){ + SrcList *pSrc; + ExprList *pEList; + Table *pTab; + if( p==0 ) return 0; /* right-hand side of IN is SELECT */ + if( p->pPrior ) return 0; /* Not a compound SELECT */ + if( p->selFlags & (SF_Distinct|SF_Aggregate) ){ + testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct ); + testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate ); + return 0; /* No DISTINCT keyword and no aggregate functions */ + } + assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */ + if( p->pLimit ) return 0; /* Has no LIMIT clause */ + assert( p->pOffset==0 ); /* No LIMIT means no OFFSET */ + if( p->pWhere ) return 0; /* Has no WHERE clause */ + pSrc = p->pSrc; + assert( pSrc!=0 ); + if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */ + if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */ + pTab = pSrc->a[0].pTab; + if( NEVER(pTab==0) ) return 0; + assert( pTab->pSelect==0 ); /* FROM clause is not a view */ + if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */ + pEList = p->pEList; + if( pEList->nExpr!=1 ) return 0; /* One column in the result set */ + if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */ + return 1; +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +/* +** Code an OP_Once instruction and allocate space for its flag. Return the +** address of the new instruction. +*/ +SQLITE_PRIVATE int sqlite3CodeOnce(Parse *pParse){ + Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */ + return sqlite3VdbeAddOp1(v, OP_Once, pParse->nOnce++); +} + +/* +** Generate code that checks the left-most column of index table iCur to see if +** it contains any NULL entries. Cause the register at regHasNull to be set +** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull +** to be set to NULL if iCur contains one or more NULL values. +*/ +static void sqlite3SetHasNullFlag(Vdbe *v, int iCur, int regHasNull){ + int addr1; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regHasNull); + addr1 = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Column, iCur, 0, regHasNull); + sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG); + VdbeComment((v, "first_entry_in(%d)", iCur)); + sqlite3VdbeJumpHere(v, addr1); +} + + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** The argument is an IN operator with a list (not a subquery) on the +** right-hand side. Return TRUE if that list is constant. +*/ +static int sqlite3InRhsIsConstant(Expr *pIn){ + Expr *pLHS; + int res; + assert( !ExprHasProperty(pIn, EP_xIsSelect) ); + pLHS = pIn->pLeft; + pIn->pLeft = 0; + res = sqlite3ExprIsConstant(pIn); + pIn->pLeft = pLHS; + return res; +} +#endif + +/* +** This function is used by the implementation of the IN (...) operator. +** The pX parameter is the expression on the RHS of the IN operator, which +** might be either a list of expressions or a subquery. +** +** The job of this routine is to find or create a b-tree object that can +** be used either to test for membership in the RHS set or to iterate through +** all members of the RHS set, skipping duplicates. +** +** A cursor is opened on the b-tree object that is the RHS of the IN operator +** and pX->iTable is set to the index of that cursor. +** +** The returned value of this function indicates the b-tree type, as follows: +** +** IN_INDEX_ROWID - The cursor was opened on a database table. +** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index. +** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index. +** IN_INDEX_EPH - The cursor was opened on a specially created and +** populated epheremal table. +** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be +** implemented as a sequence of comparisons. +** +** An existing b-tree might be used if the RHS expression pX is a simple +** subquery such as: +** +** SELECT FROM +** +** If the RHS of the IN operator is a list or a more complex subquery, then +** an ephemeral table might need to be generated from the RHS and then +** pX->iTable made to point to the ephemeral table instead of an +** existing table. +** +** The inFlags parameter must contain exactly one of the bits +** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP. If inFlags contains +** IN_INDEX_MEMBERSHIP, then the generated table will be used for a +** fast membership test. When the IN_INDEX_LOOP bit is set, the +** IN index will be used to loop over all values of the RHS of the +** IN operator. +** +** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate +** through the set members) then the b-tree must not contain duplicates. +** An epheremal table must be used unless the selected is guaranteed +** to be unique - either because it is an INTEGER PRIMARY KEY or it +** has a UNIQUE constraint or UNIQUE index. +** +** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used +** for fast set membership tests) then an epheremal table must +** be used unless is an INTEGER PRIMARY KEY or an index can +** be found with as its left-most column. +** +** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and +** if the RHS of the IN operator is a list (not a subquery) then this +** routine might decide that creating an ephemeral b-tree for membership +** testing is too expensive and return IN_INDEX_NOOP. In that case, the +** calling routine should implement the IN operator using a sequence +** of Eq or Ne comparison operations. +** +** When the b-tree is being used for membership tests, the calling function +** might need to know whether or not the RHS side of the IN operator +** contains a NULL. If prRhsHasNull is not a NULL pointer and +** if there is any chance that the (...) might contain a NULL value at +** runtime, then a register is allocated and the register number written +** to *prRhsHasNull. If there is no chance that the (...) contains a +** NULL value, then *prRhsHasNull is left unchanged. +** +** If a register is allocated and its location stored in *prRhsHasNull, then +** the value in that register will be NULL if the b-tree contains one or more +** NULL values, and it will be some non-NULL value if the b-tree contains no +** NULL values. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +SQLITE_PRIVATE int sqlite3FindInIndex(Parse *pParse, Expr *pX, u32 inFlags, int *prRhsHasNull){ + Select *p; /* SELECT to the right of IN operator */ + int eType = 0; /* Type of RHS table. IN_INDEX_* */ + int iTab = pParse->nTab++; /* Cursor of the RHS table */ + int mustBeUnique; /* True if RHS must be unique */ + Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */ + + assert( pX->op==TK_IN ); + mustBeUnique = (inFlags & IN_INDEX_LOOP)!=0; + + /* Check to see if an existing table or index can be used to + ** satisfy the query. This is preferable to generating a new + ** ephemeral table. + */ + p = (ExprHasProperty(pX, EP_xIsSelect) ? pX->x.pSelect : 0); + if( pParse->nErr==0 && isCandidateForInOpt(p) ){ + sqlite3 *db = pParse->db; /* Database connection */ + Table *pTab; /* Table
    . */ + Expr *pExpr; /* Expression */ + i16 iCol; /* Index of column */ + i16 iDb; /* Database idx for pTab */ + + assert( p ); /* Because of isCandidateForInOpt(p) */ + assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */ + assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */ + assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */ + pTab = p->pSrc->a[0].pTab; + pExpr = p->pEList->a[0].pExpr; + iCol = (i16)pExpr->iColumn; + + /* Code an OP_Transaction and OP_TableLock for
    . */ + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + sqlite3CodeVerifySchema(pParse, iDb); + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + + /* This function is only called from two places. In both cases the vdbe + ** has already been allocated. So assume sqlite3GetVdbe() is always + ** successful here. + */ + assert(v); + if( iCol<0 ){ + int iAddr = sqlite3CodeOnce(pParse); + VdbeCoverage(v); + + sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead); + eType = IN_INDEX_ROWID; + + sqlite3VdbeJumpHere(v, iAddr); + }else{ + Index *pIdx; /* Iterator variable */ + + /* The collation sequence used by the comparison. If an index is to + ** be used in place of a temp-table, it must be ordered according + ** to this collation sequence. */ + CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr); + + /* Check that the affinity that will be used to perform the + ** comparison is the same as the affinity of the column. If + ** it is not, it is not possible to use any index. + */ + int affinity_ok = sqlite3IndexAffinityOk(pX, pTab->aCol[iCol].affinity); + + for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){ + if( (pIdx->aiColumn[0]==iCol) + && sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], 0)==pReq + && (!mustBeUnique || (pIdx->nKeyCol==1 && IsUniqueIndex(pIdx))) + ){ + int iAddr = sqlite3CodeOnce(pParse); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + VdbeComment((v, "%s", pIdx->zName)); + assert( IN_INDEX_INDEX_DESC == IN_INDEX_INDEX_ASC+1 ); + eType = IN_INDEX_INDEX_ASC + pIdx->aSortOrder[0]; + + if( prRhsHasNull && !pTab->aCol[iCol].notNull ){ + *prRhsHasNull = ++pParse->nMem; + sqlite3SetHasNullFlag(v, iTab, *prRhsHasNull); + } + sqlite3VdbeJumpHere(v, iAddr); + } + } + } + } + + /* If no preexisting index is available for the IN clause + ** and IN_INDEX_NOOP is an allowed reply + ** and the RHS of the IN operator is a list, not a subquery + ** and the RHS is not contant or has two or fewer terms, + ** then it is not worth creating an ephemeral table to evaluate + ** the IN operator so return IN_INDEX_NOOP. + */ + if( eType==0 + && (inFlags & IN_INDEX_NOOP_OK) + && !ExprHasProperty(pX, EP_xIsSelect) + && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2) + ){ + eType = IN_INDEX_NOOP; + } + + + if( eType==0 ){ + /* Could not find an existing table or index to use as the RHS b-tree. + ** We will have to generate an ephemeral table to do the job. + */ + u32 savedNQueryLoop = pParse->nQueryLoop; + int rMayHaveNull = 0; + eType = IN_INDEX_EPH; + if( inFlags & IN_INDEX_LOOP ){ + pParse->nQueryLoop = 0; + if( pX->pLeft->iColumn<0 && !ExprHasProperty(pX, EP_xIsSelect) ){ + eType = IN_INDEX_ROWID; + } + }else if( prRhsHasNull ){ + *prRhsHasNull = rMayHaveNull = ++pParse->nMem; + } + sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID); + pParse->nQueryLoop = savedNQueryLoop; + }else{ + pX->iTable = iTab; + } + return eType; +} +#endif + +/* +** Generate code for scalar subqueries used as a subquery expression, EXISTS, +** or IN operators. Examples: +** +** (SELECT a FROM b) -- subquery +** EXISTS (SELECT a FROM b) -- EXISTS subquery +** x IN (4,5,11) -- IN operator with list on right-hand side +** x IN (SELECT a FROM b) -- IN operator with subquery on the right +** +** The pExpr parameter describes the expression that contains the IN +** operator or subquery. +** +** If parameter isRowid is non-zero, then expression pExpr is guaranteed +** to be of the form " IN (?, ?, ?)", where is a reference +** to some integer key column of a table B-Tree. In this case, use an +** intkey B-Tree to store the set of IN(...) values instead of the usual +** (slower) variable length keys B-Tree. +** +** If rMayHaveNull is non-zero, that means that the operation is an IN +** (not a SELECT or EXISTS) and that the RHS might contains NULLs. +** All this routine does is initialize the register given by rMayHaveNull +** to NULL. Calling routines will take care of changing this register +** value to non-NULL if the RHS is NULL-free. +** +** For a SELECT or EXISTS operator, return the register that holds the +** result. For IN operators or if an error occurs, the return value is 0. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +SQLITE_PRIVATE int sqlite3CodeSubselect( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* The IN, SELECT, or EXISTS operator */ + int rHasNullFlag, /* Register that records whether NULLs exist in RHS */ + int isRowid /* If true, LHS of IN operator is a rowid */ +){ + int jmpIfDynamic = -1; /* One-time test address */ + int rReg = 0; /* Register storing resulting */ + Vdbe *v = sqlite3GetVdbe(pParse); + if( NEVER(v==0) ) return 0; + sqlite3ExprCachePush(pParse); + + /* This code must be run in its entirety every time it is encountered + ** if any of the following is true: + ** + ** * The right-hand side is a correlated subquery + ** * The right-hand side is an expression list containing variables + ** * We are inside a trigger + ** + ** If all of the above are false, then we can run this code just once + ** save the results, and reuse the same result on subsequent invocations. + */ + if( !ExprHasProperty(pExpr, EP_VarSelect) ){ + jmpIfDynamic = sqlite3CodeOnce(pParse); VdbeCoverage(v); + } + +#ifndef SQLITE_OMIT_EXPLAIN + if( pParse->explain==2 ){ + char *zMsg = sqlite3MPrintf( + pParse->db, "EXECUTE %s%s SUBQUERY %d", jmpIfDynamic>=0?"":"CORRELATED ", + pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId + ); + sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC); + } +#endif + + switch( pExpr->op ){ + case TK_IN: { + char affinity; /* Affinity of the LHS of the IN */ + int addr; /* Address of OP_OpenEphemeral instruction */ + Expr *pLeft = pExpr->pLeft; /* the LHS of the IN operator */ + KeyInfo *pKeyInfo = 0; /* Key information */ + + affinity = sqlite3ExprAffinity(pLeft); + + /* Whether this is an 'x IN(SELECT...)' or an 'x IN()' + ** expression it is handled the same way. An ephemeral table is + ** filled with single-field index keys representing the results + ** from the SELECT or the . + ** + ** If the 'x' expression is a column value, or the SELECT... + ** statement returns a column value, then the affinity of that + ** column is used to build the index keys. If both 'x' and the + ** SELECT... statement are columns, then numeric affinity is used + ** if either column has NUMERIC or INTEGER affinity. If neither + ** 'x' nor the SELECT... statement are columns, then numeric affinity + ** is used. + */ + pExpr->iTable = pParse->nTab++; + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid); + pKeyInfo = isRowid ? 0 : sqlite3KeyInfoAlloc(pParse->db, 1, 1); + + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + /* Case 1: expr IN (SELECT ...) + ** + ** Generate code to write the results of the select into the temporary + ** table allocated and opened above. + */ + Select *pSelect = pExpr->x.pSelect; + SelectDest dest; + ExprList *pEList; + + assert( !isRowid ); + sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable); + dest.affSdst = (u8)affinity; + assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable ); + pSelect->iLimit = 0; + testcase( pSelect->selFlags & SF_Distinct ); + testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */ + if( sqlite3Select(pParse, pSelect, &dest) ){ + sqlite3KeyInfoUnref(pKeyInfo); + return 0; + } + pEList = pSelect->pEList; + assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */ + assert( pEList!=0 ); + assert( pEList->nExpr>0 ); + assert( sqlite3KeyInfoIsWriteable(pKeyInfo) ); + pKeyInfo->aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, + pEList->a[0].pExpr); + }else if( ALWAYS(pExpr->x.pList!=0) ){ + /* Case 2: expr IN (exprlist) + ** + ** For each expression, build an index key from the evaluation and + ** store it in the temporary table. If is a column, then use + ** that columns affinity when building index keys. If is not + ** a column, use numeric affinity. + */ + int i; + ExprList *pList = pExpr->x.pList; + struct ExprList_item *pItem; + int r1, r2, r3; + + if( !affinity ){ + affinity = SQLITE_AFF_BLOB; + } + if( pKeyInfo ){ + assert( sqlite3KeyInfoIsWriteable(pKeyInfo) ); + pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft); + } + + /* Loop through each expression in . */ + r1 = sqlite3GetTempReg(pParse); + r2 = sqlite3GetTempReg(pParse); + if( isRowid ) sqlite3VdbeAddOp2(v, OP_Null, 0, r2); + for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){ + Expr *pE2 = pItem->pExpr; + int iValToIns; + + /* If the expression is not constant then we will need to + ** disable the test that was generated above that makes sure + ** this code only executes once. Because for a non-constant + ** expression we need to rerun this code each time. + */ + if( jmpIfDynamic>=0 && !sqlite3ExprIsConstant(pE2) ){ + sqlite3VdbeChangeToNoop(v, jmpIfDynamic); + jmpIfDynamic = -1; + } + + /* Evaluate the expression and insert it into the temp table */ + if( isRowid && sqlite3ExprIsInteger(pE2, &iValToIns) ){ + sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns); + }else{ + r3 = sqlite3ExprCodeTarget(pParse, pE2, r1); + if( isRowid ){ + sqlite3VdbeAddOp2(v, OP_MustBeInt, r3, + sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3); + }else{ + sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1); + sqlite3ExprCacheAffinityChange(pParse, r3, 1); + sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2); + } + } + } + sqlite3ReleaseTempReg(pParse, r1); + sqlite3ReleaseTempReg(pParse, r2); + } + if( pKeyInfo ){ + sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO); + } + break; + } + + case TK_EXISTS: + case TK_SELECT: + default: { + /* If this has to be a scalar SELECT. Generate code to put the + ** value of this select in a memory cell and record the number + ** of the memory cell in iColumn. If this is an EXISTS, write + ** an integer 0 (not exists) or 1 (exists) into a memory cell + ** and record that memory cell in iColumn. + */ + Select *pSel; /* SELECT statement to encode */ + SelectDest dest; /* How to deal with SELECt result */ + + testcase( pExpr->op==TK_EXISTS ); + testcase( pExpr->op==TK_SELECT ); + assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT ); + + assert( ExprHasProperty(pExpr, EP_xIsSelect) ); + pSel = pExpr->x.pSelect; + sqlite3SelectDestInit(&dest, 0, ++pParse->nMem); + if( pExpr->op==TK_SELECT ){ + dest.eDest = SRT_Mem; + dest.iSdst = dest.iSDParm; + sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iSDParm); + VdbeComment((v, "Init subquery result")); + }else{ + dest.eDest = SRT_Exists; + sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm); + VdbeComment((v, "Init EXISTS result")); + } + sqlite3ExprDelete(pParse->db, pSel->pLimit); + pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, + &sqlite3IntTokens[1]); + pSel->iLimit = 0; + pSel->selFlags &= ~SF_MultiValue; + if( sqlite3Select(pParse, pSel, &dest) ){ + return 0; + } + rReg = dest.iSDParm; + ExprSetVVAProperty(pExpr, EP_NoReduce); + break; + } + } + + if( rHasNullFlag ){ + sqlite3SetHasNullFlag(v, pExpr->iTable, rHasNullFlag); + } + + if( jmpIfDynamic>=0 ){ + sqlite3VdbeJumpHere(v, jmpIfDynamic); + } + sqlite3ExprCachePop(pParse); + + return rReg; +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Generate code for an IN expression. +** +** x IN (SELECT ...) +** x IN (value, value, ...) +** +** The left-hand side (LHS) is a scalar expression. The right-hand side (RHS) +** is an array of zero or more values. The expression is true if the LHS is +** contained within the RHS. The value of the expression is unknown (NULL) +** if the LHS is NULL or if the LHS is not contained within the RHS and the +** RHS contains one or more NULL values. +** +** This routine generates code that jumps to destIfFalse if the LHS is not +** contained within the RHS. If due to NULLs we cannot determine if the LHS +** is contained in the RHS then jump to destIfNull. If the LHS is contained +** within the RHS then fall through. +*/ +static void sqlite3ExprCodeIN( + Parse *pParse, /* Parsing and code generating context */ + Expr *pExpr, /* The IN expression */ + int destIfFalse, /* Jump here if LHS is not contained in the RHS */ + int destIfNull /* Jump here if the results are unknown due to NULLs */ +){ + int rRhsHasNull = 0; /* Register that is true if RHS contains NULL values */ + char affinity; /* Comparison affinity to use */ + int eType; /* Type of the RHS */ + int r1; /* Temporary use register */ + Vdbe *v; /* Statement under construction */ + + /* Compute the RHS. After this step, the table with cursor + ** pExpr->iTable will contains the values that make up the RHS. + */ + v = pParse->pVdbe; + assert( v!=0 ); /* OOM detected prior to this routine */ + VdbeNoopComment((v, "begin IN expr")); + eType = sqlite3FindInIndex(pParse, pExpr, + IN_INDEX_MEMBERSHIP | IN_INDEX_NOOP_OK, + destIfFalse==destIfNull ? 0 : &rRhsHasNull); + + /* Figure out the affinity to use to create a key from the results + ** of the expression. affinityStr stores a static string suitable for + ** P4 of OP_MakeRecord. + */ + affinity = comparisonAffinity(pExpr); + + /* Code the LHS, the from " IN (...)". + */ + sqlite3ExprCachePush(pParse); + r1 = sqlite3GetTempReg(pParse); + sqlite3ExprCode(pParse, pExpr->pLeft, r1); + + /* If sqlite3FindInIndex() did not find or create an index that is + ** suitable for evaluating the IN operator, then evaluate using a + ** sequence of comparisons. + */ + if( eType==IN_INDEX_NOOP ){ + ExprList *pList = pExpr->x.pList; + CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft); + int labelOk = sqlite3VdbeMakeLabel(v); + int r2, regToFree; + int regCkNull = 0; + int ii; + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + if( destIfNull!=destIfFalse ){ + regCkNull = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_BitAnd, r1, r1, regCkNull); + } + for(ii=0; iinExpr; ii++){ + r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree); + if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){ + sqlite3VdbeAddOp3(v, OP_BitAnd, regCkNull, r2, regCkNull); + } + if( iinExpr-1 || destIfNull!=destIfFalse ){ + sqlite3VdbeAddOp4(v, OP_Eq, r1, labelOk, r2, + (void*)pColl, P4_COLLSEQ); + VdbeCoverageIf(v, iinExpr-1); + VdbeCoverageIf(v, ii==pList->nExpr-1); + sqlite3VdbeChangeP5(v, affinity); + }else{ + assert( destIfNull==destIfFalse ); + sqlite3VdbeAddOp4(v, OP_Ne, r1, destIfFalse, r2, + (void*)pColl, P4_COLLSEQ); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, affinity | SQLITE_JUMPIFNULL); + } + sqlite3ReleaseTempReg(pParse, regToFree); + } + if( regCkNull ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regCkNull, destIfNull); VdbeCoverage(v); + sqlite3VdbeGoto(v, destIfFalse); + } + sqlite3VdbeResolveLabel(v, labelOk); + sqlite3ReleaseTempReg(pParse, regCkNull); + }else{ + + /* If the LHS is NULL, then the result is either false or NULL depending + ** on whether the RHS is empty or not, respectively. + */ + if( sqlite3ExprCanBeNull(pExpr->pLeft) ){ + if( destIfNull==destIfFalse ){ + /* Shortcut for the common case where the false and NULL outcomes are + ** the same. */ + sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull); VdbeCoverage(v); + }else{ + int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse); + VdbeCoverage(v); + sqlite3VdbeGoto(v, destIfNull); + sqlite3VdbeJumpHere(v, addr1); + } + } + + if( eType==IN_INDEX_ROWID ){ + /* In this case, the RHS is the ROWID of table b-tree + */ + sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1); + VdbeCoverage(v); + }else{ + /* In this case, the RHS is an index b-tree. + */ + sqlite3VdbeAddOp4(v, OP_Affinity, r1, 1, 0, &affinity, 1); + + /* If the set membership test fails, then the result of the + ** "x IN (...)" expression must be either 0 or NULL. If the set + ** contains no NULL values, then the result is 0. If the set + ** contains one or more NULL values, then the result of the + ** expression is also NULL. + */ + assert( destIfFalse!=destIfNull || rRhsHasNull==0 ); + if( rRhsHasNull==0 ){ + /* This branch runs if it is known at compile time that the RHS + ** cannot contain NULL values. This happens as the result + ** of a "NOT NULL" constraint in the database schema. + ** + ** Also run this branch if NULL is equivalent to FALSE + ** for this particular IN operator. + */ + sqlite3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1); + VdbeCoverage(v); + }else{ + /* In this branch, the RHS of the IN might contain a NULL and + ** the presence of a NULL on the RHS makes a difference in the + ** outcome. + */ + int addr1; + + /* First check to see if the LHS is contained in the RHS. If so, + ** then the answer is TRUE the presence of NULLs in the RHS does + ** not matter. If the LHS is not contained in the RHS, then the + ** answer is NULL if the RHS contains NULLs and the answer is + ** FALSE if the RHS is NULL-free. + */ + addr1 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1); + VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_IsNull, rRhsHasNull, destIfNull); + VdbeCoverage(v); + sqlite3VdbeGoto(v, destIfFalse); + sqlite3VdbeJumpHere(v, addr1); + } + } + } + sqlite3ReleaseTempReg(pParse, r1); + sqlite3ExprCachePop(pParse); + VdbeComment((v, "end IN expr")); +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** Generate an instruction that will put the floating point +** value described by z[0..n-1] into register iMem. +** +** The z[] string will probably not be zero-terminated. But the +** z[n] character is guaranteed to be something that does not look +** like the continuation of the number. +*/ +static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){ + if( ALWAYS(z!=0) ){ + double value; + sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8); + assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */ + if( negateFlag ) value = -value; + sqlite3VdbeAddOp4Dup8(v, OP_Real, 0, iMem, 0, (u8*)&value, P4_REAL); + } +} +#endif + + +/* +** Generate an instruction that will put the integer describe by +** text z[0..n-1] into register iMem. +** +** Expr.u.zToken is always UTF8 and zero-terminated. +*/ +static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){ + Vdbe *v = pParse->pVdbe; + if( pExpr->flags & EP_IntValue ){ + int i = pExpr->u.iValue; + assert( i>=0 ); + if( negFlag ) i = -i; + sqlite3VdbeAddOp2(v, OP_Integer, i, iMem); + }else{ + int c; + i64 value; + const char *z = pExpr->u.zToken; + assert( z!=0 ); + c = sqlite3DecOrHexToI64(z, &value); + if( c==0 || (c==2 && negFlag) ){ + if( negFlag ){ value = c==2 ? SMALLEST_INT64 : -value; } + sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, iMem, 0, (u8*)&value, P4_INT64); + }else{ +#ifdef SQLITE_OMIT_FLOATING_POINT + sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z); +#else +#ifndef SQLITE_OMIT_HEX_INTEGER + if( sqlite3_strnicmp(z,"0x",2)==0 ){ + sqlite3ErrorMsg(pParse, "hex literal too big: %s", z); + }else +#endif + { + codeReal(v, z, negFlag, iMem); + } +#endif + } + } +} + +/* +** Clear a cache entry. +*/ +static void cacheEntryClear(Parse *pParse, struct yColCache *p){ + if( p->tempReg ){ + if( pParse->nTempRegaTempReg) ){ + pParse->aTempReg[pParse->nTempReg++] = p->iReg; + } + p->tempReg = 0; + } +} + + +/* +** Record in the column cache that a particular column from a +** particular table is stored in a particular register. +*/ +SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){ + int i; + int minLru; + int idxLru; + struct yColCache *p; + + /* Unless an error has occurred, register numbers are always positive. */ + assert( iReg>0 || pParse->nErr || pParse->db->mallocFailed ); + assert( iCol>=-1 && iCol<32768 ); /* Finite column numbers */ + + /* The SQLITE_ColumnCache flag disables the column cache. This is used + ** for testing only - to verify that SQLite always gets the same answer + ** with and without the column cache. + */ + if( OptimizationDisabled(pParse->db, SQLITE_ColumnCache) ) return; + + /* First replace any existing entry. + ** + ** Actually, the way the column cache is currently used, we are guaranteed + ** that the object will never already be in cache. Verify this guarantee. + */ +#ifndef NDEBUG + for(i=0, p=pParse->aColCache; iiReg==0 || p->iTable!=iTab || p->iColumn!=iCol ); + } +#endif + + /* Find an empty slot and replace it */ + for(i=0, p=pParse->aColCache; iiReg==0 ){ + p->iLevel = pParse->iCacheLevel; + p->iTable = iTab; + p->iColumn = iCol; + p->iReg = iReg; + p->tempReg = 0; + p->lru = pParse->iCacheCnt++; + return; + } + } + + /* Replace the last recently used */ + minLru = 0x7fffffff; + idxLru = -1; + for(i=0, p=pParse->aColCache; ilrulru; + } + } + if( ALWAYS(idxLru>=0) ){ + p = &pParse->aColCache[idxLru]; + p->iLevel = pParse->iCacheLevel; + p->iTable = iTab; + p->iColumn = iCol; + p->iReg = iReg; + p->tempReg = 0; + p->lru = pParse->iCacheCnt++; + return; + } +} + +/* +** Indicate that registers between iReg..iReg+nReg-1 are being overwritten. +** Purge the range of registers from the column cache. +*/ +SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){ + int i; + int iLast = iReg + nReg - 1; + struct yColCache *p; + for(i=0, p=pParse->aColCache; iiReg; + if( r>=iReg && r<=iLast ){ + cacheEntryClear(pParse, p); + p->iReg = 0; + } + } +} + +/* +** Remember the current column cache context. Any new entries added +** added to the column cache after this call are removed when the +** corresponding pop occurs. +*/ +SQLITE_PRIVATE void sqlite3ExprCachePush(Parse *pParse){ + pParse->iCacheLevel++; +#ifdef SQLITE_DEBUG + if( pParse->db->flags & SQLITE_VdbeAddopTrace ){ + printf("PUSH to %d\n", pParse->iCacheLevel); + } +#endif +} + +/* +** Remove from the column cache any entries that were added since the +** the previous sqlite3ExprCachePush operation. In other words, restore +** the cache to the state it was in prior the most recent Push. +*/ +SQLITE_PRIVATE void sqlite3ExprCachePop(Parse *pParse){ + int i; + struct yColCache *p; + assert( pParse->iCacheLevel>=1 ); + pParse->iCacheLevel--; +#ifdef SQLITE_DEBUG + if( pParse->db->flags & SQLITE_VdbeAddopTrace ){ + printf("POP to %d\n", pParse->iCacheLevel); + } +#endif + for(i=0, p=pParse->aColCache; iiReg && p->iLevel>pParse->iCacheLevel ){ + cacheEntryClear(pParse, p); + p->iReg = 0; + } + } +} + +/* +** When a cached column is reused, make sure that its register is +** no longer available as a temp register. ticket #3879: that same +** register might be in the cache in multiple places, so be sure to +** get them all. +*/ +static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){ + int i; + struct yColCache *p; + for(i=0, p=pParse->aColCache; iiReg==iReg ){ + p->tempReg = 0; + } + } +} + +/* Generate code that will load into register regOut a value that is +** appropriate for the iIdxCol-th column of index pIdx. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeLoadIndexColumn( + Parse *pParse, /* The parsing context */ + Index *pIdx, /* The index whose column is to be loaded */ + int iTabCur, /* Cursor pointing to a table row */ + int iIdxCol, /* The column of the index to be loaded */ + int regOut /* Store the index column value in this register */ +){ + i16 iTabCol = pIdx->aiColumn[iIdxCol]; + if( iTabCol==XN_EXPR ){ + assert( pIdx->aColExpr ); + assert( pIdx->aColExpr->nExpr>iIdxCol ); + pParse->iSelfTab = iTabCur; + sqlite3ExprCode(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut); + }else{ + sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pIdx->pTable, iTabCur, + iTabCol, regOut); + } +} + +/* +** Generate code to extract the value of the iCol-th column of a table. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable( + Vdbe *v, /* The VDBE under construction */ + Table *pTab, /* The table containing the value */ + int iTabCur, /* The table cursor. Or the PK cursor for WITHOUT ROWID */ + int iCol, /* Index of the column to extract */ + int regOut /* Extract the value into this register */ +){ + if( iCol<0 || iCol==pTab->iPKey ){ + sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut); + }else{ + int op = IsVirtual(pTab) ? OP_VColumn : OP_Column; + int x = iCol; + if( !HasRowid(pTab) ){ + x = sqlite3ColumnOfIndex(sqlite3PrimaryKeyIndex(pTab), iCol); + } + sqlite3VdbeAddOp3(v, op, iTabCur, x, regOut); + } + if( iCol>=0 ){ + sqlite3ColumnDefault(v, pTab, iCol, regOut); + } +} + +/* +** Generate code that will extract the iColumn-th column from +** table pTab and store the column value in a register. An effort +** is made to store the column value in register iReg, but this is +** not guaranteed. The location of the column value is returned. +** +** There must be an open cursor to pTab in iTable when this routine +** is called. If iColumn<0 then code is generated that extracts the rowid. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeGetColumn( + Parse *pParse, /* Parsing and code generating context */ + Table *pTab, /* Description of the table we are reading from */ + int iColumn, /* Index of the table column */ + int iTable, /* The cursor pointing to the table */ + int iReg, /* Store results here */ + u8 p5 /* P5 value for OP_Column */ +){ + Vdbe *v = pParse->pVdbe; + int i; + struct yColCache *p; + + for(i=0, p=pParse->aColCache; iiReg>0 && p->iTable==iTable && p->iColumn==iColumn ){ + p->lru = pParse->iCacheCnt++; + sqlite3ExprCachePinRegister(pParse, p->iReg); + return p->iReg; + } + } + assert( v!=0 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iTable, iColumn, iReg); + if( p5 ){ + sqlite3VdbeChangeP5(v, p5); + }else{ + sqlite3ExprCacheStore(pParse, iTable, iColumn, iReg); + } + return iReg; +} + +/* +** Clear all column cache entries. +*/ +SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse *pParse){ + int i; + struct yColCache *p; + +#if SQLITE_DEBUG + if( pParse->db->flags & SQLITE_VdbeAddopTrace ){ + printf("CLEAR\n"); + } +#endif + for(i=0, p=pParse->aColCache; iiReg ){ + cacheEntryClear(pParse, p); + p->iReg = 0; + } + } +} + +/* +** Record the fact that an affinity change has occurred on iCount +** registers starting with iStart. +*/ +SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){ + sqlite3ExprCacheRemove(pParse, iStart, iCount); +} + +/* +** Generate code to move content from registers iFrom...iFrom+nReg-1 +** over to iTo..iTo+nReg-1. Keep the column cache up-to-date. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){ + assert( iFrom>=iTo+nReg || iFrom+nReg<=iTo ); + sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg); + sqlite3ExprCacheRemove(pParse, iFrom, nReg); +} + +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) +/* +** Return true if any register in the range iFrom..iTo (inclusive) +** is used as part of the column cache. +** +** This routine is used within assert() and testcase() macros only +** and does not appear in a normal build. +*/ +static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){ + int i; + struct yColCache *p; + for(i=0, p=pParse->aColCache; iiReg; + if( r>=iFrom && r<=iTo ) return 1; /*NO_TEST*/ + } + return 0; +} +#endif /* SQLITE_DEBUG || SQLITE_COVERAGE_TEST */ + +/* +** Convert an expression node to a TK_REGISTER +*/ +static void exprToRegister(Expr *p, int iReg){ + p->op2 = p->op; + p->op = TK_REGISTER; + p->iTable = iReg; + ExprClearProperty(p, EP_Skip); +} + +/* +** Generate code into the current Vdbe to evaluate the given +** expression. Attempt to store the results in register "target". +** Return the register where results are stored. +** +** With this routine, there is no guarantee that results will +** be stored in target. The result might be stored in some other +** register if it is convenient to do so. The calling function +** must check the return code and move the results to the desired +** register. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){ + Vdbe *v = pParse->pVdbe; /* The VM under construction */ + int op; /* The opcode being coded */ + int inReg = target; /* Results stored in register inReg */ + int regFree1 = 0; /* If non-zero free this temporary register */ + int regFree2 = 0; /* If non-zero free this temporary register */ + int r1, r2, r3, r4; /* Various register numbers */ + sqlite3 *db = pParse->db; /* The database connection */ + Expr tempX; /* Temporary expression node */ + + assert( target>0 && target<=pParse->nMem ); + if( v==0 ){ + assert( pParse->db->mallocFailed ); + return 0; + } + + if( pExpr==0 ){ + op = TK_NULL; + }else{ + op = pExpr->op; + } + switch( op ){ + case TK_AGG_COLUMN: { + AggInfo *pAggInfo = pExpr->pAggInfo; + struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg]; + if( !pAggInfo->directMode ){ + assert( pCol->iMem>0 ); + inReg = pCol->iMem; + break; + }else if( pAggInfo->useSortingIdx ){ + sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab, + pCol->iSorterColumn, target); + break; + } + /* Otherwise, fall thru into the TK_COLUMN case */ + } + case TK_COLUMN: { + int iTab = pExpr->iTable; + if( iTab<0 ){ + if( pParse->ckBase>0 ){ + /* Generating CHECK constraints or inserting into partial index */ + inReg = pExpr->iColumn + pParse->ckBase; + break; + }else{ + /* Coding an expression that is part of an index where column names + ** in the index refer to the table to which the index belongs */ + iTab = pParse->iSelfTab; + } + } + inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab, + pExpr->iColumn, iTab, target, + pExpr->op2); + break; + } + case TK_INTEGER: { + codeInteger(pParse, pExpr, 0, target); + break; + } +#ifndef SQLITE_OMIT_FLOATING_POINT + case TK_FLOAT: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + codeReal(v, pExpr->u.zToken, 0, target); + break; + } +#endif + case TK_STRING: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3VdbeLoadString(v, target, pExpr->u.zToken); + break; + } + case TK_NULL: { + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + break; + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + case TK_BLOB: { + int n; + const char *z; + char *zBlob; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' ); + assert( pExpr->u.zToken[1]=='\'' ); + z = &pExpr->u.zToken[2]; + n = sqlite3Strlen30(z) - 1; + assert( z[n]=='\'' ); + zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n); + sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC); + break; + } +#endif + case TK_VARIABLE: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + assert( pExpr->u.zToken!=0 ); + assert( pExpr->u.zToken[0]!=0 ); + sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target); + if( pExpr->u.zToken[1]!=0 ){ + assert( pExpr->u.zToken[0]=='?' + || strcmp(pExpr->u.zToken, pParse->azVar[pExpr->iColumn-1])==0 ); + sqlite3VdbeChangeP4(v, -1, pParse->azVar[pExpr->iColumn-1], P4_STATIC); + } + break; + } + case TK_REGISTER: { + inReg = pExpr->iTable; + break; + } +#ifndef SQLITE_OMIT_CAST + case TK_CAST: { + /* Expressions of the form: CAST(pLeft AS token) */ + inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target); + if( inReg!=target ){ + sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target); + inReg = target; + } + sqlite3VdbeAddOp2(v, OP_Cast, target, + sqlite3AffinityType(pExpr->u.zToken, 0)); + testcase( usedAsColumnCache(pParse, inReg, inReg) ); + sqlite3ExprCacheAffinityChange(pParse, inReg, 1); + break; + } +#endif /* SQLITE_OMIT_CAST */ + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, + r1, r2, inReg, SQLITE_STOREP2); + assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); + assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); + assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); + assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); + assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq); + assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_IS: + case TK_ISNOT: { + testcase( op==TK_IS ); + testcase( op==TK_ISNOT ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + op = (op==TK_IS) ? TK_EQ : TK_NE; + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, + r1, r2, inReg, SQLITE_STOREP2 | SQLITE_NULLEQ); + VdbeCoverageIf(v, op==TK_EQ); + VdbeCoverageIf(v, op==TK_NE); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_AND: + case TK_OR: + case TK_PLUS: + case TK_STAR: + case TK_MINUS: + case TK_REM: + case TK_BITAND: + case TK_BITOR: + case TK_SLASH: + case TK_LSHIFT: + case TK_RSHIFT: + case TK_CONCAT: { + assert( TK_AND==OP_And ); testcase( op==TK_AND ); + assert( TK_OR==OP_Or ); testcase( op==TK_OR ); + assert( TK_PLUS==OP_Add ); testcase( op==TK_PLUS ); + assert( TK_MINUS==OP_Subtract ); testcase( op==TK_MINUS ); + assert( TK_REM==OP_Remainder ); testcase( op==TK_REM ); + assert( TK_BITAND==OP_BitAnd ); testcase( op==TK_BITAND ); + assert( TK_BITOR==OP_BitOr ); testcase( op==TK_BITOR ); + assert( TK_SLASH==OP_Divide ); testcase( op==TK_SLASH ); + assert( TK_LSHIFT==OP_ShiftLeft ); testcase( op==TK_LSHIFT ); + assert( TK_RSHIFT==OP_ShiftRight ); testcase( op==TK_RSHIFT ); + assert( TK_CONCAT==OP_Concat ); testcase( op==TK_CONCAT ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + sqlite3VdbeAddOp3(v, op, r2, r1, target); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_UMINUS: { + Expr *pLeft = pExpr->pLeft; + assert( pLeft ); + if( pLeft->op==TK_INTEGER ){ + codeInteger(pParse, pLeft, 1, target); +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( pLeft->op==TK_FLOAT ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + codeReal(v, pLeft->u.zToken, 1, target); +#endif + }else{ + tempX.op = TK_INTEGER; + tempX.flags = EP_IntValue|EP_TokenOnly; + tempX.u.iValue = 0; + r1 = sqlite3ExprCodeTemp(pParse, &tempX, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2); + sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target); + testcase( regFree2==0 ); + } + inReg = target; + break; + } + case TK_BITNOT: + case TK_NOT: { + assert( TK_BITNOT==OP_BitNot ); testcase( op==TK_BITNOT ); + assert( TK_NOT==OP_Not ); testcase( op==TK_NOT ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + testcase( regFree1==0 ); + inReg = target; + sqlite3VdbeAddOp2(v, op, r1, inReg); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + int addr; + assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL ); + assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL ); + sqlite3VdbeAddOp2(v, OP_Integer, 1, target); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + testcase( regFree1==0 ); + addr = sqlite3VdbeAddOp1(v, op, r1); + VdbeCoverageIf(v, op==TK_ISNULL); + VdbeCoverageIf(v, op==TK_NOTNULL); + sqlite3VdbeAddOp2(v, OP_Integer, 0, target); + sqlite3VdbeJumpHere(v, addr); + break; + } + case TK_AGG_FUNCTION: { + AggInfo *pInfo = pExpr->pAggInfo; + if( pInfo==0 ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken); + }else{ + inReg = pInfo->aFunc[pExpr->iAgg].iMem; + } + break; + } + case TK_FUNCTION: { + ExprList *pFarg; /* List of function arguments */ + int nFarg; /* Number of function arguments */ + FuncDef *pDef; /* The function definition object */ + int nId; /* Length of the function name in bytes */ + const char *zId; /* The function name */ + u32 constMask = 0; /* Mask of function arguments that are constant */ + int i; /* Loop counter */ + u8 enc = ENC(db); /* The text encoding used by this database */ + CollSeq *pColl = 0; /* A collating sequence */ + + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + if( ExprHasProperty(pExpr, EP_TokenOnly) ){ + pFarg = 0; + }else{ + pFarg = pExpr->x.pList; + } + nFarg = pFarg ? pFarg->nExpr : 0; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + zId = pExpr->u.zToken; + nId = sqlite3Strlen30(zId); + pDef = sqlite3FindFunction(db, zId, nId, nFarg, enc, 0); + if( pDef==0 || pDef->xFunc==0 ){ + sqlite3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId); + break; + } + + /* Attempt a direct implementation of the built-in COALESCE() and + ** IFNULL() functions. This avoids unnecessary evaluation of + ** arguments past the first non-NULL argument. + */ + if( pDef->funcFlags & SQLITE_FUNC_COALESCE ){ + int endCoalesce = sqlite3VdbeMakeLabel(v); + assert( nFarg>=2 ); + sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target); + for(i=1; ia[i].pExpr, target); + sqlite3ExprCachePop(pParse); + } + sqlite3VdbeResolveLabel(v, endCoalesce); + break; + } + + /* The UNLIKELY() function is a no-op. The result is the value + ** of the first argument. + */ + if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){ + assert( nFarg>=1 ); + inReg = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target); + break; + } + + for(i=0; ia[i].pExpr) ){ + testcase( i==31 ); + constMask |= MASKBIT32(i); + } + if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){ + pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr); + } + } + if( pFarg ){ + if( constMask ){ + r1 = pParse->nMem+1; + pParse->nMem += nFarg; + }else{ + r1 = sqlite3GetTempRange(pParse, nFarg); + } + + /* For length() and typeof() functions with a column argument, + ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG + ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data + ** loading. + */ + if( (pDef->funcFlags & (SQLITE_FUNC_LENGTH|SQLITE_FUNC_TYPEOF))!=0 ){ + u8 exprOp; + assert( nFarg==1 ); + assert( pFarg->a[0].pExpr!=0 ); + exprOp = pFarg->a[0].pExpr->op; + if( exprOp==TK_COLUMN || exprOp==TK_AGG_COLUMN ){ + assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG ); + assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG ); + testcase( pDef->funcFlags & OPFLAG_LENGTHARG ); + pFarg->a[0].pExpr->op2 = + pDef->funcFlags & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG); + } + } + + sqlite3ExprCachePush(pParse); /* Ticket 2ea2425d34be */ + sqlite3ExprCodeExprList(pParse, pFarg, r1, 0, + SQLITE_ECEL_DUP|SQLITE_ECEL_FACTOR); + sqlite3ExprCachePop(pParse); /* Ticket 2ea2425d34be */ + }else{ + r1 = 0; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Possibly overload the function if the first argument is + ** a virtual table column. + ** + ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the + ** second argument, not the first, as the argument to test to + ** see if it is a column in a virtual table. This is done because + ** the left operand of infix functions (the operand we want to + ** control overloading) ends up as the second argument to the + ** function. The expression "A glob B" is equivalent to + ** "glob(B,A). We want to use the A in "A glob B" to test + ** for function overloading. But we use the B term in "glob(B,A)". + */ + if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){ + pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr); + }else if( nFarg>0 ){ + pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr); + } +#endif + if( pDef->funcFlags & SQLITE_FUNC_NEEDCOLL ){ + if( !pColl ) pColl = db->pDfltColl; + sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ); + } + sqlite3VdbeAddOp4(v, OP_Function0, constMask, r1, target, + (char*)pDef, P4_FUNCDEF); + sqlite3VdbeChangeP5(v, (u8)nFarg); + if( nFarg && constMask==0 ){ + sqlite3ReleaseTempRange(pParse, r1, nFarg); + } + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_EXISTS: + case TK_SELECT: { + testcase( op==TK_EXISTS ); + testcase( op==TK_SELECT ); + inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0); + break; + } + case TK_IN: { + int destIfFalse = sqlite3VdbeMakeLabel(v); + int destIfNull = sqlite3VdbeMakeLabel(v); + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull); + sqlite3VdbeAddOp2(v, OP_Integer, 1, target); + sqlite3VdbeResolveLabel(v, destIfFalse); + sqlite3VdbeAddOp2(v, OP_AddImm, target, 0); + sqlite3VdbeResolveLabel(v, destIfNull); + break; + } +#endif /* SQLITE_OMIT_SUBQUERY */ + + + /* + ** x BETWEEN y AND z + ** + ** This is equivalent to + ** + ** x>=y AND x<=z + ** + ** X is stored in pExpr->pLeft. + ** Y is stored in pExpr->pList->a[0].pExpr. + ** Z is stored in pExpr->pList->a[1].pExpr. + */ + case TK_BETWEEN: { + Expr *pLeft = pExpr->pLeft; + struct ExprList_item *pLItem = pExpr->x.pList->a; + Expr *pRight = pLItem->pExpr; + + r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pRight, ®Free2); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + r3 = sqlite3GetTempReg(pParse); + r4 = sqlite3GetTempReg(pParse); + codeCompare(pParse, pLeft, pRight, OP_Ge, + r1, r2, r3, SQLITE_STOREP2); VdbeCoverage(v); + pLItem++; + pRight = pLItem->pExpr; + sqlite3ReleaseTempReg(pParse, regFree2); + r2 = sqlite3ExprCodeTemp(pParse, pRight, ®Free2); + testcase( regFree2==0 ); + codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_And, r3, r4, target); + sqlite3ReleaseTempReg(pParse, r3); + sqlite3ReleaseTempReg(pParse, r4); + break; + } + case TK_COLLATE: + case TK_UPLUS: { + inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target); + break; + } + + case TK_TRIGGER: { + /* If the opcode is TK_TRIGGER, then the expression is a reference + ** to a column in the new.* or old.* pseudo-tables available to + ** trigger programs. In this case Expr.iTable is set to 1 for the + ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn + ** is set to the column of the pseudo-table to read, or to -1 to + ** read the rowid field. + ** + ** The expression is implemented using an OP_Param opcode. The p1 + ** parameter is set to 0 for an old.rowid reference, or to (i+1) + ** to reference another column of the old.* pseudo-table, where + ** i is the index of the column. For a new.rowid reference, p1 is + ** set to (n+1), where n is the number of columns in each pseudo-table. + ** For a reference to any other column in the new.* pseudo-table, p1 + ** is set to (n+2+i), where n and i are as defined previously. For + ** example, if the table on which triggers are being fired is + ** declared as: + ** + ** CREATE TABLE t1(a, b); + ** + ** Then p1 is interpreted as follows: + ** + ** p1==0 -> old.rowid p1==3 -> new.rowid + ** p1==1 -> old.a p1==4 -> new.a + ** p1==2 -> old.b p1==5 -> new.b + */ + Table *pTab = pExpr->pTab; + int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn; + + assert( pExpr->iTable==0 || pExpr->iTable==1 ); + assert( pExpr->iColumn>=-1 && pExpr->iColumnnCol ); + assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey ); + assert( p1>=0 && p1<(pTab->nCol*2+2) ); + + sqlite3VdbeAddOp2(v, OP_Param, p1, target); + VdbeComment((v, "%s.%s -> $%d", + (pExpr->iTable ? "new" : "old"), + (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName), + target + )); + +#ifndef SQLITE_OMIT_FLOATING_POINT + /* If the column has REAL affinity, it may currently be stored as an + ** integer. Use OP_RealAffinity to make sure it is really real. + ** + ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to + ** floating point when extracting it from the record. */ + if( pExpr->iColumn>=0 + && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL + ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, target); + } +#endif + break; + } + + + /* + ** Form A: + ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END + ** + ** Form B: + ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END + ** + ** Form A is can be transformed into the equivalent form B as follows: + ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ... + ** WHEN x=eN THEN rN ELSE y END + ** + ** X (if it exists) is in pExpr->pLeft. + ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is + ** odd. The Y is also optional. If the number of elements in x.pList + ** is even, then Y is omitted and the "otherwise" result is NULL. + ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1]. + ** + ** The result of the expression is the Ri for the first matching Ei, + ** or if there is no matching Ei, the ELSE term Y, or if there is + ** no ELSE term, NULL. + */ + default: assert( op==TK_CASE ); { + int endLabel; /* GOTO label for end of CASE stmt */ + int nextCase; /* GOTO label for next WHEN clause */ + int nExpr; /* 2x number of WHEN terms */ + int i; /* Loop counter */ + ExprList *pEList; /* List of WHEN terms */ + struct ExprList_item *aListelem; /* Array of WHEN terms */ + Expr opCompare; /* The X==Ei expression */ + Expr *pX; /* The X expression */ + Expr *pTest = 0; /* X==Ei (form A) or just Ei (form B) */ + VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; ) + + assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList ); + assert(pExpr->x.pList->nExpr > 0); + pEList = pExpr->x.pList; + aListelem = pEList->a; + nExpr = pEList->nExpr; + endLabel = sqlite3VdbeMakeLabel(v); + if( (pX = pExpr->pLeft)!=0 ){ + tempX = *pX; + testcase( pX->op==TK_COLUMN ); + exprToRegister(&tempX, sqlite3ExprCodeTemp(pParse, pX, ®Free1)); + testcase( regFree1==0 ); + opCompare.op = TK_EQ; + opCompare.pLeft = &tempX; + pTest = &opCompare; + /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001: + ** The value in regFree1 might get SCopy-ed into the file result. + ** So make sure that the regFree1 register is not reused for other + ** purposes and possibly overwritten. */ + regFree1 = 0; + } + for(i=0; iop==TK_COLUMN ); + sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL); + testcase( aListelem[i+1].pExpr->op==TK_COLUMN ); + sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target); + sqlite3VdbeGoto(v, endLabel); + sqlite3ExprCachePop(pParse); + sqlite3VdbeResolveLabel(v, nextCase); + } + if( (nExpr&1)!=0 ){ + sqlite3ExprCachePush(pParse); + sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target); + sqlite3ExprCachePop(pParse); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + } + assert( db->mallocFailed || pParse->nErr>0 + || pParse->iCacheLevel==iCacheLevel ); + sqlite3VdbeResolveLabel(v, endLabel); + break; + } +#ifndef SQLITE_OMIT_TRIGGER + case TK_RAISE: { + assert( pExpr->affinity==OE_Rollback + || pExpr->affinity==OE_Abort + || pExpr->affinity==OE_Fail + || pExpr->affinity==OE_Ignore + ); + if( !pParse->pTriggerTab ){ + sqlite3ErrorMsg(pParse, + "RAISE() may only be used within a trigger-program"); + return 0; + } + if( pExpr->affinity==OE_Abort ){ + sqlite3MayAbort(pParse); + } + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + if( pExpr->affinity==OE_Ignore ){ + sqlite3VdbeAddOp4( + v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0); + VdbeCoverage(v); + }else{ + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_TRIGGER, + pExpr->affinity, pExpr->u.zToken, 0, 0); + } + + break; + } +#endif + } + sqlite3ReleaseTempReg(pParse, regFree1); + sqlite3ReleaseTempReg(pParse, regFree2); + return inReg; +} + +/* +** Factor out the code of the given expression to initialization time. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeAtInit( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* The expression to code when the VDBE initializes */ + int regDest, /* Store the value in this register */ + u8 reusable /* True if this expression is reusable */ +){ + ExprList *p; + assert( ConstFactorOk(pParse) ); + p = pParse->pConstExpr; + pExpr = sqlite3ExprDup(pParse->db, pExpr, 0); + p = sqlite3ExprListAppend(pParse, p, pExpr); + if( p ){ + struct ExprList_item *pItem = &p->a[p->nExpr-1]; + pItem->u.iConstExprReg = regDest; + pItem->reusable = reusable; + } + pParse->pConstExpr = p; +} + +/* +** Generate code to evaluate an expression and store the results +** into a register. Return the register number where the results +** are stored. +** +** If the register is a temporary register that can be deallocated, +** then write its number into *pReg. If the result register is not +** a temporary, then set *pReg to zero. +** +** If pExpr is a constant, then this routine might generate this +** code to fill the register in the initialization section of the +** VDBE program, in order to factor it out of the evaluation loop. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){ + int r2; + pExpr = sqlite3ExprSkipCollate(pExpr); + if( ConstFactorOk(pParse) + && pExpr->op!=TK_REGISTER + && sqlite3ExprIsConstantNotJoin(pExpr) + ){ + ExprList *p = pParse->pConstExpr; + int i; + *pReg = 0; + if( p ){ + struct ExprList_item *pItem; + for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){ + if( pItem->reusable && sqlite3ExprCompare(pItem->pExpr,pExpr,-1)==0 ){ + return pItem->u.iConstExprReg; + } + } + } + r2 = ++pParse->nMem; + sqlite3ExprCodeAtInit(pParse, pExpr, r2, 1); + }else{ + int r1 = sqlite3GetTempReg(pParse); + r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1); + if( r2==r1 ){ + *pReg = r1; + }else{ + sqlite3ReleaseTempReg(pParse, r1); + *pReg = 0; + } + } + return r2; +} + +/* +** Generate code that will evaluate expression pExpr and store the +** results in register target. The results are guaranteed to appear +** in register target. +*/ +SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){ + int inReg; + + assert( target>0 && target<=pParse->nMem ); + if( pExpr && pExpr->op==TK_REGISTER ){ + sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target); + }else{ + inReg = sqlite3ExprCodeTarget(pParse, pExpr, target); + assert( pParse->pVdbe || pParse->db->mallocFailed ); + if( inReg!=target && pParse->pVdbe ){ + sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target); + } + } +} + +/* +** Generate code that will evaluate expression pExpr and store the +** results in register target. The results are guaranteed to appear +** in register target. If the expression is constant, then this routine +** might choose to code the expression at initialization time. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){ + if( pParse->okConstFactor && sqlite3ExprIsConstant(pExpr) ){ + sqlite3ExprCodeAtInit(pParse, pExpr, target, 0); + }else{ + sqlite3ExprCode(pParse, pExpr, target); + } +} + +/* +** Generate code that evaluates the given expression and puts the result +** in register target. +** +** Also make a copy of the expression results into another "cache" register +** and modify the expression so that the next time it is evaluated, +** the result is a copy of the cache register. +** +** This routine is used for expressions that are used multiple +** times. They are evaluated once and the results of the expression +** are reused. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){ + Vdbe *v = pParse->pVdbe; + int iMem; + + assert( target>0 ); + assert( pExpr->op!=TK_REGISTER ); + sqlite3ExprCode(pParse, pExpr, target); + iMem = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Copy, target, iMem); + exprToRegister(pExpr, iMem); +} + +/* +** Generate code that pushes the value of every element of the given +** expression list into a sequence of registers beginning at target. +** +** Return the number of elements evaluated. +** +** The SQLITE_ECEL_DUP flag prevents the arguments from being +** filled using OP_SCopy. OP_Copy must be used instead. +** +** The SQLITE_ECEL_FACTOR argument allows constant arguments to be +** factored out into initialization code. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeExprList( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* The expression list to be coded */ + int target, /* Where to write results */ + int srcReg, /* Source registers if SQLITE_ECEL_REF */ + u8 flags /* SQLITE_ECEL_* flags */ +){ + struct ExprList_item *pItem; + int i, j, n; + u8 copyOp = (flags & SQLITE_ECEL_DUP) ? OP_Copy : OP_SCopy; + Vdbe *v = pParse->pVdbe; + assert( pList!=0 ); + assert( target>0 ); + assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */ + n = pList->nExpr; + if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR; + for(pItem=pList->a, i=0; ipExpr; + if( (flags & SQLITE_ECEL_REF)!=0 && (j = pList->a[i].u.x.iOrderByCol)>0 ){ + sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i); + }else if( (flags & SQLITE_ECEL_FACTOR)!=0 && sqlite3ExprIsConstant(pExpr) ){ + sqlite3ExprCodeAtInit(pParse, pExpr, target+i, 0); + }else{ + int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i); + if( inReg!=target+i ){ + VdbeOp *pOp; + if( copyOp==OP_Copy + && (pOp=sqlite3VdbeGetOp(v, -1))->opcode==OP_Copy + && pOp->p1+pOp->p3+1==inReg + && pOp->p2+pOp->p3+1==target+i + ){ + pOp->p3++; + }else{ + sqlite3VdbeAddOp2(v, copyOp, inReg, target+i); + } + } + } + } + return n; +} + +/* +** Generate code for a BETWEEN operator. +** +** x BETWEEN y AND z +** +** The above is equivalent to +** +** x>=y AND x<=z +** +** Code it as such, taking care to do the common subexpression +** elimination of x. +*/ +static void exprCodeBetween( + Parse *pParse, /* Parsing and code generating context */ + Expr *pExpr, /* The BETWEEN expression */ + int dest, /* Jump here if the jump is taken */ + int jumpIfTrue, /* Take the jump if the BETWEEN is true */ + int jumpIfNull /* Take the jump if the BETWEEN is NULL */ +){ + Expr exprAnd; /* The AND operator in x>=y AND x<=z */ + Expr compLeft; /* The x>=y term */ + Expr compRight; /* The x<=z term */ + Expr exprX; /* The x subexpression */ + int regFree1 = 0; /* Temporary use register */ + + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + exprX = *pExpr->pLeft; + exprAnd.op = TK_AND; + exprAnd.pLeft = &compLeft; + exprAnd.pRight = &compRight; + compLeft.op = TK_GE; + compLeft.pLeft = &exprX; + compLeft.pRight = pExpr->x.pList->a[0].pExpr; + compRight.op = TK_LE; + compRight.pLeft = &exprX; + compRight.pRight = pExpr->x.pList->a[1].pExpr; + exprToRegister(&exprX, sqlite3ExprCodeTemp(pParse, &exprX, ®Free1)); + if( jumpIfTrue ){ + sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull); + }else{ + sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull); + } + sqlite3ReleaseTempReg(pParse, regFree1); + + /* Ensure adequate test coverage */ + testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 ); + testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 ); + testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 ); + testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 ); + testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 ); + testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 ); + testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 ); + testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 ); +} + +/* +** Generate code for a boolean expression such that a jump is made +** to the label "dest" if the expression is true but execution +** continues straight thru if the expression is false. +** +** If the expression evaluates to NULL (neither true nor false), then +** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL. +** +** This code depends on the fact that certain token values (ex: TK_EQ) +** are the same as opcode values (ex: OP_Eq) that implement the corresponding +** operation. Special comments in vdbe.c and the mkopcodeh.awk script in +** the make process cause these values to align. Assert()s in the code +** below verify that the numbers are aligned correctly. +*/ +SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ + Vdbe *v = pParse->pVdbe; + int op = 0; + int regFree1 = 0; + int regFree2 = 0; + int r1, r2; + + assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 ); + if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */ + if( NEVER(pExpr==0) ) return; /* No way this can happen */ + op = pExpr->op; + switch( op ){ + case TK_AND: { + int d2 = sqlite3VdbeMakeLabel(v); + testcase( jumpIfNull==0 ); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL); + sqlite3ExprCachePush(pParse); + sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3VdbeResolveLabel(v, d2); + sqlite3ExprCachePop(pParse); + break; + } + case TK_OR: { + testcase( jumpIfNull==0 ); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprCachePush(pParse); + sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3ExprCachePop(pParse); + break; + } + case TK_NOT: { + testcase( jumpIfNull==0 ); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + break; + } + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + testcase( jumpIfNull==0 ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, + r1, r2, dest, jumpIfNull); + assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); + assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); + assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); + assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); + assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq); + assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_IS: + case TK_ISNOT: { + testcase( op==TK_IS ); + testcase( op==TK_ISNOT ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + op = (op==TK_IS) ? TK_EQ : TK_NE; + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, + r1, r2, dest, SQLITE_NULLEQ); + VdbeCoverageIf(v, op==TK_EQ); + VdbeCoverageIf(v, op==TK_NE); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL ); + assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + sqlite3VdbeAddOp2(v, op, r1, dest); + VdbeCoverageIf(v, op==TK_ISNULL); + VdbeCoverageIf(v, op==TK_NOTNULL); + testcase( regFree1==0 ); + break; + } + case TK_BETWEEN: { + testcase( jumpIfNull==0 ); + exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull); + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_IN: { + int destIfFalse = sqlite3VdbeMakeLabel(v); + int destIfNull = jumpIfNull ? dest : destIfFalse; + sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull); + sqlite3VdbeGoto(v, dest); + sqlite3VdbeResolveLabel(v, destIfFalse); + break; + } +#endif + default: { + if( exprAlwaysTrue(pExpr) ){ + sqlite3VdbeGoto(v, dest); + }else if( exprAlwaysFalse(pExpr) ){ + /* No-op */ + }else{ + r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1); + sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0); + VdbeCoverage(v); + testcase( regFree1==0 ); + testcase( jumpIfNull==0 ); + } + break; + } + } + sqlite3ReleaseTempReg(pParse, regFree1); + sqlite3ReleaseTempReg(pParse, regFree2); +} + +/* +** Generate code for a boolean expression such that a jump is made +** to the label "dest" if the expression is false but execution +** continues straight thru if the expression is true. +** +** If the expression evaluates to NULL (neither true nor false) then +** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull +** is 0. +*/ +SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ + Vdbe *v = pParse->pVdbe; + int op = 0; + int regFree1 = 0; + int regFree2 = 0; + int r1, r2; + + assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 ); + if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */ + if( pExpr==0 ) return; + + /* The value of pExpr->op and op are related as follows: + ** + ** pExpr->op op + ** --------- ---------- + ** TK_ISNULL OP_NotNull + ** TK_NOTNULL OP_IsNull + ** TK_NE OP_Eq + ** TK_EQ OP_Ne + ** TK_GT OP_Le + ** TK_LE OP_Gt + ** TK_GE OP_Lt + ** TK_LT OP_Ge + ** + ** For other values of pExpr->op, op is undefined and unused. + ** The value of TK_ and OP_ constants are arranged such that we + ** can compute the mapping above using the following expression. + ** Assert()s verify that the computation is correct. + */ + op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1); + + /* Verify correct alignment of TK_ and OP_ constants + */ + assert( pExpr->op!=TK_ISNULL || op==OP_NotNull ); + assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull ); + assert( pExpr->op!=TK_NE || op==OP_Eq ); + assert( pExpr->op!=TK_EQ || op==OP_Ne ); + assert( pExpr->op!=TK_LT || op==OP_Ge ); + assert( pExpr->op!=TK_LE || op==OP_Gt ); + assert( pExpr->op!=TK_GT || op==OP_Le ); + assert( pExpr->op!=TK_GE || op==OP_Lt ); + + switch( pExpr->op ){ + case TK_AND: { + testcase( jumpIfNull==0 ); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprCachePush(pParse); + sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3ExprCachePop(pParse); + break; + } + case TK_OR: { + int d2 = sqlite3VdbeMakeLabel(v); + testcase( jumpIfNull==0 ); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL); + sqlite3ExprCachePush(pParse); + sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3VdbeResolveLabel(v, d2); + sqlite3ExprCachePop(pParse); + break; + } + case TK_NOT: { + testcase( jumpIfNull==0 ); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + break; + } + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + testcase( jumpIfNull==0 ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, + r1, r2, dest, jumpIfNull); + assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); + assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); + assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); + assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); + assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq); + assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_IS: + case TK_ISNOT: { + testcase( pExpr->op==TK_IS ); + testcase( pExpr->op==TK_ISNOT ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ; + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, + r1, r2, dest, SQLITE_NULLEQ); + VdbeCoverageIf(v, op==TK_EQ); + VdbeCoverageIf(v, op==TK_NE); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + sqlite3VdbeAddOp2(v, op, r1, dest); + testcase( op==TK_ISNULL ); VdbeCoverageIf(v, op==TK_ISNULL); + testcase( op==TK_NOTNULL ); VdbeCoverageIf(v, op==TK_NOTNULL); + testcase( regFree1==0 ); + break; + } + case TK_BETWEEN: { + testcase( jumpIfNull==0 ); + exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull); + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_IN: { + if( jumpIfNull ){ + sqlite3ExprCodeIN(pParse, pExpr, dest, dest); + }else{ + int destIfNull = sqlite3VdbeMakeLabel(v); + sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull); + sqlite3VdbeResolveLabel(v, destIfNull); + } + break; + } +#endif + default: { + if( exprAlwaysFalse(pExpr) ){ + sqlite3VdbeGoto(v, dest); + }else if( exprAlwaysTrue(pExpr) ){ + /* no-op */ + }else{ + r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1); + sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0); + VdbeCoverage(v); + testcase( regFree1==0 ); + testcase( jumpIfNull==0 ); + } + break; + } + } + sqlite3ReleaseTempReg(pParse, regFree1); + sqlite3ReleaseTempReg(pParse, regFree2); +} + +/* +** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before +** code generation, and that copy is deleted after code generation. This +** ensures that the original pExpr is unchanged. +*/ +SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){ + sqlite3 *db = pParse->db; + Expr *pCopy = sqlite3ExprDup(db, pExpr, 0); + if( db->mallocFailed==0 ){ + sqlite3ExprIfFalse(pParse, pCopy, dest, jumpIfNull); + } + sqlite3ExprDelete(db, pCopy); +} + + +/* +** Do a deep comparison of two expression trees. Return 0 if the two +** expressions are completely identical. Return 1 if they differ only +** by a COLLATE operator at the top level. Return 2 if there are differences +** other than the top-level COLLATE operator. +** +** If any subelement of pB has Expr.iTable==(-1) then it is allowed +** to compare equal to an equivalent element in pA with Expr.iTable==iTab. +** +** The pA side might be using TK_REGISTER. If that is the case and pB is +** not using TK_REGISTER but is otherwise equivalent, then still return 0. +** +** Sometimes this routine will return 2 even if the two expressions +** really are equivalent. If we cannot prove that the expressions are +** identical, we return 2 just to be safe. So if this routine +** returns 2, then you do not really know for certain if the two +** expressions are the same. But if you get a 0 or 1 return, then you +** can be sure the expressions are the same. In the places where +** this routine is used, it does not hurt to get an extra 2 - that +** just might result in some slightly slower code. But returning +** an incorrect 0 or 1 could lead to a malfunction. +*/ +SQLITE_PRIVATE int sqlite3ExprCompare(Expr *pA, Expr *pB, int iTab){ + u32 combinedFlags; + if( pA==0 || pB==0 ){ + return pB==pA ? 0 : 2; + } + combinedFlags = pA->flags | pB->flags; + if( combinedFlags & EP_IntValue ){ + if( (pA->flags&pB->flags&EP_IntValue)!=0 && pA->u.iValue==pB->u.iValue ){ + return 0; + } + return 2; + } + if( pA->op!=pB->op ){ + if( pA->op==TK_COLLATE && sqlite3ExprCompare(pA->pLeft, pB, iTab)<2 ){ + return 1; + } + if( pB->op==TK_COLLATE && sqlite3ExprCompare(pA, pB->pLeft, iTab)<2 ){ + return 1; + } + return 2; + } + if( pA->op!=TK_COLUMN && ALWAYS(pA->op!=TK_AGG_COLUMN) && pA->u.zToken ){ + if( pA->op==TK_FUNCTION ){ + if( sqlite3StrICmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2; + }else if( strcmp(pA->u.zToken,pB->u.zToken)!=0 ){ + return pA->op==TK_COLLATE ? 1 : 2; + } + } + if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 2; + if( ALWAYS((combinedFlags & EP_TokenOnly)==0) ){ + if( combinedFlags & EP_xIsSelect ) return 2; + if( sqlite3ExprCompare(pA->pLeft, pB->pLeft, iTab) ) return 2; + if( sqlite3ExprCompare(pA->pRight, pB->pRight, iTab) ) return 2; + if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2; + if( ALWAYS((combinedFlags & EP_Reduced)==0) && pA->op!=TK_STRING ){ + if( pA->iColumn!=pB->iColumn ) return 2; + if( pA->iTable!=pB->iTable + && (pA->iTable!=iTab || NEVER(pB->iTable>=0)) ) return 2; + } + } + return 0; +} + +/* +** Compare two ExprList objects. Return 0 if they are identical and +** non-zero if they differ in any way. +** +** If any subelement of pB has Expr.iTable==(-1) then it is allowed +** to compare equal to an equivalent element in pA with Expr.iTable==iTab. +** +** This routine might return non-zero for equivalent ExprLists. The +** only consequence will be disabled optimizations. But this routine +** must never return 0 if the two ExprList objects are different, or +** a malfunction will result. +** +** Two NULL pointers are considered to be the same. But a NULL pointer +** always differs from a non-NULL pointer. +*/ +SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB, int iTab){ + int i; + if( pA==0 && pB==0 ) return 0; + if( pA==0 || pB==0 ) return 1; + if( pA->nExpr!=pB->nExpr ) return 1; + for(i=0; inExpr; i++){ + Expr *pExprA = pA->a[i].pExpr; + Expr *pExprB = pB->a[i].pExpr; + if( pA->a[i].sortOrder!=pB->a[i].sortOrder ) return 1; + if( sqlite3ExprCompare(pExprA, pExprB, iTab) ) return 1; + } + return 0; +} + +/* +** Return true if we can prove the pE2 will always be true if pE1 is +** true. Return false if we cannot complete the proof or if pE2 might +** be false. Examples: +** +** pE1: x==5 pE2: x==5 Result: true +** pE1: x>0 pE2: x==5 Result: false +** pE1: x=21 pE2: x=21 OR y=43 Result: true +** pE1: x!=123 pE2: x IS NOT NULL Result: true +** pE1: x!=?1 pE2: x IS NOT NULL Result: true +** pE1: x IS NULL pE2: x IS NOT NULL Result: false +** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false +** +** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has +** Expr.iTable<0 then assume a table number given by iTab. +** +** When in doubt, return false. Returning true might give a performance +** improvement. Returning false might cause a performance reduction, but +** it will always give the correct answer and is hence always safe. +*/ +SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Expr *pE1, Expr *pE2, int iTab){ + if( sqlite3ExprCompare(pE1, pE2, iTab)==0 ){ + return 1; + } + if( pE2->op==TK_OR + && (sqlite3ExprImpliesExpr(pE1, pE2->pLeft, iTab) + || sqlite3ExprImpliesExpr(pE1, pE2->pRight, iTab) ) + ){ + return 1; + } + if( pE2->op==TK_NOTNULL + && sqlite3ExprCompare(pE1->pLeft, pE2->pLeft, iTab)==0 + && (pE1->op!=TK_ISNULL && pE1->op!=TK_IS) + ){ + return 1; + } + return 0; +} + +/* +** An instance of the following structure is used by the tree walker +** to count references to table columns in the arguments of an +** aggregate function, in order to implement the +** sqlite3FunctionThisSrc() routine. +*/ +struct SrcCount { + SrcList *pSrc; /* One particular FROM clause in a nested query */ + int nThis; /* Number of references to columns in pSrcList */ + int nOther; /* Number of references to columns in other FROM clauses */ +}; + +/* +** Count the number of references to columns. +*/ +static int exprSrcCount(Walker *pWalker, Expr *pExpr){ + /* The NEVER() on the second term is because sqlite3FunctionUsesThisSrc() + ** is always called before sqlite3ExprAnalyzeAggregates() and so the + ** TK_COLUMNs have not yet been converted into TK_AGG_COLUMN. If + ** sqlite3FunctionUsesThisSrc() is used differently in the future, the + ** NEVER() will need to be removed. */ + if( pExpr->op==TK_COLUMN || NEVER(pExpr->op==TK_AGG_COLUMN) ){ + int i; + struct SrcCount *p = pWalker->u.pSrcCount; + SrcList *pSrc = p->pSrc; + int nSrc = pSrc ? pSrc->nSrc : 0; + for(i=0; iiTable==pSrc->a[i].iCursor ) break; + } + if( inThis++; + }else{ + p->nOther++; + } + } + return WRC_Continue; +} + +/* +** Determine if any of the arguments to the pExpr Function reference +** pSrcList. Return true if they do. Also return true if the function +** has no arguments or has only constant arguments. Return false if pExpr +** references columns but not columns of tables found in pSrcList. +*/ +SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr *pExpr, SrcList *pSrcList){ + Walker w; + struct SrcCount cnt; + assert( pExpr->op==TK_AGG_FUNCTION ); + memset(&w, 0, sizeof(w)); + w.xExprCallback = exprSrcCount; + w.u.pSrcCount = &cnt; + cnt.pSrc = pSrcList; + cnt.nThis = 0; + cnt.nOther = 0; + sqlite3WalkExprList(&w, pExpr->x.pList); + return cnt.nThis>0 || cnt.nOther==0; +} + +/* +** Add a new element to the pAggInfo->aCol[] array. Return the index of +** the new element. Return a negative number if malloc fails. +*/ +static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){ + int i; + pInfo->aCol = sqlite3ArrayAllocate( + db, + pInfo->aCol, + sizeof(pInfo->aCol[0]), + &pInfo->nColumn, + &i + ); + return i; +} + +/* +** Add a new element to the pAggInfo->aFunc[] array. Return the index of +** the new element. Return a negative number if malloc fails. +*/ +static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){ + int i; + pInfo->aFunc = sqlite3ArrayAllocate( + db, + pInfo->aFunc, + sizeof(pInfo->aFunc[0]), + &pInfo->nFunc, + &i + ); + return i; +} + +/* +** This is the xExprCallback for a tree walker. It is used to +** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates +** for additional information. +*/ +static int analyzeAggregate(Walker *pWalker, Expr *pExpr){ + int i; + NameContext *pNC = pWalker->u.pNC; + Parse *pParse = pNC->pParse; + SrcList *pSrcList = pNC->pSrcList; + AggInfo *pAggInfo = pNC->pAggInfo; + + switch( pExpr->op ){ + case TK_AGG_COLUMN: + case TK_COLUMN: { + testcase( pExpr->op==TK_AGG_COLUMN ); + testcase( pExpr->op==TK_COLUMN ); + /* Check to see if the column is in one of the tables in the FROM + ** clause of the aggregate query */ + if( ALWAYS(pSrcList!=0) ){ + struct SrcList_item *pItem = pSrcList->a; + for(i=0; inSrc; i++, pItem++){ + struct AggInfo_col *pCol; + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + if( pExpr->iTable==pItem->iCursor ){ + /* If we reach this point, it means that pExpr refers to a table + ** that is in the FROM clause of the aggregate query. + ** + ** Make an entry for the column in pAggInfo->aCol[] if there + ** is not an entry there already. + */ + int k; + pCol = pAggInfo->aCol; + for(k=0; knColumn; k++, pCol++){ + if( pCol->iTable==pExpr->iTable && + pCol->iColumn==pExpr->iColumn ){ + break; + } + } + if( (k>=pAggInfo->nColumn) + && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0 + ){ + pCol = &pAggInfo->aCol[k]; + pCol->pTab = pExpr->pTab; + pCol->iTable = pExpr->iTable; + pCol->iColumn = pExpr->iColumn; + pCol->iMem = ++pParse->nMem; + pCol->iSorterColumn = -1; + pCol->pExpr = pExpr; + if( pAggInfo->pGroupBy ){ + int j, n; + ExprList *pGB = pAggInfo->pGroupBy; + struct ExprList_item *pTerm = pGB->a; + n = pGB->nExpr; + for(j=0; jpExpr; + if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable && + pE->iColumn==pExpr->iColumn ){ + pCol->iSorterColumn = j; + break; + } + } + } + if( pCol->iSorterColumn<0 ){ + pCol->iSorterColumn = pAggInfo->nSortingColumn++; + } + } + /* There is now an entry for pExpr in pAggInfo->aCol[] (either + ** because it was there before or because we just created it). + ** Convert the pExpr to be a TK_AGG_COLUMN referring to that + ** pAggInfo->aCol[] entry. + */ + ExprSetVVAProperty(pExpr, EP_NoReduce); + pExpr->pAggInfo = pAggInfo; + pExpr->op = TK_AGG_COLUMN; + pExpr->iAgg = (i16)k; + break; + } /* endif pExpr->iTable==pItem->iCursor */ + } /* end loop over pSrcList */ + } + return WRC_Prune; + } + case TK_AGG_FUNCTION: { + if( (pNC->ncFlags & NC_InAggFunc)==0 + && pWalker->walkerDepth==pExpr->op2 + ){ + /* Check to see if pExpr is a duplicate of another aggregate + ** function that is already in the pAggInfo structure + */ + struct AggInfo_func *pItem = pAggInfo->aFunc; + for(i=0; inFunc; i++, pItem++){ + if( sqlite3ExprCompare(pItem->pExpr, pExpr, -1)==0 ){ + break; + } + } + if( i>=pAggInfo->nFunc ){ + /* pExpr is original. Make a new entry in pAggInfo->aFunc[] + */ + u8 enc = ENC(pParse->db); + i = addAggInfoFunc(pParse->db, pAggInfo); + if( i>=0 ){ + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + pItem = &pAggInfo->aFunc[i]; + pItem->pExpr = pExpr; + pItem->iMem = ++pParse->nMem; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + pItem->pFunc = sqlite3FindFunction(pParse->db, + pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken), + pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0); + if( pExpr->flags & EP_Distinct ){ + pItem->iDistinct = pParse->nTab++; + }else{ + pItem->iDistinct = -1; + } + } + } + /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry + */ + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + ExprSetVVAProperty(pExpr, EP_NoReduce); + pExpr->iAgg = (i16)i; + pExpr->pAggInfo = pAggInfo; + return WRC_Prune; + }else{ + return WRC_Continue; + } + } + } + return WRC_Continue; +} +static int analyzeAggregatesInSelect(Walker *pWalker, Select *pSelect){ + UNUSED_PARAMETER(pWalker); + UNUSED_PARAMETER(pSelect); + return WRC_Continue; +} + +/* +** Analyze the pExpr expression looking for aggregate functions and +** for variables that need to be added to AggInfo object that pNC->pAggInfo +** points to. Additional entries are made on the AggInfo object as +** necessary. +** +** This routine should only be called after the expression has been +** analyzed by sqlite3ResolveExprNames(). +*/ +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){ + Walker w; + memset(&w, 0, sizeof(w)); + w.xExprCallback = analyzeAggregate; + w.xSelectCallback = analyzeAggregatesInSelect; + w.u.pNC = pNC; + assert( pNC->pSrcList!=0 ); + sqlite3WalkExpr(&w, pExpr); +} + +/* +** Call sqlite3ExprAnalyzeAggregates() for every expression in an +** expression list. Return the number of errors. +** +** If an error is found, the analysis is cut short. +*/ +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){ + struct ExprList_item *pItem; + int i; + if( pList ){ + for(pItem=pList->a, i=0; inExpr; i++, pItem++){ + sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr); + } + } +} + +/* +** Allocate a single new register for use to hold some intermediate result. +*/ +SQLITE_PRIVATE int sqlite3GetTempReg(Parse *pParse){ + if( pParse->nTempReg==0 ){ + return ++pParse->nMem; + } + return pParse->aTempReg[--pParse->nTempReg]; +} + +/* +** Deallocate a register, making available for reuse for some other +** purpose. +** +** If a register is currently being used by the column cache, then +** the deallocation is deferred until the column cache line that uses +** the register becomes stale. +*/ +SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse *pParse, int iReg){ + if( iReg && pParse->nTempRegaTempReg) ){ + int i; + struct yColCache *p; + for(i=0, p=pParse->aColCache; iiReg==iReg ){ + p->tempReg = 1; + return; + } + } + pParse->aTempReg[pParse->nTempReg++] = iReg; + } +} + +/* +** Allocate or deallocate a block of nReg consecutive registers +*/ +SQLITE_PRIVATE int sqlite3GetTempRange(Parse *pParse, int nReg){ + int i, n; + i = pParse->iRangeReg; + n = pParse->nRangeReg; + if( nReg<=n ){ + assert( !usedAsColumnCache(pParse, i, i+n-1) ); + pParse->iRangeReg += nReg; + pParse->nRangeReg -= nReg; + }else{ + i = pParse->nMem+1; + pParse->nMem += nReg; + } + return i; +} +SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){ + sqlite3ExprCacheRemove(pParse, iReg, nReg); + if( nReg>pParse->nRangeReg ){ + pParse->nRangeReg = nReg; + pParse->iRangeReg = iReg; + } +} + +/* +** Mark all temporary registers as being unavailable for reuse. +*/ +SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse *pParse){ + pParse->nTempReg = 0; + pParse->nRangeReg = 0; +} + +/************** End of expr.c ************************************************/ +/************** Begin file alter.c *******************************************/ +/* +** 2005 February 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that used to generate VDBE code +** that implements the ALTER TABLE command. +*/ +/* #include "sqliteInt.h" */ + +/* +** The code in this file only exists if we are not omitting the +** ALTER TABLE logic from the build. +*/ +#ifndef SQLITE_OMIT_ALTERTABLE + + +/* +** This function is used by SQL generated to implement the +** ALTER TABLE command. The first argument is the text of a CREATE TABLE or +** CREATE INDEX command. The second is a table name. The table name in +** the CREATE TABLE or CREATE INDEX statement is replaced with the third +** argument and the result returned. Examples: +** +** sqlite_rename_table('CREATE TABLE abc(a, b, c)', 'def') +** -> 'CREATE TABLE def(a, b, c)' +** +** sqlite_rename_table('CREATE INDEX i ON abc(a)', 'def') +** -> 'CREATE INDEX i ON def(a, b, c)' +*/ +static void renameTableFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + unsigned char const *zSql = sqlite3_value_text(argv[0]); + unsigned char const *zTableName = sqlite3_value_text(argv[1]); + + int token; + Token tname; + unsigned char const *zCsr = zSql; + int len = 0; + char *zRet; + + sqlite3 *db = sqlite3_context_db_handle(context); + + UNUSED_PARAMETER(NotUsed); + + /* The principle used to locate the table name in the CREATE TABLE + ** statement is that the table name is the first non-space token that + ** is immediately followed by a TK_LP or TK_USING token. + */ + if( zSql ){ + do { + if( !*zCsr ){ + /* Ran out of input before finding an opening bracket. Return NULL. */ + return; + } + + /* Store the token that zCsr points to in tname. */ + tname.z = (char*)zCsr; + tname.n = len; + + /* Advance zCsr to the next token. Store that token type in 'token', + ** and its length in 'len' (to be used next iteration of this loop). + */ + do { + zCsr += len; + len = sqlite3GetToken(zCsr, &token); + } while( token==TK_SPACE ); + assert( len>0 ); + } while( token!=TK_LP && token!=TK_USING ); + + zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", (int)(((u8*)tname.z) - zSql), + zSql, zTableName, tname.z+tname.n); + sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC); + } +} + +/* +** This C function implements an SQL user function that is used by SQL code +** generated by the ALTER TABLE ... RENAME command to modify the definition +** of any foreign key constraints that use the table being renamed as the +** parent table. It is passed three arguments: +** +** 1) The complete text of the CREATE TABLE statement being modified, +** 2) The old name of the table being renamed, and +** 3) The new name of the table being renamed. +** +** It returns the new CREATE TABLE statement. For example: +** +** sqlite_rename_parent('CREATE TABLE t1(a REFERENCES t2)', 't2', 't3') +** -> 'CREATE TABLE t1(a REFERENCES t3)' +*/ +#ifndef SQLITE_OMIT_FOREIGN_KEY +static void renameParentFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + char *zOutput = 0; + char *zResult; + unsigned char const *zInput = sqlite3_value_text(argv[0]); + unsigned char const *zOld = sqlite3_value_text(argv[1]); + unsigned char const *zNew = sqlite3_value_text(argv[2]); + + unsigned const char *z; /* Pointer to token */ + int n; /* Length of token z */ + int token; /* Type of token */ + + UNUSED_PARAMETER(NotUsed); + if( zInput==0 || zOld==0 ) return; + for(z=zInput; *z; z=z+n){ + n = sqlite3GetToken(z, &token); + if( token==TK_REFERENCES ){ + char *zParent; + do { + z += n; + n = sqlite3GetToken(z, &token); + }while( token==TK_SPACE ); + + if( token==TK_ILLEGAL ) break; + zParent = sqlite3DbStrNDup(db, (const char *)z, n); + if( zParent==0 ) break; + sqlite3Dequote(zParent); + if( 0==sqlite3StrICmp((const char *)zOld, zParent) ){ + char *zOut = sqlite3MPrintf(db, "%s%.*s\"%w\"", + (zOutput?zOutput:""), (int)(z-zInput), zInput, (const char *)zNew + ); + sqlite3DbFree(db, zOutput); + zOutput = zOut; + zInput = &z[n]; + } + sqlite3DbFree(db, zParent); + } + } + + zResult = sqlite3MPrintf(db, "%s%s", (zOutput?zOutput:""), zInput), + sqlite3_result_text(context, zResult, -1, SQLITE_DYNAMIC); + sqlite3DbFree(db, zOutput); +} +#endif + +#ifndef SQLITE_OMIT_TRIGGER +/* This function is used by SQL generated to implement the +** ALTER TABLE command. The first argument is the text of a CREATE TRIGGER +** statement. The second is a table name. The table name in the CREATE +** TRIGGER statement is replaced with the third argument and the result +** returned. This is analagous to renameTableFunc() above, except for CREATE +** TRIGGER, not CREATE INDEX and CREATE TABLE. +*/ +static void renameTriggerFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + unsigned char const *zSql = sqlite3_value_text(argv[0]); + unsigned char const *zTableName = sqlite3_value_text(argv[1]); + + int token; + Token tname; + int dist = 3; + unsigned char const *zCsr = zSql; + int len = 0; + char *zRet; + sqlite3 *db = sqlite3_context_db_handle(context); + + UNUSED_PARAMETER(NotUsed); + + /* The principle used to locate the table name in the CREATE TRIGGER + ** statement is that the table name is the first token that is immediately + ** preceded by either TK_ON or TK_DOT and immediately followed by one + ** of TK_WHEN, TK_BEGIN or TK_FOR. + */ + if( zSql ){ + do { + + if( !*zCsr ){ + /* Ran out of input before finding the table name. Return NULL. */ + return; + } + + /* Store the token that zCsr points to in tname. */ + tname.z = (char*)zCsr; + tname.n = len; + + /* Advance zCsr to the next token. Store that token type in 'token', + ** and its length in 'len' (to be used next iteration of this loop). + */ + do { + zCsr += len; + len = sqlite3GetToken(zCsr, &token); + }while( token==TK_SPACE ); + assert( len>0 ); + + /* Variable 'dist' stores the number of tokens read since the most + ** recent TK_DOT or TK_ON. This means that when a WHEN, FOR or BEGIN + ** token is read and 'dist' equals 2, the condition stated above + ** to be met. + ** + ** Note that ON cannot be a database, table or column name, so + ** there is no need to worry about syntax like + ** "CREATE TRIGGER ... ON ON.ON BEGIN ..." etc. + */ + dist++; + if( token==TK_DOT || token==TK_ON ){ + dist = 0; + } + } while( dist!=2 || (token!=TK_WHEN && token!=TK_FOR && token!=TK_BEGIN) ); + + /* Variable tname now contains the token that is the old table-name + ** in the CREATE TRIGGER statement. + */ + zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", (int)(((u8*)tname.z) - zSql), + zSql, zTableName, tname.z+tname.n); + sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC); + } +} +#endif /* !SQLITE_OMIT_TRIGGER */ + +/* +** Register built-in functions used to help implement ALTER TABLE +*/ +SQLITE_PRIVATE void sqlite3AlterFunctions(void){ + static SQLITE_WSD FuncDef aAlterTableFuncs[] = { + FUNCTION(sqlite_rename_table, 2, 0, 0, renameTableFunc), +#ifndef SQLITE_OMIT_TRIGGER + FUNCTION(sqlite_rename_trigger, 2, 0, 0, renameTriggerFunc), +#endif +#ifndef SQLITE_OMIT_FOREIGN_KEY + FUNCTION(sqlite_rename_parent, 3, 0, 0, renameParentFunc), +#endif + }; + int i; + FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions); + FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aAlterTableFuncs); + + for(i=0; i OR name= OR ... +** +** If argument zWhere is NULL, then a pointer string containing the text +** "name=" is returned, where is the quoted version +** of the string passed as argument zConstant. The returned buffer is +** allocated using sqlite3DbMalloc(). It is the responsibility of the +** caller to ensure that it is eventually freed. +** +** If argument zWhere is not NULL, then the string returned is +** " OR name=", where is the contents of zWhere. +** In this case zWhere is passed to sqlite3DbFree() before returning. +** +*/ +static char *whereOrName(sqlite3 *db, char *zWhere, char *zConstant){ + char *zNew; + if( !zWhere ){ + zNew = sqlite3MPrintf(db, "name=%Q", zConstant); + }else{ + zNew = sqlite3MPrintf(db, "%s OR name=%Q", zWhere, zConstant); + sqlite3DbFree(db, zWhere); + } + return zNew; +} + +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) +/* +** Generate the text of a WHERE expression which can be used to select all +** tables that have foreign key constraints that refer to table pTab (i.e. +** constraints for which pTab is the parent table) from the sqlite_master +** table. +*/ +static char *whereForeignKeys(Parse *pParse, Table *pTab){ + FKey *p; + char *zWhere = 0; + for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ + zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName); + } + return zWhere; +} +#endif + +/* +** Generate the text of a WHERE expression which can be used to select all +** temporary triggers on table pTab from the sqlite_temp_master table. If +** table pTab has no temporary triggers, or is itself stored in the +** temporary database, NULL is returned. +*/ +static char *whereTempTriggers(Parse *pParse, Table *pTab){ + Trigger *pTrig; + char *zWhere = 0; + const Schema *pTempSchema = pParse->db->aDb[1].pSchema; /* Temp db schema */ + + /* If the table is not located in the temp-db (in which case NULL is + ** returned, loop through the tables list of triggers. For each trigger + ** that is not part of the temp-db schema, add a clause to the WHERE + ** expression being built up in zWhere. + */ + if( pTab->pSchema!=pTempSchema ){ + sqlite3 *db = pParse->db; + for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){ + if( pTrig->pSchema==pTempSchema ){ + zWhere = whereOrName(db, zWhere, pTrig->zName); + } + } + } + if( zWhere ){ + char *zNew = sqlite3MPrintf(pParse->db, "type='trigger' AND (%s)", zWhere); + sqlite3DbFree(pParse->db, zWhere); + zWhere = zNew; + } + return zWhere; +} + +/* +** Generate code to drop and reload the internal representation of table +** pTab from the database, including triggers and temporary triggers. +** Argument zName is the name of the table in the database schema at +** the time the generated code is executed. This can be different from +** pTab->zName if this function is being called to code part of an +** "ALTER TABLE RENAME TO" statement. +*/ +static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){ + Vdbe *v; + char *zWhere; + int iDb; /* Index of database containing pTab */ +#ifndef SQLITE_OMIT_TRIGGER + Trigger *pTrig; +#endif + + v = sqlite3GetVdbe(pParse); + if( NEVER(v==0) ) return; + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + assert( iDb>=0 ); + +#ifndef SQLITE_OMIT_TRIGGER + /* Drop any table triggers from the internal schema. */ + for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){ + int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema); + assert( iTrigDb==iDb || iTrigDb==1 ); + sqlite3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->zName, 0); + } +#endif + + /* Drop the table and index from the internal schema. */ + sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0); + + /* Reload the table, index and permanent trigger schemas. */ + zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName); + if( !zWhere ) return; + sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere); + +#ifndef SQLITE_OMIT_TRIGGER + /* Now, if the table is not stored in the temp database, reload any temp + ** triggers. Don't use IN(...) in case SQLITE_OMIT_SUBQUERY is defined. + */ + if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){ + sqlite3VdbeAddParseSchemaOp(v, 1, zWhere); + } +#endif +} + +/* +** Parameter zName is the name of a table that is about to be altered +** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN). +** If the table is a system table, this function leaves an error message +** in pParse->zErr (system tables may not be altered) and returns non-zero. +** +** Or, if zName is not a system table, zero is returned. +*/ +static int isSystemTable(Parse *pParse, const char *zName){ + if( sqlite3Strlen30(zName)>6 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){ + sqlite3ErrorMsg(pParse, "table %s may not be altered", zName); + return 1; + } + return 0; +} + +/* +** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy" +** command. +*/ +SQLITE_PRIVATE void sqlite3AlterRenameTable( + Parse *pParse, /* Parser context. */ + SrcList *pSrc, /* The table to rename. */ + Token *pName /* The new table name. */ +){ + int iDb; /* Database that contains the table */ + char *zDb; /* Name of database iDb */ + Table *pTab; /* Table being renamed */ + char *zName = 0; /* NULL-terminated version of pName */ + sqlite3 *db = pParse->db; /* Database connection */ + int nTabName; /* Number of UTF-8 characters in zTabName */ + const char *zTabName; /* Original name of the table */ + Vdbe *v; +#ifndef SQLITE_OMIT_TRIGGER + char *zWhere = 0; /* Where clause to locate temp triggers */ +#endif + VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */ + int savedDbFlags; /* Saved value of db->flags */ + + savedDbFlags = db->flags; + if( NEVER(db->mallocFailed) ) goto exit_rename_table; + assert( pSrc->nSrc==1 ); + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + + pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); + if( !pTab ) goto exit_rename_table; + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + zDb = db->aDb[iDb].zName; + db->flags |= SQLITE_PreferBuiltin; + + /* Get a NULL terminated version of the new table name. */ + zName = sqlite3NameFromToken(db, pName); + if( !zName ) goto exit_rename_table; + + /* Check that a table or index named 'zName' does not already exist + ** in database iDb. If so, this is an error. + */ + if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){ + sqlite3ErrorMsg(pParse, + "there is already another table or index with this name: %s", zName); + goto exit_rename_table; + } + + /* Make sure it is not a system table being altered, or a reserved name + ** that the table is being renamed to. + */ + if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){ + goto exit_rename_table; + } + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto + exit_rename_table; + } + +#ifndef SQLITE_OMIT_VIEW + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName); + goto exit_rename_table; + } +#endif + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + goto exit_rename_table; + } +#endif + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto exit_rename_table; + } + if( IsVirtual(pTab) ){ + pVTab = sqlite3GetVTable(db, pTab); + if( pVTab->pVtab->pModule->xRename==0 ){ + pVTab = 0; + } + } +#endif + + /* Begin a transaction for database iDb. + ** Then modify the schema cookie (since the ALTER TABLE modifies the + ** schema). Open a statement transaction if the table is a virtual + ** table. + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + goto exit_rename_table; + } + sqlite3BeginWriteOperation(pParse, pVTab!=0, iDb); + sqlite3ChangeCookie(pParse, iDb); + + /* If this is a virtual table, invoke the xRename() function if + ** one is defined. The xRename() callback will modify the names + ** of any resources used by the v-table implementation (including other + ** SQLite tables) that are identified by the name of the virtual table. + */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pVTab ){ + int i = ++pParse->nMem; + sqlite3VdbeLoadString(v, i, zName); + sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB); + sqlite3MayAbort(pParse); + } +#endif + + /* figure out how many UTF-8 characters are in zName */ + zTabName = pTab->zName; + nTabName = sqlite3Utf8CharLen(zTabName, -1); + +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + if( db->flags&SQLITE_ForeignKeys ){ + /* If foreign-key support is enabled, rewrite the CREATE TABLE + ** statements corresponding to all child tables of foreign key constraints + ** for which the renamed table is the parent table. */ + if( (zWhere=whereForeignKeys(pParse, pTab))!=0 ){ + sqlite3NestedParse(pParse, + "UPDATE \"%w\".%s SET " + "sql = sqlite_rename_parent(sql, %Q, %Q) " + "WHERE %s;", zDb, SCHEMA_TABLE(iDb), zTabName, zName, zWhere); + sqlite3DbFree(db, zWhere); + } + } +#endif + + /* Modify the sqlite_master table to use the new table name. */ + sqlite3NestedParse(pParse, + "UPDATE %Q.%s SET " +#ifdef SQLITE_OMIT_TRIGGER + "sql = sqlite_rename_table(sql, %Q), " +#else + "sql = CASE " + "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)" + "ELSE sqlite_rename_table(sql, %Q) END, " +#endif + "tbl_name = %Q, " + "name = CASE " + "WHEN type='table' THEN %Q " + "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN " + "'sqlite_autoindex_' || %Q || substr(name,%d+18) " + "ELSE name END " + "WHERE tbl_name=%Q COLLATE nocase AND " + "(type='table' OR type='index' OR type='trigger');", + zDb, SCHEMA_TABLE(iDb), zName, zName, zName, +#ifndef SQLITE_OMIT_TRIGGER + zName, +#endif + zName, nTabName, zTabName + ); + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* If the sqlite_sequence table exists in this database, then update + ** it with the new table name. + */ + if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){ + sqlite3NestedParse(pParse, + "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q", + zDb, zName, pTab->zName); + } +#endif + +#ifndef SQLITE_OMIT_TRIGGER + /* If there are TEMP triggers on this table, modify the sqlite_temp_master + ** table. Don't do this if the table being ALTERed is itself located in + ** the temp database. + */ + if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){ + sqlite3NestedParse(pParse, + "UPDATE sqlite_temp_master SET " + "sql = sqlite_rename_trigger(sql, %Q), " + "tbl_name = %Q " + "WHERE %s;", zName, zName, zWhere); + sqlite3DbFree(db, zWhere); + } +#endif + +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + if( db->flags&SQLITE_ForeignKeys ){ + FKey *p; + for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ + Table *pFrom = p->pFrom; + if( pFrom!=pTab ){ + reloadTableSchema(pParse, p->pFrom, pFrom->zName); + } + } + } +#endif + + /* Drop and reload the internal table schema. */ + reloadTableSchema(pParse, pTab, zName); + +exit_rename_table: + sqlite3SrcListDelete(db, pSrc); + sqlite3DbFree(db, zName); + db->flags = savedDbFlags; +} + + +/* +** Generate code to make sure the file format number is at least minFormat. +** The generated code will increase the file format number if necessary. +*/ +SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){ + Vdbe *v; + v = sqlite3GetVdbe(pParse); + /* The VDBE should have been allocated before this routine is called. + ** If that allocation failed, we would have quit before reaching this + ** point */ + if( ALWAYS(v) ){ + int r1 = sqlite3GetTempReg(pParse); + int r2 = sqlite3GetTempReg(pParse); + int addr1; + sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT); + sqlite3VdbeUsesBtree(v, iDb); + sqlite3VdbeAddOp2(v, OP_Integer, minFormat, r2); + addr1 = sqlite3VdbeAddOp3(v, OP_Ge, r2, 0, r1); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, r2); + sqlite3VdbeJumpHere(v, addr1); + sqlite3ReleaseTempReg(pParse, r1); + sqlite3ReleaseTempReg(pParse, r2); + } +} + +/* +** This function is called after an "ALTER TABLE ... ADD" statement +** has been parsed. Argument pColDef contains the text of the new +** column definition. +** +** The Table structure pParse->pNewTable was extended to include +** the new column during parsing. +*/ +SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){ + Table *pNew; /* Copy of pParse->pNewTable */ + Table *pTab; /* Table being altered */ + int iDb; /* Database number */ + const char *zDb; /* Database name */ + const char *zTab; /* Table name */ + char *zCol; /* Null-terminated column definition */ + Column *pCol; /* The new column */ + Expr *pDflt; /* Default value for the new column */ + sqlite3 *db; /* The database connection; */ + + db = pParse->db; + if( pParse->nErr || db->mallocFailed ) return; + pNew = pParse->pNewTable; + assert( pNew ); + + assert( sqlite3BtreeHoldsAllMutexes(db) ); + iDb = sqlite3SchemaToIndex(db, pNew->pSchema); + zDb = db->aDb[iDb].zName; + zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */ + pCol = &pNew->aCol[pNew->nCol-1]; + pDflt = pCol->pDflt; + pTab = sqlite3FindTable(db, zTab, zDb); + assert( pTab ); + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + return; + } +#endif + + /* If the default value for the new column was specified with a + ** literal NULL, then set pDflt to 0. This simplifies checking + ** for an SQL NULL default below. + */ + if( pDflt && pDflt->op==TK_NULL ){ + pDflt = 0; + } + + /* Check that the new column is not specified as PRIMARY KEY or UNIQUE. + ** If there is a NOT NULL constraint, then the default value for the + ** column must not be NULL. + */ + if( pCol->colFlags & COLFLAG_PRIMKEY ){ + sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column"); + return; + } + if( pNew->pIndex ){ + sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column"); + return; + } + if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){ + sqlite3ErrorMsg(pParse, + "Cannot add a REFERENCES column with non-NULL default value"); + return; + } + if( pCol->notNull && !pDflt ){ + sqlite3ErrorMsg(pParse, + "Cannot add a NOT NULL column with default value NULL"); + return; + } + + /* Ensure the default expression is something that sqlite3ValueFromExpr() + ** can handle (i.e. not CURRENT_TIME etc.) + */ + if( pDflt ){ + sqlite3_value *pVal = 0; + int rc; + rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_BLOB, &pVal); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + if( rc!=SQLITE_OK ){ + db->mallocFailed = 1; + return; + } + if( !pVal ){ + sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default"); + return; + } + sqlite3ValueFree(pVal); + } + + /* Modify the CREATE TABLE statement. */ + zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n); + if( zCol ){ + char *zEnd = &zCol[pColDef->n-1]; + int savedDbFlags = db->flags; + while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){ + *zEnd-- = '\0'; + } + db->flags |= SQLITE_PreferBuiltin; + sqlite3NestedParse(pParse, + "UPDATE \"%w\".%s SET " + "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) " + "WHERE type = 'table' AND name = %Q", + zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1, + zTab + ); + sqlite3DbFree(db, zCol); + db->flags = savedDbFlags; + } + + /* If the default value of the new column is NULL, then set the file + ** format to 2. If the default value of the new column is not NULL, + ** the file format becomes 3. + */ + sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2); + + /* Reload the schema of the modified table. */ + reloadTableSchema(pParse, pTab, pTab->zName); +} + +/* +** This function is called by the parser after the table-name in +** an "ALTER TABLE ADD" statement is parsed. Argument +** pSrc is the full-name of the table being altered. +** +** This routine makes a (partial) copy of the Table structure +** for the table being altered and sets Parse.pNewTable to point +** to it. Routines called by the parser as the column definition +** is parsed (i.e. sqlite3AddColumn()) add the new Column data to +** the copy. The copy of the Table structure is deleted by tokenize.c +** after parsing is finished. +** +** Routine sqlite3AlterFinishAddColumn() will be called to complete +** coding the "ALTER TABLE ... ADD" statement. +*/ +SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){ + Table *pNew; + Table *pTab; + Vdbe *v; + int iDb; + int i; + int nAlloc; + sqlite3 *db = pParse->db; + + /* Look up the table being altered. */ + assert( pParse->pNewTable==0 ); + assert( sqlite3BtreeHoldsAllMutexes(db) ); + if( db->mallocFailed ) goto exit_begin_add_column; + pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); + if( !pTab ) goto exit_begin_add_column; + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "virtual tables may not be altered"); + goto exit_begin_add_column; + } +#endif + + /* Make sure this is not an attempt to ALTER a view. */ + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "Cannot add a column to a view"); + goto exit_begin_add_column; + } + if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){ + goto exit_begin_add_column; + } + + assert( pTab->addColOffset>0 ); + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + + /* Put a copy of the Table struct in Parse.pNewTable for the + ** sqlite3AddColumn() function and friends to modify. But modify + ** the name by adding an "sqlite_altertab_" prefix. By adding this + ** prefix, we insure that the name will not collide with an existing + ** table because user table are not allowed to have the "sqlite_" + ** prefix on their name. + */ + pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table)); + if( !pNew ) goto exit_begin_add_column; + pParse->pNewTable = pNew; + pNew->nRef = 1; + pNew->nCol = pTab->nCol; + assert( pNew->nCol>0 ); + nAlloc = (((pNew->nCol-1)/8)*8)+8; + assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 ); + pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc); + pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName); + if( !pNew->aCol || !pNew->zName ){ + db->mallocFailed = 1; + goto exit_begin_add_column; + } + memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol); + for(i=0; inCol; i++){ + Column *pCol = &pNew->aCol[i]; + pCol->zName = sqlite3DbStrDup(db, pCol->zName); + pCol->zColl = 0; + pCol->zType = 0; + pCol->pDflt = 0; + pCol->zDflt = 0; + } + pNew->pSchema = db->aDb[iDb].pSchema; + pNew->addColOffset = pTab->addColOffset; + pNew->nRef = 1; + + /* Begin a transaction and increment the schema cookie. */ + sqlite3BeginWriteOperation(pParse, 0, iDb); + v = sqlite3GetVdbe(pParse); + if( !v ) goto exit_begin_add_column; + sqlite3ChangeCookie(pParse, iDb); + +exit_begin_add_column: + sqlite3SrcListDelete(db, pSrc); + return; +} +#endif /* SQLITE_ALTER_TABLE */ + +/************** End of alter.c ***********************************************/ +/************** Begin file analyze.c *****************************************/ +/* +** 2005-07-08 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code associated with the ANALYZE command. +** +** The ANALYZE command gather statistics about the content of tables +** and indices. These statistics are made available to the query planner +** to help it make better decisions about how to perform queries. +** +** The following system tables are or have been supported: +** +** CREATE TABLE sqlite_stat1(tbl, idx, stat); +** CREATE TABLE sqlite_stat2(tbl, idx, sampleno, sample); +** CREATE TABLE sqlite_stat3(tbl, idx, nEq, nLt, nDLt, sample); +** CREATE TABLE sqlite_stat4(tbl, idx, nEq, nLt, nDLt, sample); +** +** Additional tables might be added in future releases of SQLite. +** The sqlite_stat2 table is not created or used unless the SQLite version +** is between 3.6.18 and 3.7.8, inclusive, and unless SQLite is compiled +** with SQLITE_ENABLE_STAT2. The sqlite_stat2 table is deprecated. +** The sqlite_stat2 table is superseded by sqlite_stat3, which is only +** created and used by SQLite versions 3.7.9 and later and with +** SQLITE_ENABLE_STAT3 defined. The functionality of sqlite_stat3 +** is a superset of sqlite_stat2. The sqlite_stat4 is an enhanced +** version of sqlite_stat3 and is only available when compiled with +** SQLITE_ENABLE_STAT4 and in SQLite versions 3.8.1 and later. It is +** not possible to enable both STAT3 and STAT4 at the same time. If they +** are both enabled, then STAT4 takes precedence. +** +** For most applications, sqlite_stat1 provides all the statistics required +** for the query planner to make good choices. +** +** Format of sqlite_stat1: +** +** There is normally one row per index, with the index identified by the +** name in the idx column. The tbl column is the name of the table to +** which the index belongs. In each such row, the stat column will be +** a string consisting of a list of integers. The first integer in this +** list is the number of rows in the index. (This is the same as the +** number of rows in the table, except for partial indices.) The second +** integer is the average number of rows in the index that have the same +** value in the first column of the index. The third integer is the average +** number of rows in the index that have the same value for the first two +** columns. The N-th integer (for N>1) is the average number of rows in +** the index which have the same value for the first N-1 columns. For +** a K-column index, there will be K+1 integers in the stat column. If +** the index is unique, then the last integer will be 1. +** +** The list of integers in the stat column can optionally be followed +** by the keyword "unordered". The "unordered" keyword, if it is present, +** must be separated from the last integer by a single space. If the +** "unordered" keyword is present, then the query planner assumes that +** the index is unordered and will not use the index for a range query. +** +** If the sqlite_stat1.idx column is NULL, then the sqlite_stat1.stat +** column contains a single integer which is the (estimated) number of +** rows in the table identified by sqlite_stat1.tbl. +** +** Format of sqlite_stat2: +** +** The sqlite_stat2 is only created and is only used if SQLite is compiled +** with SQLITE_ENABLE_STAT2 and if the SQLite version number is between +** 3.6.18 and 3.7.8. The "stat2" table contains additional information +** about the distribution of keys within an index. The index is identified by +** the "idx" column and the "tbl" column is the name of the table to which +** the index belongs. There are usually 10 rows in the sqlite_stat2 +** table for each index. +** +** The sqlite_stat2 entries for an index that have sampleno between 0 and 9 +** inclusive are samples of the left-most key value in the index taken at +** evenly spaced points along the index. Let the number of samples be S +** (10 in the standard build) and let C be the number of rows in the index. +** Then the sampled rows are given by: +** +** rownumber = (i*C*2 + C)/(S*2) +** +** For i between 0 and S-1. Conceptually, the index space is divided into +** S uniform buckets and the samples are the middle row from each bucket. +** +** The format for sqlite_stat2 is recorded here for legacy reference. This +** version of SQLite does not support sqlite_stat2. It neither reads nor +** writes the sqlite_stat2 table. This version of SQLite only supports +** sqlite_stat3. +** +** Format for sqlite_stat3: +** +** The sqlite_stat3 format is a subset of sqlite_stat4. Hence, the +** sqlite_stat4 format will be described first. Further information +** about sqlite_stat3 follows the sqlite_stat4 description. +** +** Format for sqlite_stat4: +** +** As with sqlite_stat2, the sqlite_stat4 table contains histogram data +** to aid the query planner in choosing good indices based on the values +** that indexed columns are compared against in the WHERE clauses of +** queries. +** +** The sqlite_stat4 table contains multiple entries for each index. +** The idx column names the index and the tbl column is the table of the +** index. If the idx and tbl columns are the same, then the sample is +** of the INTEGER PRIMARY KEY. The sample column is a blob which is the +** binary encoding of a key from the index. The nEq column is a +** list of integers. The first integer is the approximate number +** of entries in the index whose left-most column exactly matches +** the left-most column of the sample. The second integer in nEq +** is the approximate number of entries in the index where the +** first two columns match the first two columns of the sample. +** And so forth. nLt is another list of integers that show the approximate +** number of entries that are strictly less than the sample. The first +** integer in nLt contains the number of entries in the index where the +** left-most column is less than the left-most column of the sample. +** The K-th integer in the nLt entry is the number of index entries +** where the first K columns are less than the first K columns of the +** sample. The nDLt column is like nLt except that it contains the +** number of distinct entries in the index that are less than the +** sample. +** +** There can be an arbitrary number of sqlite_stat4 entries per index. +** The ANALYZE command will typically generate sqlite_stat4 tables +** that contain between 10 and 40 samples which are distributed across +** the key space, though not uniformly, and which include samples with +** large nEq values. +** +** Format for sqlite_stat3 redux: +** +** The sqlite_stat3 table is like sqlite_stat4 except that it only +** looks at the left-most column of the index. The sqlite_stat3.sample +** column contains the actual value of the left-most column instead +** of a blob encoding of the complete index key as is found in +** sqlite_stat4.sample. The nEq, nLt, and nDLt entries of sqlite_stat3 +** all contain just a single integer which is the same as the first +** integer in the equivalent columns in sqlite_stat4. +*/ +#ifndef SQLITE_OMIT_ANALYZE +/* #include "sqliteInt.h" */ + +#if defined(SQLITE_ENABLE_STAT4) +# define IsStat4 1 +# define IsStat3 0 +#elif defined(SQLITE_ENABLE_STAT3) +# define IsStat4 0 +# define IsStat3 1 +#else +# define IsStat4 0 +# define IsStat3 0 +# undef SQLITE_STAT4_SAMPLES +# define SQLITE_STAT4_SAMPLES 1 +#endif +#define IsStat34 (IsStat3+IsStat4) /* 1 for STAT3 or STAT4. 0 otherwise */ + +/* +** This routine generates code that opens the sqlite_statN tables. +** The sqlite_stat1 table is always relevant. sqlite_stat2 is now +** obsolete. sqlite_stat3 and sqlite_stat4 are only opened when +** appropriate compile-time options are provided. +** +** If the sqlite_statN tables do not previously exist, it is created. +** +** Argument zWhere may be a pointer to a buffer containing a table name, +** or it may be a NULL pointer. If it is not NULL, then all entries in +** the sqlite_statN tables associated with the named table are deleted. +** If zWhere==0, then code is generated to delete all stat table entries. +*/ +static void openStatTable( + Parse *pParse, /* Parsing context */ + int iDb, /* The database we are looking in */ + int iStatCur, /* Open the sqlite_stat1 table on this cursor */ + const char *zWhere, /* Delete entries for this table or index */ + const char *zWhereType /* Either "tbl" or "idx" */ +){ + static const struct { + const char *zName; + const char *zCols; + } aTable[] = { + { "sqlite_stat1", "tbl,idx,stat" }, +#if defined(SQLITE_ENABLE_STAT4) + { "sqlite_stat4", "tbl,idx,neq,nlt,ndlt,sample" }, + { "sqlite_stat3", 0 }, +#elif defined(SQLITE_ENABLE_STAT3) + { "sqlite_stat3", "tbl,idx,neq,nlt,ndlt,sample" }, + { "sqlite_stat4", 0 }, +#else + { "sqlite_stat3", 0 }, + { "sqlite_stat4", 0 }, +#endif + }; + int i; + sqlite3 *db = pParse->db; + Db *pDb; + Vdbe *v = sqlite3GetVdbe(pParse); + int aRoot[ArraySize(aTable)]; + u8 aCreateTbl[ArraySize(aTable)]; + + if( v==0 ) return; + assert( sqlite3BtreeHoldsAllMutexes(db) ); + assert( sqlite3VdbeDb(v)==db ); + pDb = &db->aDb[iDb]; + + /* Create new statistic tables if they do not exist, or clear them + ** if they do already exist. + */ + for(i=0; izName))==0 ){ + if( aTable[i].zCols ){ + /* The sqlite_statN table does not exist. Create it. Note that a + ** side-effect of the CREATE TABLE statement is to leave the rootpage + ** of the new table in register pParse->regRoot. This is important + ** because the OpenWrite opcode below will be needing it. */ + sqlite3NestedParse(pParse, + "CREATE TABLE %Q.%s(%s)", pDb->zName, zTab, aTable[i].zCols + ); + aRoot[i] = pParse->regRoot; + aCreateTbl[i] = OPFLAG_P2ISREG; + } + }else{ + /* The table already exists. If zWhere is not NULL, delete all entries + ** associated with the table zWhere. If zWhere is NULL, delete the + ** entire contents of the table. */ + aRoot[i] = pStat->tnum; + aCreateTbl[i] = 0; + sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab); + if( zWhere ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE %s=%Q", + pDb->zName, zTab, zWhereType, zWhere + ); + }else{ + /* The sqlite_stat[134] table already exists. Delete all rows. */ + sqlite3VdbeAddOp2(v, OP_Clear, aRoot[i], iDb); + } + } + } + + /* Open the sqlite_stat[134] tables for writing. */ + for(i=0; aTable[i].zCols; i++){ + assert( inRowid ){ + sqlite3DbFree(db, p->u.aRowid); + p->nRowid = 0; + } +} +#endif + +/* Initialize the BLOB value of a ROWID +*/ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +static void sampleSetRowid(sqlite3 *db, Stat4Sample *p, int n, const u8 *pData){ + assert( db!=0 ); + if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid); + p->u.aRowid = sqlite3DbMallocRaw(db, n); + if( p->u.aRowid ){ + p->nRowid = n; + memcpy(p->u.aRowid, pData, n); + }else{ + p->nRowid = 0; + } +} +#endif + +/* Initialize the INTEGER value of a ROWID. +*/ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +static void sampleSetRowidInt64(sqlite3 *db, Stat4Sample *p, i64 iRowid){ + assert( db!=0 ); + if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid); + p->nRowid = 0; + p->u.iRowid = iRowid; +} +#endif + + +/* +** Copy the contents of object (*pFrom) into (*pTo). +*/ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +static void sampleCopy(Stat4Accum *p, Stat4Sample *pTo, Stat4Sample *pFrom){ + pTo->isPSample = pFrom->isPSample; + pTo->iCol = pFrom->iCol; + pTo->iHash = pFrom->iHash; + memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol); + memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol); + memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol); + if( pFrom->nRowid ){ + sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid); + }else{ + sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid); + } +} +#endif + +/* +** Reclaim all memory of a Stat4Accum structure. +*/ +static void stat4Destructor(void *pOld){ + Stat4Accum *p = (Stat4Accum*)pOld; +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + int i; + for(i=0; inCol; i++) sampleClear(p->db, p->aBest+i); + for(i=0; imxSample; i++) sampleClear(p->db, p->a+i); + sampleClear(p->db, &p->current); +#endif + sqlite3DbFree(p->db, p); +} + +/* +** Implementation of the stat_init(N,K,C) SQL function. The three parameters +** are: +** N: The number of columns in the index including the rowid/pk (note 1) +** K: The number of columns in the index excluding the rowid/pk. +** C: The number of rows in the index (note 2) +** +** Note 1: In the special case of the covering index that implements a +** WITHOUT ROWID table, N is the number of PRIMARY KEY columns, not the +** total number of columns in the table. +** +** Note 2: C is only used for STAT3 and STAT4. +** +** For indexes on ordinary rowid tables, N==K+1. But for indexes on +** WITHOUT ROWID tables, N=K+P where P is the number of columns in the +** PRIMARY KEY of the table. The covering index that implements the +** original WITHOUT ROWID table as N==K as a special case. +** +** This routine allocates the Stat4Accum object in heap memory. The return +** value is a pointer to the Stat4Accum object. The datatype of the +** return value is BLOB, but it is really just a pointer to the Stat4Accum +** object. +*/ +static void statInit( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Stat4Accum *p; + int nCol; /* Number of columns in index being sampled */ + int nKeyCol; /* Number of key columns */ + int nColUp; /* nCol rounded up for alignment */ + int n; /* Bytes of space to allocate */ + sqlite3 *db; /* Database connection */ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + int mxSample = SQLITE_STAT4_SAMPLES; +#endif + + /* Decode the three function arguments */ + UNUSED_PARAMETER(argc); + nCol = sqlite3_value_int(argv[0]); + assert( nCol>0 ); + nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol; + nKeyCol = sqlite3_value_int(argv[1]); + assert( nKeyCol<=nCol ); + assert( nKeyCol>0 ); + + /* Allocate the space required for the Stat4Accum object */ + n = sizeof(*p) + + sizeof(tRowcnt)*nColUp /* Stat4Accum.anEq */ + + sizeof(tRowcnt)*nColUp /* Stat4Accum.anDLt */ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + + sizeof(tRowcnt)*nColUp /* Stat4Accum.anLt */ + + sizeof(Stat4Sample)*(nCol+mxSample) /* Stat4Accum.aBest[], a[] */ + + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample) +#endif + ; + db = sqlite3_context_db_handle(context); + p = sqlite3DbMallocZero(db, n); + if( p==0 ){ + sqlite3_result_error_nomem(context); + return; + } + + p->db = db; + p->nRow = 0; + p->nCol = nCol; + p->nKeyCol = nKeyCol; + p->current.anDLt = (tRowcnt*)&p[1]; + p->current.anEq = &p->current.anDLt[nColUp]; + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + { + u8 *pSpace; /* Allocated space not yet assigned */ + int i; /* Used to iterate through p->aSample[] */ + + p->iGet = -1; + p->mxSample = mxSample; + p->nPSample = (tRowcnt)(sqlite3_value_int64(argv[2])/(mxSample/3+1) + 1); + p->current.anLt = &p->current.anEq[nColUp]; + p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]); + + /* Set up the Stat4Accum.a[] and aBest[] arrays */ + p->a = (struct Stat4Sample*)&p->current.anLt[nColUp]; + p->aBest = &p->a[mxSample]; + pSpace = (u8*)(&p->a[mxSample+nCol]); + for(i=0; i<(mxSample+nCol); i++){ + p->a[i].anEq = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp); + p->a[i].anLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp); + p->a[i].anDLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp); + } + assert( (pSpace - (u8*)p)==n ); + + for(i=0; iaBest[i].iCol = i; + } + } +#endif + + /* Return a pointer to the allocated object to the caller. Note that + ** only the pointer (the 2nd parameter) matters. The size of the object + ** (given by the 3rd parameter) is never used and can be any positive + ** value. */ + sqlite3_result_blob(context, p, sizeof(*p), stat4Destructor); +} +static const FuncDef statInitFuncdef = { + 2+IsStat34, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + statInit, /* xFunc */ + 0, /* xStep */ + 0, /* xFinalize */ + "stat_init", /* zName */ + 0, /* pHash */ + 0 /* pDestructor */ +}; + +#ifdef SQLITE_ENABLE_STAT4 +/* +** pNew and pOld are both candidate non-periodic samples selected for +** the same column (pNew->iCol==pOld->iCol). Ignoring this column and +** considering only any trailing columns and the sample hash value, this +** function returns true if sample pNew is to be preferred over pOld. +** In other words, if we assume that the cardinalities of the selected +** column for pNew and pOld are equal, is pNew to be preferred over pOld. +** +** This function assumes that for each argument sample, the contents of +** the anEq[] array from pSample->anEq[pSample->iCol+1] onwards are valid. +*/ +static int sampleIsBetterPost( + Stat4Accum *pAccum, + Stat4Sample *pNew, + Stat4Sample *pOld +){ + int nCol = pAccum->nCol; + int i; + assert( pNew->iCol==pOld->iCol ); + for(i=pNew->iCol+1; ianEq[i]>pOld->anEq[i] ) return 1; + if( pNew->anEq[i]anEq[i] ) return 0; + } + if( pNew->iHash>pOld->iHash ) return 1; + return 0; +} +#endif + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +/* +** Return true if pNew is to be preferred over pOld. +** +** This function assumes that for each argument sample, the contents of +** the anEq[] array from pSample->anEq[pSample->iCol] onwards are valid. +*/ +static int sampleIsBetter( + Stat4Accum *pAccum, + Stat4Sample *pNew, + Stat4Sample *pOld +){ + tRowcnt nEqNew = pNew->anEq[pNew->iCol]; + tRowcnt nEqOld = pOld->anEq[pOld->iCol]; + + assert( pOld->isPSample==0 && pNew->isPSample==0 ); + assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) ); + + if( (nEqNew>nEqOld) ) return 1; +#ifdef SQLITE_ENABLE_STAT4 + if( nEqNew==nEqOld ){ + if( pNew->iColiCol ) return 1; + return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld)); + } + return 0; +#else + return (nEqNew==nEqOld && pNew->iHash>pOld->iHash); +#endif +} + +/* +** Copy the contents of sample *pNew into the p->a[] array. If necessary, +** remove the least desirable sample from p->a[] to make room. +*/ +static void sampleInsert(Stat4Accum *p, Stat4Sample *pNew, int nEqZero){ + Stat4Sample *pSample = 0; + int i; + + assert( IsStat4 || nEqZero==0 ); + +#ifdef SQLITE_ENABLE_STAT4 + if( pNew->isPSample==0 ){ + Stat4Sample *pUpgrade = 0; + assert( pNew->anEq[pNew->iCol]>0 ); + + /* This sample is being added because the prefix that ends in column + ** iCol occurs many times in the table. However, if we have already + ** added a sample that shares this prefix, there is no need to add + ** this one. Instead, upgrade the priority of the highest priority + ** existing sample that shares this prefix. */ + for(i=p->nSample-1; i>=0; i--){ + Stat4Sample *pOld = &p->a[i]; + if( pOld->anEq[pNew->iCol]==0 ){ + if( pOld->isPSample ) return; + assert( pOld->iCol>pNew->iCol ); + assert( sampleIsBetter(p, pNew, pOld) ); + if( pUpgrade==0 || sampleIsBetter(p, pOld, pUpgrade) ){ + pUpgrade = pOld; + } + } + } + if( pUpgrade ){ + pUpgrade->iCol = pNew->iCol; + pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol]; + goto find_new_min; + } + } +#endif + + /* If necessary, remove sample iMin to make room for the new sample. */ + if( p->nSample>=p->mxSample ){ + Stat4Sample *pMin = &p->a[p->iMin]; + tRowcnt *anEq = pMin->anEq; + tRowcnt *anLt = pMin->anLt; + tRowcnt *anDLt = pMin->anDLt; + sampleClear(p->db, pMin); + memmove(pMin, &pMin[1], sizeof(p->a[0])*(p->nSample-p->iMin-1)); + pSample = &p->a[p->nSample-1]; + pSample->nRowid = 0; + pSample->anEq = anEq; + pSample->anDLt = anDLt; + pSample->anLt = anLt; + p->nSample = p->mxSample-1; + } + + /* The "rows less-than" for the rowid column must be greater than that + ** for the last sample in the p->a[] array. Otherwise, the samples would + ** be out of order. */ +#ifdef SQLITE_ENABLE_STAT4 + assert( p->nSample==0 + || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] ); +#endif + + /* Insert the new sample */ + pSample = &p->a[p->nSample]; + sampleCopy(p, pSample, pNew); + p->nSample++; + + /* Zero the first nEqZero entries in the anEq[] array. */ + memset(pSample->anEq, 0, sizeof(tRowcnt)*nEqZero); + +#ifdef SQLITE_ENABLE_STAT4 + find_new_min: +#endif + if( p->nSample>=p->mxSample ){ + int iMin = -1; + for(i=0; imxSample; i++){ + if( p->a[i].isPSample ) continue; + if( iMin<0 || sampleIsBetter(p, &p->a[iMin], &p->a[i]) ){ + iMin = i; + } + } + assert( iMin>=0 ); + p->iMin = iMin; + } +} +#endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */ + +/* +** Field iChng of the index being scanned has changed. So at this point +** p->current contains a sample that reflects the previous row of the +** index. The value of anEq[iChng] and subsequent anEq[] elements are +** correct at this point. +*/ +static void samplePushPrevious(Stat4Accum *p, int iChng){ +#ifdef SQLITE_ENABLE_STAT4 + int i; + + /* Check if any samples from the aBest[] array should be pushed + ** into IndexSample.a[] at this point. */ + for(i=(p->nCol-2); i>=iChng; i--){ + Stat4Sample *pBest = &p->aBest[i]; + pBest->anEq[i] = p->current.anEq[i]; + if( p->nSamplemxSample || sampleIsBetter(p, pBest, &p->a[p->iMin]) ){ + sampleInsert(p, pBest, i); + } + } + + /* Update the anEq[] fields of any samples already collected. */ + for(i=p->nSample-1; i>=0; i--){ + int j; + for(j=iChng; jnCol; j++){ + if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j]; + } + } +#endif + +#if defined(SQLITE_ENABLE_STAT3) && !defined(SQLITE_ENABLE_STAT4) + if( iChng==0 ){ + tRowcnt nLt = p->current.anLt[0]; + tRowcnt nEq = p->current.anEq[0]; + + /* Check if this is to be a periodic sample. If so, add it. */ + if( (nLt/p->nPSample)!=(nLt+nEq)/p->nPSample ){ + p->current.isPSample = 1; + sampleInsert(p, &p->current, 0); + p->current.isPSample = 0; + }else + + /* Or if it is a non-periodic sample. Add it in this case too. */ + if( p->nSamplemxSample + || sampleIsBetter(p, &p->current, &p->a[p->iMin]) + ){ + sampleInsert(p, &p->current, 0); + } + } +#endif + +#ifndef SQLITE_ENABLE_STAT3_OR_STAT4 + UNUSED_PARAMETER( p ); + UNUSED_PARAMETER( iChng ); +#endif +} + +/* +** Implementation of the stat_push SQL function: stat_push(P,C,R) +** Arguments: +** +** P Pointer to the Stat4Accum object created by stat_init() +** C Index of left-most column to differ from previous row +** R Rowid for the current row. Might be a key record for +** WITHOUT ROWID tables. +** +** This SQL function always returns NULL. It's purpose it to accumulate +** statistical data and/or samples in the Stat4Accum object about the +** index being analyzed. The stat_get() SQL function will later be used to +** extract relevant information for constructing the sqlite_statN tables. +** +** The R parameter is only used for STAT3 and STAT4 +*/ +static void statPush( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + + /* The three function arguments */ + Stat4Accum *p = (Stat4Accum*)sqlite3_value_blob(argv[0]); + int iChng = sqlite3_value_int(argv[1]); + + UNUSED_PARAMETER( argc ); + UNUSED_PARAMETER( context ); + assert( p->nCol>0 ); + assert( iChngnCol ); + + if( p->nRow==0 ){ + /* This is the first call to this function. Do initialization. */ + for(i=0; inCol; i++) p->current.anEq[i] = 1; + }else{ + /* Second and subsequent calls get processed here */ + samplePushPrevious(p, iChng); + + /* Update anDLt[], anLt[] and anEq[] to reflect the values that apply + ** to the current row of the index. */ + for(i=0; icurrent.anEq[i]++; + } + for(i=iChng; inCol; i++){ + p->current.anDLt[i]++; +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + p->current.anLt[i] += p->current.anEq[i]; +#endif + p->current.anEq[i] = 1; + } + } + p->nRow++; +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + if( sqlite3_value_type(argv[2])==SQLITE_INTEGER ){ + sampleSetRowidInt64(p->db, &p->current, sqlite3_value_int64(argv[2])); + }else{ + sampleSetRowid(p->db, &p->current, sqlite3_value_bytes(argv[2]), + sqlite3_value_blob(argv[2])); + } + p->current.iHash = p->iPrn = p->iPrn*1103515245 + 12345; +#endif + +#ifdef SQLITE_ENABLE_STAT4 + { + tRowcnt nLt = p->current.anLt[p->nCol-1]; + + /* Check if this is to be a periodic sample. If so, add it. */ + if( (nLt/p->nPSample)!=(nLt+1)/p->nPSample ){ + p->current.isPSample = 1; + p->current.iCol = 0; + sampleInsert(p, &p->current, p->nCol-1); + p->current.isPSample = 0; + } + + /* Update the aBest[] array. */ + for(i=0; i<(p->nCol-1); i++){ + p->current.iCol = i; + if( i>=iChng || sampleIsBetterPost(p, &p->current, &p->aBest[i]) ){ + sampleCopy(p, &p->aBest[i], &p->current); + } + } + } +#endif +} +static const FuncDef statPushFuncdef = { + 2+IsStat34, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + statPush, /* xFunc */ + 0, /* xStep */ + 0, /* xFinalize */ + "stat_push", /* zName */ + 0, /* pHash */ + 0 /* pDestructor */ +}; + +#define STAT_GET_STAT1 0 /* "stat" column of stat1 table */ +#define STAT_GET_ROWID 1 /* "rowid" column of stat[34] entry */ +#define STAT_GET_NEQ 2 /* "neq" column of stat[34] entry */ +#define STAT_GET_NLT 3 /* "nlt" column of stat[34] entry */ +#define STAT_GET_NDLT 4 /* "ndlt" column of stat[34] entry */ + +/* +** Implementation of the stat_get(P,J) SQL function. This routine is +** used to query statistical information that has been gathered into +** the Stat4Accum object by prior calls to stat_push(). The P parameter +** has type BLOB but it is really just a pointer to the Stat4Accum object. +** The content to returned is determined by the parameter J +** which is one of the STAT_GET_xxxx values defined above. +** +** If neither STAT3 nor STAT4 are enabled, then J is always +** STAT_GET_STAT1 and is hence omitted and this routine becomes +** a one-parameter function, stat_get(P), that always returns the +** stat1 table entry information. +*/ +static void statGet( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Stat4Accum *p = (Stat4Accum*)sqlite3_value_blob(argv[0]); +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + /* STAT3 and STAT4 have a parameter on this routine. */ + int eCall = sqlite3_value_int(argv[1]); + assert( argc==2 ); + assert( eCall==STAT_GET_STAT1 || eCall==STAT_GET_NEQ + || eCall==STAT_GET_ROWID || eCall==STAT_GET_NLT + || eCall==STAT_GET_NDLT + ); + if( eCall==STAT_GET_STAT1 ) +#else + assert( argc==1 ); +#endif + { + /* Return the value to store in the "stat" column of the sqlite_stat1 + ** table for this index. + ** + ** The value is a string composed of a list of integers describing + ** the index. The first integer in the list is the total number of + ** entries in the index. There is one additional integer in the list + ** for each indexed column. This additional integer is an estimate of + ** the number of rows matched by a stabbing query on the index using + ** a key with the corresponding number of fields. In other words, + ** if the index is on columns (a,b) and the sqlite_stat1 value is + ** "100 10 2", then SQLite estimates that: + ** + ** * the index contains 100 rows, + ** * "WHERE a=?" matches 10 rows, and + ** * "WHERE a=? AND b=?" matches 2 rows. + ** + ** If D is the count of distinct values and K is the total number of + ** rows, then each estimate is computed as: + ** + ** I = (K+D-1)/D + */ + char *z; + int i; + + char *zRet = sqlite3MallocZero( (p->nKeyCol+1)*25 ); + if( zRet==0 ){ + sqlite3_result_error_nomem(context); + return; + } + + sqlite3_snprintf(24, zRet, "%llu", (u64)p->nRow); + z = zRet + sqlite3Strlen30(zRet); + for(i=0; inKeyCol; i++){ + u64 nDistinct = p->current.anDLt[i] + 1; + u64 iVal = (p->nRow + nDistinct - 1) / nDistinct; + sqlite3_snprintf(24, z, " %llu", iVal); + z += sqlite3Strlen30(z); + assert( p->current.anEq[i] ); + } + assert( z[0]=='\0' && z>zRet ); + + sqlite3_result_text(context, zRet, -1, sqlite3_free); + } +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + else if( eCall==STAT_GET_ROWID ){ + if( p->iGet<0 ){ + samplePushPrevious(p, 0); + p->iGet = 0; + } + if( p->iGetnSample ){ + Stat4Sample *pS = p->a + p->iGet; + if( pS->nRowid==0 ){ + sqlite3_result_int64(context, pS->u.iRowid); + }else{ + sqlite3_result_blob(context, pS->u.aRowid, pS->nRowid, + SQLITE_TRANSIENT); + } + } + }else{ + tRowcnt *aCnt = 0; + + assert( p->iGetnSample ); + switch( eCall ){ + case STAT_GET_NEQ: aCnt = p->a[p->iGet].anEq; break; + case STAT_GET_NLT: aCnt = p->a[p->iGet].anLt; break; + default: { + aCnt = p->a[p->iGet].anDLt; + p->iGet++; + break; + } + } + + if( IsStat3 ){ + sqlite3_result_int64(context, (i64)aCnt[0]); + }else{ + char *zRet = sqlite3MallocZero(p->nCol * 25); + if( zRet==0 ){ + sqlite3_result_error_nomem(context); + }else{ + int i; + char *z = zRet; + for(i=0; inCol; i++){ + sqlite3_snprintf(24, z, "%llu ", (u64)aCnt[i]); + z += sqlite3Strlen30(z); + } + assert( z[0]=='\0' && z>zRet ); + z[-1] = '\0'; + sqlite3_result_text(context, zRet, -1, sqlite3_free); + } + } + } +#endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */ +#ifndef SQLITE_DEBUG + UNUSED_PARAMETER( argc ); +#endif +} +static const FuncDef statGetFuncdef = { + 1+IsStat34, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + statGet, /* xFunc */ + 0, /* xStep */ + 0, /* xFinalize */ + "stat_get", /* zName */ + 0, /* pHash */ + 0 /* pDestructor */ +}; + +static void callStatGet(Vdbe *v, int regStat4, int iParam, int regOut){ + assert( regOut!=regStat4 && regOut!=regStat4+1 ); +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + sqlite3VdbeAddOp2(v, OP_Integer, iParam, regStat4+1); +#elif SQLITE_DEBUG + assert( iParam==STAT_GET_STAT1 ); +#else + UNUSED_PARAMETER( iParam ); +#endif + sqlite3VdbeAddOp3(v, OP_Function0, 0, regStat4, regOut); + sqlite3VdbeChangeP4(v, -1, (char*)&statGetFuncdef, P4_FUNCDEF); + sqlite3VdbeChangeP5(v, 1 + IsStat34); +} + +/* +** Generate code to do an analysis of all indices associated with +** a single table. +*/ +static void analyzeOneTable( + Parse *pParse, /* Parser context */ + Table *pTab, /* Table whose indices are to be analyzed */ + Index *pOnlyIdx, /* If not NULL, only analyze this one index */ + int iStatCur, /* Index of VdbeCursor that writes the sqlite_stat1 table */ + int iMem, /* Available memory locations begin here */ + int iTab /* Next available cursor */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + Index *pIdx; /* An index to being analyzed */ + int iIdxCur; /* Cursor open on index being analyzed */ + int iTabCur; /* Table cursor */ + Vdbe *v; /* The virtual machine being built up */ + int i; /* Loop counter */ + int jZeroRows = -1; /* Jump from here if number of rows is zero */ + int iDb; /* Index of database containing pTab */ + u8 needTableCnt = 1; /* True to count the table */ + int regNewRowid = iMem++; /* Rowid for the inserted record */ + int regStat4 = iMem++; /* Register to hold Stat4Accum object */ + int regChng = iMem++; /* Index of changed index field */ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + int regRowid = iMem++; /* Rowid argument passed to stat_push() */ +#endif + int regTemp = iMem++; /* Temporary use register */ + int regTabname = iMem++; /* Register containing table name */ + int regIdxname = iMem++; /* Register containing index name */ + int regStat1 = iMem++; /* Value for the stat column of sqlite_stat1 */ + int regPrev = iMem; /* MUST BE LAST (see below) */ + + pParse->nMem = MAX(pParse->nMem, iMem); + v = sqlite3GetVdbe(pParse); + if( v==0 || NEVER(pTab==0) ){ + return; + } + if( pTab->tnum==0 ){ + /* Do not gather statistics on views or virtual tables */ + return; + } + if( sqlite3_strnicmp(pTab->zName, "sqlite_", 7)==0 ){ + /* Do not gather statistics on system tables */ + return; + } + assert( sqlite3BtreeHoldsAllMutexes(db) ); + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 ); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0, + db->aDb[iDb].zName ) ){ + return; + } +#endif + + /* Establish a read-lock on the table at the shared-cache level. + ** Open a read-only cursor on the table. Also allocate a cursor number + ** to use for scanning indexes (iIdxCur). No index cursor is opened at + ** this time though. */ + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + iTabCur = iTab++; + iIdxCur = iTab++; + pParse->nTab = MAX(pParse->nTab, iTab); + sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead); + sqlite3VdbeLoadString(v, regTabname, pTab->zName); + + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int nCol; /* Number of columns in pIdx. "N" */ + int addrRewind; /* Address of "OP_Rewind iIdxCur" */ + int addrNextRow; /* Address of "next_row:" */ + const char *zIdxName; /* Name of the index */ + int nColTest; /* Number of columns to test for changes */ + + if( pOnlyIdx && pOnlyIdx!=pIdx ) continue; + if( pIdx->pPartIdxWhere==0 ) needTableCnt = 0; + if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIdx) ){ + nCol = pIdx->nKeyCol; + zIdxName = pTab->zName; + nColTest = nCol - 1; + }else{ + nCol = pIdx->nColumn; + zIdxName = pIdx->zName; + nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1; + } + + /* Populate the register containing the index name. */ + sqlite3VdbeLoadString(v, regIdxname, zIdxName); + VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName)); + + /* + ** Pseudo-code for loop that calls stat_push(): + ** + ** Rewind csr + ** if eof(csr) goto end_of_scan; + ** regChng = 0 + ** goto chng_addr_0; + ** + ** next_row: + ** regChng = 0 + ** if( idx(0) != regPrev(0) ) goto chng_addr_0 + ** regChng = 1 + ** if( idx(1) != regPrev(1) ) goto chng_addr_1 + ** ... + ** regChng = N + ** goto chng_addr_N + ** + ** chng_addr_0: + ** regPrev(0) = idx(0) + ** chng_addr_1: + ** regPrev(1) = idx(1) + ** ... + ** + ** endDistinctTest: + ** regRowid = idx(rowid) + ** stat_push(P, regChng, regRowid) + ** Next csr + ** if !eof(csr) goto next_row; + ** + ** end_of_scan: + */ + + /* Make sure there are enough memory cells allocated to accommodate + ** the regPrev array and a trailing rowid (the rowid slot is required + ** when building a record to insert into the sample column of + ** the sqlite_stat4 table. */ + pParse->nMem = MAX(pParse->nMem, regPrev+nColTest); + + /* Open a read-only cursor on the index being analyzed. */ + assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) ); + sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + VdbeComment((v, "%s", pIdx->zName)); + + /* Invoke the stat_init() function. The arguments are: + ** + ** (1) the number of columns in the index including the rowid + ** (or for a WITHOUT ROWID table, the number of PK columns), + ** (2) the number of columns in the key without the rowid/pk + ** (3) the number of rows in the index, + ** + ** + ** The third argument is only used for STAT3 and STAT4 + */ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regStat4+3); +#endif + sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat4+1); + sqlite3VdbeAddOp2(v, OP_Integer, pIdx->nKeyCol, regStat4+2); + sqlite3VdbeAddOp3(v, OP_Function0, 0, regStat4+1, regStat4); + sqlite3VdbeChangeP4(v, -1, (char*)&statInitFuncdef, P4_FUNCDEF); + sqlite3VdbeChangeP5(v, 2+IsStat34); + + /* Implementation of the following: + ** + ** Rewind csr + ** if eof(csr) goto end_of_scan; + ** regChng = 0 + ** goto next_push_0; + ** + */ + addrRewind = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur); + VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Integer, 0, regChng); + addrNextRow = sqlite3VdbeCurrentAddr(v); + + if( nColTest>0 ){ + int endDistinctTest = sqlite3VdbeMakeLabel(v); + int *aGotoChng; /* Array of jump instruction addresses */ + aGotoChng = sqlite3DbMallocRaw(db, sizeof(int)*nColTest); + if( aGotoChng==0 ) continue; + + /* + ** next_row: + ** regChng = 0 + ** if( idx(0) != regPrev(0) ) goto chng_addr_0 + ** regChng = 1 + ** if( idx(1) != regPrev(1) ) goto chng_addr_1 + ** ... + ** regChng = N + ** goto endDistinctTest + */ + sqlite3VdbeAddOp0(v, OP_Goto); + addrNextRow = sqlite3VdbeCurrentAddr(v); + if( nColTest==1 && pIdx->nKeyCol==1 && IsUniqueIndex(pIdx) ){ + /* For a single-column UNIQUE index, once we have found a non-NULL + ** row, we know that all the rest will be distinct, so skip + ** subsequent distinctness tests. */ + sqlite3VdbeAddOp2(v, OP_NotNull, regPrev, endDistinctTest); + VdbeCoverage(v); + } + for(i=0; iazColl[i]); + sqlite3VdbeAddOp2(v, OP_Integer, i, regChng); + sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regTemp); + aGotoChng[i] = + sqlite3VdbeAddOp4(v, OP_Ne, regTemp, 0, regPrev+i, pColl, P4_COLLSEQ); + sqlite3VdbeChangeP5(v, SQLITE_NULLEQ); + VdbeCoverage(v); + } + sqlite3VdbeAddOp2(v, OP_Integer, nColTest, regChng); + sqlite3VdbeGoto(v, endDistinctTest); + + + /* + ** chng_addr_0: + ** regPrev(0) = idx(0) + ** chng_addr_1: + ** regPrev(1) = idx(1) + ** ... + */ + sqlite3VdbeJumpHere(v, addrNextRow-1); + for(i=0; ipTable); + int j, k, regKey; + regKey = sqlite3GetTempRange(pParse, pPk->nKeyCol); + for(j=0; jnKeyCol; j++){ + k = sqlite3ColumnOfIndex(pIdx, pPk->aiColumn[j]); + assert( k>=0 && knCol ); + sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, regKey+j); + VdbeComment((v, "%s", pTab->aCol[pPk->aiColumn[j]].zName)); + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regKey, pPk->nKeyCol, regRowid); + sqlite3ReleaseTempRange(pParse, regKey, pPk->nKeyCol); + } +#endif + assert( regChng==(regStat4+1) ); + sqlite3VdbeAddOp3(v, OP_Function0, 1, regStat4, regTemp); + sqlite3VdbeChangeP4(v, -1, (char*)&statPushFuncdef, P4_FUNCDEF); + sqlite3VdbeChangeP5(v, 2+IsStat34); + sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v); + + /* Add the entry to the stat1 table. */ + callStatGet(v, regStat4, STAT_GET_STAT1, regStat1); + assert( "BBB"[0]==SQLITE_AFF_TEXT ); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0); + sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid); + sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + + /* Add the entries to the stat3 or stat4 table. */ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + { + int regEq = regStat1; + int regLt = regStat1+1; + int regDLt = regStat1+2; + int regSample = regStat1+3; + int regCol = regStat1+4; + int regSampleRowid = regCol + nCol; + int addrNext; + int addrIsNull; + u8 seekOp = HasRowid(pTab) ? OP_NotExists : OP_NotFound; + + pParse->nMem = MAX(pParse->nMem, regCol+nCol); + + addrNext = sqlite3VdbeCurrentAddr(v); + callStatGet(v, regStat4, STAT_GET_ROWID, regSampleRowid); + addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regSampleRowid); + VdbeCoverage(v); + callStatGet(v, regStat4, STAT_GET_NEQ, regEq); + callStatGet(v, regStat4, STAT_GET_NLT, regLt); + callStatGet(v, regStat4, STAT_GET_NDLT, regDLt); + sqlite3VdbeAddOp4Int(v, seekOp, iTabCur, addrNext, regSampleRowid, 0); + /* We know that the regSampleRowid row exists because it was read by + ** the previous loop. Thus the not-found jump of seekOp will never + ** be taken */ + VdbeCoverageNeverTaken(v); +#ifdef SQLITE_ENABLE_STAT3 + sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iTabCur, 0, regSample); +#else + for(i=0; izName)); + sqlite3VdbeAddOp2(v, OP_Count, iTabCur, regStat1); + jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname); + assert( "BBB"[0]==SQLITE_AFF_TEXT ); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0); + sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid); + sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3VdbeJumpHere(v, jZeroRows); + } +} + + +/* +** Generate code that will cause the most recent index analysis to +** be loaded into internal hash tables where is can be used. +*/ +static void loadAnalysis(Parse *pParse, int iDb){ + Vdbe *v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb); + } +} + +/* +** Generate code that will do an analysis of an entire database +*/ +static void analyzeDatabase(Parse *pParse, int iDb){ + sqlite3 *db = pParse->db; + Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */ + HashElem *k; + int iStatCur; + int iMem; + int iTab; + + sqlite3BeginWriteOperation(pParse, 0, iDb); + iStatCur = pParse->nTab; + pParse->nTab += 3; + openStatTable(pParse, iDb, iStatCur, 0, 0); + iMem = pParse->nMem+1; + iTab = pParse->nTab; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){ + Table *pTab = (Table*)sqliteHashData(k); + analyzeOneTable(pParse, pTab, 0, iStatCur, iMem, iTab); + } + loadAnalysis(pParse, iDb); +} + +/* +** Generate code that will do an analysis of a single table in +** a database. If pOnlyIdx is not NULL then it is a single index +** in pTab that should be analyzed. +*/ +static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){ + int iDb; + int iStatCur; + + assert( pTab!=0 ); + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3BeginWriteOperation(pParse, 0, iDb); + iStatCur = pParse->nTab; + pParse->nTab += 3; + if( pOnlyIdx ){ + openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx"); + }else{ + openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl"); + } + analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur,pParse->nMem+1,pParse->nTab); + loadAnalysis(pParse, iDb); +} + +/* +** Generate code for the ANALYZE command. The parser calls this routine +** when it recognizes an ANALYZE command. +** +** ANALYZE -- 1 +** ANALYZE -- 2 +** ANALYZE ?.? -- 3 +** +** Form 1 causes all indices in all attached databases to be analyzed. +** Form 2 analyzes all indices the single database named. +** Form 3 analyzes all indices associated with the named table. +*/ +SQLITE_PRIVATE void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){ + sqlite3 *db = pParse->db; + int iDb; + int i; + char *z, *zDb; + Table *pTab; + Index *pIdx; + Token *pTableName; + Vdbe *v; + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return; + } + + assert( pName2!=0 || pName1==0 ); + if( pName1==0 ){ + /* Form 1: Analyze everything */ + for(i=0; inDb; i++){ + if( i==1 ) continue; /* Do not analyze the TEMP database */ + analyzeDatabase(pParse, i); + } + }else if( pName2->n==0 ){ + /* Form 2: Analyze the database or table named */ + iDb = sqlite3FindDb(db, pName1); + if( iDb>=0 ){ + analyzeDatabase(pParse, iDb); + }else{ + z = sqlite3NameFromToken(db, pName1); + if( z ){ + if( (pIdx = sqlite3FindIndex(db, z, 0))!=0 ){ + analyzeTable(pParse, pIdx->pTable, pIdx); + }else if( (pTab = sqlite3LocateTable(pParse, 0, z, 0))!=0 ){ + analyzeTable(pParse, pTab, 0); + } + sqlite3DbFree(db, z); + } + } + }else{ + /* Form 3: Analyze the fully qualified table name */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName); + if( iDb>=0 ){ + zDb = db->aDb[iDb].zName; + z = sqlite3NameFromToken(db, pTableName); + if( z ){ + if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){ + analyzeTable(pParse, pIdx->pTable, pIdx); + }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){ + analyzeTable(pParse, pTab, 0); + } + sqlite3DbFree(db, z); + } + } + } + v = sqlite3GetVdbe(pParse); + if( v ) sqlite3VdbeAddOp0(v, OP_Expire); +} + +/* +** Used to pass information from the analyzer reader through to the +** callback routine. +*/ +typedef struct analysisInfo analysisInfo; +struct analysisInfo { + sqlite3 *db; + const char *zDatabase; +}; + +/* +** The first argument points to a nul-terminated string containing a +** list of space separated integers. Read the first nOut of these into +** the array aOut[]. +*/ +static void decodeIntArray( + char *zIntArray, /* String containing int array to decode */ + int nOut, /* Number of slots in aOut[] */ + tRowcnt *aOut, /* Store integers here */ + LogEst *aLog, /* Or, if aOut==0, here */ + Index *pIndex /* Handle extra flags for this index, if not NULL */ +){ + char *z = zIntArray; + int c; + int i; + tRowcnt v; + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + if( z==0 ) z = ""; +#else + assert( z!=0 ); +#endif + for(i=0; *z && i='0' && c<='9' ){ + v = v*10 + c - '0'; + z++; + } +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + if( aOut ) aOut[i] = v; + if( aLog ) aLog[i] = sqlite3LogEst(v); +#else + assert( aOut==0 ); + UNUSED_PARAMETER(aOut); + assert( aLog!=0 ); + aLog[i] = sqlite3LogEst(v); +#endif + if( *z==' ' ) z++; + } +#ifndef SQLITE_ENABLE_STAT3_OR_STAT4 + assert( pIndex!=0 ); { +#else + if( pIndex ){ +#endif + pIndex->bUnordered = 0; + pIndex->noSkipScan = 0; + while( z[0] ){ + if( sqlite3_strglob("unordered*", z)==0 ){ + pIndex->bUnordered = 1; + }else if( sqlite3_strglob("sz=[0-9]*", z)==0 ){ + pIndex->szIdxRow = sqlite3LogEst(sqlite3Atoi(z+3)); + }else if( sqlite3_strglob("noskipscan*", z)==0 ){ + pIndex->noSkipScan = 1; + } +#ifdef SQLITE_ENABLE_COSTMULT + else if( sqlite3_strglob("costmult=[0-9]*",z)==0 ){ + pIndex->pTable->costMult = sqlite3LogEst(sqlite3Atoi(z+9)); + } +#endif + while( z[0]!=0 && z[0]!=' ' ) z++; + while( z[0]==' ' ) z++; + } + } +} + +/* +** This callback is invoked once for each index when reading the +** sqlite_stat1 table. +** +** argv[0] = name of the table +** argv[1] = name of the index (might be NULL) +** argv[2] = results of analysis - on integer for each column +** +** Entries for which argv[1]==NULL simply record the number of rows in +** the table. +*/ +static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){ + analysisInfo *pInfo = (analysisInfo*)pData; + Index *pIndex; + Table *pTable; + const char *z; + + assert( argc==3 ); + UNUSED_PARAMETER2(NotUsed, argc); + + if( argv==0 || argv[0]==0 || argv[2]==0 ){ + return 0; + } + pTable = sqlite3FindTable(pInfo->db, argv[0], pInfo->zDatabase); + if( pTable==0 ){ + return 0; + } + if( argv[1]==0 ){ + pIndex = 0; + }else if( sqlite3_stricmp(argv[0],argv[1])==0 ){ + pIndex = sqlite3PrimaryKeyIndex(pTable); + }else{ + pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase); + } + z = argv[2]; + + if( pIndex ){ + tRowcnt *aiRowEst = 0; + int nCol = pIndex->nKeyCol+1; +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + /* Index.aiRowEst may already be set here if there are duplicate + ** sqlite_stat1 entries for this index. In that case just clobber + ** the old data with the new instead of allocating a new array. */ + if( pIndex->aiRowEst==0 ){ + pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol); + if( pIndex->aiRowEst==0 ) pInfo->db->mallocFailed = 1; + } + aiRowEst = pIndex->aiRowEst; +#endif + pIndex->bUnordered = 0; + decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex); + if( pIndex->pPartIdxWhere==0 ) pTable->nRowLogEst = pIndex->aiRowLogEst[0]; + }else{ + Index fakeIdx; + fakeIdx.szIdxRow = pTable->szTabRow; +#ifdef SQLITE_ENABLE_COSTMULT + fakeIdx.pTable = pTable; +#endif + decodeIntArray((char*)z, 1, 0, &pTable->nRowLogEst, &fakeIdx); + pTable->szTabRow = fakeIdx.szIdxRow; + } + + return 0; +} + +/* +** If the Index.aSample variable is not NULL, delete the aSample[] array +** and its contents. +*/ +SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + if( pIdx->aSample ){ + int j; + for(j=0; jnSample; j++){ + IndexSample *p = &pIdx->aSample[j]; + sqlite3DbFree(db, p->p); + } + sqlite3DbFree(db, pIdx->aSample); + } + if( db && db->pnBytesFreed==0 ){ + pIdx->nSample = 0; + pIdx->aSample = 0; + } +#else + UNUSED_PARAMETER(db); + UNUSED_PARAMETER(pIdx); +#endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */ +} + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +/* +** Populate the pIdx->aAvgEq[] array based on the samples currently +** stored in pIdx->aSample[]. +*/ +static void initAvgEq(Index *pIdx){ + if( pIdx ){ + IndexSample *aSample = pIdx->aSample; + IndexSample *pFinal = &aSample[pIdx->nSample-1]; + int iCol; + int nCol = 1; + if( pIdx->nSampleCol>1 ){ + /* If this is stat4 data, then calculate aAvgEq[] values for all + ** sample columns except the last. The last is always set to 1, as + ** once the trailing PK fields are considered all index keys are + ** unique. */ + nCol = pIdx->nSampleCol-1; + pIdx->aAvgEq[nCol] = 1; + } + for(iCol=0; iColnSample; + int i; /* Used to iterate through samples */ + tRowcnt sumEq = 0; /* Sum of the nEq values */ + tRowcnt avgEq = 0; + tRowcnt nRow; /* Number of rows in index */ + i64 nSum100 = 0; /* Number of terms contributing to sumEq */ + i64 nDist100; /* Number of distinct values in index */ + + if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){ + nRow = pFinal->anLt[iCol]; + nDist100 = (i64)100 * pFinal->anDLt[iCol]; + nSample--; + }else{ + nRow = pIdx->aiRowEst[0]; + nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1]; + } + pIdx->nRowEst0 = nRow; + + /* Set nSum to the number of distinct (iCol+1) field prefixes that + ** occur in the stat4 table for this index. Set sumEq to the sum of + ** the nEq values for column iCol for the same set (adding the value + ** only once where there exist duplicate prefixes). */ + for(i=0; inSample-1) + || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol] + ){ + sumEq += aSample[i].anEq[iCol]; + nSum100 += 100; + } + } + + if( nDist100>nSum100 ){ + avgEq = ((i64)100 * (nRow - sumEq))/(nDist100 - nSum100); + } + if( avgEq==0 ) avgEq = 1; + pIdx->aAvgEq[iCol] = avgEq; + } + } +} + +/* +** Look up an index by name. Or, if the name of a WITHOUT ROWID table +** is supplied instead, find the PRIMARY KEY index for that table. +*/ +static Index *findIndexOrPrimaryKey( + sqlite3 *db, + const char *zName, + const char *zDb +){ + Index *pIdx = sqlite3FindIndex(db, zName, zDb); + if( pIdx==0 ){ + Table *pTab = sqlite3FindTable(db, zName, zDb); + if( pTab && !HasRowid(pTab) ) pIdx = sqlite3PrimaryKeyIndex(pTab); + } + return pIdx; +} + +/* +** Load the content from either the sqlite_stat4 or sqlite_stat3 table +** into the relevant Index.aSample[] arrays. +** +** Arguments zSql1 and zSql2 must point to SQL statements that return +** data equivalent to the following (statements are different for stat3, +** see the caller of this function for details): +** +** zSql1: SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx +** zSql2: SELECT idx,neq,nlt,ndlt,sample FROM %Q.sqlite_stat4 +** +** where %Q is replaced with the database name before the SQL is executed. +*/ +static int loadStatTbl( + sqlite3 *db, /* Database handle */ + int bStat3, /* Assume single column records only */ + const char *zSql1, /* SQL statement 1 (see above) */ + const char *zSql2, /* SQL statement 2 (see above) */ + const char *zDb /* Database name (e.g. "main") */ +){ + int rc; /* Result codes from subroutines */ + sqlite3_stmt *pStmt = 0; /* An SQL statement being run */ + char *zSql; /* Text of the SQL statement */ + Index *pPrevIdx = 0; /* Previous index in the loop */ + IndexSample *pSample; /* A slot in pIdx->aSample[] */ + + assert( db->lookaside.bEnabled==0 ); + zSql = sqlite3MPrintf(db, zSql1, zDb); + if( !zSql ){ + return SQLITE_NOMEM; + } + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + sqlite3DbFree(db, zSql); + if( rc ) return rc; + + while( sqlite3_step(pStmt)==SQLITE_ROW ){ + int nIdxCol = 1; /* Number of columns in stat4 records */ + + char *zIndex; /* Index name */ + Index *pIdx; /* Pointer to the index object */ + int nSample; /* Number of samples */ + int nByte; /* Bytes of space required */ + int i; /* Bytes of space required */ + tRowcnt *pSpace; + + zIndex = (char *)sqlite3_column_text(pStmt, 0); + if( zIndex==0 ) continue; + nSample = sqlite3_column_int(pStmt, 1); + pIdx = findIndexOrPrimaryKey(db, zIndex, zDb); + assert( pIdx==0 || bStat3 || pIdx->nSample==0 ); + /* Index.nSample is non-zero at this point if data has already been + ** loaded from the stat4 table. In this case ignore stat3 data. */ + if( pIdx==0 || pIdx->nSample ) continue; + if( bStat3==0 ){ + assert( !HasRowid(pIdx->pTable) || pIdx->nColumn==pIdx->nKeyCol+1 ); + if( !HasRowid(pIdx->pTable) && IsPrimaryKeyIndex(pIdx) ){ + nIdxCol = pIdx->nKeyCol; + }else{ + nIdxCol = pIdx->nColumn; + } + } + pIdx->nSampleCol = nIdxCol; + nByte = sizeof(IndexSample) * nSample; + nByte += sizeof(tRowcnt) * nIdxCol * 3 * nSample; + nByte += nIdxCol * sizeof(tRowcnt); /* Space for Index.aAvgEq[] */ + + pIdx->aSample = sqlite3DbMallocZero(db, nByte); + if( pIdx->aSample==0 ){ + sqlite3_finalize(pStmt); + return SQLITE_NOMEM; + } + pSpace = (tRowcnt*)&pIdx->aSample[nSample]; + pIdx->aAvgEq = pSpace; pSpace += nIdxCol; + for(i=0; iaSample[i].anEq = pSpace; pSpace += nIdxCol; + pIdx->aSample[i].anLt = pSpace; pSpace += nIdxCol; + pIdx->aSample[i].anDLt = pSpace; pSpace += nIdxCol; + } + assert( ((u8*)pSpace)-nByte==(u8*)(pIdx->aSample) ); + } + rc = sqlite3_finalize(pStmt); + if( rc ) return rc; + + zSql = sqlite3MPrintf(db, zSql2, zDb); + if( !zSql ){ + return SQLITE_NOMEM; + } + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + sqlite3DbFree(db, zSql); + if( rc ) return rc; + + while( sqlite3_step(pStmt)==SQLITE_ROW ){ + char *zIndex; /* Index name */ + Index *pIdx; /* Pointer to the index object */ + int nCol = 1; /* Number of columns in index */ + + zIndex = (char *)sqlite3_column_text(pStmt, 0); + if( zIndex==0 ) continue; + pIdx = findIndexOrPrimaryKey(db, zIndex, zDb); + if( pIdx==0 ) continue; + /* This next condition is true if data has already been loaded from + ** the sqlite_stat4 table. In this case ignore stat3 data. */ + nCol = pIdx->nSampleCol; + if( bStat3 && nCol>1 ) continue; + if( pIdx!=pPrevIdx ){ + initAvgEq(pPrevIdx); + pPrevIdx = pIdx; + } + pSample = &pIdx->aSample[pIdx->nSample]; + decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0); + decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0); + decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0); + + /* Take a copy of the sample. Add two 0x00 bytes the end of the buffer. + ** This is in case the sample record is corrupted. In that case, the + ** sqlite3VdbeRecordCompare() may read up to two varints past the + ** end of the allocated buffer before it realizes it is dealing with + ** a corrupt record. Adding the two 0x00 bytes prevents this from causing + ** a buffer overread. */ + pSample->n = sqlite3_column_bytes(pStmt, 4); + pSample->p = sqlite3DbMallocZero(db, pSample->n + 2); + if( pSample->p==0 ){ + sqlite3_finalize(pStmt); + return SQLITE_NOMEM; + } + memcpy(pSample->p, sqlite3_column_blob(pStmt, 4), pSample->n); + pIdx->nSample++; + } + rc = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ) initAvgEq(pPrevIdx); + return rc; +} + +/* +** Load content from the sqlite_stat4 and sqlite_stat3 tables into +** the Index.aSample[] arrays of all indices. +*/ +static int loadStat4(sqlite3 *db, const char *zDb){ + int rc = SQLITE_OK; /* Result codes from subroutines */ + + assert( db->lookaside.bEnabled==0 ); + if( sqlite3FindTable(db, "sqlite_stat4", zDb) ){ + rc = loadStatTbl(db, 0, + "SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx", + "SELECT idx,neq,nlt,ndlt,sample FROM %Q.sqlite_stat4", + zDb + ); + } + + if( rc==SQLITE_OK && sqlite3FindTable(db, "sqlite_stat3", zDb) ){ + rc = loadStatTbl(db, 1, + "SELECT idx,count(*) FROM %Q.sqlite_stat3 GROUP BY idx", + "SELECT idx,neq,nlt,ndlt,sqlite_record(sample) FROM %Q.sqlite_stat3", + zDb + ); + } + + return rc; +} +#endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */ + +/* +** Load the content of the sqlite_stat1 and sqlite_stat3/4 tables. The +** contents of sqlite_stat1 are used to populate the Index.aiRowEst[] +** arrays. The contents of sqlite_stat3/4 are used to populate the +** Index.aSample[] arrays. +** +** If the sqlite_stat1 table is not present in the database, SQLITE_ERROR +** is returned. In this case, even if SQLITE_ENABLE_STAT3/4 was defined +** during compilation and the sqlite_stat3/4 table is present, no data is +** read from it. +** +** If SQLITE_ENABLE_STAT3/4 was defined during compilation and the +** sqlite_stat4 table is not present in the database, SQLITE_ERROR is +** returned. However, in this case, data is read from the sqlite_stat1 +** table (if it is present) before returning. +** +** If an OOM error occurs, this function always sets db->mallocFailed. +** This means if the caller does not care about other errors, the return +** code may be ignored. +*/ +SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){ + analysisInfo sInfo; + HashElem *i; + char *zSql; + int rc; + + assert( iDb>=0 && iDbnDb ); + assert( db->aDb[iDb].pBt!=0 ); + + /* Clear any prior statistics */ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){ + Index *pIdx = sqliteHashData(i); + sqlite3DefaultRowEst(pIdx); +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + sqlite3DeleteIndexSamples(db, pIdx); + pIdx->aSample = 0; +#endif + } + + /* Check to make sure the sqlite_stat1 table exists */ + sInfo.db = db; + sInfo.zDatabase = db->aDb[iDb].zName; + if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){ + return SQLITE_ERROR; + } + + /* Load new statistics out of the sqlite_stat1 table */ + zSql = sqlite3MPrintf(db, + "SELECT tbl,idx,stat FROM %Q.sqlite_stat1", sInfo.zDatabase); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0); + sqlite3DbFree(db, zSql); + } + + + /* Load the statistics from the sqlite_stat4 table. */ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + if( rc==SQLITE_OK && OptimizationEnabled(db, SQLITE_Stat34) ){ + int lookasideEnabled = db->lookaside.bEnabled; + db->lookaside.bEnabled = 0; + rc = loadStat4(db, sInfo.zDatabase); + db->lookaside.bEnabled = lookasideEnabled; + } + for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){ + Index *pIdx = sqliteHashData(i); + sqlite3_free(pIdx->aiRowEst); + pIdx->aiRowEst = 0; + } +#endif + + if( rc==SQLITE_NOMEM ){ + db->mallocFailed = 1; + } + return rc; +} + + +#endif /* SQLITE_OMIT_ANALYZE */ + +/************** End of analyze.c *********************************************/ +/************** Begin file attach.c ******************************************/ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the ATTACH and DETACH commands. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_ATTACH +/* +** Resolve an expression that was part of an ATTACH or DETACH statement. This +** is slightly different from resolving a normal SQL expression, because simple +** identifiers are treated as strings, not possible column names or aliases. +** +** i.e. if the parser sees: +** +** ATTACH DATABASE abc AS def +** +** it treats the two expressions as literal strings 'abc' and 'def' instead of +** looking for columns of the same name. +** +** This only applies to the root node of pExpr, so the statement: +** +** ATTACH DATABASE abc||def AS 'db2' +** +** will fail because neither abc or def can be resolved. +*/ +static int resolveAttachExpr(NameContext *pName, Expr *pExpr) +{ + int rc = SQLITE_OK; + if( pExpr ){ + if( pExpr->op!=TK_ID ){ + rc = sqlite3ResolveExprNames(pName, pExpr); + }else{ + pExpr->op = TK_STRING; + } + } + return rc; +} + +/* +** An SQL user-function registered to do the work of an ATTACH statement. The +** three arguments to the function come directly from an attach statement: +** +** ATTACH DATABASE x AS y KEY z +** +** SELECT sqlite_attach(x, y, z) +** +** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the +** third argument. +*/ +static void attachFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + int i; + int rc = 0; + sqlite3 *db = sqlite3_context_db_handle(context); + const char *zName; + const char *zFile; + char *zPath = 0; + char *zErr = 0; + unsigned int flags; + Db *aNew; + char *zErrDyn = 0; + sqlite3_vfs *pVfs; + + UNUSED_PARAMETER(NotUsed); + + zFile = (const char *)sqlite3_value_text(argv[0]); + zName = (const char *)sqlite3_value_text(argv[1]); + if( zFile==0 ) zFile = ""; + if( zName==0 ) zName = ""; + + /* Check for the following errors: + ** + ** * Too many attached databases, + ** * Transaction currently open + ** * Specified database name already being used. + */ + if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){ + zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d", + db->aLimit[SQLITE_LIMIT_ATTACHED] + ); + goto attach_error; + } + if( !db->autoCommit ){ + zErrDyn = sqlite3MPrintf(db, "cannot ATTACH database within transaction"); + goto attach_error; + } + for(i=0; inDb; i++){ + char *z = db->aDb[i].zName; + assert( z && zName ); + if( sqlite3StrICmp(z, zName)==0 ){ + zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName); + goto attach_error; + } + } + + /* Allocate the new entry in the db->aDb[] array and initialize the schema + ** hash tables. + */ + if( db->aDb==db->aDbStatic ){ + aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 ); + if( aNew==0 ) return; + memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2); + }else{ + aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) ); + if( aNew==0 ) return; + } + db->aDb = aNew; + aNew = &db->aDb[db->nDb]; + memset(aNew, 0, sizeof(*aNew)); + + /* Open the database file. If the btree is successfully opened, use + ** it to obtain the database schema. At this point the schema may + ** or may not be initialized. + */ + flags = db->openFlags; + rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM ) db->mallocFailed = 1; + sqlite3_result_error(context, zErr, -1); + sqlite3_free(zErr); + return; + } + assert( pVfs ); + flags |= SQLITE_OPEN_MAIN_DB; + rc = sqlite3BtreeOpen(pVfs, zPath, db, &aNew->pBt, 0, flags); + sqlite3_free( zPath ); + db->nDb++; + if( rc==SQLITE_CONSTRAINT ){ + rc = SQLITE_ERROR; + zErrDyn = sqlite3MPrintf(db, "database is already attached"); + }else if( rc==SQLITE_OK ){ + Pager *pPager; + aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt); + if( !aNew->pSchema ){ + rc = SQLITE_NOMEM; + }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){ + zErrDyn = sqlite3MPrintf(db, + "attached databases must use the same text encoding as main database"); + rc = SQLITE_ERROR; + } + sqlite3BtreeEnter(aNew->pBt); + pPager = sqlite3BtreePager(aNew->pBt); + sqlite3PagerLockingMode(pPager, db->dfltLockMode); + sqlite3BtreeSecureDelete(aNew->pBt, + sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) ); +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + sqlite3BtreeSetPagerFlags(aNew->pBt, 3 | (db->flags & PAGER_FLAGS_MASK)); +#endif + sqlite3BtreeLeave(aNew->pBt); + } + aNew->safety_level = 3; + aNew->zName = sqlite3DbStrDup(db, zName); + if( rc==SQLITE_OK && aNew->zName==0 ){ + rc = SQLITE_NOMEM; + } + + +#ifdef SQLITE_HAS_CODEC + if( rc==SQLITE_OK ){ + extern int sqlite3CodecAttach(sqlite3*, int, const void*, int); + extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*); + int nKey; + char *zKey; + int t = sqlite3_value_type(argv[2]); + switch( t ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: + zErrDyn = sqlite3DbStrDup(db, "Invalid key value"); + rc = SQLITE_ERROR; + break; + + case SQLITE_TEXT: + case SQLITE_BLOB: + nKey = sqlite3_value_bytes(argv[2]); + zKey = (char *)sqlite3_value_blob(argv[2]); + rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey); + break; + + case SQLITE_NULL: + /* No key specified. Use the key from the main database */ + sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey); + if( nKey>0 || sqlite3BtreeGetOptimalReserve(db->aDb[0].pBt)>0 ){ + rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey); + } + break; + } + } +#endif + + /* If the file was opened successfully, read the schema for the new database. + ** If this fails, or if opening the file failed, then close the file and + ** remove the entry from the db->aDb[] array. i.e. put everything back the way + ** we found it. + */ + if( rc==SQLITE_OK ){ + sqlite3BtreeEnterAll(db); + rc = sqlite3Init(db, &zErrDyn); + sqlite3BtreeLeaveAll(db); + } +#ifdef SQLITE_USER_AUTHENTICATION + if( rc==SQLITE_OK ){ + u8 newAuth = 0; + rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth); + if( newAuthauth.authLevel ){ + rc = SQLITE_AUTH_USER; + } + } +#endif + if( rc ){ + int iDb = db->nDb - 1; + assert( iDb>=2 ); + if( db->aDb[iDb].pBt ){ + sqlite3BtreeClose(db->aDb[iDb].pBt); + db->aDb[iDb].pBt = 0; + db->aDb[iDb].pSchema = 0; + } + sqlite3ResetAllSchemasOfConnection(db); + db->nDb = iDb; + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + db->mallocFailed = 1; + sqlite3DbFree(db, zErrDyn); + zErrDyn = sqlite3MPrintf(db, "out of memory"); + }else if( zErrDyn==0 ){ + zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile); + } + goto attach_error; + } + + return; + +attach_error: + /* Return an error if we get here */ + if( zErrDyn ){ + sqlite3_result_error(context, zErrDyn, -1); + sqlite3DbFree(db, zErrDyn); + } + if( rc ) sqlite3_result_error_code(context, rc); +} + +/* +** An SQL user-function registered to do the work of an DETACH statement. The +** three arguments to the function come directly from a detach statement: +** +** DETACH DATABASE x +** +** SELECT sqlite_detach(x) +*/ +static void detachFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + const char *zName = (const char *)sqlite3_value_text(argv[0]); + sqlite3 *db = sqlite3_context_db_handle(context); + int i; + Db *pDb = 0; + char zErr[128]; + + UNUSED_PARAMETER(NotUsed); + + if( zName==0 ) zName = ""; + for(i=0; inDb; i++){ + pDb = &db->aDb[i]; + if( pDb->pBt==0 ) continue; + if( sqlite3StrICmp(pDb->zName, zName)==0 ) break; + } + + if( i>=db->nDb ){ + sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName); + goto detach_error; + } + if( i<2 ){ + sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName); + goto detach_error; + } + if( !db->autoCommit ){ + sqlite3_snprintf(sizeof(zErr), zErr, + "cannot DETACH database within transaction"); + goto detach_error; + } + if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){ + sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName); + goto detach_error; + } + + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + pDb->pSchema = 0; + sqlite3CollapseDatabaseArray(db); + return; + +detach_error: + sqlite3_result_error(context, zErr, -1); +} + +/* +** This procedure generates VDBE code for a single invocation of either the +** sqlite_detach() or sqlite_attach() SQL user functions. +*/ +static void codeAttach( + Parse *pParse, /* The parser context */ + int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */ + FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */ + Expr *pAuthArg, /* Expression to pass to authorization callback */ + Expr *pFilename, /* Name of database file */ + Expr *pDbname, /* Name of the database to use internally */ + Expr *pKey /* Database key for encryption extension */ +){ + int rc; + NameContext sName; + Vdbe *v; + sqlite3* db = pParse->db; + int regArgs; + + memset(&sName, 0, sizeof(NameContext)); + sName.pParse = pParse; + + if( + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) || + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) || + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey)) + ){ + goto attach_end; + } + +#ifndef SQLITE_OMIT_AUTHORIZATION + if( pAuthArg ){ + char *zAuthArg; + if( pAuthArg->op==TK_STRING ){ + zAuthArg = pAuthArg->u.zToken; + }else{ + zAuthArg = 0; + } + rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0); + if(rc!=SQLITE_OK ){ + goto attach_end; + } + } +#endif /* SQLITE_OMIT_AUTHORIZATION */ + + + v = sqlite3GetVdbe(pParse); + regArgs = sqlite3GetTempRange(pParse, 4); + sqlite3ExprCode(pParse, pFilename, regArgs); + sqlite3ExprCode(pParse, pDbname, regArgs+1); + sqlite3ExprCode(pParse, pKey, regArgs+2); + + assert( v || db->mallocFailed ); + if( v ){ + sqlite3VdbeAddOp3(v, OP_Function0, 0, regArgs+3-pFunc->nArg, regArgs+3); + assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg ); + sqlite3VdbeChangeP5(v, (u8)(pFunc->nArg)); + sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF); + + /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this + ** statement only). For DETACH, set it to false (expire all existing + ** statements). + */ + sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH)); + } + +attach_end: + sqlite3ExprDelete(db, pFilename); + sqlite3ExprDelete(db, pDbname); + sqlite3ExprDelete(db, pKey); +} + +/* +** Called by the parser to compile a DETACH statement. +** +** DETACH pDbname +*/ +SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){ + static const FuncDef detach_func = { + 1, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + detachFunc, /* xFunc */ + 0, /* xStep */ + 0, /* xFinalize */ + "sqlite_detach", /* zName */ + 0, /* pHash */ + 0 /* pDestructor */ + }; + codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname); +} + +/* +** Called by the parser to compile an ATTACH statement. +** +** ATTACH p AS pDbname KEY pKey +*/ +SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){ + static const FuncDef attach_func = { + 3, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + attachFunc, /* xFunc */ + 0, /* xStep */ + 0, /* xFinalize */ + "sqlite_attach", /* zName */ + 0, /* pHash */ + 0 /* pDestructor */ + }; + codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey); +} +#endif /* SQLITE_OMIT_ATTACH */ + +/* +** Initialize a DbFixer structure. This routine must be called prior +** to passing the structure to one of the sqliteFixAAAA() routines below. +*/ +SQLITE_PRIVATE void sqlite3FixInit( + DbFixer *pFix, /* The fixer to be initialized */ + Parse *pParse, /* Error messages will be written here */ + int iDb, /* This is the database that must be used */ + const char *zType, /* "view", "trigger", or "index" */ + const Token *pName /* Name of the view, trigger, or index */ +){ + sqlite3 *db; + + db = pParse->db; + assert( db->nDb>iDb ); + pFix->pParse = pParse; + pFix->zDb = db->aDb[iDb].zName; + pFix->pSchema = db->aDb[iDb].pSchema; + pFix->zType = zType; + pFix->pName = pName; + pFix->bVarOnly = (iDb==1); +} + +/* +** The following set of routines walk through the parse tree and assign +** a specific database to all table references where the database name +** was left unspecified in the original SQL statement. The pFix structure +** must have been initialized by a prior call to sqlite3FixInit(). +** +** These routines are used to make sure that an index, trigger, or +** view in one database does not refer to objects in a different database. +** (Exception: indices, triggers, and views in the TEMP database are +** allowed to refer to anything.) If a reference is explicitly made +** to an object in a different database, an error message is added to +** pParse->zErrMsg and these routines return non-zero. If everything +** checks out, these routines return 0. +*/ +SQLITE_PRIVATE int sqlite3FixSrcList( + DbFixer *pFix, /* Context of the fixation */ + SrcList *pList /* The Source list to check and modify */ +){ + int i; + const char *zDb; + struct SrcList_item *pItem; + + if( NEVER(pList==0) ) return 0; + zDb = pFix->zDb; + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pFix->bVarOnly==0 ){ + if( pItem->zDatabase && sqlite3StrICmp(pItem->zDatabase, zDb) ){ + sqlite3ErrorMsg(pFix->pParse, + "%s %T cannot reference objects in database %s", + pFix->zType, pFix->pName, pItem->zDatabase); + return 1; + } + sqlite3DbFree(pFix->pParse->db, pItem->zDatabase); + pItem->zDatabase = 0; + pItem->pSchema = pFix->pSchema; + } +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) + if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1; + if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1; +#endif + } + return 0; +} +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) +SQLITE_PRIVATE int sqlite3FixSelect( + DbFixer *pFix, /* Context of the fixation */ + Select *pSelect /* The SELECT statement to be fixed to one database */ +){ + while( pSelect ){ + if( sqlite3FixExprList(pFix, pSelect->pEList) ){ + return 1; + } + if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pSelect->pWhere) ){ + return 1; + } + if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pSelect->pHaving) ){ + return 1; + } + if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pSelect->pLimit) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pSelect->pOffset) ){ + return 1; + } + pSelect = pSelect->pPrior; + } + return 0; +} +SQLITE_PRIVATE int sqlite3FixExpr( + DbFixer *pFix, /* Context of the fixation */ + Expr *pExpr /* The expression to be fixed to one database */ +){ + while( pExpr ){ + if( pExpr->op==TK_VARIABLE ){ + if( pFix->pParse->db->init.busy ){ + pExpr->op = TK_NULL; + }else{ + sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType); + return 1; + } + } + if( ExprHasProperty(pExpr, EP_TokenOnly) ) break; + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1; + }else{ + if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1; + } + if( sqlite3FixExpr(pFix, pExpr->pRight) ){ + return 1; + } + pExpr = pExpr->pLeft; + } + return 0; +} +SQLITE_PRIVATE int sqlite3FixExprList( + DbFixer *pFix, /* Context of the fixation */ + ExprList *pList /* The expression to be fixed to one database */ +){ + int i; + struct ExprList_item *pItem; + if( pList==0 ) return 0; + for(i=0, pItem=pList->a; inExpr; i++, pItem++){ + if( sqlite3FixExpr(pFix, pItem->pExpr) ){ + return 1; + } + } + return 0; +} +#endif + +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE int sqlite3FixTriggerStep( + DbFixer *pFix, /* Context of the fixation */ + TriggerStep *pStep /* The trigger step be fixed to one database */ +){ + while( pStep ){ + if( sqlite3FixSelect(pFix, pStep->pSelect) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pStep->pWhere) ){ + return 1; + } + if( sqlite3FixExprList(pFix, pStep->pExprList) ){ + return 1; + } + pStep = pStep->pNext; + } + return 0; +} +#endif + +/************** End of attach.c **********************************************/ +/************** Begin file auth.c ********************************************/ +/* +** 2003 January 11 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the sqlite3_set_authorizer() +** API. This facility is an optional feature of the library. Embedded +** systems that do not need this facility may omit it by recompiling +** the library with -DSQLITE_OMIT_AUTHORIZATION=1 +*/ +/* #include "sqliteInt.h" */ + +/* +** All of the code in this file may be omitted by defining a single +** macro. +*/ +#ifndef SQLITE_OMIT_AUTHORIZATION + +/* +** Set or clear the access authorization function. +** +** The access authorization function is be called during the compilation +** phase to verify that the user has read and/or write access permission on +** various fields of the database. The first argument to the auth function +** is a copy of the 3rd argument to this routine. The second argument +** to the auth function is one of these constants: +** +** SQLITE_CREATE_INDEX +** SQLITE_CREATE_TABLE +** SQLITE_CREATE_TEMP_INDEX +** SQLITE_CREATE_TEMP_TABLE +** SQLITE_CREATE_TEMP_TRIGGER +** SQLITE_CREATE_TEMP_VIEW +** SQLITE_CREATE_TRIGGER +** SQLITE_CREATE_VIEW +** SQLITE_DELETE +** SQLITE_DROP_INDEX +** SQLITE_DROP_TABLE +** SQLITE_DROP_TEMP_INDEX +** SQLITE_DROP_TEMP_TABLE +** SQLITE_DROP_TEMP_TRIGGER +** SQLITE_DROP_TEMP_VIEW +** SQLITE_DROP_TRIGGER +** SQLITE_DROP_VIEW +** SQLITE_INSERT +** SQLITE_PRAGMA +** SQLITE_READ +** SQLITE_SELECT +** SQLITE_TRANSACTION +** SQLITE_UPDATE +** +** The third and fourth arguments to the auth function are the name of +** the table and the column that are being accessed. The auth function +** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If +** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY +** means that the SQL statement will never-run - the sqlite3_exec() call +** will return with an error. SQLITE_IGNORE means that the SQL statement +** should run but attempts to read the specified column will return NULL +** and attempts to write the column will be ignored. +** +** Setting the auth function to NULL disables this hook. The default +** setting of the auth function is NULL. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_set_authorizer( + sqlite3 *db, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pArg +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->xAuth = (sqlite3_xauth)xAuth; + db->pAuthArg = pArg; + sqlite3ExpirePreparedStatements(db); + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Write an error message into pParse->zErrMsg that explains that the +** user-supplied authorization function returned an illegal value. +*/ +static void sqliteAuthBadReturnCode(Parse *pParse){ + sqlite3ErrorMsg(pParse, "authorizer malfunction"); + pParse->rc = SQLITE_ERROR; +} + +/* +** Invoke the authorization callback for permission to read column zCol from +** table zTab in database zDb. This function assumes that an authorization +** callback has been registered (i.e. that sqlite3.xAuth is not NULL). +** +** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed +** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE +** is treated as SQLITE_DENY. In this case an error is left in pParse. +*/ +SQLITE_PRIVATE int sqlite3AuthReadCol( + Parse *pParse, /* The parser context */ + const char *zTab, /* Table name */ + const char *zCol, /* Column name */ + int iDb /* Index of containing database. */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + char *zDb = db->aDb[iDb].zName; /* Name of attached database */ + int rc; /* Auth callback return code */ + + rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext +#ifdef SQLITE_USER_AUTHENTICATION + ,db->auth.zAuthUser +#endif + ); + if( rc==SQLITE_DENY ){ + if( db->nDb>2 || iDb!=0 ){ + sqlite3ErrorMsg(pParse, "access to %s.%s.%s is prohibited",zDb,zTab,zCol); + }else{ + sqlite3ErrorMsg(pParse, "access to %s.%s is prohibited", zTab, zCol); + } + pParse->rc = SQLITE_AUTH; + }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){ + sqliteAuthBadReturnCode(pParse); + } + return rc; +} + +/* +** The pExpr should be a TK_COLUMN expression. The table referred to +** is in pTabList or else it is the NEW or OLD table of a trigger. +** Check to see if it is OK to read this particular column. +** +** If the auth function returns SQLITE_IGNORE, change the TK_COLUMN +** instruction into a TK_NULL. If the auth function returns SQLITE_DENY, +** then generate an error. +*/ +SQLITE_PRIVATE void sqlite3AuthRead( + Parse *pParse, /* The parser context */ + Expr *pExpr, /* The expression to check authorization on */ + Schema *pSchema, /* The schema of the expression */ + SrcList *pTabList /* All table that pExpr might refer to */ +){ + sqlite3 *db = pParse->db; + Table *pTab = 0; /* The table being read */ + const char *zCol; /* Name of the column of the table */ + int iSrc; /* Index in pTabList->a[] of table being read */ + int iDb; /* The index of the database the expression refers to */ + int iCol; /* Index of column in table */ + + if( db->xAuth==0 ) return; + iDb = sqlite3SchemaToIndex(pParse->db, pSchema); + if( iDb<0 ){ + /* An attempt to read a column out of a subquery or other + ** temporary table. */ + return; + } + + assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER ); + if( pExpr->op==TK_TRIGGER ){ + pTab = pParse->pTriggerTab; + }else{ + assert( pTabList ); + for(iSrc=0; ALWAYS(iSrcnSrc); iSrc++){ + if( pExpr->iTable==pTabList->a[iSrc].iCursor ){ + pTab = pTabList->a[iSrc].pTab; + break; + } + } + } + iCol = pExpr->iColumn; + if( NEVER(pTab==0) ) return; + + if( iCol>=0 ){ + assert( iColnCol ); + zCol = pTab->aCol[iCol].zName; + }else if( pTab->iPKey>=0 ){ + assert( pTab->iPKeynCol ); + zCol = pTab->aCol[pTab->iPKey].zName; + }else{ + zCol = "ROWID"; + } + assert( iDb>=0 && iDbnDb ); + if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){ + pExpr->op = TK_NULL; + } +} + +/* +** Do an authorization check using the code and arguments given. Return +** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY +** is returned, then the error count and error message in pParse are +** modified appropriately. +*/ +SQLITE_PRIVATE int sqlite3AuthCheck( + Parse *pParse, + int code, + const char *zArg1, + const char *zArg2, + const char *zArg3 +){ + sqlite3 *db = pParse->db; + int rc; + + /* Don't do any authorization checks if the database is initialising + ** or if the parser is being invoked from within sqlite3_declare_vtab. + */ + if( db->init.busy || IN_DECLARE_VTAB ){ + return SQLITE_OK; + } + + if( db->xAuth==0 ){ + return SQLITE_OK; + } + rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext +#ifdef SQLITE_USER_AUTHENTICATION + ,db->auth.zAuthUser +#endif + ); + if( rc==SQLITE_DENY ){ + sqlite3ErrorMsg(pParse, "not authorized"); + pParse->rc = SQLITE_AUTH; + }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){ + rc = SQLITE_DENY; + sqliteAuthBadReturnCode(pParse); + } + return rc; +} + +/* +** Push an authorization context. After this routine is called, the +** zArg3 argument to authorization callbacks will be zContext until +** popped. Or if pParse==0, this routine is a no-op. +*/ +SQLITE_PRIVATE void sqlite3AuthContextPush( + Parse *pParse, + AuthContext *pContext, + const char *zContext +){ + assert( pParse ); + pContext->pParse = pParse; + pContext->zAuthContext = pParse->zAuthContext; + pParse->zAuthContext = zContext; +} + +/* +** Pop an authorization context that was previously pushed +** by sqlite3AuthContextPush +*/ +SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext *pContext){ + if( pContext->pParse ){ + pContext->pParse->zAuthContext = pContext->zAuthContext; + pContext->pParse = 0; + } +} + +#endif /* SQLITE_OMIT_AUTHORIZATION */ + +/************** End of auth.c ************************************************/ +/************** Begin file build.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the SQLite parser +** when syntax rules are reduced. The routines in this file handle the +** following kinds of SQL syntax: +** +** CREATE TABLE +** DROP TABLE +** CREATE INDEX +** DROP INDEX +** creating ID lists +** BEGIN TRANSACTION +** COMMIT +** ROLLBACK +*/ +/* #include "sqliteInt.h" */ + +/* +** This routine is called when a new SQL statement is beginning to +** be parsed. Initialize the pParse structure as needed. +*/ +SQLITE_PRIVATE void sqlite3BeginParse(Parse *pParse, int explainFlag){ + pParse->explain = (u8)explainFlag; + pParse->nVar = 0; +} + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** The TableLock structure is only used by the sqlite3TableLock() and +** codeTableLocks() functions. +*/ +struct TableLock { + int iDb; /* The database containing the table to be locked */ + int iTab; /* The root page of the table to be locked */ + u8 isWriteLock; /* True for write lock. False for a read lock */ + const char *zName; /* Name of the table */ +}; + +/* +** Record the fact that we want to lock a table at run-time. +** +** The table to be locked has root page iTab and is found in database iDb. +** A read or a write lock can be taken depending on isWritelock. +** +** This routine just records the fact that the lock is desired. The +** code to make the lock occur is generated by a later call to +** codeTableLocks() which occurs during sqlite3FinishCoding(). +*/ +SQLITE_PRIVATE void sqlite3TableLock( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database containing the table to lock */ + int iTab, /* Root page number of the table to be locked */ + u8 isWriteLock, /* True for a write lock */ + const char *zName /* Name of the table to be locked */ +){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + int i; + int nBytes; + TableLock *p; + assert( iDb>=0 ); + + for(i=0; inTableLock; i++){ + p = &pToplevel->aTableLock[i]; + if( p->iDb==iDb && p->iTab==iTab ){ + p->isWriteLock = (p->isWriteLock || isWriteLock); + return; + } + } + + nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1); + pToplevel->aTableLock = + sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes); + if( pToplevel->aTableLock ){ + p = &pToplevel->aTableLock[pToplevel->nTableLock++]; + p->iDb = iDb; + p->iTab = iTab; + p->isWriteLock = isWriteLock; + p->zName = zName; + }else{ + pToplevel->nTableLock = 0; + pToplevel->db->mallocFailed = 1; + } +} + +/* +** Code an OP_TableLock instruction for each table locked by the +** statement (configured by calls to sqlite3TableLock()). +*/ +static void codeTableLocks(Parse *pParse){ + int i; + Vdbe *pVdbe; + + pVdbe = sqlite3GetVdbe(pParse); + assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */ + + for(i=0; inTableLock; i++){ + TableLock *p = &pParse->aTableLock[i]; + int p1 = p->iDb; + sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock, + p->zName, P4_STATIC); + } +} +#else + #define codeTableLocks(x) +#endif + +/* +** Return TRUE if the given yDbMask object is empty - if it contains no +** 1 bits. This routine is used by the DbMaskAllZero() and DbMaskNotZero() +** macros when SQLITE_MAX_ATTACHED is greater than 30. +*/ +#if SQLITE_MAX_ATTACHED>30 +SQLITE_PRIVATE int sqlite3DbMaskAllZero(yDbMask m){ + int i; + for(i=0; ipToplevel==0 ); + db = pParse->db; + if( pParse->nested ) return; + if( db->mallocFailed || pParse->nErr ){ + if( pParse->rc==SQLITE_OK ) pParse->rc = SQLITE_ERROR; + return; + } + + /* Begin by generating some termination code at the end of the + ** vdbe program + */ + v = sqlite3GetVdbe(pParse); + assert( !pParse->isMultiWrite + || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort)); + if( v ){ + while( sqlite3VdbeDeletePriorOpcode(v, OP_Close) ){} + sqlite3VdbeAddOp0(v, OP_Halt); + +#if SQLITE_USER_AUTHENTICATION + if( pParse->nTableLock>0 && db->init.busy==0 ){ + sqlite3UserAuthInit(db); + if( db->auth.authLevelrc = SQLITE_AUTH_USER; + sqlite3ErrorMsg(pParse, "user not authenticated"); + return; + } + } +#endif + + /* The cookie mask contains one bit for each database file open. + ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are + ** set for each database that is used. Generate code to start a + ** transaction on each used database and to verify the schema cookie + ** on each used database. + */ + if( db->mallocFailed==0 + && (DbMaskNonZero(pParse->cookieMask) || pParse->pConstExpr) + ){ + int iDb, i; + assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init ); + sqlite3VdbeJumpHere(v, 0); + for(iDb=0; iDbnDb; iDb++){ + if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue; + sqlite3VdbeUsesBtree(v, iDb); + sqlite3VdbeAddOp4Int(v, + OP_Transaction, /* Opcode */ + iDb, /* P1 */ + DbMaskTest(pParse->writeMask,iDb), /* P2 */ + pParse->cookieValue[iDb], /* P3 */ + db->aDb[iDb].pSchema->iGeneration /* P4 */ + ); + if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1); + VdbeComment((v, + "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite)); + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + for(i=0; inVtabLock; i++){ + char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]); + sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB); + } + pParse->nVtabLock = 0; +#endif + + /* Once all the cookies have been verified and transactions opened, + ** obtain the required table-locks. This is a no-op unless the + ** shared-cache feature is enabled. + */ + codeTableLocks(pParse); + + /* Initialize any AUTOINCREMENT data structures required. + */ + sqlite3AutoincrementBegin(pParse); + + /* Code constant expressions that where factored out of inner loops */ + if( pParse->pConstExpr ){ + ExprList *pEL = pParse->pConstExpr; + pParse->okConstFactor = 0; + for(i=0; inExpr; i++){ + sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg); + } + } + + /* Finally, jump back to the beginning of the executable code. */ + sqlite3VdbeGoto(v, 1); + } + } + + + /* Get the VDBE program ready for execution + */ + if( v && pParse->nErr==0 && !db->mallocFailed ){ + assert( pParse->iCacheLevel==0 ); /* Disables and re-enables match */ + /* A minimum of one cursor is required if autoincrement is used + * See ticket [a696379c1f08866] */ + if( pParse->pAinc!=0 && pParse->nTab==0 ) pParse->nTab = 1; + sqlite3VdbeMakeReady(v, pParse); + pParse->rc = SQLITE_DONE; + pParse->colNamesSet = 0; + }else{ + pParse->rc = SQLITE_ERROR; + } + pParse->nTab = 0; + pParse->nMem = 0; + pParse->nSet = 0; + pParse->nVar = 0; + DbMaskZero(pParse->cookieMask); +} + +/* +** Run the parser and code generator recursively in order to generate +** code for the SQL statement given onto the end of the pParse context +** currently under construction. When the parser is run recursively +** this way, the final OP_Halt is not appended and other initialization +** and finalization steps are omitted because those are handling by the +** outermost parser. +** +** Not everything is nestable. This facility is designed to permit +** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER. Use +** care if you decide to try to use this routine for some other purposes. +*/ +SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){ + va_list ap; + char *zSql; + char *zErrMsg = 0; + sqlite3 *db = pParse->db; +# define SAVE_SZ (sizeof(Parse) - offsetof(Parse,nVar)) + char saveBuf[SAVE_SZ]; + + if( pParse->nErr ) return; + assert( pParse->nested<10 ); /* Nesting should only be of limited depth */ + va_start(ap, zFormat); + zSql = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + if( zSql==0 ){ + return; /* A malloc must have failed */ + } + pParse->nested++; + memcpy(saveBuf, &pParse->nVar, SAVE_SZ); + memset(&pParse->nVar, 0, SAVE_SZ); + sqlite3RunParser(pParse, zSql, &zErrMsg); + sqlite3DbFree(db, zErrMsg); + sqlite3DbFree(db, zSql); + memcpy(&pParse->nVar, saveBuf, SAVE_SZ); + pParse->nested--; +} + +#if SQLITE_USER_AUTHENTICATION +/* +** Return TRUE if zTable is the name of the system table that stores the +** list of users and their access credentials. +*/ +SQLITE_PRIVATE int sqlite3UserAuthTable(const char *zTable){ + return sqlite3_stricmp(zTable, "sqlite_user")==0; +} +#endif + +/* +** Locate the in-memory structure that describes a particular database +** table given the name of that table and (optionally) the name of the +** database containing the table. Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the table and the +** first matching table is returned. (No checking for duplicate table +** names is done.) The search order is TEMP first, then MAIN, then any +** auxiliary databases added using the ATTACH command. +** +** See also sqlite3LocateTable(). +*/ +SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){ + Table *p = 0; + int i; + + /* All mutexes are required for schema access. Make sure we hold them. */ + assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) ); +#if SQLITE_USER_AUTHENTICATION + /* Only the admin user is allowed to know that the sqlite_user table + ** exists */ + if( db->auth.authLevelnDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue; + assert( sqlite3SchemaMutexHeld(db, j, 0) ); + p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName); + if( p ) break; + } + return p; +} + +/* +** Locate the in-memory structure that describes a particular database +** table given the name of that table and (optionally) the name of the +** database containing the table. Return NULL if not found. Also leave an +** error message in pParse->zErrMsg. +** +** The difference between this routine and sqlite3FindTable() is that this +** routine leaves an error message in pParse->zErrMsg where +** sqlite3FindTable() does not. +*/ +SQLITE_PRIVATE Table *sqlite3LocateTable( + Parse *pParse, /* context in which to report errors */ + int isView, /* True if looking for a VIEW rather than a TABLE */ + const char *zName, /* Name of the table we are looking for */ + const char *zDbase /* Name of the database. Might be NULL */ +){ + Table *p; + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return 0; + } + + p = sqlite3FindTable(pParse->db, zName, zDbase); + if( p==0 ){ + const char *zMsg = isView ? "no such view" : "no such table"; +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( sqlite3FindDbName(pParse->db, zDbase)<1 ){ + /* If zName is the not the name of a table in the schema created using + ** CREATE, then check to see if it is the name of an virtual table that + ** can be an eponymous virtual table. */ + Module *pMod = (Module*)sqlite3HashFind(&pParse->db->aModule, zName); + if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){ + return pMod->pEpoTab; + } + } +#endif + if( zDbase ){ + sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName); + }else{ + sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName); + } + pParse->checkSchema = 1; + } +#if SQLITE_USER_AUTHENTICATION + else if( pParse->db->auth.authLevelpSchema) if it is not NULL. p->pSchema may be +** non-NULL if it is part of a view or trigger program definition. See +** sqlite3FixSrcList() for details. +*/ +SQLITE_PRIVATE Table *sqlite3LocateTableItem( + Parse *pParse, + int isView, + struct SrcList_item *p +){ + const char *zDb; + assert( p->pSchema==0 || p->zDatabase==0 ); + if( p->pSchema ){ + int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema); + zDb = pParse->db->aDb[iDb].zName; + }else{ + zDb = p->zDatabase; + } + return sqlite3LocateTable(pParse, isView, p->zName, zDb); +} + +/* +** Locate the in-memory structure that describes +** a particular index given the name of that index +** and the name of the database that contains the index. +** Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the +** table and the first matching index is returned. (No checking +** for duplicate index names is done.) The search order is +** TEMP first, then MAIN, then any auxiliary databases added +** using the ATTACH command. +*/ +SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){ + Index *p = 0; + int i; + /* All mutexes are required for schema access. Make sure we hold them. */ + assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) ); + for(i=OMIT_TEMPDB; inDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + Schema *pSchema = db->aDb[j].pSchema; + assert( pSchema ); + if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue; + assert( sqlite3SchemaMutexHeld(db, j, 0) ); + p = sqlite3HashFind(&pSchema->idxHash, zName); + if( p ) break; + } + return p; +} + +/* +** Reclaim the memory used by an index +*/ +static void freeIndex(sqlite3 *db, Index *p){ +#ifndef SQLITE_OMIT_ANALYZE + sqlite3DeleteIndexSamples(db, p); +#endif + sqlite3ExprDelete(db, p->pPartIdxWhere); + sqlite3ExprListDelete(db, p->aColExpr); + sqlite3DbFree(db, p->zColAff); + if( p->isResized ) sqlite3DbFree(db, p->azColl); +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + sqlite3_free(p->aiRowEst); +#endif + sqlite3DbFree(db, p); +} + +/* +** For the index called zIdxName which is found in the database iDb, +** unlike that index from its Table then remove the index from +** the index hash table and free all memory structures associated +** with the index. +*/ +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){ + Index *pIndex; + Hash *pHash; + + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pHash = &db->aDb[iDb].pSchema->idxHash; + pIndex = sqlite3HashInsert(pHash, zIdxName, 0); + if( ALWAYS(pIndex) ){ + if( pIndex->pTable->pIndex==pIndex ){ + pIndex->pTable->pIndex = pIndex->pNext; + }else{ + Index *p; + /* Justification of ALWAYS(); The index must be on the list of + ** indices. */ + p = pIndex->pTable->pIndex; + while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; } + if( ALWAYS(p && p->pNext==pIndex) ){ + p->pNext = pIndex->pNext; + } + } + freeIndex(db, pIndex); + } + db->flags |= SQLITE_InternChanges; +} + +/* +** Look through the list of open database files in db->aDb[] and if +** any have been closed, remove them from the list. Reallocate the +** db->aDb[] structure to a smaller size, if possible. +** +** Entry 0 (the "main" database) and entry 1 (the "temp" database) +** are never candidates for being collapsed. +*/ +SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3 *db){ + int i, j; + for(i=j=2; inDb; i++){ + struct Db *pDb = &db->aDb[i]; + if( pDb->pBt==0 ){ + sqlite3DbFree(db, pDb->zName); + pDb->zName = 0; + continue; + } + if( jaDb[j] = db->aDb[i]; + } + j++; + } + memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j])); + db->nDb = j; + if( db->nDb<=2 && db->aDb!=db->aDbStatic ){ + memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0])); + sqlite3DbFree(db, db->aDb); + db->aDb = db->aDbStatic; + } +} + +/* +** Reset the schema for the database at index iDb. Also reset the +** TEMP schema. +*/ +SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){ + Db *pDb; + assert( iDbnDb ); + + /* Case 1: Reset the single schema identified by iDb */ + pDb = &db->aDb[iDb]; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + assert( pDb->pSchema!=0 ); + sqlite3SchemaClear(pDb->pSchema); + + /* If any database other than TEMP is reset, then also reset TEMP + ** since TEMP might be holding triggers that reference tables in the + ** other database. + */ + if( iDb!=1 ){ + pDb = &db->aDb[1]; + assert( pDb->pSchema!=0 ); + sqlite3SchemaClear(pDb->pSchema); + } + return; +} + +/* +** Erase all schema information from all attached databases (including +** "main" and "temp") for a single database connection. +*/ +SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){ + int i; + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Db *pDb = &db->aDb[i]; + if( pDb->pSchema ){ + sqlite3SchemaClear(pDb->pSchema); + } + } + db->flags &= ~SQLITE_InternChanges; + sqlite3VtabUnlockList(db); + sqlite3BtreeLeaveAll(db); + sqlite3CollapseDatabaseArray(db); +} + +/* +** This routine is called when a commit occurs. +*/ +SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){ + db->flags &= ~SQLITE_InternChanges; +} + +/* +** Delete memory allocated for the column names of a table or view (the +** Table.aCol[] array). +*/ +SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){ + int i; + Column *pCol; + assert( pTable!=0 ); + if( (pCol = pTable->aCol)!=0 ){ + for(i=0; inCol; i++, pCol++){ + sqlite3DbFree(db, pCol->zName); + sqlite3ExprDelete(db, pCol->pDflt); + sqlite3DbFree(db, pCol->zDflt); + sqlite3DbFree(db, pCol->zType); + sqlite3DbFree(db, pCol->zColl); + } + sqlite3DbFree(db, pTable->aCol); + } +} + +/* +** Remove the memory data structures associated with the given +** Table. No changes are made to disk by this routine. +** +** This routine just deletes the data structure. It does not unlink +** the table data structure from the hash table. But it does destroy +** memory structures of the indices and foreign keys associated with +** the table. +** +** The db parameter is optional. It is needed if the Table object +** contains lookaside memory. (Table objects in the schema do not use +** lookaside memory, but some ephemeral Table objects do.) Or the +** db parameter can be used with db->pnBytesFreed to measure the memory +** used by the Table object. +*/ +SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3 *db, Table *pTable){ + Index *pIndex, *pNext; + TESTONLY( int nLookaside; ) /* Used to verify lookaside not used for schema */ + + assert( !pTable || pTable->nRef>0 ); + + /* Do not delete the table until the reference count reaches zero. */ + if( !pTable ) return; + if( ((!db || db->pnBytesFreed==0) && (--pTable->nRef)>0) ) return; + + /* Record the number of outstanding lookaside allocations in schema Tables + ** prior to doing any free() operations. Since schema Tables do not use + ** lookaside, this number should not change. */ + TESTONLY( nLookaside = (db && (pTable->tabFlags & TF_Ephemeral)==0) ? + db->lookaside.nOut : 0 ); + + /* Delete all indices associated with this table. */ + for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){ + pNext = pIndex->pNext; + assert( pIndex->pSchema==pTable->pSchema ); + if( !db || db->pnBytesFreed==0 ){ + char *zName = pIndex->zName; + TESTONLY ( Index *pOld = ) sqlite3HashInsert( + &pIndex->pSchema->idxHash, zName, 0 + ); + assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) ); + assert( pOld==pIndex || pOld==0 ); + } + freeIndex(db, pIndex); + } + + /* Delete any foreign keys attached to this table. */ + sqlite3FkDelete(db, pTable); + + /* Delete the Table structure itself. + */ + sqlite3DeleteColumnNames(db, pTable); + sqlite3DbFree(db, pTable->zName); + sqlite3DbFree(db, pTable->zColAff); + sqlite3SelectDelete(db, pTable->pSelect); + sqlite3ExprListDelete(db, pTable->pCheck); +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3VtabClear(db, pTable); +#endif + sqlite3DbFree(db, pTable); + + /* Verify that no lookaside memory was used by schema tables */ + assert( nLookaside==0 || nLookaside==db->lookaside.nOut ); +} + +/* +** Unlink the given table from the hash tables and the delete the +** table structure with all its indices and foreign keys. +*/ +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){ + Table *p; + Db *pDb; + + assert( db!=0 ); + assert( iDb>=0 && iDbnDb ); + assert( zTabName ); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */ + pDb = &db->aDb[iDb]; + p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0); + sqlite3DeleteTable(db, p); + db->flags |= SQLITE_InternChanges; +} + +/* +** Given a token, return a string that consists of the text of that +** token. Space to hold the returned string +** is obtained from sqliteMalloc() and must be freed by the calling +** function. +** +** Any quotation marks (ex: "name", 'name', [name], or `name`) that +** surround the body of the token are removed. +** +** Tokens are often just pointers into the original SQL text and so +** are not \000 terminated and are not persistent. The returned string +** is \000 terminated and is persistent. +*/ +SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, Token *pName){ + char *zName; + if( pName ){ + zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n); + sqlite3Dequote(zName); + }else{ + zName = 0; + } + return zName; +} + +/* +** Open the sqlite_master table stored in database number iDb for +** writing. The table is opened using cursor 0. +*/ +SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *p, int iDb){ + Vdbe *v = sqlite3GetVdbe(p); + sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb)); + sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, MASTER_ROOT, iDb, 5); + if( p->nTab==0 ){ + p->nTab = 1; + } +} + +/* +** Parameter zName points to a nul-terminated buffer containing the name +** of a database ("main", "temp" or the name of an attached db). This +** function returns the index of the named database in db->aDb[], or +** -1 if the named db cannot be found. +*/ +SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){ + int i = -1; /* Database number */ + if( zName ){ + Db *pDb; + int n = sqlite3Strlen30(zName); + for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){ + if( (!OMIT_TEMPDB || i!=1 ) && n==sqlite3Strlen30(pDb->zName) && + 0==sqlite3StrICmp(pDb->zName, zName) ){ + break; + } + } + } + return i; +} + +/* +** The token *pName contains the name of a database (either "main" or +** "temp" or the name of an attached db). This routine returns the +** index of the named database in db->aDb[], or -1 if the named db +** does not exist. +*/ +SQLITE_PRIVATE int sqlite3FindDb(sqlite3 *db, Token *pName){ + int i; /* Database number */ + char *zName; /* Name we are searching for */ + zName = sqlite3NameFromToken(db, pName); + i = sqlite3FindDbName(db, zName); + sqlite3DbFree(db, zName); + return i; +} + +/* The table or view or trigger name is passed to this routine via tokens +** pName1 and pName2. If the table name was fully qualified, for example: +** +** CREATE TABLE xxx.yyy (...); +** +** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if +** the table name is not fully qualified, i.e.: +** +** CREATE TABLE yyy(...); +** +** Then pName1 is set to "yyy" and pName2 is "". +** +** This routine sets the *ppUnqual pointer to point at the token (pName1 or +** pName2) that stores the unqualified table name. The index of the +** database "xxx" is returned. +*/ +SQLITE_PRIVATE int sqlite3TwoPartName( + Parse *pParse, /* Parsing and code generating context */ + Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */ + Token *pName2, /* The "yyy" in the name "xxx.yyy" */ + Token **pUnqual /* Write the unqualified object name here */ +){ + int iDb; /* Database holding the object */ + sqlite3 *db = pParse->db; + + if( ALWAYS(pName2!=0) && pName2->n>0 ){ + if( db->init.busy ) { + sqlite3ErrorMsg(pParse, "corrupt database"); + return -1; + } + *pUnqual = pName2; + iDb = sqlite3FindDb(db, pName1); + if( iDb<0 ){ + sqlite3ErrorMsg(pParse, "unknown database %T", pName1); + return -1; + } + }else{ + assert( db->init.iDb==0 || db->init.busy ); + iDb = db->init.iDb; + *pUnqual = pName1; + } + return iDb; +} + +/* +** This routine is used to check if the UTF-8 string zName is a legal +** unqualified name for a new schema object (table, index, view or +** trigger). All names are legal except those that begin with the string +** "sqlite_" (in upper, lower or mixed case). This portion of the namespace +** is reserved for internal use. +*/ +SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *pParse, const char *zName){ + if( !pParse->db->init.busy && pParse->nested==0 + && (pParse->db->flags & SQLITE_WriteSchema)==0 + && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){ + sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName); + return SQLITE_ERROR; + } + return SQLITE_OK; +} + +/* +** Return the PRIMARY KEY index of a table +*/ +SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table *pTab){ + Index *p; + for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){} + return p; +} + +/* +** Return the column of index pIdx that corresponds to table +** column iCol. Return -1 if not found. +*/ +SQLITE_PRIVATE i16 sqlite3ColumnOfIndex(Index *pIdx, i16 iCol){ + int i; + for(i=0; inColumn; i++){ + if( iCol==pIdx->aiColumn[i] ) return i; + } + return -1; +} + +/* +** Begin constructing a new table representation in memory. This is +** the first of several action routines that get called in response +** to a CREATE TABLE statement. In particular, this routine is called +** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp +** flag is true if the table should be stored in the auxiliary database +** file instead of in the main database file. This is normally the case +** when the "TEMP" or "TEMPORARY" keyword occurs in between +** CREATE and TABLE. +** +** The new table record is initialized and put in pParse->pNewTable. +** As more of the CREATE TABLE statement is parsed, additional action +** routines will be called to add more information to this record. +** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine +** is called to complete the construction of the new table record. +*/ +SQLITE_PRIVATE void sqlite3StartTable( + Parse *pParse, /* Parser context */ + Token *pName1, /* First part of the name of the table or view */ + Token *pName2, /* Second part of the name of the table or view */ + int isTemp, /* True if this is a TEMP table */ + int isView, /* True if this is a VIEW */ + int isVirtual, /* True if this is a VIRTUAL table */ + int noErr /* Do nothing if table already exists */ +){ + Table *pTable; + char *zName = 0; /* The name of the new table */ + sqlite3 *db = pParse->db; + Vdbe *v; + int iDb; /* Database number to create the table in */ + Token *pName; /* Unqualified name of the table to create */ + + /* The table or view name to create is passed to this routine via tokens + ** pName1 and pName2. If the table name was fully qualified, for example: + ** + ** CREATE TABLE xxx.yyy (...); + ** + ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if + ** the table name is not fully qualified, i.e.: + ** + ** CREATE TABLE yyy(...); + ** + ** Then pName1 is set to "yyy" and pName2 is "". + ** + ** The call below sets the pName pointer to point at the token (pName1 or + ** pName2) that stores the unqualified table name. The variable iDb is + ** set to the index of the database that the table or view is to be + ** created in. + */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ) return; + if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){ + /* If creating a temp table, the name may not be qualified. Unless + ** the database name is "temp" anyway. */ + sqlite3ErrorMsg(pParse, "temporary table name must be unqualified"); + return; + } + if( !OMIT_TEMPDB && isTemp ) iDb = 1; + + pParse->sNameToken = *pName; + zName = sqlite3NameFromToken(db, pName); + if( zName==0 ) return; + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ + goto begin_table_error; + } + if( db->init.iDb==1 ) isTemp = 1; +#ifndef SQLITE_OMIT_AUTHORIZATION + assert( (isTemp & 1)==isTemp ); + { + int code; + char *zDb = db->aDb[iDb].zName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){ + goto begin_table_error; + } + if( isView ){ + if( !OMIT_TEMPDB && isTemp ){ + code = SQLITE_CREATE_TEMP_VIEW; + }else{ + code = SQLITE_CREATE_VIEW; + } + }else{ + if( !OMIT_TEMPDB && isTemp ){ + code = SQLITE_CREATE_TEMP_TABLE; + }else{ + code = SQLITE_CREATE_TABLE; + } + } + if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){ + goto begin_table_error; + } + } +#endif + + /* Make sure the new table name does not collide with an existing + ** index or table name in the same database. Issue an error message if + ** it does. The exception is if the statement being parsed was passed + ** to an sqlite3_declare_vtab() call. In that case only the column names + ** and types will be used, so there is no need to test for namespace + ** collisions. + */ + if( !IN_DECLARE_VTAB ){ + char *zDb = db->aDb[iDb].zName; + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto begin_table_error; + } + pTable = sqlite3FindTable(db, zName, zDb); + if( pTable ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "table %T already exists", pName); + }else{ + assert( !db->init.busy || CORRUPT_DB ); + sqlite3CodeVerifySchema(pParse, iDb); + } + goto begin_table_error; + } + if( sqlite3FindIndex(db, zName, zDb)!=0 ){ + sqlite3ErrorMsg(pParse, "there is already an index named %s", zName); + goto begin_table_error; + } + } + + pTable = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTable==0 ){ + db->mallocFailed = 1; + pParse->rc = SQLITE_NOMEM; + pParse->nErr++; + goto begin_table_error; + } + pTable->zName = zName; + pTable->iPKey = -1; + pTable->pSchema = db->aDb[iDb].pSchema; + pTable->nRef = 1; + pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); + assert( pParse->pNewTable==0 ); + pParse->pNewTable = pTable; + + /* If this is the magic sqlite_sequence table used by autoincrement, + ** then record a pointer to this table in the main database structure + ** so that INSERT can find the table easily. + */ +#ifndef SQLITE_OMIT_AUTOINCREMENT + if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pTable->pSchema->pSeqTab = pTable; + } +#endif + + /* Begin generating the code that will insert the table record into + ** the SQLITE_MASTER table. Note in particular that we must go ahead + ** and allocate the record number for the table entry now. Before any + ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause + ** indices to be created and the table record must come before the + ** indices. Hence, the record number for the table must be allocated + ** now. + */ + if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){ + int addr1; + int fileFormat; + int reg1, reg2, reg3; + /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */ + static const char nullRow[] = { 6, 0, 0, 0, 0, 0 }; + sqlite3BeginWriteOperation(pParse, 1, iDb); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( isVirtual ){ + sqlite3VdbeAddOp0(v, OP_VBegin); + } +#endif + + /* If the file format and encoding in the database have not been set, + ** set them now. + */ + reg1 = pParse->regRowid = ++pParse->nMem; + reg2 = pParse->regRoot = ++pParse->nMem; + reg3 = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT); + sqlite3VdbeUsesBtree(v, iDb); + addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v); + fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ? + 1 : SQLITE_MAX_FILE_FORMAT; + sqlite3VdbeAddOp2(v, OP_Integer, fileFormat, reg3); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, reg3); + sqlite3VdbeAddOp2(v, OP_Integer, ENC(db), reg3); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, reg3); + sqlite3VdbeJumpHere(v, addr1); + + /* This just creates a place-holder record in the sqlite_master table. + ** The record created does not contain anything yet. It will be replaced + ** by the real entry in code generated at sqlite3EndTable(). + ** + ** The rowid for the new entry is left in register pParse->regRowid. + ** The root page number of the new table is left in reg pParse->regRoot. + ** The rowid and root page number values are needed by the code that + ** sqlite3EndTable will generate. + */ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) + if( isView || isVirtual ){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2); + }else +#endif + { + pParse->addrCrTab = sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2); + } + sqlite3OpenMasterTable(pParse, iDb); + sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1); + sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC); + sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3VdbeAddOp0(v, OP_Close); + } + + /* Normal (non-error) return. */ + return; + + /* If an error occurs, we jump here */ +begin_table_error: + sqlite3DbFree(db, zName); + return; +} + +/* +** This macro is used to compare two strings in a case-insensitive manner. +** It is slightly faster than calling sqlite3StrICmp() directly, but +** produces larger code. +** +** WARNING: This macro is not compatible with the strcmp() family. It +** returns true if the two strings are equal, otherwise false. +*/ +#define STRICMP(x, y) (\ +sqlite3UpperToLower[*(unsigned char *)(x)]== \ +sqlite3UpperToLower[*(unsigned char *)(y)] \ +&& sqlite3StrICmp((x)+1,(y)+1)==0 ) + +/* +** Add a new column to the table currently being constructed. +** +** The parser calls this routine once for each column declaration +** in a CREATE TABLE statement. sqlite3StartTable() gets called +** first to get things going. Then this routine is called for each +** column. +*/ +SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token *pName){ + Table *p; + int i; + char *z; + Column *pCol; + sqlite3 *db = pParse->db; + if( (p = pParse->pNewTable)==0 ) return; +#if SQLITE_MAX_COLUMN + if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName); + return; + } +#endif + z = sqlite3NameFromToken(db, pName); + if( z==0 ) return; + for(i=0; inCol; i++){ + if( STRICMP(z, p->aCol[i].zName) ){ + sqlite3ErrorMsg(pParse, "duplicate column name: %s", z); + sqlite3DbFree(db, z); + return; + } + } + if( (p->nCol & 0x7)==0 ){ + Column *aNew; + aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0])); + if( aNew==0 ){ + sqlite3DbFree(db, z); + return; + } + p->aCol = aNew; + } + pCol = &p->aCol[p->nCol]; + memset(pCol, 0, sizeof(p->aCol[0])); + pCol->zName = z; + + /* If there is no type specified, columns have the default affinity + ** 'BLOB'. If there is a type specified, then sqlite3AddColumnType() will + ** be called next to set pCol->affinity correctly. + */ + pCol->affinity = SQLITE_AFF_BLOB; + pCol->szEst = 1; + p->nCol++; +} + +/* +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. A "NOT NULL" constraint has +** been seen on a column. This routine sets the notNull flag on +** the column currently under construction. +*/ +SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){ + Table *p; + p = pParse->pNewTable; + if( p==0 || NEVER(p->nCol<1) ) return; + p->aCol[p->nCol-1].notNull = (u8)onError; +} + +/* +** Scan the column type name zType (length nType) and return the +** associated affinity type. +** +** This routine does a case-independent search of zType for the +** substrings in the following table. If one of the substrings is +** found, the corresponding affinity is returned. If zType contains +** more than one of the substrings, entries toward the top of +** the table take priority. For example, if zType is 'BLOBINT', +** SQLITE_AFF_INTEGER is returned. +** +** Substring | Affinity +** -------------------------------- +** 'INT' | SQLITE_AFF_INTEGER +** 'CHAR' | SQLITE_AFF_TEXT +** 'CLOB' | SQLITE_AFF_TEXT +** 'TEXT' | SQLITE_AFF_TEXT +** 'BLOB' | SQLITE_AFF_BLOB +** 'REAL' | SQLITE_AFF_REAL +** 'FLOA' | SQLITE_AFF_REAL +** 'DOUB' | SQLITE_AFF_REAL +** +** If none of the substrings in the above table are found, +** SQLITE_AFF_NUMERIC is returned. +*/ +SQLITE_PRIVATE char sqlite3AffinityType(const char *zIn, u8 *pszEst){ + u32 h = 0; + char aff = SQLITE_AFF_NUMERIC; + const char *zChar = 0; + + if( zIn==0 ) return aff; + while( zIn[0] ){ + h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff]; + zIn++; + if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */ + aff = SQLITE_AFF_TEXT; + zChar = zIn; + }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */ + && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){ + aff = SQLITE_AFF_BLOB; + if( zIn[0]=='(' ) zChar = zIn; +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; + }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; + }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; +#endif + }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */ + aff = SQLITE_AFF_INTEGER; + break; + } + } + + /* If pszEst is not NULL, store an estimate of the field size. The + ** estimate is scaled so that the size of an integer is 1. */ + if( pszEst ){ + *pszEst = 1; /* default size is approx 4 bytes */ + if( aff255 ) v = 255; + *pszEst = v; /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */ + break; + } + zChar++; + } + }else{ + *pszEst = 5; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/ + } + } + } + return aff; +} + +/* +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. The pFirst token is the first +** token in the sequence of tokens that describe the type of the +** column currently under construction. pLast is the last token +** in the sequence. Use this information to construct a string +** that contains the typename of the column and store that string +** in zType. +*/ +SQLITE_PRIVATE void sqlite3AddColumnType(Parse *pParse, Token *pType){ + Table *p; + Column *pCol; + + p = pParse->pNewTable; + if( p==0 || NEVER(p->nCol<1) ) return; + pCol = &p->aCol[p->nCol-1]; + assert( pCol->zType==0 || CORRUPT_DB ); + sqlite3DbFree(pParse->db, pCol->zType); + pCol->zType = sqlite3NameFromToken(pParse->db, pType); + pCol->affinity = sqlite3AffinityType(pCol->zType, &pCol->szEst); +} + +/* +** The expression is the default value for the most recently added column +** of the table currently under construction. +** +** Default value expressions must be constant. Raise an exception if this +** is not the case. +** +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. +*/ +SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){ + Table *p; + Column *pCol; + sqlite3 *db = pParse->db; + p = pParse->pNewTable; + if( p!=0 ){ + pCol = &(p->aCol[p->nCol-1]); + if( !sqlite3ExprIsConstantOrFunction(pSpan->pExpr, db->init.busy) ){ + sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant", + pCol->zName); + }else{ + /* A copy of pExpr is used instead of the original, as pExpr contains + ** tokens that point to volatile memory. The 'span' of the expression + ** is required by pragma table_info. + */ + sqlite3ExprDelete(db, pCol->pDflt); + pCol->pDflt = sqlite3ExprDup(db, pSpan->pExpr, EXPRDUP_REDUCE); + sqlite3DbFree(db, pCol->zDflt); + pCol->zDflt = sqlite3DbStrNDup(db, (char*)pSpan->zStart, + (int)(pSpan->zEnd - pSpan->zStart)); + } + } + sqlite3ExprDelete(db, pSpan->pExpr); +} + +/* +** Backwards Compatibility Hack: +** +** Historical versions of SQLite accepted strings as column names in +** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example: +** +** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim) +** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC); +** +** This is goofy. But to preserve backwards compatibility we continue to +** accept it. This routine does the necessary conversion. It converts +** the expression given in its argument from a TK_STRING into a TK_ID +** if the expression is just a TK_STRING with an optional COLLATE clause. +** If the epxression is anything other than TK_STRING, the expression is +** unchanged. +*/ +static void sqlite3StringToId(Expr *p){ + if( p->op==TK_STRING ){ + p->op = TK_ID; + }else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){ + p->pLeft->op = TK_ID; + } +} + +/* +** Designate the PRIMARY KEY for the table. pList is a list of names +** of columns that form the primary key. If pList is NULL, then the +** most recently added column of the table is the primary key. +** +** A table can have at most one primary key. If the table already has +** a primary key (and this is the second primary key) then create an +** error. +** +** If the PRIMARY KEY is on a single column whose datatype is INTEGER, +** then we will try to use that column as the rowid. Set the Table.iPKey +** field of the table under construction to be the index of the +** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is +** no INTEGER PRIMARY KEY. +** +** If the key is not an INTEGER PRIMARY KEY, then create a unique +** index for the key. No index is created for INTEGER PRIMARY KEYs. +*/ +SQLITE_PRIVATE void sqlite3AddPrimaryKey( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List of field names to be indexed */ + int onError, /* What to do with a uniqueness conflict */ + int autoInc, /* True if the AUTOINCREMENT keyword is present */ + int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */ +){ + Table *pTab = pParse->pNewTable; + char *zType = 0; + int iCol = -1, i; + int nTerm; + if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit; + if( pTab->tabFlags & TF_HasPrimaryKey ){ + sqlite3ErrorMsg(pParse, + "table \"%s\" has more than one primary key", pTab->zName); + goto primary_key_exit; + } + pTab->tabFlags |= TF_HasPrimaryKey; + if( pList==0 ){ + iCol = pTab->nCol - 1; + pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY; + zType = pTab->aCol[iCol].zType; + nTerm = 1; + }else{ + nTerm = pList->nExpr; + for(i=0; ia[i].pExpr); + assert( pCExpr!=0 ); + sqlite3StringToId(pCExpr); + if( pCExpr->op==TK_ID ){ + const char *zCName = pCExpr->u.zToken; + for(iCol=0; iColnCol; iCol++){ + if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){ + pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY; + zType = pTab->aCol[iCol].zType; + break; + } + } + } + } + } + if( nTerm==1 + && zType && sqlite3StrICmp(zType, "INTEGER")==0 + && sortOrder!=SQLITE_SO_DESC + ){ + pTab->iPKey = iCol; + pTab->keyConf = (u8)onError; + assert( autoInc==0 || autoInc==1 ); + pTab->tabFlags |= autoInc*TF_Autoincrement; + if( pList ) pParse->iPkSortOrder = pList->a[0].sortOrder; + }else if( autoInc ){ +#ifndef SQLITE_OMIT_AUTOINCREMENT + sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an " + "INTEGER PRIMARY KEY"); +#endif + }else{ + Index *p; + p = sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, + 0, sortOrder, 0); + if( p ){ + p->idxType = SQLITE_IDXTYPE_PRIMARYKEY; + } + pList = 0; + } + +primary_key_exit: + sqlite3ExprListDelete(pParse->db, pList); + return; +} + +/* +** Add a new CHECK constraint to the table currently under construction. +*/ +SQLITE_PRIVATE void sqlite3AddCheckConstraint( + Parse *pParse, /* Parsing context */ + Expr *pCheckExpr /* The check expression */ +){ +#ifndef SQLITE_OMIT_CHECK + Table *pTab = pParse->pNewTable; + sqlite3 *db = pParse->db; + if( pTab && !IN_DECLARE_VTAB + && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt) + ){ + pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr); + if( pParse->constraintName.n ){ + sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1); + } + }else +#endif + { + sqlite3ExprDelete(pParse->db, pCheckExpr); + } +} + +/* +** Set the collation function of the most recently parsed table column +** to the CollSeq given. +*/ +SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){ + Table *p; + int i; + char *zColl; /* Dequoted name of collation sequence */ + sqlite3 *db; + + if( (p = pParse->pNewTable)==0 ) return; + i = p->nCol-1; + db = pParse->db; + zColl = sqlite3NameFromToken(db, pToken); + if( !zColl ) return; + + if( sqlite3LocateCollSeq(pParse, zColl) ){ + Index *pIdx; + sqlite3DbFree(db, p->aCol[i].zColl); + p->aCol[i].zColl = zColl; + + /* If the column is declared as " PRIMARY KEY COLLATE ", + ** then an index may have been created on this column before the + ** collation type was added. Correct this if it is the case. + */ + for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->nKeyCol==1 ); + if( pIdx->aiColumn[0]==i ){ + pIdx->azColl[0] = p->aCol[i].zColl; + } + } + }else{ + sqlite3DbFree(db, zColl); + } +} + +/* +** This function returns the collation sequence for database native text +** encoding identified by the string zName, length nName. +** +** If the requested collation sequence is not available, or not available +** in the database native encoding, the collation factory is invoked to +** request it. If the collation factory does not supply such a sequence, +** and the sequence is available in another text encoding, then that is +** returned instead. +** +** If no versions of the requested collations sequence are available, or +** another error occurs, NULL is returned and an error message written into +** pParse. +** +** This routine is a wrapper around sqlite3FindCollSeq(). This routine +** invokes the collation factory if the named collation cannot be found +** and generates an error message. +** +** See also: sqlite3FindCollSeq(), sqlite3GetCollSeq() +*/ +SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){ + sqlite3 *db = pParse->db; + u8 enc = ENC(db); + u8 initbusy = db->init.busy; + CollSeq *pColl; + + pColl = sqlite3FindCollSeq(db, enc, zName, initbusy); + if( !initbusy && (!pColl || !pColl->xCmp) ){ + pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName); + } + + return pColl; +} + + +/* +** Generate code that will increment the schema cookie. +** +** The schema cookie is used to determine when the schema for the +** database changes. After each schema change, the cookie value +** changes. When a process first reads the schema it records the +** cookie. Thereafter, whenever it goes to access the database, +** it checks the cookie to make sure the schema has not changed +** since it was last read. +** +** This plan is not completely bullet-proof. It is possible for +** the schema to change multiple times and for the cookie to be +** set back to prior value. But schema changes are infrequent +** and the probability of hitting the same cookie value is only +** 1 chance in 2^32. So we're safe enough. +*/ +SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){ + int r1 = sqlite3GetTempReg(pParse); + sqlite3 *db = pParse->db; + Vdbe *v = pParse->pVdbe; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + sqlite3VdbeAddOp2(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, r1); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION, r1); + sqlite3ReleaseTempReg(pParse, r1); +} + +/* +** Measure the number of characters needed to output the given +** identifier. The number returned includes any quotes used +** but does not include the null terminator. +** +** The estimate is conservative. It might be larger that what is +** really needed. +*/ +static int identLength(const char *z){ + int n; + for(n=0; *z; n++, z++){ + if( *z=='"' ){ n++; } + } + return n + 2; +} + +/* +** The first parameter is a pointer to an output buffer. The second +** parameter is a pointer to an integer that contains the offset at +** which to write into the output buffer. This function copies the +** nul-terminated string pointed to by the third parameter, zSignedIdent, +** to the specified offset in the buffer and updates *pIdx to refer +** to the first byte after the last byte written before returning. +** +** If the string zSignedIdent consists entirely of alpha-numeric +** characters, does not begin with a digit and is not an SQL keyword, +** then it is copied to the output buffer exactly as it is. Otherwise, +** it is quoted using double-quotes. +*/ +static void identPut(char *z, int *pIdx, char *zSignedIdent){ + unsigned char *zIdent = (unsigned char*)zSignedIdent; + int i, j, needQuote; + i = *pIdx; + + for(j=0; zIdent[j]; j++){ + if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break; + } + needQuote = sqlite3Isdigit(zIdent[0]) + || sqlite3KeywordCode(zIdent, j)!=TK_ID + || zIdent[j]!=0 + || j==0; + + if( needQuote ) z[i++] = '"'; + for(j=0; zIdent[j]; j++){ + z[i++] = zIdent[j]; + if( zIdent[j]=='"' ) z[i++] = '"'; + } + if( needQuote ) z[i++] = '"'; + z[i] = 0; + *pIdx = i; +} + +/* +** Generate a CREATE TABLE statement appropriate for the given +** table. Memory to hold the text of the statement is obtained +** from sqliteMalloc() and must be freed by the calling function. +*/ +static char *createTableStmt(sqlite3 *db, Table *p){ + int i, k, n; + char *zStmt; + char *zSep, *zSep2, *zEnd; + Column *pCol; + n = 0; + for(pCol = p->aCol, i=0; inCol; i++, pCol++){ + n += identLength(pCol->zName) + 5; + } + n += identLength(p->zName); + if( n<50 ){ + zSep = ""; + zSep2 = ","; + zEnd = ")"; + }else{ + zSep = "\n "; + zSep2 = ",\n "; + zEnd = "\n)"; + } + n += 35 + 6*p->nCol; + zStmt = sqlite3DbMallocRaw(0, n); + if( zStmt==0 ){ + db->mallocFailed = 1; + return 0; + } + sqlite3_snprintf(n, zStmt, "CREATE TABLE "); + k = sqlite3Strlen30(zStmt); + identPut(zStmt, &k, p->zName); + zStmt[k++] = '('; + for(pCol=p->aCol, i=0; inCol; i++, pCol++){ + static const char * const azType[] = { + /* SQLITE_AFF_BLOB */ "", + /* SQLITE_AFF_TEXT */ " TEXT", + /* SQLITE_AFF_NUMERIC */ " NUM", + /* SQLITE_AFF_INTEGER */ " INT", + /* SQLITE_AFF_REAL */ " REAL" + }; + int len; + const char *zType; + + sqlite3_snprintf(n-k, &zStmt[k], zSep); + k += sqlite3Strlen30(&zStmt[k]); + zSep = zSep2; + identPut(zStmt, &k, pCol->zName); + assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 ); + assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) ); + testcase( pCol->affinity==SQLITE_AFF_BLOB ); + testcase( pCol->affinity==SQLITE_AFF_TEXT ); + testcase( pCol->affinity==SQLITE_AFF_NUMERIC ); + testcase( pCol->affinity==SQLITE_AFF_INTEGER ); + testcase( pCol->affinity==SQLITE_AFF_REAL ); + + zType = azType[pCol->affinity - SQLITE_AFF_BLOB]; + len = sqlite3Strlen30(zType); + assert( pCol->affinity==SQLITE_AFF_BLOB + || pCol->affinity==sqlite3AffinityType(zType, 0) ); + memcpy(&zStmt[k], zType, len); + k += len; + assert( k<=n ); + } + sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd); + return zStmt; +} + +/* +** Resize an Index object to hold N columns total. Return SQLITE_OK +** on success and SQLITE_NOMEM on an OOM error. +*/ +static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){ + char *zExtra; + int nByte; + if( pIdx->nColumn>=N ) return SQLITE_OK; + assert( pIdx->isResized==0 ); + nByte = (sizeof(char*) + sizeof(i16) + 1)*N; + zExtra = sqlite3DbMallocZero(db, nByte); + if( zExtra==0 ) return SQLITE_NOMEM; + memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn); + pIdx->azColl = (char**)zExtra; + zExtra += sizeof(char*)*N; + memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn); + pIdx->aiColumn = (i16*)zExtra; + zExtra += sizeof(i16)*N; + memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn); + pIdx->aSortOrder = (u8*)zExtra; + pIdx->nColumn = N; + pIdx->isResized = 1; + return SQLITE_OK; +} + +/* +** Estimate the total row width for a table. +*/ +static void estimateTableWidth(Table *pTab){ + unsigned wTable = 0; + const Column *pTabCol; + int i; + for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){ + wTable += pTabCol->szEst; + } + if( pTab->iPKey<0 ) wTable++; + pTab->szTabRow = sqlite3LogEst(wTable*4); +} + +/* +** Estimate the average size of a row for an index. +*/ +static void estimateIndexWidth(Index *pIdx){ + unsigned wIndex = 0; + int i; + const Column *aCol = pIdx->pTable->aCol; + for(i=0; inColumn; i++){ + i16 x = pIdx->aiColumn[i]; + assert( xpTable->nCol ); + wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst; + } + pIdx->szIdxRow = sqlite3LogEst(wIndex*4); +} + +/* Return true if value x is found any of the first nCol entries of aiCol[] +*/ +static int hasColumn(const i16 *aiCol, int nCol, int x){ + while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1; + return 0; +} + +/* +** This routine runs at the end of parsing a CREATE TABLE statement that +** has a WITHOUT ROWID clause. The job of this routine is to convert both +** internal schema data structures and the generated VDBE code so that they +** are appropriate for a WITHOUT ROWID table instead of a rowid table. +** Changes include: +** +** (1) Convert the OP_CreateTable into an OP_CreateIndex. There is +** no rowid btree for a WITHOUT ROWID. Instead, the canonical +** data storage is a covering index btree. +** (2) Bypass the creation of the sqlite_master table entry +** for the PRIMARY KEY as the primary key index is now +** identified by the sqlite_master table entry of the table itself. +** (3) Set the Index.tnum of the PRIMARY KEY Index object in the +** schema to the rootpage from the main table. +** (4) Set all columns of the PRIMARY KEY schema object to be NOT NULL. +** (5) Add all table columns to the PRIMARY KEY Index object +** so that the PRIMARY KEY is a covering index. The surplus +** columns are part of KeyInfo.nXField and are not used for +** sorting or lookup or uniqueness checks. +** (6) Replace the rowid tail on all automatically generated UNIQUE +** indices with the PRIMARY KEY columns. +*/ +static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){ + Index *pIdx; + Index *pPk; + int nPk; + int i, j; + sqlite3 *db = pParse->db; + Vdbe *v = pParse->pVdbe; + + /* Convert the OP_CreateTable opcode that would normally create the + ** root-page for the table into an OP_CreateIndex opcode. The index + ** created will become the PRIMARY KEY index. + */ + if( pParse->addrCrTab ){ + assert( v ); + sqlite3VdbeChangeOpcode(v, pParse->addrCrTab, OP_CreateIndex); + } + + /* Locate the PRIMARY KEY index. Or, if this table was originally + ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index. + */ + if( pTab->iPKey>=0 ){ + ExprList *pList; + Token ipkToken; + ipkToken.z = pTab->aCol[pTab->iPKey].zName; + ipkToken.n = sqlite3Strlen30(ipkToken.z); + pList = sqlite3ExprListAppend(pParse, 0, + sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0)); + if( pList==0 ) return; + pList->a[0].sortOrder = pParse->iPkSortOrder; + assert( pParse->pNewTable==pTab ); + pPk = sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0); + if( pPk==0 ) return; + pPk->idxType = SQLITE_IDXTYPE_PRIMARYKEY; + pTab->iPKey = -1; + }else{ + pPk = sqlite3PrimaryKeyIndex(pTab); + + /* Bypass the creation of the PRIMARY KEY btree and the sqlite_master + ** table entry. This is only required if currently generating VDBE + ** code for a CREATE TABLE (not when parsing one as part of reading + ** a database schema). */ + if( v ){ + assert( db->init.busy==0 ); + sqlite3VdbeChangeOpcode(v, pPk->tnum, OP_Goto); + } + + /* + ** Remove all redundant columns from the PRIMARY KEY. For example, change + ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later + ** code assumes the PRIMARY KEY contains no repeated columns. + */ + for(i=j=1; inKeyCol; i++){ + if( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) ){ + pPk->nColumn--; + }else{ + pPk->aiColumn[j++] = pPk->aiColumn[i]; + } + } + pPk->nKeyCol = j; + } + pPk->isCovering = 1; + assert( pPk!=0 ); + nPk = pPk->nKeyCol; + + /* Make sure every column of the PRIMARY KEY is NOT NULL. (Except, + ** do not enforce this for imposter tables.) */ + if( !db->init.imposterTable ){ + for(i=0; iaCol[pPk->aiColumn[i]].notNull = 1; + } + pPk->uniqNotNull = 1; + } + + /* The root page of the PRIMARY KEY is the table root page */ + pPk->tnum = pTab->tnum; + + /* Update the in-memory representation of all UNIQUE indices by converting + ** the final rowid column into one or more columns of the PRIMARY KEY. + */ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int n; + if( IsPrimaryKeyIndex(pIdx) ) continue; + for(i=n=0; iaiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ) n++; + } + if( n==0 ){ + /* This index is a superset of the primary key */ + pIdx->nColumn = pIdx->nKeyCol; + continue; + } + if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return; + for(i=0, j=pIdx->nKeyCol; iaiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ){ + pIdx->aiColumn[j] = pPk->aiColumn[i]; + pIdx->azColl[j] = pPk->azColl[i]; + j++; + } + } + assert( pIdx->nColumn>=pIdx->nKeyCol+n ); + assert( pIdx->nColumn>=j ); + } + + /* Add all table columns to the PRIMARY KEY index + */ + if( nPknCol ){ + if( resizeIndexObject(db, pPk, pTab->nCol) ) return; + for(i=0, j=nPk; inCol; i++){ + if( !hasColumn(pPk->aiColumn, j, i) ){ + assert( jnColumn ); + pPk->aiColumn[j] = i; + pPk->azColl[j] = "BINARY"; + j++; + } + } + assert( pPk->nColumn==j ); + assert( pTab->nCol==j ); + }else{ + pPk->nColumn = pTab->nCol; + } +} + +/* +** This routine is called to report the final ")" that terminates +** a CREATE TABLE statement. +** +** The table structure that other action routines have been building +** is added to the internal hash tables, assuming no errors have +** occurred. +** +** An entry for the table is made in the master table on disk, unless +** this is a temporary table or db->init.busy==1. When db->init.busy==1 +** it means we are reading the sqlite_master table because we just +** connected to the database or because the sqlite_master table has +** recently changed, so the entry for this table already exists in +** the sqlite_master table. We do not want to create it again. +** +** If the pSelect argument is not NULL, it means that this routine +** was called to create a table generated from a +** "CREATE TABLE ... AS SELECT ..." statement. The column names of +** the new table will match the result set of the SELECT. +*/ +SQLITE_PRIVATE void sqlite3EndTable( + Parse *pParse, /* Parse context */ + Token *pCons, /* The ',' token after the last column defn. */ + Token *pEnd, /* The ')' before options in the CREATE TABLE */ + u8 tabOpts, /* Extra table options. Usually 0. */ + Select *pSelect /* Select from a "CREATE ... AS SELECT" */ +){ + Table *p; /* The new table */ + sqlite3 *db = pParse->db; /* The database connection */ + int iDb; /* Database in which the table lives */ + Index *pIdx; /* An implied index of the table */ + + if( pEnd==0 && pSelect==0 ){ + return; + } + assert( !db->mallocFailed ); + p = pParse->pNewTable; + if( p==0 ) return; + + assert( !db->init.busy || !pSelect ); + + /* If the db->init.busy is 1 it means we are reading the SQL off the + ** "sqlite_master" or "sqlite_temp_master" table on the disk. + ** So do not write to the disk again. Extract the root page number + ** for the table from the db->init.newTnum field. (The page number + ** should have been put there by the sqliteOpenCb routine.) + */ + if( db->init.busy ){ + p->tnum = db->init.newTnum; + } + + /* Special processing for WITHOUT ROWID Tables */ + if( tabOpts & TF_WithoutRowid ){ + if( (p->tabFlags & TF_Autoincrement) ){ + sqlite3ErrorMsg(pParse, + "AUTOINCREMENT not allowed on WITHOUT ROWID tables"); + return; + } + if( (p->tabFlags & TF_HasPrimaryKey)==0 ){ + sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName); + }else{ + p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid; + convertToWithoutRowidTable(pParse, p); + } + } + + iDb = sqlite3SchemaToIndex(db, p->pSchema); + +#ifndef SQLITE_OMIT_CHECK + /* Resolve names in all CHECK constraint expressions. + */ + if( p->pCheck ){ + sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck); + } +#endif /* !defined(SQLITE_OMIT_CHECK) */ + + /* Estimate the average row size for the table and for all implied indices */ + estimateTableWidth(p); + for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ + estimateIndexWidth(pIdx); + } + + /* If not initializing, then create a record for the new table + ** in the SQLITE_MASTER table of the database. + ** + ** If this is a TEMPORARY table, write the entry into the auxiliary + ** file instead of into the main database file. + */ + if( !db->init.busy ){ + int n; + Vdbe *v; + char *zType; /* "view" or "table" */ + char *zType2; /* "VIEW" or "TABLE" */ + char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */ + + v = sqlite3GetVdbe(pParse); + if( NEVER(v==0) ) return; + + sqlite3VdbeAddOp1(v, OP_Close, 0); + + /* + ** Initialize zType for the new view or table. + */ + if( p->pSelect==0 ){ + /* A regular table */ + zType = "table"; + zType2 = "TABLE"; +#ifndef SQLITE_OMIT_VIEW + }else{ + /* A view */ + zType = "view"; + zType2 = "VIEW"; +#endif + } + + /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT + ** statement to populate the new table. The root-page number for the + ** new table is in register pParse->regRoot. + ** + ** Once the SELECT has been coded by sqlite3Select(), it is in a + ** suitable state to query for the column names and types to be used + ** by the new table. + ** + ** A shared-cache write-lock is not required to write to the new table, + ** as a schema-lock must have already been obtained to create it. Since + ** a schema-lock excludes all other database users, the write-lock would + ** be redundant. + */ + if( pSelect ){ + SelectDest dest; /* Where the SELECT should store results */ + int regYield; /* Register holding co-routine entry-point */ + int addrTop; /* Top of the co-routine */ + int regRec; /* A record to be insert into the new table */ + int regRowid; /* Rowid of the next row to insert */ + int addrInsLoop; /* Top of the loop for inserting rows */ + Table *pSelTab; /* A table that describes the SELECT results */ + + regYield = ++pParse->nMem; + regRec = ++pParse->nMem; + regRowid = ++pParse->nMem; + assert(pParse->nTab==1); + sqlite3MayAbort(pParse); + sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb); + sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG); + pParse->nTab = 2; + addrTop = sqlite3VdbeCurrentAddr(v) + 1; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop); + sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield); + sqlite3Select(pParse, pSelect, &dest); + sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield); + sqlite3VdbeJumpHere(v, addrTop - 1); + if( pParse->nErr ) return; + pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect); + if( pSelTab==0 ) return; + assert( p->aCol==0 ); + p->nCol = pSelTab->nCol; + p->aCol = pSelTab->aCol; + pSelTab->nCol = 0; + pSelTab->aCol = 0; + sqlite3DeleteTable(db, pSelTab); + addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec); + sqlite3TableAffinity(v, p, 0); + sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid); + sqlite3VdbeGoto(v, addrInsLoop); + sqlite3VdbeJumpHere(v, addrInsLoop); + sqlite3VdbeAddOp1(v, OP_Close, 1); + } + + /* Compute the complete text of the CREATE statement */ + if( pSelect ){ + zStmt = createTableStmt(db, p); + }else{ + Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd; + n = (int)(pEnd2->z - pParse->sNameToken.z); + if( pEnd2->z[0]!=';' ) n += pEnd2->n; + zStmt = sqlite3MPrintf(db, + "CREATE %s %.*s", zType2, n, pParse->sNameToken.z + ); + } + + /* A slot for the record has already been allocated in the + ** SQLITE_MASTER table. We just need to update that slot with all + ** the information we've collected. + */ + sqlite3NestedParse(pParse, + "UPDATE %Q.%s " + "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q " + "WHERE rowid=#%d", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), + zType, + p->zName, + p->zName, + pParse->regRoot, + zStmt, + pParse->regRowid + ); + sqlite3DbFree(db, zStmt); + sqlite3ChangeCookie(pParse, iDb); + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Check to see if we need to create an sqlite_sequence table for + ** keeping track of autoincrement keys. + */ + if( p->tabFlags & TF_Autoincrement ){ + Db *pDb = &db->aDb[iDb]; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( pDb->pSchema->pSeqTab==0 ){ + sqlite3NestedParse(pParse, + "CREATE TABLE %Q.sqlite_sequence(name,seq)", + pDb->zName + ); + } + } +#endif + + /* Reparse everything to update our internal data structures */ + sqlite3VdbeAddParseSchemaOp(v, iDb, + sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName)); + } + + + /* Add the table to the in-memory representation of the database. + */ + if( db->init.busy ){ + Table *pOld; + Schema *pSchema = p->pSchema; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p); + if( pOld ){ + assert( p==pOld ); /* Malloc must have failed inside HashInsert() */ + db->mallocFailed = 1; + return; + } + pParse->pNewTable = 0; + db->flags |= SQLITE_InternChanges; + +#ifndef SQLITE_OMIT_ALTERTABLE + if( !p->pSelect ){ + const char *zName = (const char *)pParse->sNameToken.z; + int nName; + assert( !pSelect && pCons && pEnd ); + if( pCons->z==0 ){ + pCons = pEnd; + } + nName = (int)((const char *)pCons->z - zName); + p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName); + } +#endif + } +} + +#ifndef SQLITE_OMIT_VIEW +/* +** The parser calls this routine in order to create a new VIEW +*/ +SQLITE_PRIVATE void sqlite3CreateView( + Parse *pParse, /* The parsing context */ + Token *pBegin, /* The CREATE token that begins the statement */ + Token *pName1, /* The token that holds the name of the view */ + Token *pName2, /* The token that holds the name of the view */ + ExprList *pCNames, /* Optional list of view column names */ + Select *pSelect, /* A SELECT statement that will become the new view */ + int isTemp, /* TRUE for a TEMPORARY view */ + int noErr /* Suppress error messages if VIEW already exists */ +){ + Table *p; + int n; + const char *z; + Token sEnd; + DbFixer sFix; + Token *pName = 0; + int iDb; + sqlite3 *db = pParse->db; + + if( pParse->nVar>0 ){ + sqlite3ErrorMsg(pParse, "parameters are not allowed in views"); + goto create_view_fail; + } + sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr); + p = pParse->pNewTable; + if( p==0 || pParse->nErr ) goto create_view_fail; + sqlite3TwoPartName(pParse, pName1, pName2, &pName); + iDb = sqlite3SchemaToIndex(db, p->pSchema); + sqlite3FixInit(&sFix, pParse, iDb, "view", pName); + if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail; + + /* Make a copy of the entire SELECT statement that defines the view. + ** This will force all the Expr.token.z values to be dynamically + ** allocated rather than point to the input string - which means that + ** they will persist after the current sqlite3_exec() call returns. + */ + p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); + p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE); + if( db->mallocFailed ) goto create_view_fail; + + /* Locate the end of the CREATE VIEW statement. Make sEnd point to + ** the end. + */ + sEnd = pParse->sLastToken; + assert( sEnd.z[0]!=0 ); + if( sEnd.z[0]!=';' ){ + sEnd.z += sEnd.n; + } + sEnd.n = 0; + n = (int)(sEnd.z - pBegin->z); + assert( n>0 ); + z = pBegin->z; + while( sqlite3Isspace(z[n-1]) ){ n--; } + sEnd.z = &z[n-1]; + sEnd.n = 1; + + /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */ + sqlite3EndTable(pParse, 0, &sEnd, 0, 0); + +create_view_fail: + sqlite3SelectDelete(db, pSelect); + sqlite3ExprListDelete(db, pCNames); + return; +} +#endif /* SQLITE_OMIT_VIEW */ + +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) +/* +** The Table structure pTable is really a VIEW. Fill in the names of +** the columns of the view in the pTable structure. Return the number +** of errors. If an error is seen leave an error message in pParse->zErrMsg. +*/ +SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){ + Table *pSelTab; /* A fake table from which we get the result set */ + Select *pSel; /* Copy of the SELECT that implements the view */ + int nErr = 0; /* Number of errors encountered */ + int n; /* Temporarily holds the number of cursors assigned */ + sqlite3 *db = pParse->db; /* Database connection for malloc errors */ + sqlite3_xauth xAuth; /* Saved xAuth pointer */ + u8 bEnabledLA; /* Saved db->lookaside.bEnabled state */ + + assert( pTable ); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( sqlite3VtabCallConnect(pParse, pTable) ){ + return SQLITE_ERROR; + } + if( IsVirtual(pTable) ) return 0; +#endif + +#ifndef SQLITE_OMIT_VIEW + /* A positive nCol means the columns names for this view are + ** already known. + */ + if( pTable->nCol>0 ) return 0; + + /* A negative nCol is a special marker meaning that we are currently + ** trying to compute the column names. If we enter this routine with + ** a negative nCol, it means two or more views form a loop, like this: + ** + ** CREATE VIEW one AS SELECT * FROM two; + ** CREATE VIEW two AS SELECT * FROM one; + ** + ** Actually, the error above is now caught prior to reaching this point. + ** But the following test is still important as it does come up + ** in the following: + ** + ** CREATE TABLE main.ex1(a); + ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1; + ** SELECT * FROM temp.ex1; + */ + if( pTable->nCol<0 ){ + sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName); + return 1; + } + assert( pTable->nCol>=0 ); + + /* If we get this far, it means we need to compute the table names. + ** Note that the call to sqlite3ResultSetOfSelect() will expand any + ** "*" elements in the results set of the view and will assign cursors + ** to the elements of the FROM clause. But we do not want these changes + ** to be permanent. So the computation is done on a copy of the SELECT + ** statement that defines the view. + */ + assert( pTable->pSelect ); + bEnabledLA = db->lookaside.bEnabled; + if( pTable->pCheck ){ + db->lookaside.bEnabled = 0; + sqlite3ColumnsFromExprList(pParse, pTable->pCheck, + &pTable->nCol, &pTable->aCol); + }else{ + pSel = sqlite3SelectDup(db, pTable->pSelect, 0); + if( pSel ){ + n = pParse->nTab; + sqlite3SrcListAssignCursors(pParse, pSel->pSrc); + pTable->nCol = -1; + db->lookaside.bEnabled = 0; +#ifndef SQLITE_OMIT_AUTHORIZATION + xAuth = db->xAuth; + db->xAuth = 0; + pSelTab = sqlite3ResultSetOfSelect(pParse, pSel); + db->xAuth = xAuth; +#else + pSelTab = sqlite3ResultSetOfSelect(pParse, pSel); +#endif + pParse->nTab = n; + if( pSelTab ){ + assert( pTable->aCol==0 ); + pTable->nCol = pSelTab->nCol; + pTable->aCol = pSelTab->aCol; + pSelTab->nCol = 0; + pSelTab->aCol = 0; + sqlite3DeleteTable(db, pSelTab); + assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) ); + }else{ + pTable->nCol = 0; + nErr++; + } + sqlite3SelectDelete(db, pSel); + } else { + nErr++; + } + } + db->lookaside.bEnabled = bEnabledLA; + pTable->pSchema->schemaFlags |= DB_UnresetViews; +#endif /* SQLITE_OMIT_VIEW */ + return nErr; +} +#endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */ + +#ifndef SQLITE_OMIT_VIEW +/* +** Clear the column names from every VIEW in database idx. +*/ +static void sqliteViewResetAll(sqlite3 *db, int idx){ + HashElem *i; + assert( sqlite3SchemaMutexHeld(db, idx, 0) ); + if( !DbHasProperty(db, idx, DB_UnresetViews) ) return; + for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){ + Table *pTab = sqliteHashData(i); + if( pTab->pSelect ){ + sqlite3DeleteColumnNames(db, pTab); + pTab->aCol = 0; + pTab->nCol = 0; + } + } + DbClearProperty(db, idx, DB_UnresetViews); +} +#else +# define sqliteViewResetAll(A,B) +#endif /* SQLITE_OMIT_VIEW */ + +/* +** This function is called by the VDBE to adjust the internal schema +** used by SQLite when the btree layer moves a table root page. The +** root-page of a table or index in database iDb has changed from iFrom +** to iTo. +** +** Ticket #1728: The symbol table might still contain information +** on tables and/or indices that are the process of being deleted. +** If you are unlucky, one of those deleted indices or tables might +** have the same rootpage number as the real table or index that is +** being moved. So we cannot stop searching after the first match +** because the first match might be for one of the deleted indices +** or tables and not the table/index that is actually being moved. +** We must continue looping until all tables and indices with +** rootpage==iFrom have been converted to have a rootpage of iTo +** in order to be certain that we got the right one. +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iTo){ + HashElem *pElem; + Hash *pHash; + Db *pDb; + + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pDb = &db->aDb[iDb]; + pHash = &pDb->pSchema->tblHash; + for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = sqliteHashData(pElem); + if( pTab->tnum==iFrom ){ + pTab->tnum = iTo; + } + } + pHash = &pDb->pSchema->idxHash; + for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){ + Index *pIdx = sqliteHashData(pElem); + if( pIdx->tnum==iFrom ){ + pIdx->tnum = iTo; + } + } +} +#endif + +/* +** Write code to erase the table with root-page iTable from database iDb. +** Also write code to modify the sqlite_master table and internal schema +** if a root-page of another table is moved by the btree-layer whilst +** erasing iTable (this can happen with an auto-vacuum database). +*/ +static void destroyRootPage(Parse *pParse, int iTable, int iDb){ + Vdbe *v = sqlite3GetVdbe(pParse); + int r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb); + sqlite3MayAbort(pParse); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* OP_Destroy stores an in integer r1. If this integer + ** is non-zero, then it is the root page number of a table moved to + ** location iTable. The following code modifies the sqlite_master table to + ** reflect this. + ** + ** The "#NNN" in the SQL is a special constant that means whatever value + ** is in register NNN. See grammar rules associated with the TK_REGISTER + ** token for additional information. + */ + sqlite3NestedParse(pParse, + "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d", + pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1); +#endif + sqlite3ReleaseTempReg(pParse, r1); +} + +/* +** Write VDBE code to erase table pTab and all associated indices on disk. +** Code to update the sqlite_master tables and internal schema definitions +** in case a root-page belonging to another table is moved by the btree layer +** is also added (this can happen with an auto-vacuum database). +*/ +static void destroyTable(Parse *pParse, Table *pTab){ +#ifdef SQLITE_OMIT_AUTOVACUUM + Index *pIdx; + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + destroyRootPage(pParse, pTab->tnum, iDb); + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + destroyRootPage(pParse, pIdx->tnum, iDb); + } +#else + /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM + ** is not defined), then it is important to call OP_Destroy on the + ** table and index root-pages in order, starting with the numerically + ** largest root-page number. This guarantees that none of the root-pages + ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the + ** following were coded: + ** + ** OP_Destroy 4 0 + ** ... + ** OP_Destroy 5 0 + ** + ** and root page 5 happened to be the largest root-page number in the + ** database, then root page 5 would be moved to page 4 by the + ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit + ** a free-list page. + */ + int iTab = pTab->tnum; + int iDestroyed = 0; + + while( 1 ){ + Index *pIdx; + int iLargest = 0; + + if( iDestroyed==0 || iTabpIndex; pIdx; pIdx=pIdx->pNext){ + int iIdx = pIdx->tnum; + assert( pIdx->pSchema==pTab->pSchema ); + if( (iDestroyed==0 || (iIdxiLargest ){ + iLargest = iIdx; + } + } + if( iLargest==0 ){ + return; + }else{ + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + assert( iDb>=0 && iDbdb->nDb ); + destroyRootPage(pParse, iLargest, iDb); + iDestroyed = iLargest; + } + } +#endif +} + +/* +** Remove entries from the sqlite_statN tables (for N in (1,2,3)) +** after a DROP INDEX or DROP TABLE command. +*/ +static void sqlite3ClearStatTables( + Parse *pParse, /* The parsing context */ + int iDb, /* The database number */ + const char *zType, /* "idx" or "tbl" */ + const char *zName /* Name of index or table */ +){ + int i; + const char *zDbName = pParse->db->aDb[iDb].zName; + for(i=1; i<=4; i++){ + char zTab[24]; + sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i); + if( sqlite3FindTable(pParse->db, zTab, zDbName) ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE %s=%Q", + zDbName, zTab, zType, zName + ); + } + } +} + +/* +** Generate code to drop a table. +*/ +SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){ + Vdbe *v; + sqlite3 *db = pParse->db; + Trigger *pTrigger; + Db *pDb = &db->aDb[iDb]; + + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + sqlite3BeginWriteOperation(pParse, 1, iDb); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3VdbeAddOp0(v, OP_VBegin); + } +#endif + + /* Drop all triggers associated with the table being dropped. Code + ** is generated to remove entries from sqlite_master and/or + ** sqlite_temp_master if required. + */ + pTrigger = sqlite3TriggerList(pParse, pTab); + while( pTrigger ){ + assert( pTrigger->pSchema==pTab->pSchema || + pTrigger->pSchema==db->aDb[1].pSchema ); + sqlite3DropTriggerPtr(pParse, pTrigger); + pTrigger = pTrigger->pNext; + } + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Remove any entries of the sqlite_sequence table associated with + ** the table being dropped. This is done before the table is dropped + ** at the btree level, in case the sqlite_sequence table needs to + ** move as a result of the drop (can happen in auto-vacuum mode). + */ + if( pTab->tabFlags & TF_Autoincrement ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.sqlite_sequence WHERE name=%Q", + pDb->zName, pTab->zName + ); + } +#endif + + /* Drop all SQLITE_MASTER table and index entries that refer to the + ** table. The program name loops through the master table and deletes + ** every row that refers to a table of the same name as the one being + ** dropped. Triggers are handled separately because a trigger can be + ** created in the temp database that refers to a table in another + ** database. + */ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'", + pDb->zName, SCHEMA_TABLE(iDb), pTab->zName); + if( !isView && !IsVirtual(pTab) ){ + destroyTable(pParse, pTab); + } + + /* Remove the table entry from SQLite's internal schema and modify + ** the schema cookie. + */ + if( IsVirtual(pTab) ){ + sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0); + } + sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0); + sqlite3ChangeCookie(pParse, iDb); + sqliteViewResetAll(db, iDb); +} + +/* +** This routine is called to do the work of a DROP TABLE statement. +** pName is the name of the table to be dropped. +*/ +SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){ + Table *pTab; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + if( db->mallocFailed ){ + goto exit_drop_table; + } + assert( pParse->nErr==0 ); + assert( pName->nSrc==1 ); + if( sqlite3ReadSchema(pParse) ) goto exit_drop_table; + if( noErr ) db->suppressErr++; + pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]); + if( noErr ) db->suppressErr--; + + if( pTab==0 ){ + if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase); + goto exit_drop_table; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 && iDbnDb ); + + /* If pTab is a virtual table, call ViewGetColumnNames() to ensure + ** it is initialized. + */ + if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto exit_drop_table; + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code; + const char *zTab = SCHEMA_TABLE(iDb); + const char *zDb = db->aDb[iDb].zName; + const char *zArg2 = 0; + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){ + goto exit_drop_table; + } + if( isView ){ + if( !OMIT_TEMPDB && iDb==1 ){ + code = SQLITE_DROP_TEMP_VIEW; + }else{ + code = SQLITE_DROP_VIEW; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + }else if( IsVirtual(pTab) ){ + code = SQLITE_DROP_VTABLE; + zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName; +#endif + }else{ + if( !OMIT_TEMPDB && iDb==1 ){ + code = SQLITE_DROP_TEMP_TABLE; + }else{ + code = SQLITE_DROP_TABLE; + } + } + if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){ + goto exit_drop_table; + } + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){ + goto exit_drop_table; + } + } +#endif + if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 + && sqlite3StrNICmp(pTab->zName, "sqlite_stat", 11)!=0 ){ + sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName); + goto exit_drop_table; + } + +#ifndef SQLITE_OMIT_VIEW + /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used + ** on a table. + */ + if( isView && pTab->pSelect==0 ){ + sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName); + goto exit_drop_table; + } + if( !isView && pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName); + goto exit_drop_table; + } +#endif + + /* Generate code to remove the table from the master table + ** on disk. + */ + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3BeginWriteOperation(pParse, 1, iDb); + sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName); + sqlite3FkDropTable(pParse, pName, pTab); + sqlite3CodeDropTable(pParse, pTab, iDb, isView); + } + +exit_drop_table: + sqlite3SrcListDelete(db, pName); +} + +/* +** This routine is called to create a new foreign key on the table +** currently under construction. pFromCol determines which columns +** in the current table point to the foreign key. If pFromCol==0 then +** connect the key to the last column inserted. pTo is the name of +** the table referred to (a.k.a the "parent" table). pToCol is a list +** of tables in the parent pTo table. flags contains all +** information about the conflict resolution algorithms specified +** in the ON DELETE, ON UPDATE and ON INSERT clauses. +** +** An FKey structure is created and added to the table currently +** under construction in the pParse->pNewTable field. +** +** The foreign key is set for IMMEDIATE processing. A subsequent call +** to sqlite3DeferForeignKey() might change this to DEFERRED. +*/ +SQLITE_PRIVATE void sqlite3CreateForeignKey( + Parse *pParse, /* Parsing context */ + ExprList *pFromCol, /* Columns in this table that point to other table */ + Token *pTo, /* Name of the other table */ + ExprList *pToCol, /* Columns in the other table */ + int flags /* Conflict resolution algorithms. */ +){ + sqlite3 *db = pParse->db; +#ifndef SQLITE_OMIT_FOREIGN_KEY + FKey *pFKey = 0; + FKey *pNextTo; + Table *p = pParse->pNewTable; + int nByte; + int i; + int nCol; + char *z; + + assert( pTo!=0 ); + if( p==0 || IN_DECLARE_VTAB ) goto fk_end; + if( pFromCol==0 ){ + int iCol = p->nCol-1; + if( NEVER(iCol<0) ) goto fk_end; + if( pToCol && pToCol->nExpr!=1 ){ + sqlite3ErrorMsg(pParse, "foreign key on %s" + " should reference only one column of table %T", + p->aCol[iCol].zName, pTo); + goto fk_end; + } + nCol = 1; + }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){ + sqlite3ErrorMsg(pParse, + "number of columns in foreign key does not match the number of " + "columns in the referenced table"); + goto fk_end; + }else{ + nCol = pFromCol->nExpr; + } + nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1; + if( pToCol ){ + for(i=0; inExpr; i++){ + nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1; + } + } + pFKey = sqlite3DbMallocZero(db, nByte ); + if( pFKey==0 ){ + goto fk_end; + } + pFKey->pFrom = p; + pFKey->pNextFrom = p->pFKey; + z = (char*)&pFKey->aCol[nCol]; + pFKey->zTo = z; + memcpy(z, pTo->z, pTo->n); + z[pTo->n] = 0; + sqlite3Dequote(z); + z += pTo->n+1; + pFKey->nCol = nCol; + if( pFromCol==0 ){ + pFKey->aCol[0].iFrom = p->nCol-1; + }else{ + for(i=0; inCol; j++){ + if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){ + pFKey->aCol[i].iFrom = j; + break; + } + } + if( j>=p->nCol ){ + sqlite3ErrorMsg(pParse, + "unknown column \"%s\" in foreign key definition", + pFromCol->a[i].zName); + goto fk_end; + } + } + } + if( pToCol ){ + for(i=0; ia[i].zName); + pFKey->aCol[i].zCol = z; + memcpy(z, pToCol->a[i].zName, n); + z[n] = 0; + z += n+1; + } + } + pFKey->isDeferred = 0; + pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */ + pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */ + + assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) ); + pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash, + pFKey->zTo, (void *)pFKey + ); + if( pNextTo==pFKey ){ + db->mallocFailed = 1; + goto fk_end; + } + if( pNextTo ){ + assert( pNextTo->pPrevTo==0 ); + pFKey->pNextTo = pNextTo; + pNextTo->pPrevTo = pFKey; + } + + /* Link the foreign key to the table as the last step. + */ + p->pFKey = pFKey; + pFKey = 0; + +fk_end: + sqlite3DbFree(db, pFKey); +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + sqlite3ExprListDelete(db, pFromCol); + sqlite3ExprListDelete(db, pToCol); +} + +/* +** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED +** clause is seen as part of a foreign key definition. The isDeferred +** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE. +** The behavior of the most recently created foreign key is adjusted +** accordingly. +*/ +SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){ +#ifndef SQLITE_OMIT_FOREIGN_KEY + Table *pTab; + FKey *pFKey; + if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return; + assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */ + pFKey->isDeferred = (u8)isDeferred; +#endif +} + +/* +** Generate code that will erase and refill index *pIdx. This is +** used to initialize a newly created index or to recompute the +** content of an index in response to a REINDEX command. +** +** if memRootPage is not negative, it means that the index is newly +** created. The register specified by memRootPage contains the +** root page number of the index. If memRootPage is negative, then +** the index already exists and must be cleared before being refilled and +** the root page number of the index is taken from pIndex->tnum. +*/ +static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){ + Table *pTab = pIndex->pTable; /* The table that is indexed */ + int iTab = pParse->nTab++; /* Btree cursor used for pTab */ + int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */ + int iSorter; /* Cursor opened by OpenSorter (if in use) */ + int addr1; /* Address of top of loop */ + int addr2; /* Address to jump to for next iteration */ + int tnum; /* Root page of index */ + int iPartIdxLabel; /* Jump to this label to skip a row */ + Vdbe *v; /* Generate code into this virtual machine */ + KeyInfo *pKey; /* KeyInfo for index */ + int regRecord; /* Register holding assembled index record */ + sqlite3 *db = pParse->db; /* The database connection */ + int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema); + +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0, + db->aDb[iDb].zName ) ){ + return; + } +#endif + + /* Require a write-lock on the table to perform this operation */ + sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName); + + v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + if( memRootPage>=0 ){ + tnum = memRootPage; + }else{ + tnum = pIndex->tnum; + } + pKey = sqlite3KeyInfoOfIndex(pParse, pIndex); + + /* Open the sorter cursor if we are to use one. */ + iSorter = pParse->nTab++; + sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*) + sqlite3KeyInfoRef(pKey), P4_KEYINFO); + + /* Open the table. Loop through all rows of the table, inserting index + ** records into the sorter. */ + sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead); + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v); + regRecord = sqlite3GetTempReg(pParse); + + sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0); + sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord); + sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel); + sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb); + sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb, + (char *)pKey, P4_KEYINFO); + sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0)); + + addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v); + assert( pKey!=0 || db->mallocFailed || pParse->nErr ); + if( IsUniqueIndex(pIndex) && pKey!=0 ){ + int j2 = sqlite3VdbeCurrentAddr(v) + 3; + sqlite3VdbeGoto(v, j2); + addr2 = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord, + pIndex->nKeyCol); VdbeCoverage(v); + sqlite3UniqueConstraint(pParse, OE_Abort, pIndex); + }else{ + addr2 = sqlite3VdbeCurrentAddr(v); + } + sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx); + sqlite3VdbeAddOp3(v, OP_Last, iIdx, 0, -1); + sqlite3VdbeAddOp3(v, OP_IdxInsert, iIdx, regRecord, 0); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + sqlite3ReleaseTempReg(pParse, regRecord); + sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + + sqlite3VdbeAddOp1(v, OP_Close, iTab); + sqlite3VdbeAddOp1(v, OP_Close, iIdx); + sqlite3VdbeAddOp1(v, OP_Close, iSorter); +} + +/* +** Allocate heap space to hold an Index object with nCol columns. +** +** Increase the allocation size to provide an extra nExtra bytes +** of 8-byte aligned space after the Index object and return a +** pointer to this extra space in *ppExtra. +*/ +SQLITE_PRIVATE Index *sqlite3AllocateIndexObject( + sqlite3 *db, /* Database connection */ + i16 nCol, /* Total number of columns in the index */ + int nExtra, /* Number of bytes of extra space to alloc */ + char **ppExtra /* Pointer to the "extra" space */ +){ + Index *p; /* Allocated index object */ + int nByte; /* Bytes of space for Index object + arrays */ + + nByte = ROUND8(sizeof(Index)) + /* Index structure */ + ROUND8(sizeof(char*)*nCol) + /* Index.azColl */ + ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */ + sizeof(i16)*nCol + /* Index.aiColumn */ + sizeof(u8)*nCol); /* Index.aSortOrder */ + p = sqlite3DbMallocZero(db, nByte + nExtra); + if( p ){ + char *pExtra = ((char*)p)+ROUND8(sizeof(Index)); + p->azColl = (char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol); + p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1); + p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol; + p->aSortOrder = (u8*)pExtra; + p->nColumn = nCol; + p->nKeyCol = nCol - 1; + *ppExtra = ((char*)p) + nByte; + } + return p; +} + +/* +** Create a new index for an SQL table. pName1.pName2 is the name of the index +** and pTblList is the name of the table that is to be indexed. Both will +** be NULL for a primary key or an index that is created to satisfy a +** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable +** as the table to be indexed. pParse->pNewTable is a table that is +** currently being constructed by a CREATE TABLE statement. +** +** pList is a list of columns to be indexed. pList will be NULL if this +** is a primary key or unique-constraint on the most recent column added +** to the table currently under construction. +** +** If the index is created successfully, return a pointer to the new Index +** structure. This is used by sqlite3AddPrimaryKey() to mark the index +** as the tables primary key (Index.idxType==SQLITE_IDXTYPE_PRIMARYKEY) +*/ +SQLITE_PRIVATE Index *sqlite3CreateIndex( + Parse *pParse, /* All information about this parse */ + Token *pName1, /* First part of index name. May be NULL */ + Token *pName2, /* Second part of index name. May be NULL */ + SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */ + ExprList *pList, /* A list of columns to be indexed */ + int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + Token *pStart, /* The CREATE token that begins this statement */ + Expr *pPIWhere, /* WHERE clause for partial indices */ + int sortOrder, /* Sort order of primary key when pList==NULL */ + int ifNotExist /* Omit error if index already exists */ +){ + Index *pRet = 0; /* Pointer to return */ + Table *pTab = 0; /* Table to be indexed */ + Index *pIndex = 0; /* The index to be created */ + char *zName = 0; /* Name of the index */ + int nName; /* Number of characters in zName */ + int i, j; + DbFixer sFix; /* For assigning database names to pTable */ + int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */ + sqlite3 *db = pParse->db; + Db *pDb; /* The specific table containing the indexed database */ + int iDb; /* Index of the database that is being written */ + Token *pName = 0; /* Unqualified name of the index to create */ + struct ExprList_item *pListItem; /* For looping over pList */ + int nExtra = 0; /* Space allocated for zExtra[] */ + int nExtraCol; /* Number of extra columns needed */ + char *zExtra = 0; /* Extra space after the Index object */ + Index *pPk = 0; /* PRIMARY KEY index for WITHOUT ROWID tables */ + + if( db->mallocFailed || IN_DECLARE_VTAB || pParse->nErr>0 ){ + goto exit_create_index; + } + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto exit_create_index; + } + + /* + ** Find the table that is to be indexed. Return early if not found. + */ + if( pTblName!=0 ){ + + /* Use the two-part index name to determine the database + ** to search for the table. 'Fix' the table name to this db + ** before looking up the table. + */ + assert( pName1 && pName2 ); + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ) goto exit_create_index; + assert( pName && pName->z ); + +#ifndef SQLITE_OMIT_TEMPDB + /* If the index name was unqualified, check if the table + ** is a temp table. If so, set the database to 1. Do not do this + ** if initialising a database schema. + */ + if( !db->init.busy ){ + pTab = sqlite3SrcListLookup(pParse, pTblName); + if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){ + iDb = 1; + } + } +#endif + + sqlite3FixInit(&sFix, pParse, iDb, "index", pName); + if( sqlite3FixSrcList(&sFix, pTblName) ){ + /* Because the parser constructs pTblName from a single identifier, + ** sqlite3FixSrcList can never fail. */ + assert(0); + } + pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]); + assert( db->mallocFailed==0 || pTab==0 ); + if( pTab==0 ) goto exit_create_index; + if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){ + sqlite3ErrorMsg(pParse, + "cannot create a TEMP index on non-TEMP table \"%s\"", + pTab->zName); + goto exit_create_index; + } + if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab); + }else{ + assert( pName==0 ); + assert( pStart==0 ); + pTab = pParse->pNewTable; + if( !pTab ) goto exit_create_index; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + } + pDb = &db->aDb[iDb]; + + assert( pTab!=0 ); + assert( pParse->nErr==0 ); + if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 + && db->init.busy==0 +#if SQLITE_USER_AUTHENTICATION + && sqlite3UserAuthTable(pTab->zName)==0 +#endif + && sqlite3StrNICmp(&pTab->zName[7],"altertab_",9)!=0 ){ + sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName); + goto exit_create_index; + } +#ifndef SQLITE_OMIT_VIEW + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "views may not be indexed"); + goto exit_create_index; + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "virtual tables may not be indexed"); + goto exit_create_index; + } +#endif + + /* + ** Find the name of the index. Make sure there is not already another + ** index or table with the same name. + ** + ** Exception: If we are reading the names of permanent indices from the + ** sqlite_master table (because some other process changed the schema) and + ** one of the index names collides with the name of a temporary table or + ** index, then we will continue to process this index. + ** + ** If pName==0 it means that we are + ** dealing with a primary key or UNIQUE constraint. We have to invent our + ** own name. + */ + if( pName ){ + zName = sqlite3NameFromToken(db, pName); + if( zName==0 ) goto exit_create_index; + assert( pName->z!=0 ); + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ + goto exit_create_index; + } + if( !db->init.busy ){ + if( sqlite3FindTable(db, zName, 0)!=0 ){ + sqlite3ErrorMsg(pParse, "there is already a table named %s", zName); + goto exit_create_index; + } + } + if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){ + if( !ifNotExist ){ + sqlite3ErrorMsg(pParse, "index %s already exists", zName); + }else{ + assert( !db->init.busy ); + sqlite3CodeVerifySchema(pParse, iDb); + } + goto exit_create_index; + } + }else{ + int n; + Index *pLoop; + for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){} + zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n); + if( zName==0 ){ + goto exit_create_index; + } + } + + /* Check for authorization to create an index. + */ +#ifndef SQLITE_OMIT_AUTHORIZATION + { + const char *zDb = pDb->zName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){ + goto exit_create_index; + } + i = SQLITE_CREATE_INDEX; + if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX; + if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){ + goto exit_create_index; + } + } +#endif + + /* If pList==0, it means this routine was called to make a primary + ** key out of the last column added to the table under construction. + ** So create a fake list to simulate this. + */ + if( pList==0 ){ + Token prevCol; + prevCol.z = pTab->aCol[pTab->nCol-1].zName; + prevCol.n = sqlite3Strlen30(prevCol.z); + pList = sqlite3ExprListAppend(pParse, 0, + sqlite3ExprAlloc(db, TK_ID, &prevCol, 0)); + if( pList==0 ) goto exit_create_index; + assert( pList->nExpr==1 ); + sqlite3ExprListSetSortOrder(pList, sortOrder); + }else{ + sqlite3ExprListCheckLength(pParse, pList, "index"); + } + + /* Figure out how many bytes of space are required to store explicitly + ** specified collation sequence names. + */ + for(i=0; inExpr; i++){ + Expr *pExpr = pList->a[i].pExpr; + assert( pExpr!=0 ); + if( pExpr->op==TK_COLLATE ){ + nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken)); + } + } + + /* + ** Allocate the index structure. + */ + nName = sqlite3Strlen30(zName); + nExtraCol = pPk ? pPk->nKeyCol : 1; + pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol, + nName + nExtra + 1, &zExtra); + if( db->mallocFailed ){ + goto exit_create_index; + } + assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) ); + assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) ); + pIndex->zName = zExtra; + zExtra += nName + 1; + memcpy(pIndex->zName, zName, nName+1); + pIndex->pTable = pTab; + pIndex->onError = (u8)onError; + pIndex->uniqNotNull = onError!=OE_None; + pIndex->idxType = pName ? SQLITE_IDXTYPE_APPDEF : SQLITE_IDXTYPE_UNIQUE; + pIndex->pSchema = db->aDb[iDb].pSchema; + pIndex->nKeyCol = pList->nExpr; + if( pPIWhere ){ + sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0); + pIndex->pPartIdxWhere = pPIWhere; + pPIWhere = 0; + } + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + + /* Check to see if we should honor DESC requests on index columns + */ + if( pDb->pSchema->file_format>=4 ){ + sortOrderMask = -1; /* Honor DESC */ + }else{ + sortOrderMask = 0; /* Ignore DESC */ + } + + /* Analyze the list of expressions that form the terms of the index and + ** report any errors. In the common case where the expression is exactly + ** a table column, store that column in aiColumn[]. For general expressions, + ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[]. + ** + ** TODO: Issue a warning if two or more columns of the index are identical. + ** TODO: Issue a warning if the table primary key is used as part of the + ** index key. + */ + for(i=0, pListItem=pList->a; inExpr; i++, pListItem++){ + Expr *pCExpr; /* The i-th index expression */ + int requestedSortOrder; /* ASC or DESC on the i-th expression */ + char *zColl; /* Collation sequence name */ + + sqlite3StringToId(pListItem->pExpr); + sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0); + if( pParse->nErr ) goto exit_create_index; + pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr); + if( pCExpr->op!=TK_COLUMN ){ + if( pTab==pParse->pNewTable ){ + sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and " + "UNIQUE constraints"); + goto exit_create_index; + } + if( pIndex->aColExpr==0 ){ + ExprList *pCopy = sqlite3ExprListDup(db, pList, 0); + pIndex->aColExpr = pCopy; + if( !db->mallocFailed ){ + assert( pCopy!=0 ); + pListItem = &pCopy->a[i]; + } + } + j = XN_EXPR; + pIndex->aiColumn[i] = XN_EXPR; + pIndex->uniqNotNull = 0; + }else{ + j = pCExpr->iColumn; + assert( j<=0x7fff ); + if( j<0 ){ + j = pTab->iPKey; + }else if( pTab->aCol[j].notNull==0 ){ + pIndex->uniqNotNull = 0; + } + pIndex->aiColumn[i] = (i16)j; + } + zColl = 0; + if( pListItem->pExpr->op==TK_COLLATE ){ + int nColl; + zColl = pListItem->pExpr->u.zToken; + nColl = sqlite3Strlen30(zColl) + 1; + assert( nExtra>=nColl ); + memcpy(zExtra, zColl, nColl); + zColl = zExtra; + zExtra += nColl; + nExtra -= nColl; + }else if( j>=0 ){ + zColl = pTab->aCol[j].zColl; + } + if( !zColl ) zColl = "BINARY"; + if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){ + goto exit_create_index; + } + pIndex->azColl[i] = zColl; + requestedSortOrder = pListItem->sortOrder & sortOrderMask; + pIndex->aSortOrder[i] = (u8)requestedSortOrder; + } + + /* Append the table key to the end of the index. For WITHOUT ROWID + ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For + ** normal tables (when pPk==0) this will be the rowid. + */ + if( pPk ){ + for(j=0; jnKeyCol; j++){ + int x = pPk->aiColumn[j]; + assert( x>=0 ); + if( hasColumn(pIndex->aiColumn, pIndex->nKeyCol, x) ){ + pIndex->nColumn--; + }else{ + pIndex->aiColumn[i] = x; + pIndex->azColl[i] = pPk->azColl[j]; + pIndex->aSortOrder[i] = pPk->aSortOrder[j]; + i++; + } + } + assert( i==pIndex->nColumn ); + }else{ + pIndex->aiColumn[i] = XN_ROWID; + pIndex->azColl[i] = "BINARY"; + } + sqlite3DefaultRowEst(pIndex); + if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex); + + if( pTab==pParse->pNewTable ){ + /* This routine has been called to create an automatic index as a + ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or + ** a PRIMARY KEY or UNIQUE clause following the column definitions. + ** i.e. one of: + ** + ** CREATE TABLE t(x PRIMARY KEY, y); + ** CREATE TABLE t(x, y, UNIQUE(x, y)); + ** + ** Either way, check to see if the table already has such an index. If + ** so, don't bother creating this one. This only applies to + ** automatically created indices. Users can do as they wish with + ** explicit indices. + ** + ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent + ** (and thus suppressing the second one) even if they have different + ** sort orders. + ** + ** If there are different collating sequences or if the columns of + ** the constraint occur in different orders, then the constraints are + ** considered distinct and both result in separate indices. + */ + Index *pIdx; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int k; + assert( IsUniqueIndex(pIdx) ); + assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF ); + assert( IsUniqueIndex(pIndex) ); + + if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue; + for(k=0; knKeyCol; k++){ + const char *z1; + const char *z2; + assert( pIdx->aiColumn[k]>=0 ); + if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break; + z1 = pIdx->azColl[k]; + z2 = pIndex->azColl[k]; + if( z1!=z2 && sqlite3StrICmp(z1, z2) ) break; + } + if( k==pIdx->nKeyCol ){ + if( pIdx->onError!=pIndex->onError ){ + /* This constraint creates the same index as a previous + ** constraint specified somewhere in the CREATE TABLE statement. + ** However the ON CONFLICT clauses are different. If both this + ** constraint and the previous equivalent constraint have explicit + ** ON CONFLICT clauses this is an error. Otherwise, use the + ** explicitly specified behavior for the index. + */ + if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){ + sqlite3ErrorMsg(pParse, + "conflicting ON CONFLICT clauses specified", 0); + } + if( pIdx->onError==OE_Default ){ + pIdx->onError = pIndex->onError; + } + } + pRet = pIdx; + goto exit_create_index; + } + } + } + + /* Link the new Index structure to its table and to the other + ** in-memory database structures. + */ + assert( pParse->nErr==0 ); + if( db->init.busy ){ + Index *p; + assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) ); + p = sqlite3HashInsert(&pIndex->pSchema->idxHash, + pIndex->zName, pIndex); + if( p ){ + assert( p==pIndex ); /* Malloc must have failed */ + db->mallocFailed = 1; + goto exit_create_index; + } + db->flags |= SQLITE_InternChanges; + if( pTblName!=0 ){ + pIndex->tnum = db->init.newTnum; + } + } + + /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the + ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then + ** emit code to allocate the index rootpage on disk and make an entry for + ** the index in the sqlite_master table and populate the index with + ** content. But, do not do this if we are simply reading the sqlite_master + ** table to parse the schema, or if this index is the PRIMARY KEY index + ** of a WITHOUT ROWID table. + ** + ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY + ** or UNIQUE index in a CREATE TABLE statement. Since the table + ** has just been created, it contains no data and the index initialization + ** step can be skipped. + */ + else if( HasRowid(pTab) || pTblName!=0 ){ + Vdbe *v; + char *zStmt; + int iMem = ++pParse->nMem; + + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto exit_create_index; + + sqlite3BeginWriteOperation(pParse, 1, iDb); + + /* Create the rootpage for the index using CreateIndex. But before + ** doing so, code a Noop instruction and store its address in + ** Index.tnum. This is required in case this index is actually a + ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In + ** that case the convertToWithoutRowidTable() routine will replace + ** the Noop with a Goto to jump over the VDBE code generated below. */ + pIndex->tnum = sqlite3VdbeAddOp0(v, OP_Noop); + sqlite3VdbeAddOp2(v, OP_CreateIndex, iDb, iMem); + + /* Gather the complete text of the CREATE INDEX statement into + ** the zStmt variable + */ + if( pStart ){ + int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n; + if( pName->z[n-1]==';' ) n--; + /* A named index with an explicit CREATE INDEX statement */ + zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s", + onError==OE_None ? "" : " UNIQUE", n, pName->z); + }else{ + /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */ + /* zStmt = sqlite3MPrintf(""); */ + zStmt = 0; + } + + /* Add an entry in sqlite_master for this index + */ + sqlite3NestedParse(pParse, + "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#%d,%Q);", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), + pIndex->zName, + pTab->zName, + iMem, + zStmt + ); + sqlite3DbFree(db, zStmt); + + /* Fill the index with data and reparse the schema. Code an OP_Expire + ** to invalidate all pre-compiled statements. + */ + if( pTblName ){ + sqlite3RefillIndex(pParse, pIndex, iMem); + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddParseSchemaOp(v, iDb, + sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName)); + sqlite3VdbeAddOp1(v, OP_Expire, 0); + } + + sqlite3VdbeJumpHere(v, pIndex->tnum); + } + + /* When adding an index to the list of indices for a table, make + ** sure all indices labeled OE_Replace come after all those labeled + ** OE_Ignore. This is necessary for the correct constraint check + ** processing (in sqlite3GenerateConstraintChecks()) as part of + ** UPDATE and INSERT statements. + */ + if( db->init.busy || pTblName==0 ){ + if( onError!=OE_Replace || pTab->pIndex==0 + || pTab->pIndex->onError==OE_Replace){ + pIndex->pNext = pTab->pIndex; + pTab->pIndex = pIndex; + }else{ + Index *pOther = pTab->pIndex; + while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){ + pOther = pOther->pNext; + } + pIndex->pNext = pOther->pNext; + pOther->pNext = pIndex; + } + pRet = pIndex; + pIndex = 0; + } + + /* Clean up before exiting */ +exit_create_index: + if( pIndex ) freeIndex(db, pIndex); + sqlite3ExprDelete(db, pPIWhere); + sqlite3ExprListDelete(db, pList); + sqlite3SrcListDelete(db, pTblName); + sqlite3DbFree(db, zName); + return pRet; +} + +/* +** Fill the Index.aiRowEst[] array with default information - information +** to be used when we have not run the ANALYZE command. +** +** aiRowEst[0] is supposed to contain the number of elements in the index. +** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the +** number of rows in the table that match any particular value of the +** first column of the index. aiRowEst[2] is an estimate of the number +** of rows that match any particular combination of the first 2 columns +** of the index. And so forth. It must always be the case that +* +** aiRowEst[N]<=aiRowEst[N-1] +** aiRowEst[N]>=1 +** +** Apart from that, we have little to go on besides intuition as to +** how aiRowEst[] should be initialized. The numbers generated here +** are based on typical values found in actual indices. +*/ +SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){ + /* 10, 9, 8, 7, 6 */ + LogEst aVal[] = { 33, 32, 30, 28, 26 }; + LogEst *a = pIdx->aiRowLogEst; + int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol); + int i; + + /* Set the first entry (number of rows in the index) to the estimated + ** number of rows in the table. Or 10, if the estimated number of rows + ** in the table is less than that. */ + a[0] = pIdx->pTable->nRowLogEst; + if( a[0]<33 ) a[0] = 33; assert( 33==sqlite3LogEst(10) ); + + /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is + ** 6 and each subsequent value (if any) is 5. */ + memcpy(&a[1], aVal, nCopy*sizeof(LogEst)); + for(i=nCopy+1; i<=pIdx->nKeyCol; i++){ + a[i] = 23; assert( 23==sqlite3LogEst(5) ); + } + + assert( 0==sqlite3LogEst(1) ); + if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0; +} + +/* +** This routine will drop an existing named index. This routine +** implements the DROP INDEX statement. +*/ +SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){ + Index *pIndex; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + assert( pParse->nErr==0 ); /* Never called with prior errors */ + if( db->mallocFailed ){ + goto exit_drop_index; + } + assert( pName->nSrc==1 ); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto exit_drop_index; + } + pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase); + if( pIndex==0 ){ + if( !ifExists ){ + sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0); + }else{ + sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase); + } + pParse->checkSchema = 1; + goto exit_drop_index; + } + if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){ + sqlite3ErrorMsg(pParse, "index associated with UNIQUE " + "or PRIMARY KEY constraint cannot be dropped", 0); + goto exit_drop_index; + } + iDb = sqlite3SchemaToIndex(db, pIndex->pSchema); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code = SQLITE_DROP_INDEX; + Table *pTab = pIndex->pTable; + const char *zDb = db->aDb[iDb].zName; + const char *zTab = SCHEMA_TABLE(iDb); + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ + goto exit_drop_index; + } + if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX; + if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){ + goto exit_drop_index; + } + } +#endif + + /* Generate code to remove the index and from the master table */ + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3BeginWriteOperation(pParse, 1, iDb); + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE name=%Q AND type='index'", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pIndex->zName + ); + sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName); + sqlite3ChangeCookie(pParse, iDb); + destroyRootPage(pParse, pIndex->tnum, iDb); + sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0); + } + +exit_drop_index: + sqlite3SrcListDelete(db, pName); +} + +/* +** pArray is a pointer to an array of objects. Each object in the +** array is szEntry bytes in size. This routine uses sqlite3DbRealloc() +** to extend the array so that there is space for a new object at the end. +** +** When this function is called, *pnEntry contains the current size of +** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes +** in total). +** +** If the realloc() is successful (i.e. if no OOM condition occurs), the +** space allocated for the new object is zeroed, *pnEntry updated to +** reflect the new size of the array and a pointer to the new allocation +** returned. *pIdx is set to the index of the new array entry in this case. +** +** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains +** unchanged and a copy of pArray returned. +*/ +SQLITE_PRIVATE void *sqlite3ArrayAllocate( + sqlite3 *db, /* Connection to notify of malloc failures */ + void *pArray, /* Array of objects. Might be reallocated */ + int szEntry, /* Size of each object in the array */ + int *pnEntry, /* Number of objects currently in use */ + int *pIdx /* Write the index of a new slot here */ +){ + char *z; + int n = *pnEntry; + if( (n & (n-1))==0 ){ + int sz = (n==0) ? 1 : 2*n; + void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry); + if( pNew==0 ){ + *pIdx = -1; + return pArray; + } + pArray = pNew; + } + z = (char*)pArray; + memset(&z[n * szEntry], 0, szEntry); + *pIdx = n; + ++*pnEntry; + return pArray; +} + +/* +** Append a new element to the given IdList. Create a new IdList if +** need be. +** +** A new IdList is returned, or NULL if malloc() fails. +*/ +SQLITE_PRIVATE IdList *sqlite3IdListAppend(sqlite3 *db, IdList *pList, Token *pToken){ + int i; + if( pList==0 ){ + pList = sqlite3DbMallocZero(db, sizeof(IdList) ); + if( pList==0 ) return 0; + } + pList->a = sqlite3ArrayAllocate( + db, + pList->a, + sizeof(pList->a[0]), + &pList->nId, + &i + ); + if( i<0 ){ + sqlite3IdListDelete(db, pList); + return 0; + } + pList->a[i].zName = sqlite3NameFromToken(db, pToken); + return pList; +} + +/* +** Delete an IdList. +*/ +SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3 *db, IdList *pList){ + int i; + if( pList==0 ) return; + for(i=0; inId; i++){ + sqlite3DbFree(db, pList->a[i].zName); + } + sqlite3DbFree(db, pList->a); + sqlite3DbFree(db, pList); +} + +/* +** Return the index in pList of the identifier named zId. Return -1 +** if not found. +*/ +SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){ + int i; + if( pList==0 ) return -1; + for(i=0; inId; i++){ + if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i; + } + return -1; +} + +/* +** Expand the space allocated for the given SrcList object by +** creating nExtra new slots beginning at iStart. iStart is zero based. +** New slots are zeroed. +** +** For example, suppose a SrcList initially contains two entries: A,B. +** To append 3 new entries onto the end, do this: +** +** sqlite3SrcListEnlarge(db, pSrclist, 3, 2); +** +** After the call above it would contain: A, B, nil, nil, nil. +** If the iStart argument had been 1 instead of 2, then the result +** would have been: A, nil, nil, nil, B. To prepend the new slots, +** the iStart value would be 0. The result then would +** be: nil, nil, nil, A, B. +** +** If a memory allocation fails the SrcList is unchanged. The +** db->mallocFailed flag will be set to true. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge( + sqlite3 *db, /* Database connection to notify of OOM errors */ + SrcList *pSrc, /* The SrcList to be enlarged */ + int nExtra, /* Number of new slots to add to pSrc->a[] */ + int iStart /* Index in pSrc->a[] of first new slot */ +){ + int i; + + /* Sanity checking on calling parameters */ + assert( iStart>=0 ); + assert( nExtra>=1 ); + assert( pSrc!=0 ); + assert( iStart<=pSrc->nSrc ); + + /* Allocate additional space if needed */ + if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){ + SrcList *pNew; + int nAlloc = pSrc->nSrc+nExtra; + int nGot; + pNew = sqlite3DbRealloc(db, pSrc, + sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) ); + if( pNew==0 ){ + assert( db->mallocFailed ); + return pSrc; + } + pSrc = pNew; + nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1; + pSrc->nAlloc = nGot; + } + + /* Move existing slots that come after the newly inserted slots + ** out of the way */ + for(i=pSrc->nSrc-1; i>=iStart; i--){ + pSrc->a[i+nExtra] = pSrc->a[i]; + } + pSrc->nSrc += nExtra; + + /* Zero the newly allocated slots */ + memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra); + for(i=iStart; ia[i].iCursor = -1; + } + + /* Return a pointer to the enlarged SrcList */ + return pSrc; +} + + +/* +** Append a new table name to the given SrcList. Create a new SrcList if +** need be. A new entry is created in the SrcList even if pTable is NULL. +** +** A SrcList is returned, or NULL if there is an OOM error. The returned +** SrcList might be the same as the SrcList that was input or it might be +** a new one. If an OOM error does occurs, then the prior value of pList +** that is input to this routine is automatically freed. +** +** If pDatabase is not null, it means that the table has an optional +** database name prefix. Like this: "database.table". The pDatabase +** points to the table name and the pTable points to the database name. +** The SrcList.a[].zName field is filled with the table name which might +** come from pTable (if pDatabase is NULL) or from pDatabase. +** SrcList.a[].zDatabase is filled with the database name from pTable, +** or with NULL if no database is specified. +** +** In other words, if call like this: +** +** sqlite3SrcListAppend(D,A,B,0); +** +** Then B is a table name and the database name is unspecified. If called +** like this: +** +** sqlite3SrcListAppend(D,A,B,C); +** +** Then C is the table name and B is the database name. If C is defined +** then so is B. In other words, we never have a case where: +** +** sqlite3SrcListAppend(D,A,0,C); +** +** Both pTable and pDatabase are assumed to be quoted. They are dequoted +** before being added to the SrcList. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListAppend( + sqlite3 *db, /* Connection to notify of malloc failures */ + SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */ + Token *pTable, /* Table to append */ + Token *pDatabase /* Database of the table */ +){ + struct SrcList_item *pItem; + assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */ + if( pList==0 ){ + pList = sqlite3DbMallocZero(db, sizeof(SrcList) ); + if( pList==0 ) return 0; + pList->nAlloc = 1; + } + pList = sqlite3SrcListEnlarge(db, pList, 1, pList->nSrc); + if( db->mallocFailed ){ + sqlite3SrcListDelete(db, pList); + return 0; + } + pItem = &pList->a[pList->nSrc-1]; + if( pDatabase && pDatabase->z==0 ){ + pDatabase = 0; + } + if( pDatabase ){ + Token *pTemp = pDatabase; + pDatabase = pTable; + pTable = pTemp; + } + pItem->zName = sqlite3NameFromToken(db, pTable); + pItem->zDatabase = sqlite3NameFromToken(db, pDatabase); + return pList; +} + +/* +** Assign VdbeCursor index numbers to all tables in a SrcList +*/ +SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){ + int i; + struct SrcList_item *pItem; + assert(pList || pParse->db->mallocFailed ); + if( pList ){ + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pItem->iCursor>=0 ) break; + pItem->iCursor = pParse->nTab++; + if( pItem->pSelect ){ + sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc); + } + } + } +} + +/* +** Delete an entire SrcList including all its substructure. +*/ +SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){ + int i; + struct SrcList_item *pItem; + if( pList==0 ) return; + for(pItem=pList->a, i=0; inSrc; i++, pItem++){ + sqlite3DbFree(db, pItem->zDatabase); + sqlite3DbFree(db, pItem->zName); + sqlite3DbFree(db, pItem->zAlias); + if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy); + if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg); + sqlite3DeleteTable(db, pItem->pTab); + sqlite3SelectDelete(db, pItem->pSelect); + sqlite3ExprDelete(db, pItem->pOn); + sqlite3IdListDelete(db, pItem->pUsing); + } + sqlite3DbFree(db, pList); +} + +/* +** This routine is called by the parser to add a new term to the +** end of a growing FROM clause. The "p" parameter is the part of +** the FROM clause that has already been constructed. "p" is NULL +** if this is the first term of the FROM clause. pTable and pDatabase +** are the name of the table and database named in the FROM clause term. +** pDatabase is NULL if the database name qualifier is missing - the +** usual case. If the term has an alias, then pAlias points to the +** alias token. If the term is a subquery, then pSubquery is the +** SELECT statement that the subquery encodes. The pTable and +** pDatabase parameters are NULL for subqueries. The pOn and pUsing +** parameters are the content of the ON and USING clauses. +** +** Return a new SrcList which encodes is the FROM with the new +** term added. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm( + Parse *pParse, /* Parsing context */ + SrcList *p, /* The left part of the FROM clause already seen */ + Token *pTable, /* Name of the table to add to the FROM clause */ + Token *pDatabase, /* Name of the database containing pTable */ + Token *pAlias, /* The right-hand side of the AS subexpression */ + Select *pSubquery, /* A subquery used in place of a table name */ + Expr *pOn, /* The ON clause of a join */ + IdList *pUsing /* The USING clause of a join */ +){ + struct SrcList_item *pItem; + sqlite3 *db = pParse->db; + if( !p && (pOn || pUsing) ){ + sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s", + (pOn ? "ON" : "USING") + ); + goto append_from_error; + } + p = sqlite3SrcListAppend(db, p, pTable, pDatabase); + if( p==0 || NEVER(p->nSrc==0) ){ + goto append_from_error; + } + pItem = &p->a[p->nSrc-1]; + assert( pAlias!=0 ); + if( pAlias->n ){ + pItem->zAlias = sqlite3NameFromToken(db, pAlias); + } + pItem->pSelect = pSubquery; + pItem->pOn = pOn; + pItem->pUsing = pUsing; + return p; + + append_from_error: + assert( p==0 ); + sqlite3ExprDelete(db, pOn); + sqlite3IdListDelete(db, pUsing); + sqlite3SelectDelete(db, pSubquery); + return 0; +} + +/* +** Add an INDEXED BY or NOT INDEXED clause to the most recently added +** element of the source-list passed as the second argument. +*/ +SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){ + assert( pIndexedBy!=0 ); + if( p && ALWAYS(p->nSrc>0) ){ + struct SrcList_item *pItem = &p->a[p->nSrc-1]; + assert( pItem->fg.notIndexed==0 ); + assert( pItem->fg.isIndexedBy==0 ); + assert( pItem->fg.isTabFunc==0 ); + if( pIndexedBy->n==1 && !pIndexedBy->z ){ + /* A "NOT INDEXED" clause was supplied. See parse.y + ** construct "indexed_opt" for details. */ + pItem->fg.notIndexed = 1; + }else{ + pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy); + pItem->fg.isIndexedBy = (pItem->u1.zIndexedBy!=0); + } + } +} + +/* +** Add the list of function arguments to the SrcList entry for a +** table-valued-function. +*/ +SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){ + if( p && pList ){ + struct SrcList_item *pItem = &p->a[p->nSrc-1]; + assert( pItem->fg.notIndexed==0 ); + assert( pItem->fg.isIndexedBy==0 ); + assert( pItem->fg.isTabFunc==0 ); + pItem->u1.pFuncArg = pList; + pItem->fg.isTabFunc = 1; + }else{ + sqlite3ExprListDelete(pParse->db, pList); + } +} + +/* +** When building up a FROM clause in the parser, the join operator +** is initially attached to the left operand. But the code generator +** expects the join operator to be on the right operand. This routine +** Shifts all join operators from left to right for an entire FROM +** clause. +** +** Example: Suppose the join is like this: +** +** A natural cross join B +** +** The operator is "natural cross join". The A and B operands are stored +** in p->a[0] and p->a[1], respectively. The parser initially stores the +** operator with A. This routine shifts that operator over to B. +*/ +SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList *p){ + if( p ){ + int i; + for(i=p->nSrc-1; i>0; i--){ + p->a[i].fg.jointype = p->a[i-1].fg.jointype; + } + p->a[0].fg.jointype = 0; + } +} + +/* +** Begin a transaction +*/ +SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){ + sqlite3 *db; + Vdbe *v; + int i; + + assert( pParse!=0 ); + db = pParse->db; + assert( db!=0 ); +/* if( db->aDb[0].pBt==0 ) return; */ + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){ + return; + } + v = sqlite3GetVdbe(pParse); + if( !v ) return; + if( type!=TK_DEFERRED ){ + for(i=0; inDb; i++){ + sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1); + sqlite3VdbeUsesBtree(v, i); + } + } + sqlite3VdbeAddOp2(v, OP_AutoCommit, 0, 0); +} + +/* +** Commit a transaction +*/ +SQLITE_PRIVATE void sqlite3CommitTransaction(Parse *pParse){ + Vdbe *v; + + assert( pParse!=0 ); + assert( pParse->db!=0 ); + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ){ + return; + } + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 0); + } +} + +/* +** Rollback a transaction +*/ +SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse *pParse){ + Vdbe *v; + + assert( pParse!=0 ); + assert( pParse->db!=0 ); + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ){ + return; + } + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 1); + } +} + +/* +** This function is called by the parser when it parses a command to create, +** release or rollback an SQL savepoint. +*/ +SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){ + char *zName = sqlite3NameFromToken(pParse->db, pName); + if( zName ){ + Vdbe *v = sqlite3GetVdbe(pParse); +#ifndef SQLITE_OMIT_AUTHORIZATION + static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" }; + assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 ); +#endif + if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){ + sqlite3DbFree(pParse->db, zName); + return; + } + sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC); + } +} + +/* +** Make sure the TEMP database is open and available for use. Return +** the number of errors. Leave any error messages in the pParse structure. +*/ +SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){ + sqlite3 *db = pParse->db; + if( db->aDb[1].pBt==0 && !pParse->explain ){ + int rc; + Btree *pBt; + static const int flags = + SQLITE_OPEN_READWRITE | + SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | + SQLITE_OPEN_DELETEONCLOSE | + SQLITE_OPEN_TEMP_DB; + + rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags); + if( rc!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "unable to open a temporary database " + "file for storing temporary tables"); + pParse->rc = rc; + return 1; + } + db->aDb[1].pBt = pBt; + assert( db->aDb[1].pSchema ); + if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){ + db->mallocFailed = 1; + return 1; + } + } + return 0; +} + +/* +** Record the fact that the schema cookie will need to be verified +** for database iDb. The code to actually verify the schema cookie +** will occur at the end of the top-level VDBE and will be generated +** later, by sqlite3FinishCoding(). +*/ +SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + sqlite3 *db = pToplevel->db; + + assert( iDb>=0 && iDbnDb ); + assert( db->aDb[iDb].pBt!=0 || iDb==1 ); + assert( iDbcookieMask, iDb)==0 ){ + DbMaskSet(pToplevel->cookieMask, iDb); + pToplevel->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie; + if( !OMIT_TEMPDB && iDb==1 ){ + sqlite3OpenTempDatabase(pToplevel); + } + } +} + +/* +** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each +** attached database. Otherwise, invoke it for the database named zDb only. +*/ +SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){ + sqlite3 *db = pParse->db; + int i; + for(i=0; inDb; i++){ + Db *pDb = &db->aDb[i]; + if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zName)) ){ + sqlite3CodeVerifySchema(pParse, i); + } + } +} + +/* +** Generate VDBE code that prepares for doing an operation that +** might change the database. +** +** This routine starts a new transaction if we are not already within +** a transaction. If we are already within a transaction, then a checkpoint +** is set if the setStatement parameter is true. A checkpoint should +** be set for operations that might fail (due to a constraint) part of +** the way through and which will need to undo some writes without having to +** rollback the whole transaction. For operations where all constraints +** can be checked before any changes are made to the database, it is never +** necessary to undo a write and the checkpoint should not be set. +*/ +SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + sqlite3CodeVerifySchema(pParse, iDb); + DbMaskSet(pToplevel->writeMask, iDb); + pToplevel->isMultiWrite |= setStatement; +} + +/* +** Indicate that the statement currently under construction might write +** more than one entry (example: deleting one row then inserting another, +** inserting multiple rows in a table, or inserting a row and index entries.) +** If an abort occurs after some of these writes have completed, then it will +** be necessary to undo the completed writes. +*/ +SQLITE_PRIVATE void sqlite3MultiWrite(Parse *pParse){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + pToplevel->isMultiWrite = 1; +} + +/* +** The code generator calls this routine if is discovers that it is +** possible to abort a statement prior to completion. In order to +** perform this abort without corrupting the database, we need to make +** sure that the statement is protected by a statement transaction. +** +** Technically, we only need to set the mayAbort flag if the +** isMultiWrite flag was previously set. There is a time dependency +** such that the abort must occur after the multiwrite. This makes +** some statements involving the REPLACE conflict resolution algorithm +** go a little faster. But taking advantage of this time dependency +** makes it more difficult to prove that the code is correct (in +** particular, it prevents us from writing an effective +** implementation of sqlite3AssertMayAbort()) and so we have chosen +** to take the safe route and skip the optimization. +*/ +SQLITE_PRIVATE void sqlite3MayAbort(Parse *pParse){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + pToplevel->mayAbort = 1; +} + +/* +** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT +** error. The onError parameter determines which (if any) of the statement +** and/or current transaction is rolled back. +*/ +SQLITE_PRIVATE void sqlite3HaltConstraint( + Parse *pParse, /* Parsing context */ + int errCode, /* extended error code */ + int onError, /* Constraint type */ + char *p4, /* Error message */ + i8 p4type, /* P4_STATIC or P4_TRANSIENT */ + u8 p5Errmsg /* P5_ErrMsg type */ +){ + Vdbe *v = sqlite3GetVdbe(pParse); + assert( (errCode&0xff)==SQLITE_CONSTRAINT ); + if( onError==OE_Abort ){ + sqlite3MayAbort(pParse); + } + sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type); + if( p5Errmsg ) sqlite3VdbeChangeP5(v, p5Errmsg); +} + +/* +** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation. +*/ +SQLITE_PRIVATE void sqlite3UniqueConstraint( + Parse *pParse, /* Parsing context */ + int onError, /* Constraint type */ + Index *pIdx /* The index that triggers the constraint */ +){ + char *zErr; + int j; + StrAccum errMsg; + Table *pTab = pIdx->pTable; + + sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0, 200); + if( pIdx->aColExpr ){ + sqlite3XPrintf(&errMsg, 0, "index '%q'", pIdx->zName); + }else{ + for(j=0; jnKeyCol; j++){ + char *zCol; + assert( pIdx->aiColumn[j]>=0 ); + zCol = pTab->aCol[pIdx->aiColumn[j]].zName; + if( j ) sqlite3StrAccumAppend(&errMsg, ", ", 2); + sqlite3XPrintf(&errMsg, 0, "%s.%s", pTab->zName, zCol); + } + } + zErr = sqlite3StrAccumFinish(&errMsg); + sqlite3HaltConstraint(pParse, + IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY + : SQLITE_CONSTRAINT_UNIQUE, + onError, zErr, P4_DYNAMIC, P5_ConstraintUnique); +} + + +/* +** Code an OP_Halt due to non-unique rowid. +*/ +SQLITE_PRIVATE void sqlite3RowidConstraint( + Parse *pParse, /* Parsing context */ + int onError, /* Conflict resolution algorithm */ + Table *pTab /* The table with the non-unique rowid */ +){ + char *zMsg; + int rc; + if( pTab->iPKey>=0 ){ + zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName, + pTab->aCol[pTab->iPKey].zName); + rc = SQLITE_CONSTRAINT_PRIMARYKEY; + }else{ + zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName); + rc = SQLITE_CONSTRAINT_ROWID; + } + sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC, + P5_ConstraintUnique); +} + +/* +** Check to see if pIndex uses the collating sequence pColl. Return +** true if it does and false if it does not. +*/ +#ifndef SQLITE_OMIT_REINDEX +static int collationMatch(const char *zColl, Index *pIndex){ + int i; + assert( zColl!=0 ); + for(i=0; inColumn; i++){ + const char *z = pIndex->azColl[i]; + assert( z!=0 || pIndex->aiColumn[i]<0 ); + if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){ + return 1; + } + } + return 0; +} +#endif + +/* +** Recompute all indices of pTab that use the collating sequence pColl. +** If pColl==0 then recompute all indices of pTab. +*/ +#ifndef SQLITE_OMIT_REINDEX +static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){ + Index *pIndex; /* An index associated with pTab */ + + for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){ + if( zColl==0 || collationMatch(zColl, pIndex) ){ + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3RefillIndex(pParse, pIndex, -1); + } + } +} +#endif + +/* +** Recompute all indices of all tables in all databases where the +** indices use the collating sequence pColl. If pColl==0 then recompute +** all indices everywhere. +*/ +#ifndef SQLITE_OMIT_REINDEX +static void reindexDatabases(Parse *pParse, char const *zColl){ + Db *pDb; /* A single database */ + int iDb; /* The database index number */ + sqlite3 *db = pParse->db; /* The database connection */ + HashElem *k; /* For looping over tables in pDb */ + Table *pTab; /* A table in the database */ + + assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */ + for(iDb=0, pDb=db->aDb; iDbnDb; iDb++, pDb++){ + assert( pDb!=0 ); + for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){ + pTab = (Table*)sqliteHashData(k); + reindexTable(pParse, pTab, zColl); + } + } +} +#endif + +/* +** Generate code for the REINDEX command. +** +** REINDEX -- 1 +** REINDEX -- 2 +** REINDEX ?.? -- 3 +** REINDEX ?.? -- 4 +** +** Form 1 causes all indices in all attached databases to be rebuilt. +** Form 2 rebuilds all indices in all databases that use the named +** collating function. Forms 3 and 4 rebuild the named index or all +** indices associated with the named table. +*/ +#ifndef SQLITE_OMIT_REINDEX +SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){ + CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */ + char *z; /* Name of a table or index */ + const char *zDb; /* Name of the database */ + Table *pTab; /* A table in the database */ + Index *pIndex; /* An index associated with pTab */ + int iDb; /* The database index number */ + sqlite3 *db = pParse->db; /* The database connection */ + Token *pObjName; /* Name of the table or index to be reindexed */ + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return; + } + + if( pName1==0 ){ + reindexDatabases(pParse, 0); + return; + }else if( NEVER(pName2==0) || pName2->z==0 ){ + char *zColl; + assert( pName1->z ); + zColl = sqlite3NameFromToken(pParse->db, pName1); + if( !zColl ) return; + pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0); + if( pColl ){ + reindexDatabases(pParse, zColl); + sqlite3DbFree(db, zColl); + return; + } + sqlite3DbFree(db, zColl); + } + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName); + if( iDb<0 ) return; + z = sqlite3NameFromToken(db, pObjName); + if( z==0 ) return; + zDb = db->aDb[iDb].zName; + pTab = sqlite3FindTable(db, z, zDb); + if( pTab ){ + reindexTable(pParse, pTab, 0); + sqlite3DbFree(db, z); + return; + } + pIndex = sqlite3FindIndex(db, z, zDb); + sqlite3DbFree(db, z); + if( pIndex ){ + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3RefillIndex(pParse, pIndex, -1); + return; + } + sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed"); +} +#endif + +/* +** Return a KeyInfo structure that is appropriate for the given Index. +** +** The KeyInfo structure for an index is cached in the Index object. +** So there might be multiple references to the returned pointer. The +** caller should not try to modify the KeyInfo object. +** +** The caller should invoke sqlite3KeyInfoUnref() on the returned object +** when it has finished using it. +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){ + int i; + int nCol = pIdx->nColumn; + int nKey = pIdx->nKeyCol; + KeyInfo *pKey; + if( pParse->nErr ) return 0; + if( pIdx->uniqNotNull ){ + pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey); + }else{ + pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0); + } + if( pKey ){ + assert( sqlite3KeyInfoIsWriteable(pKey) ); + for(i=0; iazColl[i]; + assert( zColl!=0 ); + pKey->aColl[i] = strcmp(zColl,"BINARY")==0 ? 0 : + sqlite3LocateCollSeq(pParse, zColl); + pKey->aSortOrder[i] = pIdx->aSortOrder[i]; + } + if( pParse->nErr ){ + sqlite3KeyInfoUnref(pKey); + pKey = 0; + } + } + return pKey; +} + +#ifndef SQLITE_OMIT_CTE +/* +** This routine is invoked once per CTE by the parser while parsing a +** WITH clause. +*/ +SQLITE_PRIVATE With *sqlite3WithAdd( + Parse *pParse, /* Parsing context */ + With *pWith, /* Existing WITH clause, or NULL */ + Token *pName, /* Name of the common-table */ + ExprList *pArglist, /* Optional column name list for the table */ + Select *pQuery /* Query used to initialize the table */ +){ + sqlite3 *db = pParse->db; + With *pNew; + char *zName; + + /* Check that the CTE name is unique within this WITH clause. If + ** not, store an error in the Parse structure. */ + zName = sqlite3NameFromToken(pParse->db, pName); + if( zName && pWith ){ + int i; + for(i=0; inCte; i++){ + if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){ + sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName); + } + } + } + + if( pWith ){ + int nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte); + pNew = sqlite3DbRealloc(db, pWith, nByte); + }else{ + pNew = sqlite3DbMallocZero(db, sizeof(*pWith)); + } + assert( zName!=0 || pNew==0 ); + assert( db->mallocFailed==0 || pNew==0 ); + + if( pNew==0 ){ + sqlite3ExprListDelete(db, pArglist); + sqlite3SelectDelete(db, pQuery); + sqlite3DbFree(db, zName); + pNew = pWith; + }else{ + pNew->a[pNew->nCte].pSelect = pQuery; + pNew->a[pNew->nCte].pCols = pArglist; + pNew->a[pNew->nCte].zName = zName; + pNew->a[pNew->nCte].zCteErr = 0; + pNew->nCte++; + } + + return pNew; +} + +/* +** Free the contents of the With object passed as the second argument. +*/ +SQLITE_PRIVATE void sqlite3WithDelete(sqlite3 *db, With *pWith){ + if( pWith ){ + int i; + for(i=0; inCte; i++){ + struct Cte *pCte = &pWith->a[i]; + sqlite3ExprListDelete(db, pCte->pCols); + sqlite3SelectDelete(db, pCte->pSelect); + sqlite3DbFree(db, pCte->zName); + } + sqlite3DbFree(db, pWith); + } +} +#endif /* !defined(SQLITE_OMIT_CTE) */ + +/************** End of build.c ***********************************************/ +/************** Begin file callback.c ****************************************/ +/* +** 2005 May 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains functions used to access the internal hash tables +** of user defined functions and collation sequences. +*/ + +/* #include "sqliteInt.h" */ + +/* +** Invoke the 'collation needed' callback to request a collation sequence +** in the encoding enc of name zName, length nName. +*/ +static void callCollNeeded(sqlite3 *db, int enc, const char *zName){ + assert( !db->xCollNeeded || !db->xCollNeeded16 ); + if( db->xCollNeeded ){ + char *zExternal = sqlite3DbStrDup(db, zName); + if( !zExternal ) return; + db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal); + sqlite3DbFree(db, zExternal); + } +#ifndef SQLITE_OMIT_UTF16 + if( db->xCollNeeded16 ){ + char const *zExternal; + sqlite3_value *pTmp = sqlite3ValueNew(db); + sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC); + zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE); + if( zExternal ){ + db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal); + } + sqlite3ValueFree(pTmp); + } +#endif +} + +/* +** This routine is called if the collation factory fails to deliver a +** collation function in the best encoding but there may be other versions +** of this collation function (for other text encodings) available. Use one +** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if +** possible. +*/ +static int synthCollSeq(sqlite3 *db, CollSeq *pColl){ + CollSeq *pColl2; + char *z = pColl->zName; + int i; + static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 }; + for(i=0; i<3; i++){ + pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, 0); + if( pColl2->xCmp!=0 ){ + memcpy(pColl, pColl2, sizeof(CollSeq)); + pColl->xDel = 0; /* Do not copy the destructor */ + return SQLITE_OK; + } + } + return SQLITE_ERROR; +} + +/* +** This function is responsible for invoking the collation factory callback +** or substituting a collation sequence of a different encoding when the +** requested collation sequence is not available in the desired encoding. +** +** If it is not NULL, then pColl must point to the database native encoding +** collation sequence with name zName, length nName. +** +** The return value is either the collation sequence to be used in database +** db for collation type name zName, length nName, or NULL, if no collation +** sequence can be found. If no collation is found, leave an error message. +** +** See also: sqlite3LocateCollSeq(), sqlite3FindCollSeq() +*/ +SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq( + Parse *pParse, /* Parsing context */ + u8 enc, /* The desired encoding for the collating sequence */ + CollSeq *pColl, /* Collating sequence with native encoding, or NULL */ + const char *zName /* Collating sequence name */ +){ + CollSeq *p; + sqlite3 *db = pParse->db; + + p = pColl; + if( !p ){ + p = sqlite3FindCollSeq(db, enc, zName, 0); + } + if( !p || !p->xCmp ){ + /* No collation sequence of this type for this encoding is registered. + ** Call the collation factory to see if it can supply us with one. + */ + callCollNeeded(db, enc, zName); + p = sqlite3FindCollSeq(db, enc, zName, 0); + } + if( p && !p->xCmp && synthCollSeq(db, p) ){ + p = 0; + } + assert( !p || p->xCmp ); + if( p==0 ){ + sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName); + } + return p; +} + +/* +** This routine is called on a collation sequence before it is used to +** check that it is defined. An undefined collation sequence exists when +** a database is loaded that contains references to collation sequences +** that have not been defined by sqlite3_create_collation() etc. +** +** If required, this routine calls the 'collation needed' callback to +** request a definition of the collating sequence. If this doesn't work, +** an equivalent collating sequence that uses a text encoding different +** from the main database is substituted, if one is available. +*/ +SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){ + if( pColl ){ + const char *zName = pColl->zName; + sqlite3 *db = pParse->db; + CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName); + if( !p ){ + return SQLITE_ERROR; + } + assert( p==pColl ); + } + return SQLITE_OK; +} + + + +/* +** Locate and return an entry from the db.aCollSeq hash table. If the entry +** specified by zName and nName is not found and parameter 'create' is +** true, then create a new entry. Otherwise return NULL. +** +** Each pointer stored in the sqlite3.aCollSeq hash table contains an +** array of three CollSeq structures. The first is the collation sequence +** preferred for UTF-8, the second UTF-16le, and the third UTF-16be. +** +** Stored immediately after the three collation sequences is a copy of +** the collation sequence name. A pointer to this string is stored in +** each collation sequence structure. +*/ +static CollSeq *findCollSeqEntry( + sqlite3 *db, /* Database connection */ + const char *zName, /* Name of the collating sequence */ + int create /* Create a new entry if true */ +){ + CollSeq *pColl; + pColl = sqlite3HashFind(&db->aCollSeq, zName); + + if( 0==pColl && create ){ + int nName = sqlite3Strlen30(zName); + pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName + 1); + if( pColl ){ + CollSeq *pDel = 0; + pColl[0].zName = (char*)&pColl[3]; + pColl[0].enc = SQLITE_UTF8; + pColl[1].zName = (char*)&pColl[3]; + pColl[1].enc = SQLITE_UTF16LE; + pColl[2].zName = (char*)&pColl[3]; + pColl[2].enc = SQLITE_UTF16BE; + memcpy(pColl[0].zName, zName, nName); + pColl[0].zName[nName] = 0; + pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl); + + /* If a malloc() failure occurred in sqlite3HashInsert(), it will + ** return the pColl pointer to be deleted (because it wasn't added + ** to the hash table). + */ + assert( pDel==0 || pDel==pColl ); + if( pDel!=0 ){ + db->mallocFailed = 1; + sqlite3DbFree(db, pDel); + pColl = 0; + } + } + } + return pColl; +} + +/* +** Parameter zName points to a UTF-8 encoded string nName bytes long. +** Return the CollSeq* pointer for the collation sequence named zName +** for the encoding 'enc' from the database 'db'. +** +** If the entry specified is not found and 'create' is true, then create a +** new entry. Otherwise return NULL. +** +** A separate function sqlite3LocateCollSeq() is a wrapper around +** this routine. sqlite3LocateCollSeq() invokes the collation factory +** if necessary and generates an error message if the collating sequence +** cannot be found. +** +** See also: sqlite3LocateCollSeq(), sqlite3GetCollSeq() +*/ +SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq( + sqlite3 *db, + u8 enc, + const char *zName, + int create +){ + CollSeq *pColl; + if( zName ){ + pColl = findCollSeqEntry(db, zName, create); + }else{ + pColl = db->pDfltColl; + } + assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE ); + if( pColl ) pColl += enc-1; + return pColl; +} + +/* During the search for the best function definition, this procedure +** is called to test how well the function passed as the first argument +** matches the request for a function with nArg arguments in a system +** that uses encoding enc. The value returned indicates how well the +** request is matched. A higher value indicates a better match. +** +** If nArg is -1 that means to only return a match (non-zero) if p->nArg +** is also -1. In other words, we are searching for a function that +** takes a variable number of arguments. +** +** If nArg is -2 that means that we are searching for any function +** regardless of the number of arguments it uses, so return a positive +** match score for any +** +** The returned value is always between 0 and 6, as follows: +** +** 0: Not a match. +** 1: UTF8/16 conversion required and function takes any number of arguments. +** 2: UTF16 byte order change required and function takes any number of args. +** 3: encoding matches and function takes any number of arguments +** 4: UTF8/16 conversion required - argument count matches exactly +** 5: UTF16 byte order conversion required - argument count matches exactly +** 6: Perfect match: encoding and argument count match exactly. +** +** If nArg==(-2) then any function with a non-null xStep or xFunc is +** a perfect match and any function with both xStep and xFunc NULL is +** a non-match. +*/ +#define FUNC_PERFECT_MATCH 6 /* The score for a perfect match */ +static int matchQuality( + FuncDef *p, /* The function we are evaluating for match quality */ + int nArg, /* Desired number of arguments. (-1)==any */ + u8 enc /* Desired text encoding */ +){ + int match; + + /* nArg of -2 is a special case */ + if( nArg==(-2) ) return (p->xFunc==0 && p->xStep==0) ? 0 : FUNC_PERFECT_MATCH; + + /* Wrong number of arguments means "no match" */ + if( p->nArg!=nArg && p->nArg>=0 ) return 0; + + /* Give a better score to a function with a specific number of arguments + ** than to function that accepts any number of arguments. */ + if( p->nArg==nArg ){ + match = 4; + }else{ + match = 1; + } + + /* Bonus points if the text encoding matches */ + if( enc==(p->funcFlags & SQLITE_FUNC_ENCMASK) ){ + match += 2; /* Exact encoding match */ + }else if( (enc & p->funcFlags & 2)!=0 ){ + match += 1; /* Both are UTF16, but with different byte orders */ + } + + return match; +} + +/* +** Search a FuncDefHash for a function with the given name. Return +** a pointer to the matching FuncDef if found, or 0 if there is no match. +*/ +static FuncDef *functionSearch( + FuncDefHash *pHash, /* Hash table to search */ + int h, /* Hash of the name */ + const char *zFunc, /* Name of function */ + int nFunc /* Number of bytes in zFunc */ +){ + FuncDef *p; + for(p=pHash->a[h]; p; p=p->pHash){ + if( sqlite3StrNICmp(p->zName, zFunc, nFunc)==0 && p->zName[nFunc]==0 ){ + return p; + } + } + return 0; +} + +/* +** Insert a new FuncDef into a FuncDefHash hash table. +*/ +SQLITE_PRIVATE void sqlite3FuncDefInsert( + FuncDefHash *pHash, /* The hash table into which to insert */ + FuncDef *pDef /* The function definition to insert */ +){ + FuncDef *pOther; + int nName = sqlite3Strlen30(pDef->zName); + u8 c1 = (u8)pDef->zName[0]; + int h = (sqlite3UpperToLower[c1] + nName) % ArraySize(pHash->a); + pOther = functionSearch(pHash, h, pDef->zName, nName); + if( pOther ){ + assert( pOther!=pDef && pOther->pNext!=pDef ); + pDef->pNext = pOther->pNext; + pOther->pNext = pDef; + }else{ + pDef->pNext = 0; + pDef->pHash = pHash->a[h]; + pHash->a[h] = pDef; + } +} + + + +/* +** Locate a user function given a name, a number of arguments and a flag +** indicating whether the function prefers UTF-16 over UTF-8. Return a +** pointer to the FuncDef structure that defines that function, or return +** NULL if the function does not exist. +** +** If the createFlag argument is true, then a new (blank) FuncDef +** structure is created and liked into the "db" structure if a +** no matching function previously existed. +** +** If nArg is -2, then the first valid function found is returned. A +** function is valid if either xFunc or xStep is non-zero. The nArg==(-2) +** case is used to see if zName is a valid function name for some number +** of arguments. If nArg is -2, then createFlag must be 0. +** +** If createFlag is false, then a function with the required name and +** number of arguments may be returned even if the eTextRep flag does not +** match that requested. +*/ +SQLITE_PRIVATE FuncDef *sqlite3FindFunction( + sqlite3 *db, /* An open database */ + const char *zName, /* Name of the function. Not null-terminated */ + int nName, /* Number of characters in the name */ + int nArg, /* Number of arguments. -1 means any number */ + u8 enc, /* Preferred text encoding */ + u8 createFlag /* Create new entry if true and does not otherwise exist */ +){ + FuncDef *p; /* Iterator variable */ + FuncDef *pBest = 0; /* Best match found so far */ + int bestScore = 0; /* Score of best match */ + int h; /* Hash value */ + + assert( nArg>=(-2) ); + assert( nArg>=(-1) || createFlag==0 ); + h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a); + + /* First search for a match amongst the application-defined functions. + */ + p = functionSearch(&db->aFunc, h, zName, nName); + while( p ){ + int score = matchQuality(p, nArg, enc); + if( score>bestScore ){ + pBest = p; + bestScore = score; + } + p = p->pNext; + } + + /* If no match is found, search the built-in functions. + ** + ** If the SQLITE_PreferBuiltin flag is set, then search the built-in + ** functions even if a prior app-defined function was found. And give + ** priority to built-in functions. + ** + ** Except, if createFlag is true, that means that we are trying to + ** install a new function. Whatever FuncDef structure is returned it will + ** have fields overwritten with new information appropriate for the + ** new function. But the FuncDefs for built-in functions are read-only. + ** So we must not search for built-ins when creating a new function. + */ + if( !createFlag && (pBest==0 || (db->flags & SQLITE_PreferBuiltin)!=0) ){ + FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions); + bestScore = 0; + p = functionSearch(pHash, h, zName, nName); + while( p ){ + int score = matchQuality(p, nArg, enc); + if( score>bestScore ){ + pBest = p; + bestScore = score; + } + p = p->pNext; + } + } + + /* If the createFlag parameter is true and the search did not reveal an + ** exact match for the name, number of arguments and encoding, then add a + ** new entry to the hash table and return it. + */ + if( createFlag && bestScorezName = (char *)&pBest[1]; + pBest->nArg = (u16)nArg; + pBest->funcFlags = enc; + memcpy(pBest->zName, zName, nName); + pBest->zName[nName] = 0; + sqlite3FuncDefInsert(&db->aFunc, pBest); + } + + if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){ + return pBest; + } + return 0; +} + +/* +** Free all resources held by the schema structure. The void* argument points +** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the +** pointer itself, it just cleans up subsidiary resources (i.e. the contents +** of the schema hash tables). +** +** The Schema.cache_size variable is not cleared. +*/ +SQLITE_PRIVATE void sqlite3SchemaClear(void *p){ + Hash temp1; + Hash temp2; + HashElem *pElem; + Schema *pSchema = (Schema *)p; + + temp1 = pSchema->tblHash; + temp2 = pSchema->trigHash; + sqlite3HashInit(&pSchema->trigHash); + sqlite3HashClear(&pSchema->idxHash); + for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){ + sqlite3DeleteTrigger(0, (Trigger*)sqliteHashData(pElem)); + } + sqlite3HashClear(&temp2); + sqlite3HashInit(&pSchema->tblHash); + for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = sqliteHashData(pElem); + sqlite3DeleteTable(0, pTab); + } + sqlite3HashClear(&temp1); + sqlite3HashClear(&pSchema->fkeyHash); + pSchema->pSeqTab = 0; + if( pSchema->schemaFlags & DB_SchemaLoaded ){ + pSchema->iGeneration++; + pSchema->schemaFlags &= ~DB_SchemaLoaded; + } +} + +/* +** Find and return the schema associated with a BTree. Create +** a new one if necessary. +*/ +SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){ + Schema * p; + if( pBt ){ + p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear); + }else{ + p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema)); + } + if( !p ){ + db->mallocFailed = 1; + }else if ( 0==p->file_format ){ + sqlite3HashInit(&p->tblHash); + sqlite3HashInit(&p->idxHash); + sqlite3HashInit(&p->trigHash); + sqlite3HashInit(&p->fkeyHash); + p->enc = SQLITE_UTF8; + } + return p; +} + +/************** End of callback.c ********************************************/ +/************** Begin file delete.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** in order to generate code for DELETE FROM statements. +*/ +/* #include "sqliteInt.h" */ + +/* +** While a SrcList can in general represent multiple tables and subqueries +** (as in the FROM clause of a SELECT statement) in this case it contains +** the name of a single table, as one might find in an INSERT, DELETE, +** or UPDATE statement. Look up that table in the symbol table and +** return a pointer. Set an error message and return NULL if the table +** name is not found or if any other error occurs. +** +** The following fields are initialized appropriate in pSrc: +** +** pSrc->a[0].pTab Pointer to the Table object +** pSrc->a[0].pIndex Pointer to the INDEXED BY index, if there is one +** +*/ +SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){ + struct SrcList_item *pItem = pSrc->a; + Table *pTab; + assert( pItem && pSrc->nSrc==1 ); + pTab = sqlite3LocateTableItem(pParse, 0, pItem); + sqlite3DeleteTable(pParse->db, pItem->pTab); + pItem->pTab = pTab; + if( pTab ){ + pTab->nRef++; + } + if( sqlite3IndexedByLookup(pParse, pItem) ){ + pTab = 0; + } + return pTab; +} + +/* +** Check to make sure the given table is writable. If it is not +** writable, generate an error message and return 1. If it is +** writable return 0; +*/ +SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){ + /* A table is not writable under the following circumstances: + ** + ** 1) It is a virtual table and no implementation of the xUpdate method + ** has been provided, or + ** 2) It is a system table (i.e. sqlite_master), this call is not + ** part of a nested parse and writable_schema pragma has not + ** been specified. + ** + ** In either case leave an error message in pParse and return non-zero. + */ + if( ( IsVirtual(pTab) + && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 ) + || ( (pTab->tabFlags & TF_Readonly)!=0 + && (pParse->db->flags & SQLITE_WriteSchema)==0 + && pParse->nested==0 ) + ){ + sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName); + return 1; + } + +#ifndef SQLITE_OMIT_VIEW + if( !viewOk && pTab->pSelect ){ + sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName); + return 1; + } +#endif + return 0; +} + + +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) +/* +** Evaluate a view and store its result in an ephemeral table. The +** pWhere argument is an optional WHERE clause that restricts the +** set of rows in the view that are to be added to the ephemeral table. +*/ +SQLITE_PRIVATE void sqlite3MaterializeView( + Parse *pParse, /* Parsing context */ + Table *pView, /* View definition */ + Expr *pWhere, /* Optional WHERE clause to be added */ + int iCur /* Cursor number for ephemeral table */ +){ + SelectDest dest; + Select *pSel; + SrcList *pFrom; + sqlite3 *db = pParse->db; + int iDb = sqlite3SchemaToIndex(db, pView->pSchema); + pWhere = sqlite3ExprDup(db, pWhere, 0); + pFrom = sqlite3SrcListAppend(db, 0, 0, 0); + if( pFrom ){ + assert( pFrom->nSrc==1 ); + pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName); + pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName); + assert( pFrom->a[0].pOn==0 ); + assert( pFrom->a[0].pUsing==0 ); + } + pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0); + sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur); + sqlite3Select(pParse, pSel, &dest); + sqlite3SelectDelete(db, pSel); +} +#endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */ + +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) +/* +** Generate an expression tree to implement the WHERE, ORDER BY, +** and LIMIT/OFFSET portion of DELETE and UPDATE statements. +** +** DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1; +** \__________________________/ +** pLimitWhere (pInClause) +*/ +SQLITE_PRIVATE Expr *sqlite3LimitWhere( + Parse *pParse, /* The parser context */ + SrcList *pSrc, /* the FROM clause -- which tables to scan */ + Expr *pWhere, /* The WHERE clause. May be null */ + ExprList *pOrderBy, /* The ORDER BY clause. May be null */ + Expr *pLimit, /* The LIMIT clause. May be null */ + Expr *pOffset, /* The OFFSET clause. May be null */ + char *zStmtType /* Either DELETE or UPDATE. For err msgs. */ +){ + Expr *pWhereRowid = NULL; /* WHERE rowid .. */ + Expr *pInClause = NULL; /* WHERE rowid IN ( select ) */ + Expr *pSelectRowid = NULL; /* SELECT rowid ... */ + ExprList *pEList = NULL; /* Expression list contaning only pSelectRowid */ + SrcList *pSelectSrc = NULL; /* SELECT rowid FROM x ... (dup of pSrc) */ + Select *pSelect = NULL; /* Complete SELECT tree */ + + /* Check that there isn't an ORDER BY without a LIMIT clause. + */ + if( pOrderBy && (pLimit == 0) ) { + sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType); + goto limit_where_cleanup_2; + } + + /* We only need to generate a select expression if there + ** is a limit/offset term to enforce. + */ + if( pLimit == 0 ) { + /* if pLimit is null, pOffset will always be null as well. */ + assert( pOffset == 0 ); + return pWhere; + } + + /* Generate a select expression tree to enforce the limit/offset + ** term for the DELETE or UPDATE statement. For example: + ** DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1 + ** becomes: + ** DELETE FROM table_a WHERE rowid IN ( + ** SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1 + ** ); + */ + + pSelectRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0); + if( pSelectRowid == 0 ) goto limit_where_cleanup_2; + pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid); + if( pEList == 0 ) goto limit_where_cleanup_2; + + /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree + ** and the SELECT subtree. */ + pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0); + if( pSelectSrc == 0 ) { + sqlite3ExprListDelete(pParse->db, pEList); + goto limit_where_cleanup_2; + } + + /* generate the SELECT expression tree. */ + pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0, + pOrderBy,0,pLimit,pOffset); + if( pSelect == 0 ) return 0; + + /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */ + pWhereRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0); + if( pWhereRowid == 0 ) goto limit_where_cleanup_1; + pInClause = sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0, 0); + if( pInClause == 0 ) goto limit_where_cleanup_1; + + pInClause->x.pSelect = pSelect; + pInClause->flags |= EP_xIsSelect; + sqlite3ExprSetHeightAndFlags(pParse, pInClause); + return pInClause; + + /* something went wrong. clean up anything allocated. */ +limit_where_cleanup_1: + sqlite3SelectDelete(pParse->db, pSelect); + return 0; + +limit_where_cleanup_2: + sqlite3ExprDelete(pParse->db, pWhere); + sqlite3ExprListDelete(pParse->db, pOrderBy); + sqlite3ExprDelete(pParse->db, pLimit); + sqlite3ExprDelete(pParse->db, pOffset); + return 0; +} +#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) */ + /* && !defined(SQLITE_OMIT_SUBQUERY) */ + +/* +** Generate code for a DELETE FROM statement. +** +** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL; +** \________/ \________________/ +** pTabList pWhere +*/ +SQLITE_PRIVATE void sqlite3DeleteFrom( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* The table from which we should delete things */ + Expr *pWhere /* The WHERE clause. May be null */ +){ + Vdbe *v; /* The virtual database engine */ + Table *pTab; /* The table from which records will be deleted */ + const char *zDb; /* Name of database holding pTab */ + int i; /* Loop counter */ + WhereInfo *pWInfo; /* Information about the WHERE clause */ + Index *pIdx; /* For looping over indices of the table */ + int iTabCur; /* Cursor number for the table */ + int iDataCur = 0; /* VDBE cursor for the canonical data source */ + int iIdxCur = 0; /* Cursor number of the first index */ + int nIdx; /* Number of indices */ + sqlite3 *db; /* Main database structure */ + AuthContext sContext; /* Authorization context */ + NameContext sNC; /* Name context to resolve expressions in */ + int iDb; /* Database number */ + int memCnt = -1; /* Memory cell used for change counting */ + int rcauth; /* Value returned by authorization callback */ + int eOnePass; /* ONEPASS_OFF or _SINGLE or _MULTI */ + int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ + u8 *aToOpen = 0; /* Open cursor iTabCur+j if aToOpen[j] is true */ + Index *pPk; /* The PRIMARY KEY index on the table */ + int iPk = 0; /* First of nPk registers holding PRIMARY KEY value */ + i16 nPk = 1; /* Number of columns in the PRIMARY KEY */ + int iKey; /* Memory cell holding key of row to be deleted */ + i16 nKey; /* Number of memory cells in the row key */ + int iEphCur = 0; /* Ephemeral table holding all primary key values */ + int iRowSet = 0; /* Register for rowset of rows to delete */ + int addrBypass = 0; /* Address of jump over the delete logic */ + int addrLoop = 0; /* Top of the delete loop */ + int addrEphOpen = 0; /* Instruction to open the Ephemeral table */ + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True if attempting to delete from a view */ + Trigger *pTrigger; /* List of table triggers, if required */ + int bComplex; /* True if there are either triggers or FKs */ +#endif + + memset(&sContext, 0, sizeof(sContext)); + db = pParse->db; + if( pParse->nErr || db->mallocFailed ){ + goto delete_from_cleanup; + } + assert( pTabList->nSrc==1 ); + + /* Locate the table which we want to delete. This table has to be + ** put in an SrcList structure because some of the subroutines we + ** will be calling are designed to work with multiple tables and expect + ** an SrcList* parameter instead of just a Table* parameter. + */ + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ) goto delete_from_cleanup; + + /* Figure out if we have any triggers and if the table being + ** deleted from is a view + */ +#ifndef SQLITE_OMIT_TRIGGER + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0); + isView = pTab->pSelect!=0; + bComplex = pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0); +#else +# define pTrigger 0 +# define isView 0 +# define bComplex 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + + /* If pTab is really a view, make sure it has been initialized. + */ + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto delete_from_cleanup; + } + + if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){ + goto delete_from_cleanup; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDbnDb ); + zDb = db->aDb[iDb].zName; + rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb); + assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE ); + if( rcauth==SQLITE_DENY ){ + goto delete_from_cleanup; + } + assert(!isView || pTrigger); + + /* Assign cursor numbers to the table and all its indices. + */ + assert( pTabList->nSrc==1 ); + iTabCur = pTabList->a[0].iCursor = pParse->nTab++; + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ + pParse->nTab++; + } + + /* Start the view context + */ + if( isView ){ + sqlite3AuthContextPush(pParse, &sContext, pTab->zName); + } + + /* Begin generating code. + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + goto delete_from_cleanup; + } + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, 1, iDb); + + /* If we are trying to delete from a view, realize that view into + ** an ephemeral table. + */ +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) + if( isView ){ + sqlite3MaterializeView(pParse, pTab, pWhere, iTabCur); + iDataCur = iIdxCur = iTabCur; + } +#endif + + /* Resolve the column names in the WHERE clause. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + if( sqlite3ResolveExprNames(&sNC, pWhere) ){ + goto delete_from_cleanup; + } + + /* Initialize the counter of the number of rows deleted, if + ** we are counting rows. + */ + if( db->flags & SQLITE_CountRows ){ + memCnt = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt); + } + +#ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION + /* Special case: A DELETE without a WHERE clause deletes everything. + ** It is easier just to erase the whole table. Prior to version 3.6.5, + ** this optimization caused the row change count (the value returned by + ** API function sqlite3_count_changes) to be set incorrectly. */ + if( rcauth==SQLITE_OK + && pWhere==0 + && !bComplex + && !IsVirtual(pTab) + ){ + assert( !isView ); + sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName); + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt, + pTab->zName, P4_STATIC); + } + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->pSchema==pTab->pSchema ); + sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb); + } + }else +#endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */ + { + u16 wcf = WHERE_ONEPASS_DESIRED|WHERE_DUPLICATES_OK; + wcf |= (bComplex ? 0 : WHERE_ONEPASS_MULTIROW); + if( HasRowid(pTab) ){ + /* For a rowid table, initialize the RowSet to an empty set */ + pPk = 0; + nPk = 1; + iRowSet = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet); + }else{ + /* For a WITHOUT ROWID table, create an ephemeral table used to + ** hold all primary keys for rows to be deleted. */ + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + nPk = pPk->nKeyCol; + iPk = pParse->nMem+1; + pParse->nMem += nPk; + iEphCur = pParse->nTab++; + addrEphOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEphCur, nPk); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + } + + /* Construct a query to find the rowid or primary key for every row + ** to be deleted, based on the WHERE clause. Set variable eOnePass + ** to indicate the strategy used to implement this delete: + ** + ** ONEPASS_OFF: Two-pass approach - use a FIFO for rowids/PK values. + ** ONEPASS_SINGLE: One-pass approach - at most one row deleted. + ** ONEPASS_MULTI: One-pass approach - any number of rows may be deleted. + */ + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, wcf, iTabCur+1); + if( pWInfo==0 ) goto delete_from_cleanup; + eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); + assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI ); + assert( IsVirtual(pTab) || bComplex || eOnePass!=ONEPASS_OFF ); + + /* Keep track of the number of rows to be deleted */ + if( db->flags & SQLITE_CountRows ){ + sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1); + } + + /* Extract the rowid or primary key for the current row */ + if( pPk ){ + for(i=0; iaiColumn[i]>=0 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, + pPk->aiColumn[i], iPk+i); + } + iKey = iPk; + }else{ + iKey = pParse->nMem + 1; + iKey = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iTabCur, iKey, 0); + if( iKey>pParse->nMem ) pParse->nMem = iKey; + } + + if( eOnePass!=ONEPASS_OFF ){ + /* For ONEPASS, no need to store the rowid/primary-key. There is only + ** one, so just keep it in its register(s) and fall through to the + ** delete code. */ + nKey = nPk; /* OP_Found will use an unpacked key */ + aToOpen = sqlite3DbMallocRaw(db, nIdx+2); + if( aToOpen==0 ){ + sqlite3WhereEnd(pWInfo); + goto delete_from_cleanup; + } + memset(aToOpen, 1, nIdx+1); + aToOpen[nIdx+1] = 0; + if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iTabCur] = 0; + if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iTabCur] = 0; + if( addrEphOpen ) sqlite3VdbeChangeToNoop(v, addrEphOpen); + }else{ + if( pPk ){ + /* Add the PK key for this row to the temporary table */ + iKey = ++pParse->nMem; + nKey = 0; /* Zero tells OP_Found to use a composite key */ + sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, iKey, + sqlite3IndexAffinityStr(pParse->db, pPk), nPk); + sqlite3VdbeAddOp2(v, OP_IdxInsert, iEphCur, iKey); + }else{ + /* Add the rowid of the row to be deleted to the RowSet */ + nKey = 1; /* OP_Seek always uses a single rowid */ + sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iKey); + } + } + + /* If this DELETE cannot use the ONEPASS strategy, this is the + ** end of the WHERE loop */ + if( eOnePass!=ONEPASS_OFF ){ + addrBypass = sqlite3VdbeMakeLabel(v); + }else{ + sqlite3WhereEnd(pWInfo); + } + + /* Unless this is a view, open cursors for the table we are + ** deleting from and all its indices. If this is a view, then the + ** only effect this statement has is to fire the INSTEAD OF + ** triggers. + */ + if( !isView ){ + int iAddrOnce = 0; + if( eOnePass==ONEPASS_MULTI ){ + iAddrOnce = sqlite3CodeOnce(pParse); VdbeCoverage(v); + } + testcase( IsVirtual(pTab) ); + sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iTabCur, aToOpen, + &iDataCur, &iIdxCur); + assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur ); + assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 ); + if( eOnePass==ONEPASS_MULTI ) sqlite3VdbeJumpHere(v, iAddrOnce); + } + + /* Set up a loop over the rowids/primary-keys that were found in the + ** where-clause loop above. + */ + if( eOnePass!=ONEPASS_OFF ){ + assert( nKey==nPk ); /* OP_Found will use an unpacked key */ + if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){ + assert( pPk!=0 || pTab->pSelect!=0 ); + sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey); + VdbeCoverage(v); + } + }else if( pPk ){ + addrLoop = sqlite3VdbeAddOp1(v, OP_Rewind, iEphCur); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_RowKey, iEphCur, iKey); + assert( nKey==0 ); /* OP_Found will use a composite key */ + }else{ + addrLoop = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, 0, iKey); + VdbeCoverage(v); + assert( nKey==1 ); + } + + /* Delete the row */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); + sqlite3VtabMakeWritable(pParse, pTab); + sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB); + sqlite3VdbeChangeP5(v, OE_Abort); + assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE ); + sqlite3MayAbort(pParse); + if( eOnePass==ONEPASS_SINGLE && sqlite3IsToplevel(pParse) ){ + pParse->isMultiWrite = 0; + } + }else +#endif + { + int count = (pParse->nested==0); /* True to count changes */ + int iIdxNoSeek = -1; + if( bComplex==0 && aiCurOnePass[1]!=iDataCur ){ + iIdxNoSeek = aiCurOnePass[1]; + } + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur, + iKey, nKey, count, OE_Default, eOnePass, iIdxNoSeek); + } + + /* End of the loop over all rowids/primary-keys. */ + if( eOnePass!=ONEPASS_OFF ){ + sqlite3VdbeResolveLabel(v, addrBypass); + sqlite3WhereEnd(pWInfo); + }else if( pPk ){ + sqlite3VdbeAddOp2(v, OP_Next, iEphCur, addrLoop+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrLoop); + }else{ + sqlite3VdbeGoto(v, addrLoop); + sqlite3VdbeJumpHere(v, addrLoop); + } + + /* Close the cursors open on the table and its indexes. */ + if( !isView && !IsVirtual(pTab) ){ + if( !pPk ) sqlite3VdbeAddOp1(v, OP_Close, iDataCur); + for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ + sqlite3VdbeAddOp1(v, OP_Close, iIdxCur + i); + } + } + } /* End non-truncate path */ + + /* Update the sqlite_sequence table by storing the content of the + ** maximum rowid counter values recorded while inserting into + ** autoincrement tables. + */ + if( pParse->nested==0 && pParse->pTriggerTab==0 ){ + sqlite3AutoincrementEnd(pParse); + } + + /* Return the number of rows that were deleted. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. + */ + if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){ + sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC); + } + +delete_from_cleanup: + sqlite3AuthContextPop(&sContext); + sqlite3SrcListDelete(db, pTabList); + sqlite3ExprDelete(db, pWhere); + sqlite3DbFree(db, aToOpen); + return; +} +/* Make sure "isView" and other macros defined above are undefined. Otherwise +** they may interfere with compilation of other functions in this file +** (or in another file, if this file becomes part of the amalgamation). */ +#ifdef isView + #undef isView +#endif +#ifdef pTrigger + #undef pTrigger +#endif + +/* +** This routine generates VDBE code that causes a single row of a +** single table to be deleted. Both the original table entry and +** all indices are removed. +** +** Preconditions: +** +** 1. iDataCur is an open cursor on the btree that is the canonical data +** store for the table. (This will be either the table itself, +** in the case of a rowid table, or the PRIMARY KEY index in the case +** of a WITHOUT ROWID table.) +** +** 2. Read/write cursors for all indices of pTab must be open as +** cursor number iIdxCur+i for the i-th index. +** +** 3. The primary key for the row to be deleted must be stored in a +** sequence of nPk memory cells starting at iPk. If nPk==0 that means +** that a search record formed from OP_MakeRecord is contained in the +** single memory location iPk. +** +** eMode: +** Parameter eMode may be passed either ONEPASS_OFF (0), ONEPASS_SINGLE, or +** ONEPASS_MULTI. If eMode is not ONEPASS_OFF, then the cursor +** iDataCur already points to the row to delete. If eMode is ONEPASS_OFF +** then this function must seek iDataCur to the entry identified by iPk +** and nPk before reading from it. +** +** If eMode is ONEPASS_MULTI, then this call is being made as part +** of a ONEPASS delete that affects multiple rows. In this case, if +** iIdxNoSeek is a valid cursor number (>=0), then its position should +** be preserved following the delete operation. Or, if iIdxNoSeek is not +** a valid cursor number, the position of iDataCur should be preserved +** instead. +** +** iIdxNoSeek: +** If iIdxNoSeek is a valid cursor number (>=0), then it identifies an +** index cursor (from within array of cursors starting at iIdxCur) that +** already points to the index entry to be deleted. +*/ +SQLITE_PRIVATE void sqlite3GenerateRowDelete( + Parse *pParse, /* Parsing context */ + Table *pTab, /* Table containing the row to be deleted */ + Trigger *pTrigger, /* List of triggers to (potentially) fire */ + int iDataCur, /* Cursor from which column data is extracted */ + int iIdxCur, /* First index cursor */ + int iPk, /* First memory cell containing the PRIMARY KEY */ + i16 nPk, /* Number of PRIMARY KEY memory cells */ + u8 count, /* If non-zero, increment the row change counter */ + u8 onconf, /* Default ON CONFLICT policy for triggers */ + u8 eMode, /* ONEPASS_OFF, _SINGLE, or _MULTI. See above */ + int iIdxNoSeek /* Cursor number of cursor that does not need seeking */ +){ + Vdbe *v = pParse->pVdbe; /* Vdbe */ + int iOld = 0; /* First register in OLD.* array */ + int iLabel; /* Label resolved to end of generated code */ + u8 opSeek; /* Seek opcode */ + + /* Vdbe is guaranteed to have been allocated by this stage. */ + assert( v ); + VdbeModuleComment((v, "BEGIN: GenRowDel(%d,%d,%d,%d)", + iDataCur, iIdxCur, iPk, (int)nPk)); + + /* Seek cursor iCur to the row to delete. If this row no longer exists + ** (this can happen if a trigger program has already deleted it), do + ** not attempt to delete it or fire any DELETE triggers. */ + iLabel = sqlite3VdbeMakeLabel(v); + opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound; + if( eMode==ONEPASS_OFF ){ + sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk); + VdbeCoverageIf(v, opSeek==OP_NotExists); + VdbeCoverageIf(v, opSeek==OP_NotFound); + } + + /* If there are any triggers to fire, allocate a range of registers to + ** use for the old.* references in the triggers. */ + if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){ + u32 mask; /* Mask of OLD.* columns in use */ + int iCol; /* Iterator used while populating OLD.* */ + int addrStart; /* Start of BEFORE trigger programs */ + + /* TODO: Could use temporary registers here. Also could attempt to + ** avoid copying the contents of the rowid register. */ + mask = sqlite3TriggerColmask( + pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf + ); + mask |= sqlite3FkOldmask(pParse, pTab); + iOld = pParse->nMem+1; + pParse->nMem += (1 + pTab->nCol); + + /* Populate the OLD.* pseudo-table register array. These values will be + ** used by any BEFORE and AFTER triggers that exist. */ + sqlite3VdbeAddOp2(v, OP_Copy, iPk, iOld); + for(iCol=0; iColnCol; iCol++){ + testcase( mask!=0xffffffff && iCol==31 ); + testcase( mask!=0xffffffff && iCol==32 ); + if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+iCol+1); + } + } + + /* Invoke BEFORE DELETE trigger programs. */ + addrStart = sqlite3VdbeCurrentAddr(v); + sqlite3CodeRowTrigger(pParse, pTrigger, + TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel + ); + + /* If any BEFORE triggers were coded, then seek the cursor to the + ** row to be deleted again. It may be that the BEFORE triggers moved + ** the cursor or of already deleted the row that the cursor was + ** pointing to. + */ + if( addrStartpSelect==0 ){ + sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek); + sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0)); + if( count ){ + sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT); + } + if( iIdxNoSeek>=0 ){ + sqlite3VdbeAddOp1(v, OP_Delete, iIdxNoSeek); + } + sqlite3VdbeChangeP5(v, eMode==ONEPASS_MULTI); + } + + /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to + ** handle rows (possibly in other tables) that refer via a foreign key + ** to the row just deleted. */ + sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0); + + /* Invoke AFTER DELETE trigger programs. */ + sqlite3CodeRowTrigger(pParse, pTrigger, + TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel + ); + + /* Jump here if the row had already been deleted before any BEFORE + ** trigger programs were invoked. Or if a trigger program throws a + ** RAISE(IGNORE) exception. */ + sqlite3VdbeResolveLabel(v, iLabel); + VdbeModuleComment((v, "END: GenRowDel()")); +} + +/* +** This routine generates VDBE code that causes the deletion of all +** index entries associated with a single row of a single table, pTab +** +** Preconditions: +** +** 1. A read/write cursor "iDataCur" must be open on the canonical storage +** btree for the table pTab. (This will be either the table itself +** for rowid tables or to the primary key index for WITHOUT ROWID +** tables.) +** +** 2. Read/write cursors for all indices of pTab must be open as +** cursor number iIdxCur+i for the i-th index. (The pTab->pIndex +** index is the 0-th index.) +** +** 3. The "iDataCur" cursor must be already be positioned on the row +** that is to be deleted. +*/ +SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete( + Parse *pParse, /* Parsing and code generating context */ + Table *pTab, /* Table containing the row to be deleted */ + int iDataCur, /* Cursor of table holding data. */ + int iIdxCur, /* First index cursor */ + int *aRegIdx, /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */ + int iIdxNoSeek /* Do not delete from this cursor */ +){ + int i; /* Index loop counter */ + int r1 = -1; /* Register holding an index key */ + int iPartIdxLabel; /* Jump destination for skipping partial index entries */ + Index *pIdx; /* Current index */ + Index *pPrior = 0; /* Prior index */ + Vdbe *v; /* The prepared statement under construction */ + Index *pPk; /* PRIMARY KEY index, or NULL for rowid tables */ + + v = pParse->pVdbe; + pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); + for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ + assert( iIdxCur+i!=iDataCur || pPk==pIdx ); + if( aRegIdx!=0 && aRegIdx[i]==0 ) continue; + if( pIdx==pPk ) continue; + if( iIdxCur+i==iIdxNoSeek ) continue; + VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName)); + r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1, + &iPartIdxLabel, pPrior, r1); + sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1, + pIdx->uniqNotNull ? pIdx->nKeyCol : pIdx->nColumn); + sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel); + pPrior = pIdx; + } +} + +/* +** Generate code that will assemble an index key and stores it in register +** regOut. The key with be for index pIdx which is an index on pTab. +** iCur is the index of a cursor open on the pTab table and pointing to +** the entry that needs indexing. If pTab is a WITHOUT ROWID table, then +** iCur must be the cursor of the PRIMARY KEY index. +** +** Return a register number which is the first in a block of +** registers that holds the elements of the index key. The +** block of registers has already been deallocated by the time +** this routine returns. +** +** If *piPartIdxLabel is not NULL, fill it in with a label and jump +** to that label if pIdx is a partial index that should be skipped. +** The label should be resolved using sqlite3ResolvePartIdxLabel(). +** A partial index should be skipped if its WHERE clause evaluates +** to false or null. If pIdx is not a partial index, *piPartIdxLabel +** will be set to zero which is an empty label that is ignored by +** sqlite3ResolvePartIdxLabel(). +** +** The pPrior and regPrior parameters are used to implement a cache to +** avoid unnecessary register loads. If pPrior is not NULL, then it is +** a pointer to a different index for which an index key has just been +** computed into register regPrior. If the current pIdx index is generating +** its key into the same sequence of registers and if pPrior and pIdx share +** a column in common, then the register corresponding to that column already +** holds the correct value and the loading of that register is skipped. +** This optimization is helpful when doing a DELETE or an INTEGRITY_CHECK +** on a table with multiple indices, and especially with the ROWID or +** PRIMARY KEY columns of the index. +*/ +SQLITE_PRIVATE int sqlite3GenerateIndexKey( + Parse *pParse, /* Parsing context */ + Index *pIdx, /* The index for which to generate a key */ + int iDataCur, /* Cursor number from which to take column data */ + int regOut, /* Put the new key into this register if not 0 */ + int prefixOnly, /* Compute only a unique prefix of the key */ + int *piPartIdxLabel, /* OUT: Jump to this label to skip partial index */ + Index *pPrior, /* Previously generated index key */ + int regPrior /* Register holding previous generated key */ +){ + Vdbe *v = pParse->pVdbe; + int j; + int regBase; + int nCol; + + if( piPartIdxLabel ){ + if( pIdx->pPartIdxWhere ){ + *piPartIdxLabel = sqlite3VdbeMakeLabel(v); + pParse->iSelfTab = iDataCur; + sqlite3ExprCachePush(pParse); + sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel, + SQLITE_JUMPIFNULL); + }else{ + *piPartIdxLabel = 0; + } + } + nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn; + regBase = sqlite3GetTempRange(pParse, nCol); + if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0; + for(j=0; jaiColumn[j]==pIdx->aiColumn[j] + && pPrior->aiColumn[j]!=XN_EXPR + ){ + /* This column was already computed by the previous index */ + continue; + } + sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iDataCur, j, regBase+j); + /* If the column affinity is REAL but the number is an integer, then it + ** might be stored in the table as an integer (using a compact + ** representation) then converted to REAL by an OP_RealAffinity opcode. + ** But we are getting ready to store this value back into an index, where + ** it should be converted by to INTEGER again. So omit the OP_RealAffinity + ** opcode if it is present */ + sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity); + } + if( regOut ){ + sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut); + } + sqlite3ReleaseTempRange(pParse, regBase, nCol); + return regBase; +} + +/* +** If a prior call to sqlite3GenerateIndexKey() generated a jump-over label +** because it was a partial index, then this routine should be called to +** resolve that label. +*/ +SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse *pParse, int iLabel){ + if( iLabel ){ + sqlite3VdbeResolveLabel(pParse->pVdbe, iLabel); + sqlite3ExprCachePop(pParse); + } +} + +/************** End of delete.c **********************************************/ +/************** Begin file func.c ********************************************/ +/* +** 2002 February 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C-language implementations for many of the SQL +** functions of SQLite. (Some function, and in particular the date and +** time functions, are implemented separately.) +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ +/* #include "vdbeInt.h" */ + +/* +** Return the collating function associated with a function. +*/ +static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){ + VdbeOp *pOp; + assert( context->pVdbe!=0 ); + pOp = &context->pVdbe->aOp[context->iOp-1]; + assert( pOp->opcode==OP_CollSeq ); + assert( pOp->p4type==P4_COLLSEQ ); + return pOp->p4.pColl; +} + +/* +** Indicate that the accumulator load should be skipped on this +** iteration of the aggregate loop. +*/ +static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){ + context->skipFlag = 1; +} + +/* +** Implementation of the non-aggregate min() and max() functions +*/ +static void minmaxFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + int mask; /* 0 for min() or 0xffffffff for max() */ + int iBest; + CollSeq *pColl; + + assert( argc>1 ); + mask = sqlite3_user_data(context)==0 ? 0 : -1; + pColl = sqlite3GetFuncCollSeq(context); + assert( pColl ); + assert( mask==-1 || mask==0 ); + iBest = 0; + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + for(i=1; i=0 ){ + testcase( mask==0 ); + iBest = i; + } + } + sqlite3_result_value(context, argv[iBest]); +} + +/* +** Return the type of the argument. +*/ +static void typeofFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + const char *z = 0; + UNUSED_PARAMETER(NotUsed); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_INTEGER: z = "integer"; break; + case SQLITE_TEXT: z = "text"; break; + case SQLITE_FLOAT: z = "real"; break; + case SQLITE_BLOB: z = "blob"; break; + default: z = "null"; break; + } + sqlite3_result_text(context, z, -1, SQLITE_STATIC); +} + + +/* +** Implementation of the length() function +*/ +static void lengthFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int len; + + assert( argc==1 ); + UNUSED_PARAMETER(argc); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_BLOB: + case SQLITE_INTEGER: + case SQLITE_FLOAT: { + sqlite3_result_int(context, sqlite3_value_bytes(argv[0])); + break; + } + case SQLITE_TEXT: { + const unsigned char *z = sqlite3_value_text(argv[0]); + if( z==0 ) return; + len = 0; + while( *z ){ + len++; + SQLITE_SKIP_UTF8(z); + } + sqlite3_result_int(context, len); + break; + } + default: { + sqlite3_result_null(context); + break; + } + } +} + +/* +** Implementation of the abs() function. +** +** IMP: R-23979-26855 The abs(X) function returns the absolute value of +** the numeric argument X. +*/ +static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + assert( argc==1 ); + UNUSED_PARAMETER(argc); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_INTEGER: { + i64 iVal = sqlite3_value_int64(argv[0]); + if( iVal<0 ){ + if( iVal==SMALLEST_INT64 ){ + /* IMP: R-31676-45509 If X is the integer -9223372036854775808 + ** then abs(X) throws an integer overflow error since there is no + ** equivalent positive 64-bit two complement value. */ + sqlite3_result_error(context, "integer overflow", -1); + return; + } + iVal = -iVal; + } + sqlite3_result_int64(context, iVal); + break; + } + case SQLITE_NULL: { + /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */ + sqlite3_result_null(context); + break; + } + default: { + /* Because sqlite3_value_double() returns 0.0 if the argument is not + ** something that can be converted into a number, we have: + ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob + ** that cannot be converted to a numeric value. + */ + double rVal = sqlite3_value_double(argv[0]); + if( rVal<0 ) rVal = -rVal; + sqlite3_result_double(context, rVal); + break; + } + } +} + +/* +** Implementation of the instr() function. +** +** instr(haystack,needle) finds the first occurrence of needle +** in haystack and returns the number of previous characters plus 1, +** or 0 if needle does not occur within haystack. +** +** If both haystack and needle are BLOBs, then the result is one more than +** the number of bytes in haystack prior to the first occurrence of needle, +** or 0 if needle never occurs in haystack. +*/ +static void instrFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zHaystack; + const unsigned char *zNeedle; + int nHaystack; + int nNeedle; + int typeHaystack, typeNeedle; + int N = 1; + int isText; + + UNUSED_PARAMETER(argc); + typeHaystack = sqlite3_value_type(argv[0]); + typeNeedle = sqlite3_value_type(argv[1]); + if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return; + nHaystack = sqlite3_value_bytes(argv[0]); + nNeedle = sqlite3_value_bytes(argv[1]); + if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){ + zHaystack = sqlite3_value_blob(argv[0]); + zNeedle = sqlite3_value_blob(argv[1]); + isText = 0; + }else{ + zHaystack = sqlite3_value_text(argv[0]); + zNeedle = sqlite3_value_text(argv[1]); + isText = 1; + } + while( nNeedle<=nHaystack && memcmp(zHaystack, zNeedle, nNeedle)!=0 ){ + N++; + do{ + nHaystack--; + zHaystack++; + }while( isText && (zHaystack[0]&0xc0)==0x80 ); + } + if( nNeedle>nHaystack ) N = 0; + sqlite3_result_int(context, N); +} + +/* +** Implementation of the printf() function. +*/ +static void printfFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + PrintfArguments x; + StrAccum str; + const char *zFormat; + int n; + sqlite3 *db = sqlite3_context_db_handle(context); + + if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){ + x.nArg = argc-1; + x.nUsed = 0; + x.apArg = argv+1; + sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); + sqlite3XPrintf(&str, SQLITE_PRINTF_SQLFUNC, zFormat, &x); + n = str.nChar; + sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n, + SQLITE_DYNAMIC); + } +} + +/* +** Implementation of the substr() function. +** +** substr(x,p1,p2) returns p2 characters of x[] beginning with p1. +** p1 is 1-indexed. So substr(x,1,1) returns the first character +** of x. If x is text, then we actually count UTF-8 characters. +** If x is a blob, then we count bytes. +** +** If p1 is negative, then we begin abs(p1) from the end of x[]. +** +** If p2 is negative, return the p2 characters preceding p1. +*/ +static void substrFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *z; + const unsigned char *z2; + int len; + int p0type; + i64 p1, p2; + int negP2 = 0; + + assert( argc==3 || argc==2 ); + if( sqlite3_value_type(argv[1])==SQLITE_NULL + || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL) + ){ + return; + } + p0type = sqlite3_value_type(argv[0]); + p1 = sqlite3_value_int(argv[1]); + if( p0type==SQLITE_BLOB ){ + len = sqlite3_value_bytes(argv[0]); + z = sqlite3_value_blob(argv[0]); + if( z==0 ) return; + assert( len==sqlite3_value_bytes(argv[0]) ); + }else{ + z = sqlite3_value_text(argv[0]); + if( z==0 ) return; + len = 0; + if( p1<0 ){ + for(z2=z; *z2; len++){ + SQLITE_SKIP_UTF8(z2); + } + } + } +#ifdef SQLITE_SUBSTR_COMPATIBILITY + /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as + ** as substr(X,1,N) - it returns the first N characters of X. This + ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8] + ** from 2009-02-02 for compatibility of applications that exploited the + ** old buggy behavior. */ + if( p1==0 ) p1 = 1; /* */ +#endif + if( argc==3 ){ + p2 = sqlite3_value_int(argv[2]); + if( p2<0 ){ + p2 = -p2; + negP2 = 1; + } + }else{ + p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH]; + } + if( p1<0 ){ + p1 += len; + if( p1<0 ){ + p2 += p1; + if( p2<0 ) p2 = 0; + p1 = 0; + } + }else if( p1>0 ){ + p1--; + }else if( p2>0 ){ + p2--; + } + if( negP2 ){ + p1 -= p2; + if( p1<0 ){ + p2 += p1; + p1 = 0; + } + } + assert( p1>=0 && p2>=0 ); + if( p0type!=SQLITE_BLOB ){ + while( *z && p1 ){ + SQLITE_SKIP_UTF8(z); + p1--; + } + for(z2=z; *z2 && p2; p2--){ + SQLITE_SKIP_UTF8(z2); + } + sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT, + SQLITE_UTF8); + }else{ + if( p1+p2>len ){ + p2 = len-p1; + if( p2<0 ) p2 = 0; + } + sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT); + } +} + +/* +** Implementation of the round() function +*/ +#ifndef SQLITE_OMIT_FLOATING_POINT +static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + int n = 0; + double r; + char *zBuf; + assert( argc==1 || argc==2 ); + if( argc==2 ){ + if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return; + n = sqlite3_value_int(argv[1]); + if( n>30 ) n = 30; + if( n<0 ) n = 0; + } + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + r = sqlite3_value_double(argv[0]); + /* If Y==0 and X will fit in a 64-bit int, + ** handle the rounding directly, + ** otherwise use printf. + */ + if( n==0 && r>=0 && r0 ); + testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] ); + testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 ); + if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + sqlite3_result_error_toobig(context); + z = 0; + }else{ + z = sqlite3Malloc(nByte); + if( !z ){ + sqlite3_result_error_nomem(context); + } + } + return z; +} + +/* +** Implementation of the upper() and lower() SQL functions. +*/ +static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + char *z1; + const char *z2; + int i, n; + UNUSED_PARAMETER(argc); + z2 = (char*)sqlite3_value_text(argv[0]); + n = sqlite3_value_bytes(argv[0]); + /* Verify that the call to _bytes() does not invalidate the _text() pointer */ + assert( z2==(char*)sqlite3_value_text(argv[0]) ); + if( z2 ){ + z1 = contextMalloc(context, ((i64)n)+1); + if( z1 ){ + for(i=0; imatchOne; /* "?" or "_" */ + u32 matchAll = pInfo->matchAll; /* "*" or "%" */ + u32 matchOther; /* "[" or the escape character */ + u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */ + const u8 *zEscaped = 0; /* One past the last escaped input char */ + + /* The GLOB operator does not have an ESCAPE clause. And LIKE does not + ** have the matchSet operator. So we either have to look for one or + ** the other, never both. Hence the single variable matchOther is used + ** to store the one we have to look for. + */ + matchOther = esc ? esc : pInfo->matchSet; + + while( (c = Utf8Read(zPattern))!=0 ){ + if( c==matchAll ){ /* Match "*" */ + /* Skip over multiple "*" characters in the pattern. If there + ** are also "?" characters, skip those as well, but consume a + ** single character of the input string for each "?" skipped */ + while( (c=Utf8Read(zPattern)) == matchAll || c == matchOne ){ + if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){ + return 0; + } + } + if( c==0 ){ + return 1; /* "*" at the end of the pattern matches */ + }else if( c==matchOther ){ + if( esc ){ + c = sqlite3Utf8Read(&zPattern); + if( c==0 ) return 0; + }else{ + /* "[...]" immediately follows the "*". We have to do a slow + ** recursive search in this case, but it is an unusual case. */ + assert( matchOther<0x80 ); /* '[' is a single-byte character */ + while( *zString + && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){ + SQLITE_SKIP_UTF8(zString); + } + return *zString!=0; + } + } + + /* At this point variable c contains the first character of the + ** pattern string past the "*". Search in the input string for the + ** first matching character and recursively contine the match from + ** that point. + ** + ** For a case-insensitive search, set variable cx to be the same as + ** c but in the other case and search the input string for either + ** c or cx. + */ + if( c<=0x80 ){ + u32 cx; + if( noCase ){ + cx = sqlite3Toupper(c); + c = sqlite3Tolower(c); + }else{ + cx = c; + } + while( (c2 = *(zString++))!=0 ){ + if( c2!=c && c2!=cx ) continue; + if( patternCompare(zPattern,zString,pInfo,esc) ) return 1; + } + }else{ + while( (c2 = Utf8Read(zString))!=0 ){ + if( c2!=c ) continue; + if( patternCompare(zPattern,zString,pInfo,esc) ) return 1; + } + } + return 0; + } + if( c==matchOther ){ + if( esc ){ + c = sqlite3Utf8Read(&zPattern); + if( c==0 ) return 0; + zEscaped = zPattern; + }else{ + u32 prior_c = 0; + int seen = 0; + int invert = 0; + c = sqlite3Utf8Read(&zString); + if( c==0 ) return 0; + c2 = sqlite3Utf8Read(&zPattern); + if( c2=='^' ){ + invert = 1; + c2 = sqlite3Utf8Read(&zPattern); + } + if( c2==']' ){ + if( c==']' ) seen = 1; + c2 = sqlite3Utf8Read(&zPattern); + } + while( c2 && c2!=']' ){ + if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){ + c2 = sqlite3Utf8Read(&zPattern); + if( c>=prior_c && c<=c2 ) seen = 1; + prior_c = 0; + }else{ + if( c==c2 ){ + seen = 1; + } + prior_c = c2; + } + c2 = sqlite3Utf8Read(&zPattern); + } + if( c2==0 || (seen ^ invert)==0 ){ + return 0; + } + continue; + } + } + c2 = Utf8Read(zString); + if( c==c2 ) continue; + if( noCase && c<0x80 && c2<0x80 && sqlite3Tolower(c)==sqlite3Tolower(c2) ){ + continue; + } + if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue; + return 0; + } + return *zString==0; +} + +/* +** The sqlite3_strglob() interface. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_strglob(const char *zGlobPattern, const char *zString){ + return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, 0)==0; +} + +/* +** Count the number of times that the LIKE operator (or GLOB which is +** just a variation of LIKE) gets called. This is used for testing +** only. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_like_count = 0; +#endif + + +/* +** Implementation of the like() SQL function. This function implements +** the build-in LIKE operator. The first argument to the function is the +** pattern and the second argument is the string. So, the SQL statements: +** +** A LIKE B +** +** is implemented as like(B,A). +** +** This same function (with a different compareInfo structure) computes +** the GLOB operator. +*/ +static void likeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zA, *zB; + u32 escape = 0; + int nPat; + sqlite3 *db = sqlite3_context_db_handle(context); + + zB = sqlite3_value_text(argv[0]); + zA = sqlite3_value_text(argv[1]); + + /* Limit the length of the LIKE or GLOB pattern to avoid problems + ** of deep recursion and N*N behavior in patternCompare(). + */ + nPat = sqlite3_value_bytes(argv[0]); + testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ); + testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 ); + if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){ + sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); + return; + } + assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */ + + if( argc==3 ){ + /* The escape character string must consist of a single UTF-8 character. + ** Otherwise, return an error. + */ + const unsigned char *zEsc = sqlite3_value_text(argv[2]); + if( zEsc==0 ) return; + if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){ + sqlite3_result_error(context, + "ESCAPE expression must be a single character", -1); + return; + } + escape = sqlite3Utf8Read(&zEsc); + } + if( zA && zB ){ + struct compareInfo *pInfo = sqlite3_user_data(context); +#ifdef SQLITE_TEST + sqlite3_like_count++; +#endif + + sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape)); + } +} + +/* +** Implementation of the NULLIF(x,y) function. The result is the first +** argument if the arguments are different. The result is NULL if the +** arguments are equal to each other. +*/ +static void nullifFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + CollSeq *pColl = sqlite3GetFuncCollSeq(context); + UNUSED_PARAMETER(NotUsed); + if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ + sqlite3_result_value(context, argv[0]); + } +} + +/* +** Implementation of the sqlite_version() function. The result is the version +** of the SQLite library that is running. +*/ +static void versionFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + /* IMP: R-48699-48617 This function is an SQL wrapper around the + ** sqlite3_libversion() C-interface. */ + sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC); +} + +/* +** Implementation of the sqlite_source_id() function. The result is a string +** that identifies the particular version of the source code used to build +** SQLite. +*/ +static void sourceidFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + /* IMP: R-24470-31136 This function is an SQL wrapper around the + ** sqlite3_sourceid() C interface. */ + sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC); +} + +/* +** Implementation of the sqlite_log() function. This is a wrapper around +** sqlite3_log(). The return value is NULL. The function exists purely for +** its side-effects. +*/ +static void errlogFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(context); + sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1])); +} + +/* +** Implementation of the sqlite_compileoption_used() function. +** The result is an integer that identifies if the compiler option +** was used to build SQLite. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +static void compileoptionusedFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zOptName; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL + ** function is a wrapper around the sqlite3_compileoption_used() C/C++ + ** function. + */ + if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){ + sqlite3_result_int(context, sqlite3_compileoption_used(zOptName)); + } +} +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +/* +** Implementation of the sqlite_compileoption_get() function. +** The result is a string that identifies the compiler options +** used to build SQLite. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +static void compileoptiongetFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int n; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function + ** is a wrapper around the sqlite3_compileoption_get() C/C++ function. + */ + n = sqlite3_value_int(argv[0]); + sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC); +} +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +/* Array for converting from half-bytes (nybbles) into ASCII hex +** digits. */ +static const char hexdigits[] = { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' +}; + +/* +** Implementation of the QUOTE() function. This function takes a single +** argument. If the argument is numeric, the return value is the same as +** the argument. If the argument is NULL, the return value is the string +** "NULL". Otherwise, the argument is enclosed in single quotes with +** single-quote escapes. +*/ +static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + assert( argc==1 ); + UNUSED_PARAMETER(argc); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_FLOAT: { + double r1, r2; + char zBuf[50]; + r1 = sqlite3_value_double(argv[0]); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1); + sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8); + if( r1!=r2 ){ + sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1); + } + sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); + break; + } + case SQLITE_INTEGER: { + sqlite3_result_value(context, argv[0]); + break; + } + case SQLITE_BLOB: { + char *zText = 0; + char const *zBlob = sqlite3_value_blob(argv[0]); + int nBlob = sqlite3_value_bytes(argv[0]); + assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ + zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4); + if( zText ){ + int i; + for(i=0; i>4)&0x0F]; + zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; + } + zText[(nBlob*2)+2] = '\''; + zText[(nBlob*2)+3] = '\0'; + zText[0] = 'X'; + zText[1] = '\''; + sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); + sqlite3_free(zText); + } + break; + } + case SQLITE_TEXT: { + int i,j; + u64 n; + const unsigned char *zArg = sqlite3_value_text(argv[0]); + char *z; + + if( zArg==0 ) return; + for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; } + z = contextMalloc(context, ((i64)i)+((i64)n)+3); + if( z ){ + z[0] = '\''; + for(i=0, j=1; zArg[i]; i++){ + z[j++] = zArg[i]; + if( zArg[i]=='\'' ){ + z[j++] = '\''; + } + } + z[j++] = '\''; + z[j] = 0; + sqlite3_result_text(context, z, j, sqlite3_free); + } + break; + } + default: { + assert( sqlite3_value_type(argv[0])==SQLITE_NULL ); + sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC); + break; + } + } +} + +/* +** The unicode() function. Return the integer unicode code-point value +** for the first character of the input string. +*/ +static void unicodeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *z = sqlite3_value_text(argv[0]); + (void)argc; + if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z)); +} + +/* +** The char() function takes zero or more arguments, each of which is +** an integer. It constructs a string where each character of the string +** is the unicode character for the corresponding integer argument. +*/ +static void charFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + unsigned char *z, *zOut; + int i; + zOut = z = sqlite3_malloc64( argc*4+1 ); + if( z==0 ){ + sqlite3_result_error_nomem(context); + return; + } + for(i=0; i0x10ffff ) x = 0xfffd; + c = (unsigned)(x & 0x1fffff); + if( c<0x00080 ){ + *zOut++ = (u8)(c&0xFF); + }else if( c<0x00800 ){ + *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); + *zOut++ = 0x80 + (u8)(c & 0x3F); + }else if( c<0x10000 ){ + *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); + *zOut++ = 0x80 + (u8)(c & 0x3F); + }else{ + *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); + *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); + *zOut++ = 0x80 + (u8)(c & 0x3F); + } \ + } + sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8); +} + +/* +** The hex() function. Interpret the argument as a blob. Return +** a hexadecimal rendering as text. +*/ +static void hexFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i, n; + const unsigned char *pBlob; + char *zHex, *z; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + pBlob = sqlite3_value_blob(argv[0]); + n = sqlite3_value_bytes(argv[0]); + assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ + z = zHex = contextMalloc(context, ((i64)n)*2 + 1); + if( zHex ){ + for(i=0; i>4)&0xf]; + *(z++) = hexdigits[c&0xf]; + } + *z = 0; + sqlite3_result_text(context, zHex, n*2, sqlite3_free); + } +} + +/* +** The zeroblob(N) function returns a zero-filled blob of size N bytes. +*/ +static void zeroblobFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + i64 n; + int rc; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + n = sqlite3_value_int64(argv[0]); + if( n<0 ) n = 0; + rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */ + if( rc ){ + sqlite3_result_error_code(context, rc); + } +} + +/* +** The replace() function. Three arguments are all strings: call +** them A, B, and C. The result is also a string which is derived +** from A by replacing every occurrence of B with C. The match +** must be exact. Collating sequences are not used. +*/ +static void replaceFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zStr; /* The input string A */ + const unsigned char *zPattern; /* The pattern string B */ + const unsigned char *zRep; /* The replacement string C */ + unsigned char *zOut; /* The output */ + int nStr; /* Size of zStr */ + int nPattern; /* Size of zPattern */ + int nRep; /* Size of zRep */ + i64 nOut; /* Maximum size of zOut */ + int loopLimit; /* Last zStr[] that might match zPattern[] */ + int i, j; /* Loop counters */ + + assert( argc==3 ); + UNUSED_PARAMETER(argc); + zStr = sqlite3_value_text(argv[0]); + if( zStr==0 ) return; + nStr = sqlite3_value_bytes(argv[0]); + assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */ + zPattern = sqlite3_value_text(argv[1]); + if( zPattern==0 ){ + assert( sqlite3_value_type(argv[1])==SQLITE_NULL + || sqlite3_context_db_handle(context)->mallocFailed ); + return; + } + if( zPattern[0]==0 ){ + assert( sqlite3_value_type(argv[1])!=SQLITE_NULL ); + sqlite3_result_value(context, argv[0]); + return; + } + nPattern = sqlite3_value_bytes(argv[1]); + assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */ + zRep = sqlite3_value_text(argv[2]); + if( zRep==0 ) return; + nRep = sqlite3_value_bytes(argv[2]); + assert( zRep==sqlite3_value_text(argv[2]) ); + nOut = nStr + 1; + assert( nOutaLimit[SQLITE_LIMIT_LENGTH] ); + testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] ); + if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + sqlite3_result_error_toobig(context); + sqlite3_free(zOut); + return; + } + zOld = zOut; + zOut = sqlite3_realloc64(zOut, (int)nOut); + if( zOut==0 ){ + sqlite3_result_error_nomem(context); + sqlite3_free(zOld); + return; + } + memcpy(&zOut[j], zRep, nRep); + j += nRep; + i += nPattern-1; + } + } + assert( j+nStr-i+1==nOut ); + memcpy(&zOut[j], &zStr[i], nStr-i); + j += nStr - i; + assert( j<=nOut ); + zOut[j] = 0; + sqlite3_result_text(context, (char*)zOut, j, sqlite3_free); +} + +/* +** Implementation of the TRIM(), LTRIM(), and RTRIM() functions. +** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both. +*/ +static void trimFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zIn; /* Input string */ + const unsigned char *zCharSet; /* Set of characters to trim */ + int nIn; /* Number of bytes in input */ + int flags; /* 1: trimleft 2: trimright 3: trim */ + int i; /* Loop counter */ + unsigned char *aLen = 0; /* Length of each character in zCharSet */ + unsigned char **azChar = 0; /* Individual characters in zCharSet */ + int nChar; /* Number of characters in zCharSet */ + + if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ + return; + } + zIn = sqlite3_value_text(argv[0]); + if( zIn==0 ) return; + nIn = sqlite3_value_bytes(argv[0]); + assert( zIn==sqlite3_value_text(argv[0]) ); + if( argc==1 ){ + static const unsigned char lenOne[] = { 1 }; + static unsigned char * const azOne[] = { (u8*)" " }; + nChar = 1; + aLen = (u8*)lenOne; + azChar = (unsigned char **)azOne; + zCharSet = 0; + }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ + return; + }else{ + const unsigned char *z; + for(z=zCharSet, nChar=0; *z; nChar++){ + SQLITE_SKIP_UTF8(z); + } + if( nChar>0 ){ + azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1)); + if( azChar==0 ){ + return; + } + aLen = (unsigned char*)&azChar[nChar]; + for(z=zCharSet, nChar=0; *z; nChar++){ + azChar[nChar] = (unsigned char *)z; + SQLITE_SKIP_UTF8(z); + aLen[nChar] = (u8)(z - azChar[nChar]); + } + } + } + if( nChar>0 ){ + flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context)); + if( flags & 1 ){ + while( nIn>0 ){ + int len = 0; + for(i=0; i=nChar ) break; + zIn += len; + nIn -= len; + } + } + if( flags & 2 ){ + while( nIn>0 ){ + int len = 0; + for(i=0; i=nChar ) break; + nIn -= len; + } + } + if( zCharSet ){ + sqlite3_free(azChar); + } + } + sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT); +} + + +/* IMP: R-25361-16150 This function is omitted from SQLite by default. It +** is only available if the SQLITE_SOUNDEX compile-time option is used +** when SQLite is built. +*/ +#ifdef SQLITE_SOUNDEX +/* +** Compute the soundex encoding of a word. +** +** IMP: R-59782-00072 The soundex(X) function returns a string that is the +** soundex encoding of the string X. +*/ +static void soundexFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + char zResult[8]; + const u8 *zIn; + int i, j; + static const unsigned char iCode[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, + 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, + 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, + }; + assert( argc==1 ); + zIn = (u8*)sqlite3_value_text(argv[0]); + if( zIn==0 ) zIn = (u8*)""; + for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){} + if( zIn[i] ){ + u8 prevcode = iCode[zIn[i]&0x7f]; + zResult[0] = sqlite3Toupper(zIn[i]); + for(j=1; j<4 && zIn[i]; i++){ + int code = iCode[zIn[i]&0x7f]; + if( code>0 ){ + if( code!=prevcode ){ + prevcode = code; + zResult[j++] = code + '0'; + } + }else{ + prevcode = 0; + } + } + while( j<4 ){ + zResult[j++] = '0'; + } + zResult[j] = 0; + sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); + }else{ + /* IMP: R-64894-50321 The string "?000" is returned if the argument + ** is NULL or contains no ASCII alphabetic characters. */ + sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); + } +} +#endif /* SQLITE_SOUNDEX */ + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** A function that loads a shared-library extension then returns NULL. +*/ +static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){ + const char *zFile = (const char *)sqlite3_value_text(argv[0]); + const char *zProc; + sqlite3 *db = sqlite3_context_db_handle(context); + char *zErrMsg = 0; + + if( argc==2 ){ + zProc = (const char *)sqlite3_value_text(argv[1]); + }else{ + zProc = 0; + } + if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){ + sqlite3_result_error(context, zErrMsg, -1); + sqlite3_free(zErrMsg); + } +} +#endif + + +/* +** An instance of the following structure holds the context of a +** sum() or avg() aggregate computation. +*/ +typedef struct SumCtx SumCtx; +struct SumCtx { + double rSum; /* Floating point sum */ + i64 iSum; /* Integer sum */ + i64 cnt; /* Number of elements summed */ + u8 overflow; /* True if integer overflow seen */ + u8 approx; /* True if non-integer value was input to the sum */ +}; + +/* +** Routines used to compute the sum, average, and total. +** +** The SUM() function follows the (broken) SQL standard which means +** that it returns NULL if it sums over no inputs. TOTAL returns +** 0.0 in that case. In addition, TOTAL always returns a float where +** SUM might return an integer if it never encounters a floating point +** value. TOTAL never fails, but SUM might through an exception if +** it overflows an integer. +*/ +static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ + SumCtx *p; + int type; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + p = sqlite3_aggregate_context(context, sizeof(*p)); + type = sqlite3_value_numeric_type(argv[0]); + if( p && type!=SQLITE_NULL ){ + p->cnt++; + if( type==SQLITE_INTEGER ){ + i64 v = sqlite3_value_int64(argv[0]); + p->rSum += v; + if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){ + p->overflow = 1; + } + }else{ + p->rSum += sqlite3_value_double(argv[0]); + p->approx = 1; + } + } +} +static void sumFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + if( p && p->cnt>0 ){ + if( p->overflow ){ + sqlite3_result_error(context,"integer overflow",-1); + }else if( p->approx ){ + sqlite3_result_double(context, p->rSum); + }else{ + sqlite3_result_int64(context, p->iSum); + } + } +} +static void avgFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + if( p && p->cnt>0 ){ + sqlite3_result_double(context, p->rSum/(double)p->cnt); + } +} +static void totalFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + sqlite3_result_double(context, p ? p->rSum : (double)0); +} + +/* +** The following structure keeps track of state information for the +** count() aggregate function. +*/ +typedef struct CountCtx CountCtx; +struct CountCtx { + i64 n; +}; + +/* +** Routines to implement the count() aggregate function. +*/ +static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ + CountCtx *p; + p = sqlite3_aggregate_context(context, sizeof(*p)); + if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ + p->n++; + } + +#ifndef SQLITE_OMIT_DEPRECATED + /* The sqlite3_aggregate_count() function is deprecated. But just to make + ** sure it still operates correctly, verify that its count agrees with our + ** internal count when using count(*) and when the total count can be + ** expressed as a 32-bit integer. */ + assert( argc==1 || p==0 || p->n>0x7fffffff + || p->n==sqlite3_aggregate_count(context) ); +#endif +} +static void countFinalize(sqlite3_context *context){ + CountCtx *p; + p = sqlite3_aggregate_context(context, 0); + sqlite3_result_int64(context, p ? p->n : 0); +} + +/* +** Routines to implement min() and max() aggregate functions. +*/ +static void minmaxStep( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + Mem *pArg = (Mem *)argv[0]; + Mem *pBest; + UNUSED_PARAMETER(NotUsed); + + pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); + if( !pBest ) return; + + if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ + if( pBest->flags ) sqlite3SkipAccumulatorLoad(context); + }else if( pBest->flags ){ + int max; + int cmp; + CollSeq *pColl = sqlite3GetFuncCollSeq(context); + /* This step function is used for both the min() and max() aggregates, + ** the only difference between the two being that the sense of the + ** comparison is inverted. For the max() aggregate, the + ** sqlite3_user_data() function returns (void *)-1. For min() it + ** returns (void *)db, where db is the sqlite3* database pointer. + ** Therefore the next statement sets variable 'max' to 1 for the max() + ** aggregate, or 0 for min(). + */ + max = sqlite3_user_data(context)!=0; + cmp = sqlite3MemCompare(pBest, pArg, pColl); + if( (max && cmp<0) || (!max && cmp>0) ){ + sqlite3VdbeMemCopy(pBest, pArg); + }else{ + sqlite3SkipAccumulatorLoad(context); + } + }else{ + pBest->db = sqlite3_context_db_handle(context); + sqlite3VdbeMemCopy(pBest, pArg); + } +} +static void minMaxFinalize(sqlite3_context *context){ + sqlite3_value *pRes; + pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); + if( pRes ){ + if( pRes->flags ){ + sqlite3_result_value(context, pRes); + } + sqlite3VdbeMemRelease(pRes); + } +} + +/* +** group_concat(EXPR, ?SEPARATOR?) +*/ +static void groupConcatStep( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zVal; + StrAccum *pAccum; + const char *zSep; + int nVal, nSep; + assert( argc==1 || argc==2 ); + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum)); + + if( pAccum ){ + sqlite3 *db = sqlite3_context_db_handle(context); + int firstTerm = pAccum->mxAlloc==0; + pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH]; + if( !firstTerm ){ + if( argc==2 ){ + zSep = (char*)sqlite3_value_text(argv[1]); + nSep = sqlite3_value_bytes(argv[1]); + }else{ + zSep = ","; + nSep = 1; + } + if( nSep ) sqlite3StrAccumAppend(pAccum, zSep, nSep); + } + zVal = (char*)sqlite3_value_text(argv[0]); + nVal = sqlite3_value_bytes(argv[0]); + if( zVal ) sqlite3StrAccumAppend(pAccum, zVal, nVal); + } +} +static void groupConcatFinalize(sqlite3_context *context){ + StrAccum *pAccum; + pAccum = sqlite3_aggregate_context(context, 0); + if( pAccum ){ + if( pAccum->accError==STRACCUM_TOOBIG ){ + sqlite3_result_error_toobig(context); + }else if( pAccum->accError==STRACCUM_NOMEM ){ + sqlite3_result_error_nomem(context); + }else{ + sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1, + sqlite3_free); + } + } +} + +/* +** This routine does per-connection function registration. Most +** of the built-in functions above are part of the global function set. +** This routine only deals with those that are not global. +*/ +SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3 *db){ + int rc = sqlite3_overload_function(db, "MATCH", 2); + assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); + if( rc==SQLITE_NOMEM ){ + db->mallocFailed = 1; + } +} + +/* +** Set the LIKEOPT flag on the 2-argument function with the given name. +*/ +static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){ + FuncDef *pDef; + pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName), + 2, SQLITE_UTF8, 0); + if( ALWAYS(pDef) ){ + pDef->funcFlags |= flagVal; + } +} + +/* +** Register the built-in LIKE and GLOB functions. The caseSensitive +** parameter determines whether or not the LIKE operator is case +** sensitive. GLOB is always case sensitive. +*/ +SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ + struct compareInfo *pInfo; + if( caseSensitive ){ + pInfo = (struct compareInfo*)&likeInfoAlt; + }else{ + pInfo = (struct compareInfo*)&likeInfoNorm; + } + sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0); + sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0); + sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8, + (struct compareInfo*)&globInfo, likeFunc, 0, 0, 0); + setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE); + setLikeOptFlag(db, "like", + caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE); +} + +/* +** pExpr points to an expression which implements a function. If +** it is appropriate to apply the LIKE optimization to that function +** then set aWc[0] through aWc[2] to the wildcard characters and +** return TRUE. If the function is not a LIKE-style function then +** return FALSE. +** +** *pIsNocase is set to true if uppercase and lowercase are equivalent for +** the function (default for LIKE). If the function makes the distinction +** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to +** false. +*/ +SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ + FuncDef *pDef; + if( pExpr->op!=TK_FUNCTION + || !pExpr->x.pList + || pExpr->x.pList->nExpr!=2 + ){ + return 0; + } + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + pDef = sqlite3FindFunction(db, pExpr->u.zToken, + sqlite3Strlen30(pExpr->u.zToken), + 2, SQLITE_UTF8, 0); + if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){ + return 0; + } + + /* The memcpy() statement assumes that the wildcard characters are + ** the first three statements in the compareInfo structure. The + ** asserts() that follow verify that assumption + */ + memcpy(aWc, pDef->pUserData, 3); + assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); + assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); + assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); + *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0; + return 1; +} + +/* +** All of the FuncDef structures in the aBuiltinFunc[] array above +** to the global function hash table. This occurs at start-time (as +** a consequence of calling sqlite3_initialize()). +** +** After this routine runs +*/ +SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void){ + /* + ** The following array holds FuncDef structures for all of the functions + ** defined in this file. + ** + ** The array cannot be constant since changes are made to the + ** FuncDef.pHash elements at start-time. The elements of this array + ** are read-only after initialization is complete. + */ + static SQLITE_WSD FuncDef aBuiltinFunc[] = { + FUNCTION(ltrim, 1, 1, 0, trimFunc ), + FUNCTION(ltrim, 2, 1, 0, trimFunc ), + FUNCTION(rtrim, 1, 2, 0, trimFunc ), + FUNCTION(rtrim, 2, 2, 0, trimFunc ), + FUNCTION(trim, 1, 3, 0, trimFunc ), + FUNCTION(trim, 2, 3, 0, trimFunc ), + FUNCTION(min, -1, 0, 1, minmaxFunc ), + FUNCTION(min, 0, 0, 1, 0 ), + AGGREGATE2(min, 1, 0, 1, minmaxStep, minMaxFinalize, + SQLITE_FUNC_MINMAX ), + FUNCTION(max, -1, 1, 1, minmaxFunc ), + FUNCTION(max, 0, 1, 1, 0 ), + AGGREGATE2(max, 1, 1, 1, minmaxStep, minMaxFinalize, + SQLITE_FUNC_MINMAX ), + FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF), + FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH), + FUNCTION(instr, 2, 0, 0, instrFunc ), + FUNCTION(substr, 2, 0, 0, substrFunc ), + FUNCTION(substr, 3, 0, 0, substrFunc ), + FUNCTION(printf, -1, 0, 0, printfFunc ), + FUNCTION(unicode, 1, 0, 0, unicodeFunc ), + FUNCTION(char, -1, 0, 0, charFunc ), + FUNCTION(abs, 1, 0, 0, absFunc ), +#ifndef SQLITE_OMIT_FLOATING_POINT + FUNCTION(round, 1, 0, 0, roundFunc ), + FUNCTION(round, 2, 0, 0, roundFunc ), +#endif + FUNCTION(upper, 1, 0, 0, upperFunc ), + FUNCTION(lower, 1, 0, 0, lowerFunc ), + FUNCTION(coalesce, 1, 0, 0, 0 ), + FUNCTION(coalesce, 0, 0, 0, 0 ), + FUNCTION2(coalesce, -1, 0, 0, noopFunc, SQLITE_FUNC_COALESCE), + FUNCTION(hex, 1, 0, 0, hexFunc ), + FUNCTION2(ifnull, 2, 0, 0, noopFunc, SQLITE_FUNC_COALESCE), + FUNCTION2(unlikely, 1, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), + FUNCTION2(likelihood, 2, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), + FUNCTION2(likely, 1, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY), + VFUNCTION(random, 0, 0, 0, randomFunc ), + VFUNCTION(randomblob, 1, 0, 0, randomBlob ), + FUNCTION(nullif, 2, 0, 1, nullifFunc ), + DFUNCTION(sqlite_version, 0, 0, 0, versionFunc ), + DFUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ), + FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ), +#if SQLITE_USER_AUTHENTICATION + FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ), +#endif +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS + DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ), + DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ), +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + FUNCTION(quote, 1, 0, 0, quoteFunc ), + VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid), + VFUNCTION(changes, 0, 0, 0, changes ), + VFUNCTION(total_changes, 0, 0, 0, total_changes ), + FUNCTION(replace, 3, 0, 0, replaceFunc ), + FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ), + #ifdef SQLITE_SOUNDEX + FUNCTION(soundex, 1, 0, 0, soundexFunc ), + #endif + #ifndef SQLITE_OMIT_LOAD_EXTENSION + VFUNCTION(load_extension, 1, 0, 0, loadExt ), + VFUNCTION(load_extension, 2, 0, 0, loadExt ), + #endif + AGGREGATE(sum, 1, 0, 0, sumStep, sumFinalize ), + AGGREGATE(total, 1, 0, 0, sumStep, totalFinalize ), + AGGREGATE(avg, 1, 0, 0, sumStep, avgFinalize ), + AGGREGATE2(count, 0, 0, 0, countStep, countFinalize, + SQLITE_FUNC_COUNT ), + AGGREGATE(count, 1, 0, 0, countStep, countFinalize ), + AGGREGATE(group_concat, 1, 0, 0, groupConcatStep, groupConcatFinalize), + AGGREGATE(group_concat, 2, 0, 0, groupConcatStep, groupConcatFinalize), + + LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), + #ifdef SQLITE_CASE_SENSITIVE_LIKE + LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), + LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), + #else + LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE), + LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE), + #endif + }; + + int i; + FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions); + FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aBuiltinFunc); + + for(i=0; idb->mallocFailed flag is set. +*/ +SQLITE_PRIVATE int sqlite3FkLocateIndex( + Parse *pParse, /* Parse context to store any error in */ + Table *pParent, /* Parent table of FK constraint pFKey */ + FKey *pFKey, /* Foreign key to find index for */ + Index **ppIdx, /* OUT: Unique index on parent table */ + int **paiCol /* OUT: Map of index columns in pFKey */ +){ + Index *pIdx = 0; /* Value to return via *ppIdx */ + int *aiCol = 0; /* Value to return via *paiCol */ + int nCol = pFKey->nCol; /* Number of columns in parent key */ + char *zKey = pFKey->aCol[0].zCol; /* Name of left-most parent key column */ + + /* The caller is responsible for zeroing output parameters. */ + assert( ppIdx && *ppIdx==0 ); + assert( !paiCol || *paiCol==0 ); + assert( pParse ); + + /* If this is a non-composite (single column) foreign key, check if it + ** maps to the INTEGER PRIMARY KEY of table pParent. If so, leave *ppIdx + ** and *paiCol set to zero and return early. + ** + ** Otherwise, for a composite foreign key (more than one column), allocate + ** space for the aiCol array (returned via output parameter *paiCol). + ** Non-composite foreign keys do not require the aiCol array. + */ + if( nCol==1 ){ + /* The FK maps to the IPK if any of the following are true: + ** + ** 1) There is an INTEGER PRIMARY KEY column and the FK is implicitly + ** mapped to the primary key of table pParent, or + ** 2) The FK is explicitly mapped to a column declared as INTEGER + ** PRIMARY KEY. + */ + if( pParent->iPKey>=0 ){ + if( !zKey ) return 0; + if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0; + } + }else if( paiCol ){ + assert( nCol>1 ); + aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int)); + if( !aiCol ) return 1; + *paiCol = aiCol; + } + + for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) ){ + /* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number + ** of columns. If each indexed column corresponds to a foreign key + ** column of pFKey, then this index is a winner. */ + + if( zKey==0 ){ + /* If zKey is NULL, then this foreign key is implicitly mapped to + ** the PRIMARY KEY of table pParent. The PRIMARY KEY index may be + ** identified by the test. */ + if( IsPrimaryKeyIndex(pIdx) ){ + if( aiCol ){ + int i; + for(i=0; iaCol[i].iFrom; + } + break; + } + }else{ + /* If zKey is non-NULL, then this foreign key was declared to + ** map to an explicit list of columns in table pParent. Check if this + ** index matches those columns. Also, check that the index uses + ** the default collation sequences for each column. */ + int i, j; + for(i=0; iaiColumn[i]; /* Index of column in parent tbl */ + char *zDfltColl; /* Def. collation for column */ + char *zIdxCol; /* Name of indexed column */ + + if( iCol<0 ) break; /* No foreign keys against expression indexes */ + + /* If the index uses a collation sequence that is different from + ** the default collation sequence for the column, this index is + ** unusable. Bail out early in this case. */ + zDfltColl = pParent->aCol[iCol].zColl; + if( !zDfltColl ){ + zDfltColl = "BINARY"; + } + if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break; + + zIdxCol = pParent->aCol[iCol].zName; + for(j=0; jaCol[j].zCol, zIdxCol)==0 ){ + if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom; + break; + } + } + if( j==nCol ) break; + } + if( i==nCol ) break; /* pIdx is usable */ + } + } + } + + if( !pIdx ){ + if( !pParse->disableTriggers ){ + sqlite3ErrorMsg(pParse, + "foreign key mismatch - \"%w\" referencing \"%w\"", + pFKey->pFrom->zName, pFKey->zTo); + } + sqlite3DbFree(pParse->db, aiCol); + return 1; + } + + *ppIdx = pIdx; + return 0; +} + +/* +** This function is called when a row is inserted into or deleted from the +** child table of foreign key constraint pFKey. If an SQL UPDATE is executed +** on the child table of pFKey, this function is invoked twice for each row +** affected - once to "delete" the old row, and then again to "insert" the +** new row. +** +** Each time it is called, this function generates VDBE code to locate the +** row in the parent table that corresponds to the row being inserted into +** or deleted from the child table. If the parent row can be found, no +** special action is taken. Otherwise, if the parent row can *not* be +** found in the parent table: +** +** Operation | FK type | Action taken +** -------------------------------------------------------------------------- +** INSERT immediate Increment the "immediate constraint counter". +** +** DELETE immediate Decrement the "immediate constraint counter". +** +** INSERT deferred Increment the "deferred constraint counter". +** +** DELETE deferred Decrement the "deferred constraint counter". +** +** These operations are identified in the comment at the top of this file +** (fkey.c) as "I.1" and "D.1". +*/ +static void fkLookupParent( + Parse *pParse, /* Parse context */ + int iDb, /* Index of database housing pTab */ + Table *pTab, /* Parent table of FK pFKey */ + Index *pIdx, /* Unique index on parent key columns in pTab */ + FKey *pFKey, /* Foreign key constraint */ + int *aiCol, /* Map from parent key columns to child table columns */ + int regData, /* Address of array containing child table row */ + int nIncr, /* Increment constraint counter by this */ + int isIgnore /* If true, pretend pTab contains all NULL values */ +){ + int i; /* Iterator variable */ + Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */ + int iCur = pParse->nTab - 1; /* Cursor number to use */ + int iOk = sqlite3VdbeMakeLabel(v); /* jump here if parent key found */ + + /* If nIncr is less than zero, then check at runtime if there are any + ** outstanding constraints to resolve. If there are not, there is no need + ** to check if deleting this row resolves any outstanding violations. + ** + ** Check if any of the key columns in the child table row are NULL. If + ** any are, then the constraint is considered satisfied. No need to + ** search for a matching row in the parent table. */ + if( nIncr<0 ){ + sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk); + VdbeCoverage(v); + } + for(i=0; inCol; i++){ + int iReg = aiCol[i] + regData + 1; + sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk); VdbeCoverage(v); + } + + if( isIgnore==0 ){ + if( pIdx==0 ){ + /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY + ** column of the parent table (table pTab). */ + int iMustBeInt; /* Address of MustBeInt instruction */ + int regTemp = sqlite3GetTempReg(pParse); + + /* Invoke MustBeInt to coerce the child key value to an integer (i.e. + ** apply the affinity of the parent key). If this fails, then there + ** is no matching parent key. Before using MustBeInt, make a copy of + ** the value. Otherwise, the value inserted into the child key column + ** will have INTEGER affinity applied to it, which may not be correct. */ + sqlite3VdbeAddOp2(v, OP_SCopy, aiCol[0]+1+regData, regTemp); + iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0); + VdbeCoverage(v); + + /* If the parent table is the same as the child table, and we are about + ** to increment the constraint-counter (i.e. this is an INSERT operation), + ** then check if the row being inserted matches itself. If so, do not + ** increment the constraint-counter. */ + if( pTab==pFKey->pFrom && nIncr==1 ){ + sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + } + + sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead); + sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp); VdbeCoverage(v); + sqlite3VdbeGoto(v, iOk); + sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); + sqlite3VdbeJumpHere(v, iMustBeInt); + sqlite3ReleaseTempReg(pParse, regTemp); + }else{ + int nCol = pFKey->nCol; + int regTemp = sqlite3GetTempRange(pParse, nCol); + int regRec = sqlite3GetTempReg(pParse); + + sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + for(i=0; ipFrom && nIncr==1 ){ + int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1; + for(i=0; iaiColumn[i]+1+regData; + assert( pIdx->aiColumn[i]>=0 ); + assert( aiCol[i]!=pTab->iPKey ); + if( pIdx->aiColumn[i]==pTab->iPKey ){ + /* The parent key is a composite key that includes the IPK column */ + iParent = regData; + } + sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL); + } + sqlite3VdbeGoto(v, iOk); + } + + sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec, + sqlite3IndexAffinityStr(pParse->db,pIdx), nCol); + sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regRec, 0); VdbeCoverage(v); + + sqlite3ReleaseTempReg(pParse, regRec); + sqlite3ReleaseTempRange(pParse, regTemp, nCol); + } + } + + if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs) + && !pParse->pToplevel + && !pParse->isMultiWrite + ){ + /* Special case: If this is an INSERT statement that will insert exactly + ** one row into the table, raise a constraint immediately instead of + ** incrementing a counter. This is necessary as the VM code is being + ** generated for will not open a statement transaction. */ + assert( nIncr==1 ); + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY, + OE_Abort, 0, P4_STATIC, P5_ConstraintFK); + }else{ + if( nIncr>0 && pFKey->isDeferred==0 ){ + sqlite3MayAbort(pParse); + } + sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr); + } + + sqlite3VdbeResolveLabel(v, iOk); + sqlite3VdbeAddOp1(v, OP_Close, iCur); +} + + +/* +** Return an Expr object that refers to a memory register corresponding +** to column iCol of table pTab. +** +** regBase is the first of an array of register that contains the data +** for pTab. regBase itself holds the rowid. regBase+1 holds the first +** column. regBase+2 holds the second column, and so forth. +*/ +static Expr *exprTableRegister( + Parse *pParse, /* Parsing and code generating context */ + Table *pTab, /* The table whose content is at r[regBase]... */ + int regBase, /* Contents of table pTab */ + i16 iCol /* Which column of pTab is desired */ +){ + Expr *pExpr; + Column *pCol; + const char *zColl; + sqlite3 *db = pParse->db; + + pExpr = sqlite3Expr(db, TK_REGISTER, 0); + if( pExpr ){ + if( iCol>=0 && iCol!=pTab->iPKey ){ + pCol = &pTab->aCol[iCol]; + pExpr->iTable = regBase + iCol + 1; + pExpr->affinity = pCol->affinity; + zColl = pCol->zColl; + if( zColl==0 ) zColl = db->pDfltColl->zName; + pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl); + }else{ + pExpr->iTable = regBase; + pExpr->affinity = SQLITE_AFF_INTEGER; + } + } + return pExpr; +} + +/* +** Return an Expr object that refers to column iCol of table pTab which +** has cursor iCur. +*/ +static Expr *exprTableColumn( + sqlite3 *db, /* The database connection */ + Table *pTab, /* The table whose column is desired */ + int iCursor, /* The open cursor on the table */ + i16 iCol /* The column that is wanted */ +){ + Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0); + if( pExpr ){ + pExpr->pTab = pTab; + pExpr->iTable = iCursor; + pExpr->iColumn = iCol; + } + return pExpr; +} + +/* +** This function is called to generate code executed when a row is deleted +** from the parent table of foreign key constraint pFKey and, if pFKey is +** deferred, when a row is inserted into the same table. When generating +** code for an SQL UPDATE operation, this function may be called twice - +** once to "delete" the old row and once to "insert" the new row. +** +** Parameter nIncr is passed -1 when inserting a row (as this may decrease +** the number of FK violations in the db) or +1 when deleting one (as this +** may increase the number of FK constraint problems). +** +** The code generated by this function scans through the rows in the child +** table that correspond to the parent table row being deleted or inserted. +** For each child row found, one of the following actions is taken: +** +** Operation | FK type | Action taken +** -------------------------------------------------------------------------- +** DELETE immediate Increment the "immediate constraint counter". +** Or, if the ON (UPDATE|DELETE) action is RESTRICT, +** throw a "FOREIGN KEY constraint failed" exception. +** +** INSERT immediate Decrement the "immediate constraint counter". +** +** DELETE deferred Increment the "deferred constraint counter". +** Or, if the ON (UPDATE|DELETE) action is RESTRICT, +** throw a "FOREIGN KEY constraint failed" exception. +** +** INSERT deferred Decrement the "deferred constraint counter". +** +** These operations are identified in the comment at the top of this file +** (fkey.c) as "I.2" and "D.2". +*/ +static void fkScanChildren( + Parse *pParse, /* Parse context */ + SrcList *pSrc, /* The child table to be scanned */ + Table *pTab, /* The parent table */ + Index *pIdx, /* Index on parent covering the foreign key */ + FKey *pFKey, /* The foreign key linking pSrc to pTab */ + int *aiCol, /* Map from pIdx cols to child table cols */ + int regData, /* Parent row data starts here */ + int nIncr /* Amount to increment deferred counter by */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + int i; /* Iterator variable */ + Expr *pWhere = 0; /* WHERE clause to scan with */ + NameContext sNameContext; /* Context used to resolve WHERE clause */ + WhereInfo *pWInfo; /* Context used by sqlite3WhereXXX() */ + int iFkIfZero = 0; /* Address of OP_FkIfZero */ + Vdbe *v = sqlite3GetVdbe(pParse); + + assert( pIdx==0 || pIdx->pTable==pTab ); + assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol ); + assert( pIdx!=0 || pFKey->nCol==1 ); + assert( pIdx!=0 || HasRowid(pTab) ); + + if( nIncr<0 ){ + iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0); + VdbeCoverage(v); + } + + /* Create an Expr object representing an SQL expression like: + ** + ** = AND = ... + ** + ** The collation sequence used for the comparison should be that of + ** the parent key columns. The affinity of the parent key column should + ** be applied to each child key value before the comparison takes place. + */ + for(i=0; inCol; i++){ + Expr *pLeft; /* Value from parent table row */ + Expr *pRight; /* Column ref to child table */ + Expr *pEq; /* Expression (pLeft = pRight) */ + i16 iCol; /* Index of column in child table */ + const char *zCol; /* Name of column in child table */ + + iCol = pIdx ? pIdx->aiColumn[i] : -1; + pLeft = exprTableRegister(pParse, pTab, regData, iCol); + iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom; + assert( iCol>=0 ); + zCol = pFKey->pFrom->aCol[iCol].zName; + pRight = sqlite3Expr(db, TK_ID, zCol); + pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight, 0); + pWhere = sqlite3ExprAnd(db, pWhere, pEq); + } + + /* If the child table is the same as the parent table, then add terms + ** to the WHERE clause that prevent this entry from being scanned. + ** The added WHERE clause terms are like this: + ** + ** $current_rowid!=rowid + ** NOT( $current_a==a AND $current_b==b AND ... ) + ** + ** The first form is used for rowid tables. The second form is used + ** for WITHOUT ROWID tables. In the second form, the primary key is + ** (a,b,...) + */ + if( pTab==pFKey->pFrom && nIncr>0 ){ + Expr *pNe; /* Expression (pLeft != pRight) */ + Expr *pLeft; /* Value from parent table row */ + Expr *pRight; /* Column ref to child table */ + if( HasRowid(pTab) ){ + pLeft = exprTableRegister(pParse, pTab, regData, -1); + pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1); + pNe = sqlite3PExpr(pParse, TK_NE, pLeft, pRight, 0); + }else{ + Expr *pEq, *pAll = 0; + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pIdx!=0 ); + for(i=0; inKeyCol; i++){ + i16 iCol = pIdx->aiColumn[i]; + assert( iCol>=0 ); + pLeft = exprTableRegister(pParse, pTab, regData, iCol); + pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, iCol); + pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight, 0); + pAll = sqlite3ExprAnd(db, pAll, pEq); + } + pNe = sqlite3PExpr(pParse, TK_NOT, pAll, 0, 0); + } + pWhere = sqlite3ExprAnd(db, pWhere, pNe); + } + + /* Resolve the references in the WHERE clause. */ + memset(&sNameContext, 0, sizeof(NameContext)); + sNameContext.pSrcList = pSrc; + sNameContext.pParse = pParse; + sqlite3ResolveExprNames(&sNameContext, pWhere); + + /* Create VDBE to loop through the entries in pSrc that match the WHERE + ** clause. For each row found, increment either the deferred or immediate + ** foreign key constraint counter. */ + pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0, 0); + sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr); + if( pWInfo ){ + sqlite3WhereEnd(pWInfo); + } + + /* Clean up the WHERE clause constructed above. */ + sqlite3ExprDelete(db, pWhere); + if( iFkIfZero ){ + sqlite3VdbeJumpHere(v, iFkIfZero); + } +} + +/* +** This function returns a linked list of FKey objects (connected by +** FKey.pNextTo) holding all children of table pTab. For example, +** given the following schema: +** +** CREATE TABLE t1(a PRIMARY KEY); +** CREATE TABLE t2(b REFERENCES t1(a); +** +** Calling this function with table "t1" as an argument returns a pointer +** to the FKey structure representing the foreign key constraint on table +** "t2". Calling this function with "t2" as the argument would return a +** NULL pointer (as there are no FK constraints for which t2 is the parent +** table). +*/ +SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *pTab){ + return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName); +} + +/* +** The second argument is a Trigger structure allocated by the +** fkActionTrigger() routine. This function deletes the Trigger structure +** and all of its sub-components. +** +** The Trigger structure or any of its sub-components may be allocated from +** the lookaside buffer belonging to database handle dbMem. +*/ +static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){ + if( p ){ + TriggerStep *pStep = p->step_list; + sqlite3ExprDelete(dbMem, pStep->pWhere); + sqlite3ExprListDelete(dbMem, pStep->pExprList); + sqlite3SelectDelete(dbMem, pStep->pSelect); + sqlite3ExprDelete(dbMem, p->pWhen); + sqlite3DbFree(dbMem, p); + } +} + +/* +** This function is called to generate code that runs when table pTab is +** being dropped from the database. The SrcList passed as the second argument +** to this function contains a single entry guaranteed to resolve to +** table pTab. +** +** Normally, no code is required. However, if either +** +** (a) The table is the parent table of a FK constraint, or +** (b) The table is the child table of a deferred FK constraint and it is +** determined at runtime that there are outstanding deferred FK +** constraint violations in the database, +** +** then the equivalent of "DELETE FROM " is executed before dropping +** the table from the database. Triggers are disabled while running this +** DELETE, but foreign key actions are not. +*/ +SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){ + sqlite3 *db = pParse->db; + if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) && !pTab->pSelect ){ + int iSkip = 0; + Vdbe *v = sqlite3GetVdbe(pParse); + + assert( v ); /* VDBE has already been allocated */ + if( sqlite3FkReferences(pTab)==0 ){ + /* Search for a deferred foreign key constraint for which this table + ** is the child table. If one cannot be found, return without + ** generating any VDBE code. If one can be found, then jump over + ** the entire DELETE if there are no outstanding deferred constraints + ** when this statement is run. */ + FKey *p; + for(p=pTab->pFKey; p; p=p->pNextFrom){ + if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break; + } + if( !p ) return; + iSkip = sqlite3VdbeMakeLabel(v); + sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v); + } + + pParse->disableTriggers = 1; + sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0); + pParse->disableTriggers = 0; + + /* If the DELETE has generated immediate foreign key constraint + ** violations, halt the VDBE and return an error at this point, before + ** any modifications to the schema are made. This is because statement + ** transactions are not able to rollback schema changes. + ** + ** If the SQLITE_DeferFKs flag is set, then this is not required, as + ** the statement transaction will not be rolled back even if FK + ** constraints are violated. + */ + if( (db->flags & SQLITE_DeferFKs)==0 ){ + sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY, + OE_Abort, 0, P4_STATIC, P5_ConstraintFK); + } + + if( iSkip ){ + sqlite3VdbeResolveLabel(v, iSkip); + } + } +} + + +/* +** The second argument points to an FKey object representing a foreign key +** for which pTab is the child table. An UPDATE statement against pTab +** is currently being processed. For each column of the table that is +** actually updated, the corresponding element in the aChange[] array +** is zero or greater (if a column is unmodified the corresponding element +** is set to -1). If the rowid column is modified by the UPDATE statement +** the bChngRowid argument is non-zero. +** +** This function returns true if any of the columns that are part of the +** child key for FK constraint *p are modified. +*/ +static int fkChildIsModified( + Table *pTab, /* Table being updated */ + FKey *p, /* Foreign key for which pTab is the child */ + int *aChange, /* Array indicating modified columns */ + int bChngRowid /* True if rowid is modified by this update */ +){ + int i; + for(i=0; inCol; i++){ + int iChildKey = p->aCol[i].iFrom; + if( aChange[iChildKey]>=0 ) return 1; + if( iChildKey==pTab->iPKey && bChngRowid ) return 1; + } + return 0; +} + +/* +** The second argument points to an FKey object representing a foreign key +** for which pTab is the parent table. An UPDATE statement against pTab +** is currently being processed. For each column of the table that is +** actually updated, the corresponding element in the aChange[] array +** is zero or greater (if a column is unmodified the corresponding element +** is set to -1). If the rowid column is modified by the UPDATE statement +** the bChngRowid argument is non-zero. +** +** This function returns true if any of the columns that are part of the +** parent key for FK constraint *p are modified. +*/ +static int fkParentIsModified( + Table *pTab, + FKey *p, + int *aChange, + int bChngRowid +){ + int i; + for(i=0; inCol; i++){ + char *zKey = p->aCol[i].zCol; + int iKey; + for(iKey=0; iKeynCol; iKey++){ + if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){ + Column *pCol = &pTab->aCol[iKey]; + if( zKey ){ + if( 0==sqlite3StrICmp(pCol->zName, zKey) ) return 1; + }else if( pCol->colFlags & COLFLAG_PRIMKEY ){ + return 1; + } + } + } + } + return 0; +} + +/* +** Return true if the parser passed as the first argument is being +** used to code a trigger that is really a "SET NULL" action belonging +** to trigger pFKey. +*/ +static int isSetNullAction(Parse *pParse, FKey *pFKey){ + Parse *pTop = sqlite3ParseToplevel(pParse); + if( pTop->pTriggerPrg ){ + Trigger *p = pTop->pTriggerPrg->pTrigger; + if( (p==pFKey->apTrigger[0] && pFKey->aAction[0]==OE_SetNull) + || (p==pFKey->apTrigger[1] && pFKey->aAction[1]==OE_SetNull) + ){ + return 1; + } + } + return 0; +} + +/* +** This function is called when inserting, deleting or updating a row of +** table pTab to generate VDBE code to perform foreign key constraint +** processing for the operation. +** +** For a DELETE operation, parameter regOld is passed the index of the +** first register in an array of (pTab->nCol+1) registers containing the +** rowid of the row being deleted, followed by each of the column values +** of the row being deleted, from left to right. Parameter regNew is passed +** zero in this case. +** +** For an INSERT operation, regOld is passed zero and regNew is passed the +** first register of an array of (pTab->nCol+1) registers containing the new +** row data. +** +** For an UPDATE operation, this function is called twice. Once before +** the original record is deleted from the table using the calling convention +** described for DELETE. Then again after the original record is deleted +** but before the new record is inserted using the INSERT convention. +*/ +SQLITE_PRIVATE void sqlite3FkCheck( + Parse *pParse, /* Parse context */ + Table *pTab, /* Row is being deleted from this table */ + int regOld, /* Previous row data is stored here */ + int regNew, /* New row data is stored here */ + int *aChange, /* Array indicating UPDATEd columns (or 0) */ + int bChngRowid /* True if rowid is UPDATEd */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + FKey *pFKey; /* Used to iterate through FKs */ + int iDb; /* Index of database containing pTab */ + const char *zDb; /* Name of database containing pTab */ + int isIgnoreErrors = pParse->disableTriggers; + + /* Exactly one of regOld and regNew should be non-zero. */ + assert( (regOld==0)!=(regNew==0) ); + + /* If foreign-keys are disabled, this function is a no-op. */ + if( (db->flags&SQLITE_ForeignKeys)==0 ) return; + + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + zDb = db->aDb[iDb].zName; + + /* Loop through all the foreign key constraints for which pTab is the + ** child table (the table that the foreign key definition is part of). */ + for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + Table *pTo; /* Parent table of foreign key pFKey */ + Index *pIdx = 0; /* Index on key columns in pTo */ + int *aiFree = 0; + int *aiCol; + int iCol; + int i; + int bIgnore = 0; + + if( aChange + && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0 + && fkChildIsModified(pTab, pFKey, aChange, bChngRowid)==0 + ){ + continue; + } + + /* Find the parent table of this foreign key. Also find a unique index + ** on the parent key columns in the parent table. If either of these + ** schema items cannot be located, set an error in pParse and return + ** early. */ + if( pParse->disableTriggers ){ + pTo = sqlite3FindTable(db, pFKey->zTo, zDb); + }else{ + pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb); + } + if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){ + assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) ); + if( !isIgnoreErrors || db->mallocFailed ) return; + if( pTo==0 ){ + /* If isIgnoreErrors is true, then a table is being dropped. In this + ** case SQLite runs a "DELETE FROM xxx" on the table being dropped + ** before actually dropping it in order to check FK constraints. + ** If the parent table of an FK constraint on the current table is + ** missing, behave as if it is empty. i.e. decrement the relevant + ** FK counter for each row of the current table with non-NULL keys. + */ + Vdbe *v = sqlite3GetVdbe(pParse); + int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1; + for(i=0; inCol; i++){ + int iReg = pFKey->aCol[i].iFrom + regOld + 1; + sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump); VdbeCoverage(v); + } + sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1); + } + continue; + } + assert( pFKey->nCol==1 || (aiFree && pIdx) ); + + if( aiFree ){ + aiCol = aiFree; + }else{ + iCol = pFKey->aCol[0].iFrom; + aiCol = &iCol; + } + for(i=0; inCol; i++){ + if( aiCol[i]==pTab->iPKey ){ + aiCol[i] = -1; + } + assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Request permission to read the parent key columns. If the + ** authorization callback returns SQLITE_IGNORE, behave as if any + ** values read from the parent table are NULL. */ + if( db->xAuth ){ + int rcauth; + char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName; + rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb); + bIgnore = (rcauth==SQLITE_IGNORE); + } +#endif + } + + /* Take a shared-cache advisory read-lock on the parent table. Allocate + ** a cursor to use to search the unique index on the parent key columns + ** in the parent table. */ + sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName); + pParse->nTab++; + + if( regOld!=0 ){ + /* A row is being removed from the child table. Search for the parent. + ** If the parent does not exist, removing the child row resolves an + ** outstanding foreign key constraint violation. */ + fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore); + } + if( regNew!=0 && !isSetNullAction(pParse, pFKey) ){ + /* A row is being added to the child table. If a parent row cannot + ** be found, adding the child row has violated the FK constraint. + ** + ** If this operation is being performed as part of a trigger program + ** that is actually a "SET NULL" action belonging to this very + ** foreign key, then omit this scan altogether. As all child key + ** values are guaranteed to be NULL, it is not possible for adding + ** this row to cause an FK violation. */ + fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore); + } + + sqlite3DbFree(db, aiFree); + } + + /* Loop through all the foreign key constraints that refer to this table. + ** (the "child" constraints) */ + for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){ + Index *pIdx = 0; /* Foreign key index for pFKey */ + SrcList *pSrc; + int *aiCol = 0; + + if( aChange && fkParentIsModified(pTab, pFKey, aChange, bChngRowid)==0 ){ + continue; + } + + if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs) + && !pParse->pToplevel && !pParse->isMultiWrite + ){ + assert( regOld==0 && regNew!=0 ); + /* Inserting a single row into a parent table cannot cause (or fix) + ** an immediate foreign key violation. So do nothing in this case. */ + continue; + } + + if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){ + if( !isIgnoreErrors || db->mallocFailed ) return; + continue; + } + assert( aiCol || pFKey->nCol==1 ); + + /* Create a SrcList structure containing the child table. We need the + ** child table as a SrcList for sqlite3WhereBegin() */ + pSrc = sqlite3SrcListAppend(db, 0, 0, 0); + if( pSrc ){ + struct SrcList_item *pItem = pSrc->a; + pItem->pTab = pFKey->pFrom; + pItem->zName = pFKey->pFrom->zName; + pItem->pTab->nRef++; + pItem->iCursor = pParse->nTab++; + + if( regNew!=0 ){ + fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1); + } + if( regOld!=0 ){ + int eAction = pFKey->aAction[aChange!=0]; + fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1); + /* If this is a deferred FK constraint, or a CASCADE or SET NULL + ** action applies, then any foreign key violations caused by + ** removing the parent key will be rectified by the action trigger. + ** So do not set the "may-abort" flag in this case. + ** + ** Note 1: If the FK is declared "ON UPDATE CASCADE", then the + ** may-abort flag will eventually be set on this statement anyway + ** (when this function is called as part of processing the UPDATE + ** within the action trigger). + ** + ** Note 2: At first glance it may seem like SQLite could simply omit + ** all OP_FkCounter related scans when either CASCADE or SET NULL + ** applies. The trouble starts if the CASCADE or SET NULL action + ** trigger causes other triggers or action rules attached to the + ** child table to fire. In these cases the fk constraint counters + ** might be set incorrectly if any OP_FkCounter related scans are + ** omitted. */ + if( !pFKey->isDeferred && eAction!=OE_Cascade && eAction!=OE_SetNull ){ + sqlite3MayAbort(pParse); + } + } + pItem->zName = 0; + sqlite3SrcListDelete(db, pSrc); + } + sqlite3DbFree(db, aiCol); + } +} + +#define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x))) + +/* +** This function is called before generating code to update or delete a +** row contained in table pTab. +*/ +SQLITE_PRIVATE u32 sqlite3FkOldmask( + Parse *pParse, /* Parse context */ + Table *pTab /* Table being modified */ +){ + u32 mask = 0; + if( pParse->db->flags&SQLITE_ForeignKeys ){ + FKey *p; + int i; + for(p=pTab->pFKey; p; p=p->pNextFrom){ + for(i=0; inCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom); + } + for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ + Index *pIdx = 0; + sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0); + if( pIdx ){ + for(i=0; inKeyCol; i++){ + assert( pIdx->aiColumn[i]>=0 ); + mask |= COLUMN_MASK(pIdx->aiColumn[i]); + } + } + } + } + return mask; +} + + +/* +** This function is called before generating code to update or delete a +** row contained in table pTab. If the operation is a DELETE, then +** parameter aChange is passed a NULL value. For an UPDATE, aChange points +** to an array of size N, where N is the number of columns in table pTab. +** If the i'th column is not modified by the UPDATE, then the corresponding +** entry in the aChange[] array is set to -1. If the column is modified, +** the value is 0 or greater. Parameter chngRowid is set to true if the +** UPDATE statement modifies the rowid fields of the table. +** +** If any foreign key processing will be required, this function returns +** true. If there is no foreign key related processing, this function +** returns false. +*/ +SQLITE_PRIVATE int sqlite3FkRequired( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being modified */ + int *aChange, /* Non-NULL for UPDATE operations */ + int chngRowid /* True for UPDATE that affects rowid */ +){ + if( pParse->db->flags&SQLITE_ForeignKeys ){ + if( !aChange ){ + /* A DELETE operation. Foreign key processing is required if the + ** table in question is either the child or parent table for any + ** foreign key constraint. */ + return (sqlite3FkReferences(pTab) || pTab->pFKey); + }else{ + /* This is an UPDATE. Foreign key processing is only required if the + ** operation modifies one or more child or parent key columns. */ + FKey *p; + + /* Check if any child key columns are being modified. */ + for(p=pTab->pFKey; p; p=p->pNextFrom){ + if( fkChildIsModified(pTab, p, aChange, chngRowid) ) return 1; + } + + /* Check if any parent key columns are being modified. */ + for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ + if( fkParentIsModified(pTab, p, aChange, chngRowid) ) return 1; + } + } + } + return 0; +} + +/* +** This function is called when an UPDATE or DELETE operation is being +** compiled on table pTab, which is the parent table of foreign-key pFKey. +** If the current operation is an UPDATE, then the pChanges parameter is +** passed a pointer to the list of columns being modified. If it is a +** DELETE, pChanges is passed a NULL pointer. +** +** It returns a pointer to a Trigger structure containing a trigger +** equivalent to the ON UPDATE or ON DELETE action specified by pFKey. +** If the action is "NO ACTION" or "RESTRICT", then a NULL pointer is +** returned (these actions require no special handling by the triggers +** sub-system, code for them is created by fkScanChildren()). +** +** For example, if pFKey is the foreign key and pTab is table "p" in +** the following schema: +** +** CREATE TABLE p(pk PRIMARY KEY); +** CREATE TABLE c(ck REFERENCES p ON DELETE CASCADE); +** +** then the returned trigger structure is equivalent to: +** +** CREATE TRIGGER ... DELETE ON p BEGIN +** DELETE FROM c WHERE ck = old.pk; +** END; +** +** The returned pointer is cached as part of the foreign key object. It +** is eventually freed along with the rest of the foreign key object by +** sqlite3FkDelete(). +*/ +static Trigger *fkActionTrigger( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being updated or deleted from */ + FKey *pFKey, /* Foreign key to get action for */ + ExprList *pChanges /* Change-list for UPDATE, NULL for DELETE */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + int action; /* One of OE_None, OE_Cascade etc. */ + Trigger *pTrigger; /* Trigger definition to return */ + int iAction = (pChanges!=0); /* 1 for UPDATE, 0 for DELETE */ + + action = pFKey->aAction[iAction]; + pTrigger = pFKey->apTrigger[iAction]; + + if( action!=OE_None && !pTrigger ){ + u8 enableLookaside; /* Copy of db->lookaside.bEnabled */ + char const *zFrom; /* Name of child table */ + int nFrom; /* Length in bytes of zFrom */ + Index *pIdx = 0; /* Parent key index for this FK */ + int *aiCol = 0; /* child table cols -> parent key cols */ + TriggerStep *pStep = 0; /* First (only) step of trigger program */ + Expr *pWhere = 0; /* WHERE clause of trigger step */ + ExprList *pList = 0; /* Changes list if ON UPDATE CASCADE */ + Select *pSelect = 0; /* If RESTRICT, "SELECT RAISE(...)" */ + int i; /* Iterator variable */ + Expr *pWhen = 0; /* WHEN clause for the trigger */ + + if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0; + assert( aiCol || pFKey->nCol==1 ); + + for(i=0; inCol; i++){ + Token tOld = { "old", 3 }; /* Literal "old" token */ + Token tNew = { "new", 3 }; /* Literal "new" token */ + Token tFromCol; /* Name of column in child table */ + Token tToCol; /* Name of column in parent table */ + int iFromCol; /* Idx of column in child table */ + Expr *pEq; /* tFromCol = OLD.tToCol */ + + iFromCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom; + assert( iFromCol>=0 ); + assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKeynCol) ); + assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); + tToCol.z = pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zName; + tFromCol.z = pFKey->pFrom->aCol[iFromCol].zName; + + tToCol.n = sqlite3Strlen30(tToCol.z); + tFromCol.n = sqlite3Strlen30(tFromCol.z); + + /* Create the expression "OLD.zToCol = zFromCol". It is important + ** that the "OLD.zToCol" term is on the LHS of the = operator, so + ** that the affinity and collation sequence associated with the + ** parent table are used for the comparison. */ + pEq = sqlite3PExpr(pParse, TK_EQ, + sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tOld, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0) + , 0), + sqlite3ExprAlloc(db, TK_ID, &tFromCol, 0) + , 0); + pWhere = sqlite3ExprAnd(db, pWhere, pEq); + + /* For ON UPDATE, construct the next term of the WHEN clause. + ** The final WHEN clause will be like this: + ** + ** WHEN NOT(old.col1 IS new.col1 AND ... AND old.colN IS new.colN) + */ + if( pChanges ){ + pEq = sqlite3PExpr(pParse, TK_IS, + sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tOld, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0), + 0), + sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tNew, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0), + 0), + 0); + pWhen = sqlite3ExprAnd(db, pWhen, pEq); + } + + if( action!=OE_Restrict && (action!=OE_Cascade || pChanges) ){ + Expr *pNew; + if( action==OE_Cascade ){ + pNew = sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tNew, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0) + , 0); + }else if( action==OE_SetDflt ){ + Expr *pDflt = pFKey->pFrom->aCol[iFromCol].pDflt; + if( pDflt ){ + pNew = sqlite3ExprDup(db, pDflt, 0); + }else{ + pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0); + } + }else{ + pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0); + } + pList = sqlite3ExprListAppend(pParse, pList, pNew); + sqlite3ExprListSetName(pParse, pList, &tFromCol, 0); + } + } + sqlite3DbFree(db, aiCol); + + zFrom = pFKey->pFrom->zName; + nFrom = sqlite3Strlen30(zFrom); + + if( action==OE_Restrict ){ + Token tFrom; + Expr *pRaise; + + tFrom.z = zFrom; + tFrom.n = nFrom; + pRaise = sqlite3Expr(db, TK_RAISE, "FOREIGN KEY constraint failed"); + if( pRaise ){ + pRaise->affinity = OE_Abort; + } + pSelect = sqlite3SelectNew(pParse, + sqlite3ExprListAppend(pParse, 0, pRaise), + sqlite3SrcListAppend(db, 0, &tFrom, 0), + pWhere, + 0, 0, 0, 0, 0, 0 + ); + pWhere = 0; + } + + /* Disable lookaside memory allocation */ + enableLookaside = db->lookaside.bEnabled; + db->lookaside.bEnabled = 0; + + pTrigger = (Trigger *)sqlite3DbMallocZero(db, + sizeof(Trigger) + /* struct Trigger */ + sizeof(TriggerStep) + /* Single step in trigger program */ + nFrom + 1 /* Space for pStep->zTarget */ + ); + if( pTrigger ){ + pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1]; + pStep->zTarget = (char *)&pStep[1]; + memcpy((char *)pStep->zTarget, zFrom, nFrom); + + pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); + pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE); + pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); + if( pWhen ){ + pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0, 0); + pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE); + } + } + + /* Re-enable the lookaside buffer, if it was disabled earlier. */ + db->lookaside.bEnabled = enableLookaside; + + sqlite3ExprDelete(db, pWhere); + sqlite3ExprDelete(db, pWhen); + sqlite3ExprListDelete(db, pList); + sqlite3SelectDelete(db, pSelect); + if( db->mallocFailed==1 ){ + fkTriggerDelete(db, pTrigger); + return 0; + } + assert( pStep!=0 ); + + switch( action ){ + case OE_Restrict: + pStep->op = TK_SELECT; + break; + case OE_Cascade: + if( !pChanges ){ + pStep->op = TK_DELETE; + break; + } + default: + pStep->op = TK_UPDATE; + } + pStep->pTrig = pTrigger; + pTrigger->pSchema = pTab->pSchema; + pTrigger->pTabSchema = pTab->pSchema; + pFKey->apTrigger[iAction] = pTrigger; + pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE); + } + + return pTrigger; +} + +/* +** This function is called when deleting or updating a row to implement +** any required CASCADE, SET NULL or SET DEFAULT actions. +*/ +SQLITE_PRIVATE void sqlite3FkActions( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being updated or deleted from */ + ExprList *pChanges, /* Change-list for UPDATE, NULL for DELETE */ + int regOld, /* Address of array containing old row */ + int *aChange, /* Array indicating UPDATEd columns (or 0) */ + int bChngRowid /* True if rowid is UPDATEd */ +){ + /* If foreign-key support is enabled, iterate through all FKs that + ** refer to table pTab. If there is an action associated with the FK + ** for this operation (either update or delete), invoke the associated + ** trigger sub-program. */ + if( pParse->db->flags&SQLITE_ForeignKeys ){ + FKey *pFKey; /* Iterator variable */ + for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){ + if( aChange==0 || fkParentIsModified(pTab, pFKey, aChange, bChngRowid) ){ + Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges); + if( pAct ){ + sqlite3CodeRowTriggerDirect(pParse, pAct, pTab, regOld, OE_Abort, 0); + } + } + } + } +} + +#endif /* ifndef SQLITE_OMIT_TRIGGER */ + +/* +** Free all memory associated with foreign key definitions attached to +** table pTab. Remove the deleted foreign keys from the Schema.fkeyHash +** hash table. +*/ +SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){ + FKey *pFKey; /* Iterator variable */ + FKey *pNext; /* Copy of pFKey->pNextFrom */ + + assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) ); + for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){ + + /* Remove the FK from the fkeyHash hash table. */ + if( !db || db->pnBytesFreed==0 ){ + if( pFKey->pPrevTo ){ + pFKey->pPrevTo->pNextTo = pFKey->pNextTo; + }else{ + void *p = (void *)pFKey->pNextTo; + const char *z = (p ? pFKey->pNextTo->zTo : pFKey->zTo); + sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, p); + } + if( pFKey->pNextTo ){ + pFKey->pNextTo->pPrevTo = pFKey->pPrevTo; + } + } + + /* EV: R-30323-21917 Each foreign key constraint in SQLite is + ** classified as either immediate or deferred. + */ + assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 ); + + /* Delete any triggers created to implement actions for this FK. */ +#ifndef SQLITE_OMIT_TRIGGER + fkTriggerDelete(db, pFKey->apTrigger[0]); + fkTriggerDelete(db, pFKey->apTrigger[1]); +#endif + + pNext = pFKey->pNextFrom; + sqlite3DbFree(db, pFKey); + } +} +#endif /* ifndef SQLITE_OMIT_FOREIGN_KEY */ + +/************** End of fkey.c ************************************************/ +/************** Begin file insert.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle INSERT statements in SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* +** Generate code that will +** +** (1) acquire a lock for table pTab then +** (2) open pTab as cursor iCur. +** +** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index +** for that table that is actually opened. +*/ +SQLITE_PRIVATE void sqlite3OpenTable( + Parse *pParse, /* Generate code into this VDBE */ + int iCur, /* The cursor number of the table */ + int iDb, /* The database index in sqlite3.aDb[] */ + Table *pTab, /* The table to be opened */ + int opcode /* OP_OpenRead or OP_OpenWrite */ +){ + Vdbe *v; + assert( !IsVirtual(pTab) ); + v = sqlite3GetVdbe(pParse); + assert( opcode==OP_OpenWrite || opcode==OP_OpenRead ); + sqlite3TableLock(pParse, iDb, pTab->tnum, + (opcode==OP_OpenWrite)?1:0, pTab->zName); + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol); + VdbeComment((v, "%s", pTab->zName)); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + assert( pPk->tnum==pTab->tnum ); + sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + VdbeComment((v, "%s", pTab->zName)); + } +} + +/* +** Return a pointer to the column affinity string associated with index +** pIdx. A column affinity string has one character for each column in +** the table, according to the affinity of the column: +** +** Character Column affinity +** ------------------------------ +** 'A' BLOB +** 'B' TEXT +** 'C' NUMERIC +** 'D' INTEGER +** 'F' REAL +** +** An extra 'D' is appended to the end of the string to cover the +** rowid that appears as the last column in every index. +** +** Memory for the buffer containing the column index affinity string +** is managed along with the rest of the Index structure. It will be +** released when sqlite3DeleteIndex() is called. +*/ +SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){ + if( !pIdx->zColAff ){ + /* The first time a column affinity string for a particular index is + ** required, it is allocated and populated here. It is then stored as + ** a member of the Index structure for subsequent use. + ** + ** The column affinity string will eventually be deleted by + ** sqliteDeleteIndex() when the Index structure itself is cleaned + ** up. + */ + int n; + Table *pTab = pIdx->pTable; + pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1); + if( !pIdx->zColAff ){ + db->mallocFailed = 1; + return 0; + } + for(n=0; nnColumn; n++){ + i16 x = pIdx->aiColumn[n]; + if( x>=0 ){ + pIdx->zColAff[n] = pTab->aCol[x].affinity; + }else if( x==XN_ROWID ){ + pIdx->zColAff[n] = SQLITE_AFF_INTEGER; + }else{ + char aff; + assert( x==XN_EXPR ); + assert( pIdx->aColExpr!=0 ); + aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr); + if( aff==0 ) aff = SQLITE_AFF_BLOB; + pIdx->zColAff[n] = aff; + } + } + pIdx->zColAff[n] = 0; + } + + return pIdx->zColAff; +} + +/* +** Compute the affinity string for table pTab, if it has not already been +** computed. As an optimization, omit trailing SQLITE_AFF_BLOB affinities. +** +** If the affinity exists (if it is no entirely SQLITE_AFF_BLOB values) and +** if iReg>0 then code an OP_Affinity opcode that will set the affinities +** for register iReg and following. Or if affinities exists and iReg==0, +** then just set the P4 operand of the previous opcode (which should be +** an OP_MakeRecord) to the affinity string. +** +** A column affinity string has one character per column: +** +** Character Column affinity +** ------------------------------ +** 'A' BLOB +** 'B' TEXT +** 'C' NUMERIC +** 'D' INTEGER +** 'E' REAL +*/ +SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){ + int i; + char *zColAff = pTab->zColAff; + if( zColAff==0 ){ + sqlite3 *db = sqlite3VdbeDb(v); + zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1); + if( !zColAff ){ + db->mallocFailed = 1; + return; + } + + for(i=0; inCol; i++){ + zColAff[i] = pTab->aCol[i].affinity; + } + do{ + zColAff[i--] = 0; + }while( i>=0 && zColAff[i]==SQLITE_AFF_BLOB ); + pTab->zColAff = zColAff; + } + i = sqlite3Strlen30(zColAff); + if( i ){ + if( iReg ){ + sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i); + }else{ + sqlite3VdbeChangeP4(v, -1, zColAff, i); + } + } +} + +/* +** Return non-zero if the table pTab in database iDb or any of its indices +** have been opened at any point in the VDBE program. This is used to see if +** a statement of the form "INSERT INTO SELECT ..." can +** run without using a temporary table for the results of the SELECT. +*/ +static int readsTable(Parse *p, int iDb, Table *pTab){ + Vdbe *v = sqlite3GetVdbe(p); + int i; + int iEnd = sqlite3VdbeCurrentAddr(v); +#ifndef SQLITE_OMIT_VIRTUALTABLE + VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0; +#endif + + for(i=1; iopcode==OP_OpenRead && pOp->p3==iDb ){ + Index *pIndex; + int tnum = pOp->p2; + if( tnum==pTab->tnum ){ + return 1; + } + for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){ + if( tnum==pIndex->tnum ){ + return 1; + } + } + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){ + assert( pOp->p4.pVtab!=0 ); + assert( pOp->p4type==P4_VTAB ); + return 1; + } +#endif + } + return 0; +} + +#ifndef SQLITE_OMIT_AUTOINCREMENT +/* +** Locate or create an AutoincInfo structure associated with table pTab +** which is in database iDb. Return the register number for the register +** that holds the maximum rowid. +** +** There is at most one AutoincInfo structure per table even if the +** same table is autoincremented multiple times due to inserts within +** triggers. A new AutoincInfo structure is created if this is the +** first use of table pTab. On 2nd and subsequent uses, the original +** AutoincInfo structure is used. +** +** Three memory locations are allocated: +** +** (1) Register to hold the name of the pTab table. +** (2) Register to hold the maximum ROWID of pTab. +** (3) Register to hold the rowid in sqlite_sequence of pTab +** +** The 2nd register is the one that is returned. That is all the +** insert routine needs to know about. +*/ +static int autoIncBegin( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database holding pTab */ + Table *pTab /* The table we are writing to */ +){ + int memId = 0; /* Register holding maximum rowid */ + if( pTab->tabFlags & TF_Autoincrement ){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + AutoincInfo *pInfo; + + pInfo = pToplevel->pAinc; + while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; } + if( pInfo==0 ){ + pInfo = sqlite3DbMallocRaw(pParse->db, sizeof(*pInfo)); + if( pInfo==0 ) return 0; + pInfo->pNext = pToplevel->pAinc; + pToplevel->pAinc = pInfo; + pInfo->pTab = pTab; + pInfo->iDb = iDb; + pToplevel->nMem++; /* Register to hold name of table */ + pInfo->regCtr = ++pToplevel->nMem; /* Max rowid register */ + pToplevel->nMem++; /* Rowid in sqlite_sequence */ + } + memId = pInfo->regCtr; + } + return memId; +} + +/* +** This routine generates code that will initialize all of the +** register used by the autoincrement tracker. +*/ +SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){ + AutoincInfo *p; /* Information about an AUTOINCREMENT */ + sqlite3 *db = pParse->db; /* The database connection */ + Db *pDb; /* Database only autoinc table */ + int memId; /* Register holding max rowid */ + int addr; /* A VDBE address */ + Vdbe *v = pParse->pVdbe; /* VDBE under construction */ + + /* This routine is never called during trigger-generation. It is + ** only called from the top-level */ + assert( pParse->pTriggerTab==0 ); + assert( sqlite3IsToplevel(pParse) ); + + assert( v ); /* We failed long ago if this is not so */ + for(p = pParse->pAinc; p; p = p->pNext){ + pDb = &db->aDb[p->iDb]; + memId = p->regCtr; + assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) ); + sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead); + sqlite3VdbeAddOp3(v, OP_Null, 0, memId, memId+1); + addr = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeLoadString(v, memId-1, p->pTab->zName); + sqlite3VdbeAddOp2(v, OP_Rewind, 0, addr+9); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Column, 0, 0, memId); + sqlite3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL); + sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1); + sqlite3VdbeAddOp3(v, OP_Column, 0, 1, memId); + sqlite3VdbeGoto(v, addr+9); + sqlite3VdbeAddOp2(v, OP_Next, 0, addr+2); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Integer, 0, memId); + sqlite3VdbeAddOp0(v, OP_Close); + } +} + +/* +** Update the maximum rowid for an autoincrement calculation. +** +** This routine should be called when the top of the stack holds a +** new rowid that is about to be inserted. If that new rowid is +** larger than the maximum rowid in the memId memory cell, then the +** memory cell is updated. The stack is unchanged. +*/ +static void autoIncStep(Parse *pParse, int memId, int regRowid){ + if( memId>0 ){ + sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid); + } +} + +/* +** This routine generates the code needed to write autoincrement +** maximum rowid values back into the sqlite_sequence register. +** Every statement that might do an INSERT into an autoincrement +** table (either directly or through triggers) needs to call this +** routine just before the "exit" code. +*/ +SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){ + AutoincInfo *p; + Vdbe *v = pParse->pVdbe; + sqlite3 *db = pParse->db; + + assert( v ); + for(p = pParse->pAinc; p; p = p->pNext){ + Db *pDb = &db->aDb[p->iDb]; + int addr1; + int iRec; + int memId = p->regCtr; + + iRec = sqlite3GetTempReg(pParse); + assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) ); + sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite); + addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_NewRowid, 0, memId+1); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec); + sqlite3VdbeAddOp3(v, OP_Insert, 0, iRec, memId+1); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3VdbeAddOp0(v, OP_Close); + sqlite3ReleaseTempReg(pParse, iRec); + } +} +#else +/* +** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines +** above are all no-ops +*/ +# define autoIncBegin(A,B,C) (0) +# define autoIncStep(A,B,C) +#endif /* SQLITE_OMIT_AUTOINCREMENT */ + + +/* Forward declaration */ +static int xferOptimization( + Parse *pParse, /* Parser context */ + Table *pDest, /* The table we are inserting into */ + Select *pSelect, /* A SELECT statement to use as the data source */ + int onError, /* How to handle constraint errors */ + int iDbDest /* The database of pDest */ +); + +/* +** This routine is called to handle SQL of the following forms: +** +** insert into TABLE (IDLIST) values(EXPRLIST),(EXPRLIST),... +** insert into TABLE (IDLIST) select +** insert into TABLE (IDLIST) default values +** +** The IDLIST following the table name is always optional. If omitted, +** then a list of all (non-hidden) columns for the table is substituted. +** The IDLIST appears in the pColumn parameter. pColumn is NULL if IDLIST +** is omitted. +** +** For the pSelect parameter holds the values to be inserted for the +** first two forms shown above. A VALUES clause is really just short-hand +** for a SELECT statement that omits the FROM clause and everything else +** that follows. If the pSelect parameter is NULL, that means that the +** DEFAULT VALUES form of the INSERT statement is intended. +** +** The code generated follows one of four templates. For a simple +** insert with data coming from a single-row VALUES clause, the code executes +** once straight down through. Pseudo-code follows (we call this +** the "1st template"): +** +** open write cursor to
    and its indices +** put VALUES clause expressions into registers +** write the resulting record into
    +** cleanup +** +** The three remaining templates assume the statement is of the form +** +** INSERT INTO
    SELECT ... +** +** If the SELECT clause is of the restricted form "SELECT * FROM " - +** in other words if the SELECT pulls all columns from a single table +** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and +** if and are distinct tables but have identical +** schemas, including all the same indices, then a special optimization +** is invoked that copies raw records from over to . +** See the xferOptimization() function for the implementation of this +** template. This is the 2nd template. +** +** open a write cursor to
    +** open read cursor on +** transfer all records in over to
    +** close cursors +** foreach index on
    +** open a write cursor on the
    index +** open a read cursor on the corresponding index +** transfer all records from the read to the write cursors +** close cursors +** end foreach +** +** The 3rd template is for when the second template does not apply +** and the SELECT clause does not read from
    at any time. +** The generated code follows this template: +** +** X <- A +** goto B +** A: setup for the SELECT +** loop over the rows in the SELECT +** load values into registers R..R+n +** yield X +** end loop +** cleanup after the SELECT +** end-coroutine X +** B: open write cursor to
    and its indices +** C: yield X, at EOF goto D +** insert the select result into
    from R..R+n +** goto C +** D: cleanup +** +** The 4th template is used if the insert statement takes its +** values from a SELECT but the data is being inserted into a table +** that is also read as part of the SELECT. In the third form, +** we have to use an intermediate table to store the results of +** the select. The template is like this: +** +** X <- A +** goto B +** A: setup for the SELECT +** loop over the tables in the SELECT +** load value into register R..R+n +** yield X +** end loop +** cleanup after the SELECT +** end co-routine R +** B: open temp table +** L: yield X, at EOF goto M +** insert row from R..R+n into temp table +** goto L +** M: open write cursor to
    and its indices +** rewind temp table +** C: loop over rows of intermediate table +** transfer values form intermediate table into
    +** end loop +** D: cleanup +*/ +SQLITE_PRIVATE void sqlite3Insert( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* Name of table into which we are inserting */ + Select *pSelect, /* A SELECT statement to use as the data source */ + IdList *pColumn, /* Column names corresponding to IDLIST. */ + int onError /* How to handle constraint errors */ +){ + sqlite3 *db; /* The main database structure */ + Table *pTab; /* The table to insert into. aka TABLE */ + char *zTab; /* Name of the table into which we are inserting */ + const char *zDb; /* Name of the database holding this table */ + int i, j, idx; /* Loop counters */ + Vdbe *v; /* Generate code into this virtual machine */ + Index *pIdx; /* For looping over indices of the table */ + int nColumn; /* Number of columns in the data */ + int nHidden = 0; /* Number of hidden columns if TABLE is virtual */ + int iDataCur = 0; /* VDBE cursor that is the main data repository */ + int iIdxCur = 0; /* First index cursor */ + int ipkColumn = -1; /* Column that is the INTEGER PRIMARY KEY */ + int endOfLoop; /* Label for the end of the insertion loop */ + int srcTab = 0; /* Data comes from this temporary cursor if >=0 */ + int addrInsTop = 0; /* Jump to label "D" */ + int addrCont = 0; /* Top of insert loop. Label "C" in templates 3 and 4 */ + SelectDest dest; /* Destination for SELECT on rhs of INSERT */ + int iDb; /* Index of database holding TABLE */ + Db *pDb; /* The database containing table being inserted into */ + u8 useTempTable = 0; /* Store SELECT results in intermediate table */ + u8 appendFlag = 0; /* True if the insert is likely to be an append */ + u8 withoutRowid; /* 0 for normal table. 1 for WITHOUT ROWID table */ + u8 bIdListInOrder; /* True if IDLIST is in table order */ + ExprList *pList = 0; /* List of VALUES() to be inserted */ + + /* Register allocations */ + int regFromSelect = 0;/* Base register for data coming from SELECT */ + int regAutoinc = 0; /* Register holding the AUTOINCREMENT counter */ + int regRowCount = 0; /* Memory cell used for the row counter */ + int regIns; /* Block of regs holding rowid+data being inserted */ + int regRowid; /* registers holding insert rowid */ + int regData; /* register holding first column to insert */ + int *aRegIdx = 0; /* One register allocated to each index */ + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True if attempting to insert into a view */ + Trigger *pTrigger; /* List of triggers on pTab, if required */ + int tmask; /* Mask of trigger times */ +#endif + + db = pParse->db; + memset(&dest, 0, sizeof(dest)); + if( pParse->nErr || db->mallocFailed ){ + goto insert_cleanup; + } + + /* If the Select object is really just a simple VALUES() list with a + ** single row (the common case) then keep that one row of values + ** and discard the other (unused) parts of the pSelect object + */ + if( pSelect && (pSelect->selFlags & SF_Values)!=0 && pSelect->pPrior==0 ){ + pList = pSelect->pEList; + pSelect->pEList = 0; + sqlite3SelectDelete(db, pSelect); + pSelect = 0; + } + + /* Locate the table into which we will be inserting new information. + */ + assert( pTabList->nSrc==1 ); + zTab = pTabList->a[0].zName; + if( NEVER(zTab==0) ) goto insert_cleanup; + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ){ + goto insert_cleanup; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDbnDb ); + pDb = &db->aDb[iDb]; + zDb = pDb->zName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){ + goto insert_cleanup; + } + withoutRowid = !HasRowid(pTab); + + /* Figure out if we have any triggers and if the table being + ** inserted into is a view + */ +#ifndef SQLITE_OMIT_TRIGGER + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask); + isView = pTab->pSelect!=0; +#else +# define pTrigger 0 +# define tmask 0 +# define isView 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) ); + + /* If pTab is really a view, make sure it has been initialized. + ** ViewGetColumnNames() is a no-op if pTab is not a view. + */ + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto insert_cleanup; + } + + /* Cannot insert into a read-only table. + */ + if( sqlite3IsReadOnly(pParse, pTab, tmask) ){ + goto insert_cleanup; + } + + /* Allocate a VDBE + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto insert_cleanup; + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb); + +#ifndef SQLITE_OMIT_XFER_OPT + /* If the statement is of the form + ** + ** INSERT INTO SELECT * FROM ; + ** + ** Then special optimizations can be applied that make the transfer + ** very fast and which reduce fragmentation of indices. + ** + ** This is the 2nd template. + */ + if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){ + assert( !pTrigger ); + assert( pList==0 ); + goto insert_end; + } +#endif /* SQLITE_OMIT_XFER_OPT */ + + /* If this is an AUTOINCREMENT table, look up the sequence number in the + ** sqlite_sequence table and store it in memory cell regAutoinc. + */ + regAutoinc = autoIncBegin(pParse, iDb, pTab); + + /* Allocate registers for holding the rowid of the new row, + ** the content of the new row, and the assembled row record. + */ + regRowid = regIns = pParse->nMem+1; + pParse->nMem += pTab->nCol + 1; + if( IsVirtual(pTab) ){ + regRowid++; + pParse->nMem++; + } + regData = regRowid+1; + + /* If the INSERT statement included an IDLIST term, then make sure + ** all elements of the IDLIST really are columns of the table and + ** remember the column indices. + ** + ** If the table has an INTEGER PRIMARY KEY column and that column + ** is named in the IDLIST, then record in the ipkColumn variable + ** the index into IDLIST of the primary key column. ipkColumn is + ** the index of the primary key as it appears in IDLIST, not as + ** is appears in the original table. (The index of the INTEGER + ** PRIMARY KEY in the original table is pTab->iPKey.) + */ + bIdListInOrder = (pTab->tabFlags & TF_OOOHidden)==0; + if( pColumn ){ + for(i=0; inId; i++){ + pColumn->a[i].idx = -1; + } + for(i=0; inId; i++){ + for(j=0; jnCol; j++){ + if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){ + pColumn->a[i].idx = j; + if( i!=j ) bIdListInOrder = 0; + if( j==pTab->iPKey ){ + ipkColumn = i; assert( !withoutRowid ); + } + break; + } + } + if( j>=pTab->nCol ){ + if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){ + ipkColumn = i; + bIdListInOrder = 0; + }else{ + sqlite3ErrorMsg(pParse, "table %S has no column named %s", + pTabList, 0, pColumn->a[i].zName); + pParse->checkSchema = 1; + goto insert_cleanup; + } + } + } + } + + /* Figure out how many columns of data are supplied. If the data + ** is coming from a SELECT statement, then generate a co-routine that + ** produces a single row of the SELECT on each invocation. The + ** co-routine is the common header to the 3rd and 4th templates. + */ + if( pSelect ){ + /* Data is coming from a SELECT or from a multi-row VALUES clause. + ** Generate a co-routine to run the SELECT. */ + int regYield; /* Register holding co-routine entry-point */ + int addrTop; /* Top of the co-routine */ + int rc; /* Result code */ + + regYield = ++pParse->nMem; + addrTop = sqlite3VdbeCurrentAddr(v) + 1; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop); + sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield); + dest.iSdst = bIdListInOrder ? regData : 0; + dest.nSdst = pTab->nCol; + rc = sqlite3Select(pParse, pSelect, &dest); + regFromSelect = dest.iSdst; + if( rc || db->mallocFailed || pParse->nErr ) goto insert_cleanup; + sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield); + sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */ + assert( pSelect->pEList ); + nColumn = pSelect->pEList->nExpr; + + /* Set useTempTable to TRUE if the result of the SELECT statement + ** should be written into a temporary table (template 4). Set to + ** FALSE if each output row of the SELECT can be written directly into + ** the destination table (template 3). + ** + ** A temp table must be used if the table being updated is also one + ** of the tables being read by the SELECT statement. Also use a + ** temp table in the case of row triggers. + */ + if( pTrigger || readsTable(pParse, iDb, pTab) ){ + useTempTable = 1; + } + + if( useTempTable ){ + /* Invoke the coroutine to extract information from the SELECT + ** and add it to a transient table srcTab. The code generated + ** here is from the 4th template: + ** + ** B: open temp table + ** L: yield X, goto M at EOF + ** insert row from R..R+n into temp table + ** goto L + ** M: ... + */ + int regRec; /* Register to hold packed record */ + int regTempRowid; /* Register to hold temp table ROWID */ + int addrL; /* Label "L" */ + + srcTab = pParse->nTab++; + regRec = sqlite3GetTempReg(pParse); + regTempRowid = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn); + addrL = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec); + sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid); + sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid); + sqlite3VdbeGoto(v, addrL); + sqlite3VdbeJumpHere(v, addrL); + sqlite3ReleaseTempReg(pParse, regRec); + sqlite3ReleaseTempReg(pParse, regTempRowid); + } + }else{ + /* This is the case if the data for the INSERT is coming from a + ** single-row VALUES clause + */ + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + srcTab = -1; + assert( useTempTable==0 ); + if( pList ){ + nColumn = pList->nExpr; + if( sqlite3ResolveExprListNames(&sNC, pList) ){ + goto insert_cleanup; + } + }else{ + nColumn = 0; + } + } + + /* If there is no IDLIST term but the table has an integer primary + ** key, the set the ipkColumn variable to the integer primary key + ** column index in the original table definition. + */ + if( pColumn==0 && nColumn>0 ){ + ipkColumn = pTab->iPKey; + } + + /* Make sure the number of columns in the source data matches the number + ** of columns to be inserted into the table. + */ + if( IsVirtual(pTab) ){ + for(i=0; inCol; i++){ + nHidden += (IsHiddenColumn(&pTab->aCol[i]) ? 1 : 0); + } + } + if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){ + sqlite3ErrorMsg(pParse, + "table %S has %d columns but %d values were supplied", + pTabList, 0, pTab->nCol-nHidden, nColumn); + goto insert_cleanup; + } + if( pColumn!=0 && nColumn!=pColumn->nId ){ + sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId); + goto insert_cleanup; + } + + /* Initialize the count of rows to be inserted + */ + if( db->flags & SQLITE_CountRows ){ + regRowCount = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); + } + + /* If this is not a view, open the table and and all indices */ + if( !isView ){ + int nIdx; + nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, -1, 0, + &iDataCur, &iIdxCur); + aRegIdx = sqlite3DbMallocRaw(db, sizeof(int)*(nIdx+1)); + if( aRegIdx==0 ){ + goto insert_cleanup; + } + for(i=0; inMem; + } + } + + /* This is the top of the main insertion loop */ + if( useTempTable ){ + /* This block codes the top of loop only. The complete loop is the + ** following pseudocode (template 4): + ** + ** rewind temp table, if empty goto D + ** C: loop over rows of intermediate table + ** transfer values form intermediate table into
    + ** end loop + ** D: ... + */ + addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab); VdbeCoverage(v); + addrCont = sqlite3VdbeCurrentAddr(v); + }else if( pSelect ){ + /* This block codes the top of loop only. The complete loop is the + ** following pseudocode (template 3): + ** + ** C: yield X, at EOF goto D + ** insert the select result into
    from R..R+n + ** goto C + ** D: ... + */ + addrInsTop = addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); + VdbeCoverage(v); + } + + /* Run the BEFORE and INSTEAD OF triggers, if there are any + */ + endOfLoop = sqlite3VdbeMakeLabel(v); + if( tmask & TRIGGER_BEFORE ){ + int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1); + + /* build the NEW.* reference row. Note that if there is an INTEGER + ** PRIMARY KEY into which a NULL is being inserted, that NULL will be + ** translated into a unique ID for the row. But on a BEFORE trigger, + ** we do not know what the unique ID will be (because the insert has + ** not happened yet) so we substitute a rowid of -1 + */ + if( ipkColumn<0 ){ + sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols); + }else{ + int addr1; + assert( !withoutRowid ); + if( useTempTable ){ + sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regCols); + }else{ + assert( pSelect==0 ); /* Otherwise useTempTable is true */ + sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols); + } + addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v); + } + + /* Cannot have triggers on a virtual table. If it were possible, + ** this block would have to account for hidden column. + */ + assert( !IsVirtual(pTab) ); + + /* Create the new column data + */ + for(i=0; inCol; i++){ + if( pColumn==0 ){ + j = i; + }else{ + for(j=0; jnId; j++){ + if( pColumn->a[j].idx==i ) break; + } + } + if( (!useTempTable && !pList) || (pColumn && j>=pColumn->nId) ){ + sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i+1); + }else if( useTempTable ){ + sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, regCols+i+1); + }else{ + assert( pSelect==0 ); /* Otherwise useTempTable is true */ + sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i+1); + } + } + + /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger, + ** do not attempt any conversions before assembling the record. + ** If this is a real table, attempt conversions as required by the + ** table column affinities. + */ + if( !isView ){ + sqlite3TableAffinity(v, pTab, regCols+1); + } + + /* Fire BEFORE or INSTEAD OF triggers */ + sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE, + pTab, regCols-pTab->nCol-1, onError, endOfLoop); + + sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1); + } + + /* Compute the content of the next row to insert into a range of + ** registers beginning at regIns. + */ + if( !isView ){ + if( IsVirtual(pTab) ){ + /* The row that the VUpdate opcode will delete: none */ + sqlite3VdbeAddOp2(v, OP_Null, 0, regIns); + } + if( ipkColumn>=0 ){ + if( useTempTable ){ + sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regRowid); + }else if( pSelect ){ + sqlite3VdbeAddOp2(v, OP_Copy, regFromSelect+ipkColumn, regRowid); + }else{ + VdbeOp *pOp; + sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid); + pOp = sqlite3VdbeGetOp(v, -1); + if( ALWAYS(pOp) && pOp->opcode==OP_Null && !IsVirtual(pTab) ){ + appendFlag = 1; + pOp->opcode = OP_NewRowid; + pOp->p1 = iDataCur; + pOp->p2 = regRowid; + pOp->p3 = regAutoinc; + } + } + /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid + ** to generate a unique primary key value. + */ + if( !appendFlag ){ + int addr1; + if( !IsVirtual(pTab) ){ + addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc); + sqlite3VdbeJumpHere(v, addr1); + }else{ + addr1 = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, addr1+2); VdbeCoverage(v); + } + sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid); VdbeCoverage(v); + } + }else if( IsVirtual(pTab) || withoutRowid ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid); + }else{ + sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc); + appendFlag = 1; + } + autoIncStep(pParse, regAutoinc, regRowid); + + /* Compute data for all columns of the new entry, beginning + ** with the first column. + */ + nHidden = 0; + for(i=0; inCol; i++){ + int iRegStore = regRowid+1+i; + if( i==pTab->iPKey ){ + /* The value of the INTEGER PRIMARY KEY column is always a NULL. + ** Whenever this column is read, the rowid will be substituted + ** in its place. Hence, fill this column with a NULL to avoid + ** taking up data space with information that will never be used. + ** As there may be shallow copies of this value, make it a soft-NULL */ + sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore); + continue; + } + if( pColumn==0 ){ + if( IsHiddenColumn(&pTab->aCol[i]) ){ + assert( IsVirtual(pTab) ); + j = -1; + nHidden++; + }else{ + j = i - nHidden; + } + }else{ + for(j=0; jnId; j++){ + if( pColumn->a[j].idx==i ) break; + } + } + if( j<0 || nColumn==0 || (pColumn && j>=pColumn->nId) ){ + sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore); + }else if( useTempTable ){ + sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, iRegStore); + }else if( pSelect ){ + if( regFromSelect!=regData ){ + sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+j, iRegStore); + } + }else{ + sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore); + } + } + + /* Generate code to check constraints and generate index keys and + ** do the insertion. + */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); + sqlite3VtabMakeWritable(pParse, pTab); + sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB); + sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError); + sqlite3MayAbort(pParse); + }else +#endif + { + int isReplace; /* Set to true if constraints may cause a replace */ + sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, + regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace + ); + sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0); + sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur, + regIns, aRegIdx, 0, appendFlag, isReplace==0); + } + } + + /* Update the count of rows that are inserted + */ + if( (db->flags & SQLITE_CountRows)!=0 ){ + sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1); + } + + if( pTrigger ){ + /* Code AFTER triggers */ + sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER, + pTab, regData-2-pTab->nCol, onError, endOfLoop); + } + + /* The bottom of the main insertion loop, if the data source + ** is a SELECT statement. + */ + sqlite3VdbeResolveLabel(v, endOfLoop); + if( useTempTable ){ + sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrInsTop); + sqlite3VdbeAddOp1(v, OP_Close, srcTab); + }else if( pSelect ){ + sqlite3VdbeGoto(v, addrCont); + sqlite3VdbeJumpHere(v, addrInsTop); + } + + if( !IsVirtual(pTab) && !isView ){ + /* Close all tables opened */ + if( iDataCurpIndex; pIdx; pIdx=pIdx->pNext, idx++){ + sqlite3VdbeAddOp1(v, OP_Close, idx+iIdxCur); + } + } + +insert_end: + /* Update the sqlite_sequence table by storing the content of the + ** maximum rowid counter values recorded while inserting into + ** autoincrement tables. + */ + if( pParse->nested==0 && pParse->pTriggerTab==0 ){ + sqlite3AutoincrementEnd(pParse); + } + + /* + ** Return the number of rows inserted. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. + */ + if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){ + sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLITE_STATIC); + } + +insert_cleanup: + sqlite3SrcListDelete(db, pTabList); + sqlite3ExprListDelete(db, pList); + sqlite3SelectDelete(db, pSelect); + sqlite3IdListDelete(db, pColumn); + sqlite3DbFree(db, aRegIdx); +} + +/* Make sure "isView" and other macros defined above are undefined. Otherwise +** they may interfere with compilation of other functions in this file +** (or in another file, if this file becomes part of the amalgamation). */ +#ifdef isView + #undef isView +#endif +#ifdef pTrigger + #undef pTrigger +#endif +#ifdef tmask + #undef tmask +#endif + +/* +** Generate code to do constraint checks prior to an INSERT or an UPDATE +** on table pTab. +** +** The regNewData parameter is the first register in a range that contains +** the data to be inserted or the data after the update. There will be +** pTab->nCol+1 registers in this range. The first register (the one +** that regNewData points to) will contain the new rowid, or NULL in the +** case of a WITHOUT ROWID table. The second register in the range will +** contain the content of the first table column. The third register will +** contain the content of the second table column. And so forth. +** +** The regOldData parameter is similar to regNewData except that it contains +** the data prior to an UPDATE rather than afterwards. regOldData is zero +** for an INSERT. This routine can distinguish between UPDATE and INSERT by +** checking regOldData for zero. +** +** For an UPDATE, the pkChng boolean is true if the true primary key (the +** rowid for a normal table or the PRIMARY KEY for a WITHOUT ROWID table) +** might be modified by the UPDATE. If pkChng is false, then the key of +** the iDataCur content table is guaranteed to be unchanged by the UPDATE. +** +** For an INSERT, the pkChng boolean indicates whether or not the rowid +** was explicitly specified as part of the INSERT statement. If pkChng +** is zero, it means that the either rowid is computed automatically or +** that the table is a WITHOUT ROWID table and has no rowid. On an INSERT, +** pkChng will only be true if the INSERT statement provides an integer +** value for either the rowid column or its INTEGER PRIMARY KEY alias. +** +** The code generated by this routine will store new index entries into +** registers identified by aRegIdx[]. No index entry is created for +** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is +** the same as the order of indices on the linked list of indices +** at pTab->pIndex. +** +** The caller must have already opened writeable cursors on the main +** table and all applicable indices (that is to say, all indices for which +** aRegIdx[] is not zero). iDataCur is the cursor for the main table when +** inserting or updating a rowid table, or the cursor for the PRIMARY KEY +** index when operating on a WITHOUT ROWID table. iIdxCur is the cursor +** for the first index in the pTab->pIndex list. Cursors for other indices +** are at iIdxCur+N for the N-th element of the pTab->pIndex list. +** +** This routine also generates code to check constraints. NOT NULL, +** CHECK, and UNIQUE constraints are all checked. If a constraint fails, +** then the appropriate action is performed. There are five possible +** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE. +** +** Constraint type Action What Happens +** --------------- ---------- ---------------------------------------- +** any ROLLBACK The current transaction is rolled back and +** sqlite3_step() returns immediately with a +** return code of SQLITE_CONSTRAINT. +** +** any ABORT Back out changes from the current command +** only (do not do a complete rollback) then +** cause sqlite3_step() to return immediately +** with SQLITE_CONSTRAINT. +** +** any FAIL Sqlite3_step() returns immediately with a +** return code of SQLITE_CONSTRAINT. The +** transaction is not rolled back and any +** changes to prior rows are retained. +** +** any IGNORE The attempt in insert or update the current +** row is skipped, without throwing an error. +** Processing continues with the next row. +** (There is an immediate jump to ignoreDest.) +** +** NOT NULL REPLACE The NULL value is replace by the default +** value for that column. If the default value +** is NULL, the action is the same as ABORT. +** +** UNIQUE REPLACE The other row that conflicts with the row +** being inserted is removed. +** +** CHECK REPLACE Illegal. The results in an exception. +** +** Which action to take is determined by the overrideError parameter. +** Or if overrideError==OE_Default, then the pParse->onError parameter +** is used. Or if pParse->onError==OE_Default then the onError value +** for the constraint is used. +*/ +SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( + Parse *pParse, /* The parser context */ + Table *pTab, /* The table being inserted or updated */ + int *aRegIdx, /* Use register aRegIdx[i] for index i. 0 for unused */ + int iDataCur, /* Canonical data cursor (main table or PK index) */ + int iIdxCur, /* First index cursor */ + int regNewData, /* First register in a range holding values to insert */ + int regOldData, /* Previous content. 0 for INSERTs */ + u8 pkChng, /* Non-zero if the rowid or PRIMARY KEY changed */ + u8 overrideError, /* Override onError to this if not OE_Default */ + int ignoreDest, /* Jump to this label on an OE_Ignore resolution */ + int *pbMayReplace /* OUT: Set to true if constraint may cause a replace */ +){ + Vdbe *v; /* VDBE under constrution */ + Index *pIdx; /* Pointer to one of the indices */ + Index *pPk = 0; /* The PRIMARY KEY index */ + sqlite3 *db; /* Database connection */ + int i; /* loop counter */ + int ix; /* Index loop counter */ + int nCol; /* Number of columns */ + int onError; /* Conflict resolution strategy */ + int addr1; /* Address of jump instruction */ + int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */ + int nPkField; /* Number of fields in PRIMARY KEY. 1 for ROWID tables */ + int ipkTop = 0; /* Top of the rowid change constraint check */ + int ipkBottom = 0; /* Bottom of the rowid change constraint check */ + u8 isUpdate; /* True if this is an UPDATE operation */ + u8 bAffinityDone = 0; /* True if the OP_Affinity operation has been run */ + int regRowid = -1; /* Register holding ROWID value */ + + isUpdate = regOldData!=0; + db = pParse->db; + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + assert( pTab->pSelect==0 ); /* This table is not a VIEW */ + nCol = pTab->nCol; + + /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for + ** normal rowid tables. nPkField is the number of key fields in the + ** pPk index or 1 for a rowid table. In other words, nPkField is the + ** number of fields in the true primary key of the table. */ + if( HasRowid(pTab) ){ + pPk = 0; + nPkField = 1; + }else{ + pPk = sqlite3PrimaryKeyIndex(pTab); + nPkField = pPk->nKeyCol; + } + + /* Record that this module has started */ + VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)", + iDataCur, iIdxCur, regNewData, regOldData, pkChng)); + + /* Test all NOT NULL constraints. + */ + for(i=0; iiPKey ){ + continue; + } + onError = pTab->aCol[i].notNull; + if( onError==OE_None ) continue; + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){ + onError = OE_Abort; + } + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail + || onError==OE_Ignore || onError==OE_Replace ); + switch( onError ){ + case OE_Abort: + sqlite3MayAbort(pParse); + /* Fall through */ + case OE_Rollback: + case OE_Fail: { + char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName, + pTab->aCol[i].zName); + sqlite3VdbeAddOp4(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL, onError, + regNewData+1+i, zMsg, P4_DYNAMIC); + sqlite3VdbeChangeP5(v, P5_ConstraintNotNull); + VdbeCoverage(v); + break; + } + case OE_Ignore: { + sqlite3VdbeAddOp2(v, OP_IsNull, regNewData+1+i, ignoreDest); + VdbeCoverage(v); + break; + } + default: { + assert( onError==OE_Replace ); + addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regNewData+1+i); + VdbeCoverage(v); + sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regNewData+1+i); + sqlite3VdbeJumpHere(v, addr1); + break; + } + } + } + + /* Test all CHECK constraints + */ +#ifndef SQLITE_OMIT_CHECK + if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){ + ExprList *pCheck = pTab->pCheck; + pParse->ckBase = regNewData+1; + onError = overrideError!=OE_Default ? overrideError : OE_Abort; + for(i=0; inExpr; i++){ + int allOk = sqlite3VdbeMakeLabel(v); + sqlite3ExprIfTrue(pParse, pCheck->a[i].pExpr, allOk, SQLITE_JUMPIFNULL); + if( onError==OE_Ignore ){ + sqlite3VdbeGoto(v, ignoreDest); + }else{ + char *zName = pCheck->a[i].zName; + if( zName==0 ) zName = pTab->zName; + if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-15569-63625 */ + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK, + onError, zName, P4_TRANSIENT, + P5_ConstraintCheck); + } + sqlite3VdbeResolveLabel(v, allOk); + } + } +#endif /* !defined(SQLITE_OMIT_CHECK) */ + + /* If rowid is changing, make sure the new rowid does not previously + ** exist in the table. + */ + if( pkChng && pPk==0 ){ + int addrRowidOk = sqlite3VdbeMakeLabel(v); + + /* Figure out what action to take in case of a rowid collision */ + onError = pTab->keyConf; + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + + if( isUpdate ){ + /* pkChng!=0 does not mean that the rowid has change, only that + ** it might have changed. Skip the conflict logic below if the rowid + ** is unchanged. */ + sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRowidOk, regOldData); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverage(v); + } + + /* If the response to a rowid conflict is REPLACE but the response + ** to some other UNIQUE constraint is FAIL or IGNORE, then we need + ** to defer the running of the rowid conflict checking until after + ** the UNIQUE constraints have run. + */ + if( onError==OE_Replace && overrideError!=OE_Replace ){ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->onError==OE_Ignore || pIdx->onError==OE_Fail ){ + ipkTop = sqlite3VdbeAddOp0(v, OP_Goto); + break; + } + } + } + + /* Check to see if the new rowid already exists in the table. Skip + ** the following conflict logic if it does not. */ + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData); + VdbeCoverage(v); + + /* Generate code that deals with a rowid collision */ + switch( onError ){ + default: { + onError = OE_Abort; + /* Fall thru into the next case */ + } + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + sqlite3RowidConstraint(pParse, onError, pTab); + break; + } + case OE_Replace: { + /* If there are DELETE triggers on this table and the + ** recursive-triggers flag is set, call GenerateRowDelete() to + ** remove the conflicting row from the table. This will fire + ** the triggers and remove both the table and index b-tree entries. + ** + ** Otherwise, if there are no triggers or the recursive-triggers + ** flag is not set, but the table has one or more indexes, call + ** GenerateRowIndexDelete(). This removes the index b-tree entries + ** only. The table b-tree entry will be replaced by the new entry + ** when it is inserted. + ** + ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called, + ** also invoke MultiWrite() to indicate that this VDBE may require + ** statement rollback (if the statement is aborted after the delete + ** takes place). Earlier versions called sqlite3MultiWrite() regardless, + ** but being more selective here allows statements like: + ** + ** REPLACE INTO t(rowid) VALUES($newrowid) + ** + ** to run without a statement journal if there are no indexes on the + ** table. + */ + Trigger *pTrigger = 0; + if( db->flags&SQLITE_RecTriggers ){ + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0); + } + if( pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0) ){ + sqlite3MultiWrite(pParse); + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur, + regNewData, 1, 0, OE_Replace, + ONEPASS_SINGLE, -1); + }else{ + if( pTab->pIndex ){ + sqlite3MultiWrite(pParse); + sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1); + } + } + seenReplace = 1; + break; + } + case OE_Ignore: { + /*assert( seenReplace==0 );*/ + sqlite3VdbeGoto(v, ignoreDest); + break; + } + } + sqlite3VdbeResolveLabel(v, addrRowidOk); + if( ipkTop ){ + ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto); + sqlite3VdbeJumpHere(v, ipkTop); + } + } + + /* Test all UNIQUE constraints by creating entries for each UNIQUE + ** index and making sure that duplicate entries do not already exist. + ** Compute the revised record entries for indices as we go. + ** + ** This loop also handles the case of the PRIMARY KEY index for a + ** WITHOUT ROWID table. + */ + for(ix=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, ix++){ + int regIdx; /* Range of registers hold conent for pIdx */ + int regR; /* Range of registers holding conflicting PK */ + int iThisCur; /* Cursor for this UNIQUE index */ + int addrUniqueOk; /* Jump here if the UNIQUE constraint is satisfied */ + + if( aRegIdx[ix]==0 ) continue; /* Skip indices that do not change */ + if( bAffinityDone==0 ){ + sqlite3TableAffinity(v, pTab, regNewData+1); + bAffinityDone = 1; + } + iThisCur = iIdxCur+ix; + addrUniqueOk = sqlite3VdbeMakeLabel(v); + + /* Skip partial indices for which the WHERE clause is not true */ + if( pIdx->pPartIdxWhere ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]); + pParse->ckBase = regNewData+1; + sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, addrUniqueOk, + SQLITE_JUMPIFNULL); + pParse->ckBase = 0; + } + + /* Create a record for this index entry as it should appear after + ** the insert or update. Store that record in the aRegIdx[ix] register + */ + regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn); + for(i=0; inColumn; i++){ + int iField = pIdx->aiColumn[i]; + int x; + if( iField==XN_EXPR ){ + pParse->ckBase = regNewData+1; + sqlite3ExprCode(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i); + pParse->ckBase = 0; + VdbeComment((v, "%s column %d", pIdx->zName, i)); + }else{ + if( iField==XN_ROWID || iField==pTab->iPKey ){ + if( regRowid==regIdx+i ) continue; /* ROWID already in regIdx+i */ + x = regNewData; + regRowid = pIdx->pPartIdxWhere ? -1 : regIdx+i; + }else{ + x = iField + regNewData + 1; + } + sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i); + VdbeComment((v, "%s", iField<0 ? "rowid" : pTab->aCol[iField].zName)); + } + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]); + VdbeComment((v, "for %s", pIdx->zName)); + sqlite3ExprCacheAffinityChange(pParse, regIdx, pIdx->nColumn); + + /* In an UPDATE operation, if this index is the PRIMARY KEY index + ** of a WITHOUT ROWID table and there has been no change the + ** primary key, then no collision is possible. The collision detection + ** logic below can all be skipped. */ + if( isUpdate && pPk==pIdx && pkChng==0 ){ + sqlite3VdbeResolveLabel(v, addrUniqueOk); + continue; + } + + /* Find out what action to take in case there is a uniqueness conflict */ + onError = pIdx->onError; + if( onError==OE_None ){ + sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn); + sqlite3VdbeResolveLabel(v, addrUniqueOk); + continue; /* pIdx is not a UNIQUE index */ + } + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + + /* Check to see if the new index entry will be unique */ + sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk, + regIdx, pIdx->nKeyCol); VdbeCoverage(v); + + /* Generate code to handle collisions */ + regR = (pIdx==pPk) ? regIdx : sqlite3GetTempRange(pParse, nPkField); + if( isUpdate || onError==OE_Replace ){ + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR); + /* Conflict only if the rowid of the existing index entry + ** is different from old-rowid */ + if( isUpdate ){ + sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverage(v); + } + }else{ + int x; + /* Extract the PRIMARY KEY from the end of the index entry and + ** store it in registers regR..regR+nPk-1 */ + if( pIdx!=pPk ){ + for(i=0; inKeyCol; i++){ + assert( pPk->aiColumn[i]>=0 ); + x = sqlite3ColumnOfIndex(pIdx, pPk->aiColumn[i]); + sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i); + VdbeComment((v, "%s.%s", pTab->zName, + pTab->aCol[pPk->aiColumn[i]].zName)); + } + } + if( isUpdate ){ + /* If currently processing the PRIMARY KEY of a WITHOUT ROWID + ** table, only conflict if the new PRIMARY KEY values are actually + ** different from the old. + ** + ** For a UNIQUE index, only conflict if the PRIMARY KEY values + ** of the matched index row are different from the original PRIMARY + ** KEY values of this row before the update. */ + int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol; + int op = OP_Ne; + int regCmp = (IsPrimaryKeyIndex(pIdx) ? regIdx : regR); + + for(i=0; inKeyCol; i++){ + char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]); + x = pPk->aiColumn[i]; + assert( x>=0 ); + if( i==(pPk->nKeyCol-1) ){ + addrJump = addrUniqueOk; + op = OP_Eq; + } + sqlite3VdbeAddOp4(v, op, + regOldData+1+x, addrJump, regCmp+i, p4, P4_COLLSEQ + ); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverageIf(v, op==OP_Eq); + VdbeCoverageIf(v, op==OP_Ne); + } + } + } + } + + /* Generate code that executes if the new index entry is not unique */ + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail + || onError==OE_Ignore || onError==OE_Replace ); + switch( onError ){ + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + sqlite3UniqueConstraint(pParse, onError, pIdx); + break; + } + case OE_Ignore: { + sqlite3VdbeGoto(v, ignoreDest); + break; + } + default: { + Trigger *pTrigger = 0; + assert( onError==OE_Replace ); + sqlite3MultiWrite(pParse); + if( db->flags&SQLITE_RecTriggers ){ + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0); + } + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur, + regR, nPkField, 0, OE_Replace, + (pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), -1); + seenReplace = 1; + break; + } + } + sqlite3VdbeResolveLabel(v, addrUniqueOk); + sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn); + if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField); + } + if( ipkTop ){ + sqlite3VdbeGoto(v, ipkTop+1); + sqlite3VdbeJumpHere(v, ipkBottom); + } + + *pbMayReplace = seenReplace; + VdbeModuleComment((v, "END: GenCnstCks(%d)", seenReplace)); +} + +/* +** This routine generates code to finish the INSERT or UPDATE operation +** that was started by a prior call to sqlite3GenerateConstraintChecks. +** A consecutive range of registers starting at regNewData contains the +** rowid and the content to be inserted. +** +** The arguments to this routine should be the same as the first six +** arguments to sqlite3GenerateConstraintChecks. +*/ +SQLITE_PRIVATE void sqlite3CompleteInsertion( + Parse *pParse, /* The parser context */ + Table *pTab, /* the table into which we are inserting */ + int iDataCur, /* Cursor of the canonical data source */ + int iIdxCur, /* First index cursor */ + int regNewData, /* Range of content */ + int *aRegIdx, /* Register used by each index. 0 for unused indices */ + int isUpdate, /* True for UPDATE, False for INSERT */ + int appendBias, /* True if this is likely to be an append */ + int useSeekResult /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */ +){ + Vdbe *v; /* Prepared statements under construction */ + Index *pIdx; /* An index being inserted or updated */ + u8 pik_flags; /* flag values passed to the btree insert */ + int regData; /* Content registers (after the rowid) */ + int regRec; /* Register holding assembled record for the table */ + int i; /* Loop counter */ + u8 bAffinityDone = 0; /* True if OP_Affinity has been run already */ + + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + assert( pTab->pSelect==0 ); /* This table is not a VIEW */ + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + if( aRegIdx[i]==0 ) continue; + bAffinityDone = 1; + if( pIdx->pPartIdxWhere ){ + sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + } + sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i]); + pik_flags = 0; + if( useSeekResult ) pik_flags = OPFLAG_USESEEKRESULT; + if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){ + assert( pParse->nested==0 ); + pik_flags |= OPFLAG_NCHANGE; + } + if( pik_flags ) sqlite3VdbeChangeP5(v, pik_flags); + } + if( !HasRowid(pTab) ) return; + regData = regNewData + 1; + regRec = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec); + if( !bAffinityDone ) sqlite3TableAffinity(v, pTab, 0); + sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol); + if( pParse->nested ){ + pik_flags = 0; + }else{ + pik_flags = OPFLAG_NCHANGE; + pik_flags |= (isUpdate?OPFLAG_ISUPDATE:OPFLAG_LASTROWID); + } + if( appendBias ){ + pik_flags |= OPFLAG_APPEND; + } + if( useSeekResult ){ + pik_flags |= OPFLAG_USESEEKRESULT; + } + sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, regRec, regNewData); + if( !pParse->nested ){ + sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT); + } + sqlite3VdbeChangeP5(v, pik_flags); +} + +/* +** Allocate cursors for the pTab table and all its indices and generate +** code to open and initialized those cursors. +** +** The cursor for the object that contains the complete data (normally +** the table itself, but the PRIMARY KEY index in the case of a WITHOUT +** ROWID table) is returned in *piDataCur. The first index cursor is +** returned in *piIdxCur. The number of indices is returned. +** +** Use iBase as the first cursor (either the *piDataCur for rowid tables +** or the first index for WITHOUT ROWID tables) if it is non-negative. +** If iBase is negative, then allocate the next available cursor. +** +** For a rowid table, *piDataCur will be exactly one less than *piIdxCur. +** For a WITHOUT ROWID table, *piDataCur will be somewhere in the range +** of *piIdxCurs, depending on where the PRIMARY KEY index appears on the +** pTab->pIndex list. +** +** If pTab is a virtual table, then this routine is a no-op and the +** *piDataCur and *piIdxCur values are left uninitialized. +*/ +SQLITE_PRIVATE int sqlite3OpenTableAndIndices( + Parse *pParse, /* Parsing context */ + Table *pTab, /* Table to be opened */ + int op, /* OP_OpenRead or OP_OpenWrite */ + int iBase, /* Use this for the table cursor, if there is one */ + u8 *aToOpen, /* If not NULL: boolean for each table and index */ + int *piDataCur, /* Write the database source cursor number here */ + int *piIdxCur /* Write the first index cursor number here */ +){ + int i; + int iDb; + int iDataCur; + Index *pIdx; + Vdbe *v; + + assert( op==OP_OpenRead || op==OP_OpenWrite ); + if( IsVirtual(pTab) ){ + /* This routine is a no-op for virtual tables. Leave the output + ** variables *piDataCur and *piIdxCur uninitialized so that valgrind + ** can detect if they are used by mistake in the caller. */ + return 0; + } + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + if( iBase<0 ) iBase = pParse->nTab; + iDataCur = iBase++; + if( piDataCur ) *piDataCur = iDataCur; + if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){ + sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op); + }else{ + sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName); + } + if( piIdxCur ) *piIdxCur = iBase; + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + int iIdxCur = iBase++; + assert( pIdx->pSchema==pTab->pSchema ); + if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) && piDataCur ){ + *piDataCur = iIdxCur; + } + if( aToOpen==0 || aToOpen[i+1] ){ + sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + VdbeComment((v, "%s", pIdx->zName)); + } + } + if( iBase>pParse->nTab ) pParse->nTab = iBase; + return i; +} + + +#ifdef SQLITE_TEST +/* +** The following global variable is incremented whenever the +** transfer optimization is used. This is used for testing +** purposes only - to make sure the transfer optimization really +** is happening when it is supposed to. +*/ +SQLITE_API int sqlite3_xferopt_count; +#endif /* SQLITE_TEST */ + + +#ifndef SQLITE_OMIT_XFER_OPT +/* +** Check to collation names to see if they are compatible. +*/ +static int xferCompatibleCollation(const char *z1, const char *z2){ + if( z1==0 ){ + return z2==0; + } + if( z2==0 ){ + return 0; + } + return sqlite3StrICmp(z1, z2)==0; +} + + +/* +** Check to see if index pSrc is compatible as a source of data +** for index pDest in an insert transfer optimization. The rules +** for a compatible index: +** +** * The index is over the same set of columns +** * The same DESC and ASC markings occurs on all columns +** * The same onError processing (OE_Abort, OE_Ignore, etc) +** * The same collating sequence on each column +** * The index has the exact same WHERE clause +*/ +static int xferCompatibleIndex(Index *pDest, Index *pSrc){ + int i; + assert( pDest && pSrc ); + assert( pDest->pTable!=pSrc->pTable ); + if( pDest->nKeyCol!=pSrc->nKeyCol ){ + return 0; /* Different number of columns */ + } + if( pDest->onError!=pSrc->onError ){ + return 0; /* Different conflict resolution strategies */ + } + for(i=0; inKeyCol; i++){ + if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){ + return 0; /* Different columns indexed */ + } + if( pSrc->aiColumn[i]==XN_EXPR ){ + assert( pSrc->aColExpr!=0 && pDest->aColExpr!=0 ); + if( sqlite3ExprCompare(pSrc->aColExpr->a[i].pExpr, + pDest->aColExpr->a[i].pExpr, -1)!=0 ){ + return 0; /* Different expressions in the index */ + } + } + if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){ + return 0; /* Different sort orders */ + } + if( !xferCompatibleCollation(pSrc->azColl[i],pDest->azColl[i]) ){ + return 0; /* Different collating sequences */ + } + } + if( sqlite3ExprCompare(pSrc->pPartIdxWhere, pDest->pPartIdxWhere, -1) ){ + return 0; /* Different WHERE clauses */ + } + + /* If no test above fails then the indices must be compatible */ + return 1; +} + +/* +** Attempt the transfer optimization on INSERTs of the form +** +** INSERT INTO tab1 SELECT * FROM tab2; +** +** The xfer optimization transfers raw records from tab2 over to tab1. +** Columns are not decoded and reassembled, which greatly improves +** performance. Raw index records are transferred in the same way. +** +** The xfer optimization is only attempted if tab1 and tab2 are compatible. +** There are lots of rules for determining compatibility - see comments +** embedded in the code for details. +** +** This routine returns TRUE if the optimization is guaranteed to be used. +** Sometimes the xfer optimization will only work if the destination table +** is empty - a factor that can only be determined at run-time. In that +** case, this routine generates code for the xfer optimization but also +** does a test to see if the destination table is empty and jumps over the +** xfer optimization code if the test fails. In that case, this routine +** returns FALSE so that the caller will know to go ahead and generate +** an unoptimized transfer. This routine also returns FALSE if there +** is no chance that the xfer optimization can be applied. +** +** This optimization is particularly useful at making VACUUM run faster. +*/ +static int xferOptimization( + Parse *pParse, /* Parser context */ + Table *pDest, /* The table we are inserting into */ + Select *pSelect, /* A SELECT statement to use as the data source */ + int onError, /* How to handle constraint errors */ + int iDbDest /* The database of pDest */ +){ + sqlite3 *db = pParse->db; + ExprList *pEList; /* The result set of the SELECT */ + Table *pSrc; /* The table in the FROM clause of SELECT */ + Index *pSrcIdx, *pDestIdx; /* Source and destination indices */ + struct SrcList_item *pItem; /* An element of pSelect->pSrc */ + int i; /* Loop counter */ + int iDbSrc; /* The database of pSrc */ + int iSrc, iDest; /* Cursors from source and destination */ + int addr1, addr2; /* Loop addresses */ + int emptyDestTest = 0; /* Address of test for empty pDest */ + int emptySrcTest = 0; /* Address of test for empty pSrc */ + Vdbe *v; /* The VDBE we are building */ + int regAutoinc; /* Memory register used by AUTOINC */ + int destHasUniqueIdx = 0; /* True if pDest has a UNIQUE index */ + int regData, regRowid; /* Registers holding data and rowid */ + + if( pSelect==0 ){ + return 0; /* Must be of the form INSERT INTO ... SELECT ... */ + } + if( pParse->pWith || pSelect->pWith ){ + /* Do not attempt to process this query if there are an WITH clauses + ** attached to it. Proceeding may generate a false "no such table: xxx" + ** error if pSelect reads from a CTE named "xxx". */ + return 0; + } + if( sqlite3TriggerList(pParse, pDest) ){ + return 0; /* tab1 must not have triggers */ + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pDest->tabFlags & TF_Virtual ){ + return 0; /* tab1 must not be a virtual table */ + } +#endif + if( onError==OE_Default ){ + if( pDest->iPKey>=0 ) onError = pDest->keyConf; + if( onError==OE_Default ) onError = OE_Abort; + } + assert(pSelect->pSrc); /* allocated even if there is no FROM clause */ + if( pSelect->pSrc->nSrc!=1 ){ + return 0; /* FROM clause must have exactly one term */ + } + if( pSelect->pSrc->a[0].pSelect ){ + return 0; /* FROM clause cannot contain a subquery */ + } + if( pSelect->pWhere ){ + return 0; /* SELECT may not have a WHERE clause */ + } + if( pSelect->pOrderBy ){ + return 0; /* SELECT may not have an ORDER BY clause */ + } + /* Do not need to test for a HAVING clause. If HAVING is present but + ** there is no ORDER BY, we will get an error. */ + if( pSelect->pGroupBy ){ + return 0; /* SELECT may not have a GROUP BY clause */ + } + if( pSelect->pLimit ){ + return 0; /* SELECT may not have a LIMIT clause */ + } + assert( pSelect->pOffset==0 ); /* Must be so if pLimit==0 */ + if( pSelect->pPrior ){ + return 0; /* SELECT may not be a compound query */ + } + if( pSelect->selFlags & SF_Distinct ){ + return 0; /* SELECT may not be DISTINCT */ + } + pEList = pSelect->pEList; + assert( pEList!=0 ); + if( pEList->nExpr!=1 ){ + return 0; /* The result set must have exactly one column */ + } + assert( pEList->a[0].pExpr ); + if( pEList->a[0].pExpr->op!=TK_ALL ){ + return 0; /* The result set must be the special operator "*" */ + } + + /* At this point we have established that the statement is of the + ** correct syntactic form to participate in this optimization. Now + ** we have to check the semantics. + */ + pItem = pSelect->pSrc->a; + pSrc = sqlite3LocateTableItem(pParse, 0, pItem); + if( pSrc==0 ){ + return 0; /* FROM clause does not contain a real table */ + } + if( pSrc==pDest ){ + return 0; /* tab1 and tab2 may not be the same table */ + } + if( HasRowid(pDest)!=HasRowid(pSrc) ){ + return 0; /* source and destination must both be WITHOUT ROWID or not */ + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pSrc->tabFlags & TF_Virtual ){ + return 0; /* tab2 must not be a virtual table */ + } +#endif + if( pSrc->pSelect ){ + return 0; /* tab2 may not be a view */ + } + if( pDest->nCol!=pSrc->nCol ){ + return 0; /* Number of columns must be the same in tab1 and tab2 */ + } + if( pDest->iPKey!=pSrc->iPKey ){ + return 0; /* Both tables must have the same INTEGER PRIMARY KEY */ + } + for(i=0; inCol; i++){ + Column *pDestCol = &pDest->aCol[i]; + Column *pSrcCol = &pSrc->aCol[i]; + if( pDestCol->affinity!=pSrcCol->affinity ){ + return 0; /* Affinity must be the same on all columns */ + } + if( !xferCompatibleCollation(pDestCol->zColl, pSrcCol->zColl) ){ + return 0; /* Collating sequence must be the same on all columns */ + } + if( pDestCol->notNull && !pSrcCol->notNull ){ + return 0; /* tab2 must be NOT NULL if tab1 is */ + } + /* Default values for second and subsequent columns need to match. */ + if( i>0 + && ((pDestCol->zDflt==0)!=(pSrcCol->zDflt==0) + || (pDestCol->zDflt && strcmp(pDestCol->zDflt, pSrcCol->zDflt)!=0)) + ){ + return 0; /* Default values must be the same for all columns */ + } + } + for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){ + if( IsUniqueIndex(pDestIdx) ){ + destHasUniqueIdx = 1; + } + for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){ + if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break; + } + if( pSrcIdx==0 ){ + return 0; /* pDestIdx has no corresponding index in pSrc */ + } + } +#ifndef SQLITE_OMIT_CHECK + if( pDest->pCheck && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1) ){ + return 0; /* Tables have different CHECK constraints. Ticket #2252 */ + } +#endif +#ifndef SQLITE_OMIT_FOREIGN_KEY + /* Disallow the transfer optimization if the destination table constains + ** any foreign key constraints. This is more restrictive than necessary. + ** But the main beneficiary of the transfer optimization is the VACUUM + ** command, and the VACUUM command disables foreign key constraints. So + ** the extra complication to make this rule less restrictive is probably + ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e] + */ + if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){ + return 0; + } +#endif + if( (db->flags & SQLITE_CountRows)!=0 ){ + return 0; /* xfer opt does not play well with PRAGMA count_changes */ + } + + /* If we get this far, it means that the xfer optimization is at + ** least a possibility, though it might only work if the destination + ** table (tab1) is initially empty. + */ +#ifdef SQLITE_TEST + sqlite3_xferopt_count++; +#endif + iDbSrc = sqlite3SchemaToIndex(db, pSrc->pSchema); + v = sqlite3GetVdbe(pParse); + sqlite3CodeVerifySchema(pParse, iDbSrc); + iSrc = pParse->nTab++; + iDest = pParse->nTab++; + regAutoinc = autoIncBegin(pParse, iDbDest, pDest); + regData = sqlite3GetTempReg(pParse); + regRowid = sqlite3GetTempReg(pParse); + sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite); + assert( HasRowid(pDest) || destHasUniqueIdx ); + if( (db->flags & SQLITE_Vacuum)==0 && ( + (pDest->iPKey<0 && pDest->pIndex!=0) /* (1) */ + || destHasUniqueIdx /* (2) */ + || (onError!=OE_Abort && onError!=OE_Rollback) /* (3) */ + )){ + /* In some circumstances, we are able to run the xfer optimization + ** only if the destination table is initially empty. Unless the + ** SQLITE_Vacuum flag is set, this block generates code to make + ** that determination. If SQLITE_Vacuum is set, then the destination + ** table is always empty. + ** + ** Conditions under which the destination must be empty: + ** + ** (1) There is no INTEGER PRIMARY KEY but there are indices. + ** (If the destination is not initially empty, the rowid fields + ** of index entries might need to change.) + ** + ** (2) The destination has a unique index. (The xfer optimization + ** is unable to test uniqueness.) + ** + ** (3) onError is something other than OE_Abort and OE_Rollback. + */ + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0); VdbeCoverage(v); + emptyDestTest = sqlite3VdbeAddOp0(v, OP_Goto); + sqlite3VdbeJumpHere(v, addr1); + } + if( HasRowid(pSrc) ){ + sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead); + emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v); + if( pDest->iPKey>=0 ){ + addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid); + addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid); + VdbeCoverage(v); + sqlite3RowidConstraint(pParse, onError, pDest); + sqlite3VdbeJumpHere(v, addr2); + autoIncStep(pParse, regAutoinc, regRowid); + }else if( pDest->pIndex==0 ){ + addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid); + }else{ + addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid); + assert( (pDest->tabFlags & TF_Autoincrement)==0 ); + } + sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData); + sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid); + sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND); + sqlite3VdbeChangeP4(v, -1, pDest->zName, 0); + sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0); + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0); + }else{ + sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName); + sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName); + } + for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){ + u8 idxInsFlags = 0; + for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){ + if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break; + } + assert( pSrcIdx ); + sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc); + sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx); + VdbeComment((v, "%s", pSrcIdx->zName)); + sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest); + sqlite3VdbeSetP4KeyInfo(pParse, pDestIdx); + sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR); + VdbeComment((v, "%s", pDestIdx->zName)); + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_RowKey, iSrc, regData); + if( db->flags & SQLITE_Vacuum ){ + /* This INSERT command is part of a VACUUM operation, which guarantees + ** that the destination table is empty. If all indexed columns use + ** collation sequence BINARY, then it can also be assumed that the + ** index will be populated by inserting keys in strictly sorted + ** order. In this case, instead of seeking within the b-tree as part + ** of every OP_IdxInsert opcode, an OP_Last is added before the + ** OP_IdxInsert to seek to the point within the b-tree where each key + ** should be inserted. This is faster. + ** + ** If any of the indexed columns use a collation sequence other than + ** BINARY, this optimization is disabled. This is because the user + ** might change the definition of a collation sequence and then run + ** a VACUUM command. In that case keys may not be written in strictly + ** sorted order. */ + for(i=0; inColumn; i++){ + char *zColl = pSrcIdx->azColl[i]; + assert( zColl!=0 ); + if( sqlite3_stricmp("BINARY", zColl) ) break; + } + if( i==pSrcIdx->nColumn ){ + idxInsFlags = OPFLAG_USESEEKRESULT; + sqlite3VdbeAddOp3(v, OP_Last, iDest, 0, -1); + } + } + if( !HasRowid(pSrc) && pDestIdx->idxType==2 ){ + idxInsFlags |= OPFLAG_NCHANGE; + } + sqlite3VdbeAddOp3(v, OP_IdxInsert, iDest, regData, 1); + sqlite3VdbeChangeP5(v, idxInsFlags); + sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0); + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0); + } + if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest); + sqlite3ReleaseTempReg(pParse, regRowid); + sqlite3ReleaseTempReg(pParse, regData); + if( emptyDestTest ){ + sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0); + sqlite3VdbeJumpHere(v, emptyDestTest); + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0); + return 0; + }else{ + return 1; + } +} +#endif /* SQLITE_OMIT_XFER_OPT */ + +/************** End of insert.c **********************************************/ +/************** Begin file legacy.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Main file for the SQLite library. The routines in this file +** implement the programmer interface to the library. Routines in +** other files are for internal use by SQLite and should not be +** accessed by users of the library. +*/ + +/* #include "sqliteInt.h" */ + +/* +** Execute SQL code. Return one of the SQLITE_ success/failure +** codes. Also write an error message into memory obtained from +** malloc() and make *pzErrMsg point to that message. +** +** If the SQL is a query, then for each row in the query result +** the xCallback() function is called. pArg becomes the first +** argument to xCallback(). If xCallback=NULL then no callback +** is invoked, even for queries. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_exec( + sqlite3 *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + sqlite3_callback xCallback, /* Invoke this callback routine */ + void *pArg, /* First argument to xCallback() */ + char **pzErrMsg /* Write error messages here */ +){ + int rc = SQLITE_OK; /* Return code */ + const char *zLeftover; /* Tail of unprocessed SQL */ + sqlite3_stmt *pStmt = 0; /* The current SQL statement */ + char **azCols = 0; /* Names of result columns */ + int callbackIsInit; /* True if callback data is initialized */ + + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; + if( zSql==0 ) zSql = ""; + + sqlite3_mutex_enter(db->mutex); + sqlite3Error(db, SQLITE_OK); + while( rc==SQLITE_OK && zSql[0] ){ + int nCol; + char **azVals = 0; + + pStmt = 0; + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover); + assert( rc==SQLITE_OK || pStmt==0 ); + if( rc!=SQLITE_OK ){ + continue; + } + if( !pStmt ){ + /* this happens for a comment or white-space */ + zSql = zLeftover; + continue; + } + + callbackIsInit = 0; + nCol = sqlite3_column_count(pStmt); + + while( 1 ){ + int i; + rc = sqlite3_step(pStmt); + + /* Invoke the callback function if required */ + if( xCallback && (SQLITE_ROW==rc || + (SQLITE_DONE==rc && !callbackIsInit + && db->flags&SQLITE_NullCallback)) ){ + if( !callbackIsInit ){ + azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1); + if( azCols==0 ){ + goto exec_out; + } + for(i=0; imallocFailed = 1; + goto exec_out; + } + } + } + if( xCallback(pArg, nCol, azVals, azCols) ){ + /* EVIDENCE-OF: R-38229-40159 If the callback function to + ** sqlite3_exec() returns non-zero, then sqlite3_exec() will + ** return SQLITE_ABORT. */ + rc = SQLITE_ABORT; + sqlite3VdbeFinalize((Vdbe *)pStmt); + pStmt = 0; + sqlite3Error(db, SQLITE_ABORT); + goto exec_out; + } + } + + if( rc!=SQLITE_ROW ){ + rc = sqlite3VdbeFinalize((Vdbe *)pStmt); + pStmt = 0; + zSql = zLeftover; + while( sqlite3Isspace(zSql[0]) ) zSql++; + break; + } + } + + sqlite3DbFree(db, azCols); + azCols = 0; + } + +exec_out: + if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt); + sqlite3DbFree(db, azCols); + + rc = sqlite3ApiExit(db, rc); + if( rc!=SQLITE_OK && pzErrMsg ){ + int nErrMsg = 1 + sqlite3Strlen30(sqlite3_errmsg(db)); + *pzErrMsg = sqlite3Malloc(nErrMsg); + if( *pzErrMsg ){ + memcpy(*pzErrMsg, sqlite3_errmsg(db), nErrMsg); + }else{ + rc = SQLITE_NOMEM; + sqlite3Error(db, SQLITE_NOMEM); + } + }else if( pzErrMsg ){ + *pzErrMsg = 0; + } + + assert( (rc&db->errMask)==rc ); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/************** End of legacy.c **********************************************/ +/************** Begin file loadext.c *****************************************/ +/* +** 2006 June 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to dynamically load extensions into +** the SQLite library. +*/ + +#ifndef SQLITE_CORE + #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */ +#endif +/************** Include sqlite3ext.h in the middle of loadext.c **************/ +/************** Begin file sqlite3ext.h **************************************/ +/* +** 2006 June 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the SQLite interface for use by +** shared libraries that want to be imported as extensions into +** an SQLite instance. Shared libraries that intend to be loaded +** as extensions by SQLite should #include this file instead of +** sqlite3.h. +*/ +#ifndef _SQLITE3EXT_H_ +#define _SQLITE3EXT_H_ +/* #include "sqlite3.h" */ + +typedef struct sqlite3_api_routines sqlite3_api_routines; + +/* +** The following structure holds pointers to all of the SQLite API +** routines. +** +** WARNING: In order to maintain backwards compatibility, add new +** interfaces to the end of this structure only. If you insert new +** interfaces in the middle of this structure, then older different +** versions of SQLite will not be able to load each other's shared +** libraries! +*/ +struct sqlite3_api_routines { + void * (*aggregate_context)(sqlite3_context*,int nBytes); + int (*aggregate_count)(sqlite3_context*); + int (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*)); + int (*bind_double)(sqlite3_stmt*,int,double); + int (*bind_int)(sqlite3_stmt*,int,int); + int (*bind_int64)(sqlite3_stmt*,int,sqlite_int64); + int (*bind_null)(sqlite3_stmt*,int); + int (*bind_parameter_count)(sqlite3_stmt*); + int (*bind_parameter_index)(sqlite3_stmt*,const char*zName); + const char * (*bind_parameter_name)(sqlite3_stmt*,int); + int (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*)); + int (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*)); + int (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*); + int (*busy_handler)(sqlite3*,int(*)(void*,int),void*); + int (*busy_timeout)(sqlite3*,int ms); + int (*changes)(sqlite3*); + int (*close)(sqlite3*); + int (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*, + int eTextRep,const char*)); + int (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*, + int eTextRep,const void*)); + const void * (*column_blob)(sqlite3_stmt*,int iCol); + int (*column_bytes)(sqlite3_stmt*,int iCol); + int (*column_bytes16)(sqlite3_stmt*,int iCol); + int (*column_count)(sqlite3_stmt*pStmt); + const char * (*column_database_name)(sqlite3_stmt*,int); + const void * (*column_database_name16)(sqlite3_stmt*,int); + const char * (*column_decltype)(sqlite3_stmt*,int i); + const void * (*column_decltype16)(sqlite3_stmt*,int); + double (*column_double)(sqlite3_stmt*,int iCol); + int (*column_int)(sqlite3_stmt*,int iCol); + sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol); + const char * (*column_name)(sqlite3_stmt*,int); + const void * (*column_name16)(sqlite3_stmt*,int); + const char * (*column_origin_name)(sqlite3_stmt*,int); + const void * (*column_origin_name16)(sqlite3_stmt*,int); + const char * (*column_table_name)(sqlite3_stmt*,int); + const void * (*column_table_name16)(sqlite3_stmt*,int); + const unsigned char * (*column_text)(sqlite3_stmt*,int iCol); + const void * (*column_text16)(sqlite3_stmt*,int iCol); + int (*column_type)(sqlite3_stmt*,int iCol); + sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol); + void * (*commit_hook)(sqlite3*,int(*)(void*),void*); + int (*complete)(const char*sql); + int (*complete16)(const void*sql); + int (*create_collation)(sqlite3*,const char*,int,void*, + int(*)(void*,int,const void*,int,const void*)); + int (*create_collation16)(sqlite3*,const void*,int,void*, + int(*)(void*,int,const void*,int,const void*)); + int (*create_function)(sqlite3*,const char*,int,int,void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*)); + int (*create_function16)(sqlite3*,const void*,int,int,void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*)); + int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*); + int (*data_count)(sqlite3_stmt*pStmt); + sqlite3 * (*db_handle)(sqlite3_stmt*); + int (*declare_vtab)(sqlite3*,const char*); + int (*enable_shared_cache)(int); + int (*errcode)(sqlite3*db); + const char * (*errmsg)(sqlite3*); + const void * (*errmsg16)(sqlite3*); + int (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**); + int (*expired)(sqlite3_stmt*); + int (*finalize)(sqlite3_stmt*pStmt); + void (*free)(void*); + void (*free_table)(char**result); + int (*get_autocommit)(sqlite3*); + void * (*get_auxdata)(sqlite3_context*,int); + int (*get_table)(sqlite3*,const char*,char***,int*,int*,char**); + int (*global_recover)(void); + void (*interruptx)(sqlite3*); + sqlite_int64 (*last_insert_rowid)(sqlite3*); + const char * (*libversion)(void); + int (*libversion_number)(void); + void *(*malloc)(int); + char * (*mprintf)(const char*,...); + int (*open)(const char*,sqlite3**); + int (*open16)(const void*,sqlite3**); + int (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**); + int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); + void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*); + void (*progress_handler)(sqlite3*,int,int(*)(void*),void*); + void *(*realloc)(void*,int); + int (*reset)(sqlite3_stmt*pStmt); + void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_double)(sqlite3_context*,double); + void (*result_error)(sqlite3_context*,const char*,int); + void (*result_error16)(sqlite3_context*,const void*,int); + void (*result_int)(sqlite3_context*,int); + void (*result_int64)(sqlite3_context*,sqlite_int64); + void (*result_null)(sqlite3_context*); + void (*result_text)(sqlite3_context*,const char*,int,void(*)(void*)); + void (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_value)(sqlite3_context*,sqlite3_value*); + void * (*rollback_hook)(sqlite3*,void(*)(void*),void*); + int (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*, + const char*,const char*),void*); + void (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*)); + char * (*snprintf)(int,char*,const char*,...); + int (*step)(sqlite3_stmt*); + int (*table_column_metadata)(sqlite3*,const char*,const char*,const char*, + char const**,char const**,int*,int*,int*); + void (*thread_cleanup)(void); + int (*total_changes)(sqlite3*); + void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*); + int (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*); + void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*, + sqlite_int64),void*); + void * (*user_data)(sqlite3_context*); + const void * (*value_blob)(sqlite3_value*); + int (*value_bytes)(sqlite3_value*); + int (*value_bytes16)(sqlite3_value*); + double (*value_double)(sqlite3_value*); + int (*value_int)(sqlite3_value*); + sqlite_int64 (*value_int64)(sqlite3_value*); + int (*value_numeric_type)(sqlite3_value*); + const unsigned char * (*value_text)(sqlite3_value*); + const void * (*value_text16)(sqlite3_value*); + const void * (*value_text16be)(sqlite3_value*); + const void * (*value_text16le)(sqlite3_value*); + int (*value_type)(sqlite3_value*); + char *(*vmprintf)(const char*,va_list); + /* Added ??? */ + int (*overload_function)(sqlite3*, const char *zFuncName, int nArg); + /* Added by 3.3.13 */ + int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**); + int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); + int (*clear_bindings)(sqlite3_stmt*); + /* Added by 3.4.1 */ + int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*, + void (*xDestroy)(void *)); + /* Added by 3.5.0 */ + int (*bind_zeroblob)(sqlite3_stmt*,int,int); + int (*blob_bytes)(sqlite3_blob*); + int (*blob_close)(sqlite3_blob*); + int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64, + int,sqlite3_blob**); + int (*blob_read)(sqlite3_blob*,void*,int,int); + int (*blob_write)(sqlite3_blob*,const void*,int,int); + int (*create_collation_v2)(sqlite3*,const char*,int,void*, + int(*)(void*,int,const void*,int,const void*), + void(*)(void*)); + int (*file_control)(sqlite3*,const char*,int,void*); + sqlite3_int64 (*memory_highwater)(int); + sqlite3_int64 (*memory_used)(void); + sqlite3_mutex *(*mutex_alloc)(int); + void (*mutex_enter)(sqlite3_mutex*); + void (*mutex_free)(sqlite3_mutex*); + void (*mutex_leave)(sqlite3_mutex*); + int (*mutex_try)(sqlite3_mutex*); + int (*open_v2)(const char*,sqlite3**,int,const char*); + int (*release_memory)(int); + void (*result_error_nomem)(sqlite3_context*); + void (*result_error_toobig)(sqlite3_context*); + int (*sleep)(int); + void (*soft_heap_limit)(int); + sqlite3_vfs *(*vfs_find)(const char*); + int (*vfs_register)(sqlite3_vfs*,int); + int (*vfs_unregister)(sqlite3_vfs*); + int (*xthreadsafe)(void); + void (*result_zeroblob)(sqlite3_context*,int); + void (*result_error_code)(sqlite3_context*,int); + int (*test_control)(int, ...); + void (*randomness)(int,void*); + sqlite3 *(*context_db_handle)(sqlite3_context*); + int (*extended_result_codes)(sqlite3*,int); + int (*limit)(sqlite3*,int,int); + sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*); + const char *(*sql)(sqlite3_stmt*); + int (*status)(int,int*,int*,int); + int (*backup_finish)(sqlite3_backup*); + sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*); + int (*backup_pagecount)(sqlite3_backup*); + int (*backup_remaining)(sqlite3_backup*); + int (*backup_step)(sqlite3_backup*,int); + const char *(*compileoption_get)(int); + int (*compileoption_used)(const char*); + int (*create_function_v2)(sqlite3*,const char*,int,int,void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void(*xDestroy)(void*)); + int (*db_config)(sqlite3*,int,...); + sqlite3_mutex *(*db_mutex)(sqlite3*); + int (*db_status)(sqlite3*,int,int*,int*,int); + int (*extended_errcode)(sqlite3*); + void (*log)(int,const char*,...); + sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64); + const char *(*sourceid)(void); + int (*stmt_status)(sqlite3_stmt*,int,int); + int (*strnicmp)(const char*,const char*,int); + int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*); + int (*wal_autocheckpoint)(sqlite3*,int); + int (*wal_checkpoint)(sqlite3*,const char*); + void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*); + int (*blob_reopen)(sqlite3_blob*,sqlite3_int64); + int (*vtab_config)(sqlite3*,int op,...); + int (*vtab_on_conflict)(sqlite3*); + /* Version 3.7.16 and later */ + int (*close_v2)(sqlite3*); + const char *(*db_filename)(sqlite3*,const char*); + int (*db_readonly)(sqlite3*,const char*); + int (*db_release_memory)(sqlite3*); + const char *(*errstr)(int); + int (*stmt_busy)(sqlite3_stmt*); + int (*stmt_readonly)(sqlite3_stmt*); + int (*stricmp)(const char*,const char*); + int (*uri_boolean)(const char*,const char*,int); + sqlite3_int64 (*uri_int64)(const char*,const char*,sqlite3_int64); + const char *(*uri_parameter)(const char*,const char*); + char *(*vsnprintf)(int,char*,const char*,va_list); + int (*wal_checkpoint_v2)(sqlite3*,const char*,int,int*,int*); + /* Version 3.8.7 and later */ + int (*auto_extension)(void(*)(void)); + int (*bind_blob64)(sqlite3_stmt*,int,const void*,sqlite3_uint64, + void(*)(void*)); + int (*bind_text64)(sqlite3_stmt*,int,const char*,sqlite3_uint64, + void(*)(void*),unsigned char); + int (*cancel_auto_extension)(void(*)(void)); + int (*load_extension)(sqlite3*,const char*,const char*,char**); + void *(*malloc64)(sqlite3_uint64); + sqlite3_uint64 (*msize)(void*); + void *(*realloc64)(void*,sqlite3_uint64); + void (*reset_auto_extension)(void); + void (*result_blob64)(sqlite3_context*,const void*,sqlite3_uint64, + void(*)(void*)); + void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64, + void(*)(void*), unsigned char); + int (*strglob)(const char*,const char*); + /* Version 3.8.11 and later */ + sqlite3_value *(*value_dup)(const sqlite3_value*); + void (*value_free)(sqlite3_value*); + int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64); + int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64); + /* Version 3.9.0 and later */ + unsigned int (*value_subtype)(sqlite3_value*); + void (*result_subtype)(sqlite3_context*,unsigned int); +}; + +/* +** The following macros redefine the API routines so that they are +** redirected through the global sqlite3_api structure. +** +** This header file is also used by the loadext.c source file +** (part of the main SQLite library - not an extension) so that +** it can get access to the sqlite3_api_routines structure +** definition. But the main library does not want to redefine +** the API. So the redefinition macros are only valid if the +** SQLITE_CORE macros is undefined. +*/ +#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) +#define sqlite3_aggregate_context sqlite3_api->aggregate_context +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_aggregate_count sqlite3_api->aggregate_count +#endif +#define sqlite3_bind_blob sqlite3_api->bind_blob +#define sqlite3_bind_double sqlite3_api->bind_double +#define sqlite3_bind_int sqlite3_api->bind_int +#define sqlite3_bind_int64 sqlite3_api->bind_int64 +#define sqlite3_bind_null sqlite3_api->bind_null +#define sqlite3_bind_parameter_count sqlite3_api->bind_parameter_count +#define sqlite3_bind_parameter_index sqlite3_api->bind_parameter_index +#define sqlite3_bind_parameter_name sqlite3_api->bind_parameter_name +#define sqlite3_bind_text sqlite3_api->bind_text +#define sqlite3_bind_text16 sqlite3_api->bind_text16 +#define sqlite3_bind_value sqlite3_api->bind_value +#define sqlite3_busy_handler sqlite3_api->busy_handler +#define sqlite3_busy_timeout sqlite3_api->busy_timeout +#define sqlite3_changes sqlite3_api->changes +#define sqlite3_close sqlite3_api->close +#define sqlite3_collation_needed sqlite3_api->collation_needed +#define sqlite3_collation_needed16 sqlite3_api->collation_needed16 +#define sqlite3_column_blob sqlite3_api->column_blob +#define sqlite3_column_bytes sqlite3_api->column_bytes +#define sqlite3_column_bytes16 sqlite3_api->column_bytes16 +#define sqlite3_column_count sqlite3_api->column_count +#define sqlite3_column_database_name sqlite3_api->column_database_name +#define sqlite3_column_database_name16 sqlite3_api->column_database_name16 +#define sqlite3_column_decltype sqlite3_api->column_decltype +#define sqlite3_column_decltype16 sqlite3_api->column_decltype16 +#define sqlite3_column_double sqlite3_api->column_double +#define sqlite3_column_int sqlite3_api->column_int +#define sqlite3_column_int64 sqlite3_api->column_int64 +#define sqlite3_column_name sqlite3_api->column_name +#define sqlite3_column_name16 sqlite3_api->column_name16 +#define sqlite3_column_origin_name sqlite3_api->column_origin_name +#define sqlite3_column_origin_name16 sqlite3_api->column_origin_name16 +#define sqlite3_column_table_name sqlite3_api->column_table_name +#define sqlite3_column_table_name16 sqlite3_api->column_table_name16 +#define sqlite3_column_text sqlite3_api->column_text +#define sqlite3_column_text16 sqlite3_api->column_text16 +#define sqlite3_column_type sqlite3_api->column_type +#define sqlite3_column_value sqlite3_api->column_value +#define sqlite3_commit_hook sqlite3_api->commit_hook +#define sqlite3_complete sqlite3_api->complete +#define sqlite3_complete16 sqlite3_api->complete16 +#define sqlite3_create_collation sqlite3_api->create_collation +#define sqlite3_create_collation16 sqlite3_api->create_collation16 +#define sqlite3_create_function sqlite3_api->create_function +#define sqlite3_create_function16 sqlite3_api->create_function16 +#define sqlite3_create_module sqlite3_api->create_module +#define sqlite3_create_module_v2 sqlite3_api->create_module_v2 +#define sqlite3_data_count sqlite3_api->data_count +#define sqlite3_db_handle sqlite3_api->db_handle +#define sqlite3_declare_vtab sqlite3_api->declare_vtab +#define sqlite3_enable_shared_cache sqlite3_api->enable_shared_cache +#define sqlite3_errcode sqlite3_api->errcode +#define sqlite3_errmsg sqlite3_api->errmsg +#define sqlite3_errmsg16 sqlite3_api->errmsg16 +#define sqlite3_exec sqlite3_api->exec +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_expired sqlite3_api->expired +#endif +#define sqlite3_finalize sqlite3_api->finalize +#define sqlite3_free sqlite3_api->free +#define sqlite3_free_table sqlite3_api->free_table +#define sqlite3_get_autocommit sqlite3_api->get_autocommit +#define sqlite3_get_auxdata sqlite3_api->get_auxdata +#define sqlite3_get_table sqlite3_api->get_table +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_global_recover sqlite3_api->global_recover +#endif +#define sqlite3_interrupt sqlite3_api->interruptx +#define sqlite3_last_insert_rowid sqlite3_api->last_insert_rowid +#define sqlite3_libversion sqlite3_api->libversion +#define sqlite3_libversion_number sqlite3_api->libversion_number +#define sqlite3_malloc sqlite3_api->malloc +#define sqlite3_mprintf sqlite3_api->mprintf +#define sqlite3_open sqlite3_api->open +#define sqlite3_open16 sqlite3_api->open16 +#define sqlite3_prepare sqlite3_api->prepare +#define sqlite3_prepare16 sqlite3_api->prepare16 +#define sqlite3_prepare_v2 sqlite3_api->prepare_v2 +#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2 +#define sqlite3_profile sqlite3_api->profile +#define sqlite3_progress_handler sqlite3_api->progress_handler +#define sqlite3_realloc sqlite3_api->realloc +#define sqlite3_reset sqlite3_api->reset +#define sqlite3_result_blob sqlite3_api->result_blob +#define sqlite3_result_double sqlite3_api->result_double +#define sqlite3_result_error sqlite3_api->result_error +#define sqlite3_result_error16 sqlite3_api->result_error16 +#define sqlite3_result_int sqlite3_api->result_int +#define sqlite3_result_int64 sqlite3_api->result_int64 +#define sqlite3_result_null sqlite3_api->result_null +#define sqlite3_result_text sqlite3_api->result_text +#define sqlite3_result_text16 sqlite3_api->result_text16 +#define sqlite3_result_text16be sqlite3_api->result_text16be +#define sqlite3_result_text16le sqlite3_api->result_text16le +#define sqlite3_result_value sqlite3_api->result_value +#define sqlite3_rollback_hook sqlite3_api->rollback_hook +#define sqlite3_set_authorizer sqlite3_api->set_authorizer +#define sqlite3_set_auxdata sqlite3_api->set_auxdata +#define sqlite3_snprintf sqlite3_api->snprintf +#define sqlite3_step sqlite3_api->step +#define sqlite3_table_column_metadata sqlite3_api->table_column_metadata +#define sqlite3_thread_cleanup sqlite3_api->thread_cleanup +#define sqlite3_total_changes sqlite3_api->total_changes +#define sqlite3_trace sqlite3_api->trace +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_transfer_bindings sqlite3_api->transfer_bindings +#endif +#define sqlite3_update_hook sqlite3_api->update_hook +#define sqlite3_user_data sqlite3_api->user_data +#define sqlite3_value_blob sqlite3_api->value_blob +#define sqlite3_value_bytes sqlite3_api->value_bytes +#define sqlite3_value_bytes16 sqlite3_api->value_bytes16 +#define sqlite3_value_double sqlite3_api->value_double +#define sqlite3_value_int sqlite3_api->value_int +#define sqlite3_value_int64 sqlite3_api->value_int64 +#define sqlite3_value_numeric_type sqlite3_api->value_numeric_type +#define sqlite3_value_text sqlite3_api->value_text +#define sqlite3_value_text16 sqlite3_api->value_text16 +#define sqlite3_value_text16be sqlite3_api->value_text16be +#define sqlite3_value_text16le sqlite3_api->value_text16le +#define sqlite3_value_type sqlite3_api->value_type +#define sqlite3_vmprintf sqlite3_api->vmprintf +#define sqlite3_vsnprintf sqlite3_api->vsnprintf +#define sqlite3_overload_function sqlite3_api->overload_function +#define sqlite3_prepare_v2 sqlite3_api->prepare_v2 +#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2 +#define sqlite3_clear_bindings sqlite3_api->clear_bindings +#define sqlite3_bind_zeroblob sqlite3_api->bind_zeroblob +#define sqlite3_blob_bytes sqlite3_api->blob_bytes +#define sqlite3_blob_close sqlite3_api->blob_close +#define sqlite3_blob_open sqlite3_api->blob_open +#define sqlite3_blob_read sqlite3_api->blob_read +#define sqlite3_blob_write sqlite3_api->blob_write +#define sqlite3_create_collation_v2 sqlite3_api->create_collation_v2 +#define sqlite3_file_control sqlite3_api->file_control +#define sqlite3_memory_highwater sqlite3_api->memory_highwater +#define sqlite3_memory_used sqlite3_api->memory_used +#define sqlite3_mutex_alloc sqlite3_api->mutex_alloc +#define sqlite3_mutex_enter sqlite3_api->mutex_enter +#define sqlite3_mutex_free sqlite3_api->mutex_free +#define sqlite3_mutex_leave sqlite3_api->mutex_leave +#define sqlite3_mutex_try sqlite3_api->mutex_try +#define sqlite3_open_v2 sqlite3_api->open_v2 +#define sqlite3_release_memory sqlite3_api->release_memory +#define sqlite3_result_error_nomem sqlite3_api->result_error_nomem +#define sqlite3_result_error_toobig sqlite3_api->result_error_toobig +#define sqlite3_sleep sqlite3_api->sleep +#define sqlite3_soft_heap_limit sqlite3_api->soft_heap_limit +#define sqlite3_vfs_find sqlite3_api->vfs_find +#define sqlite3_vfs_register sqlite3_api->vfs_register +#define sqlite3_vfs_unregister sqlite3_api->vfs_unregister +#define sqlite3_threadsafe sqlite3_api->xthreadsafe +#define sqlite3_result_zeroblob sqlite3_api->result_zeroblob +#define sqlite3_result_error_code sqlite3_api->result_error_code +#define sqlite3_test_control sqlite3_api->test_control +#define sqlite3_randomness sqlite3_api->randomness +#define sqlite3_context_db_handle sqlite3_api->context_db_handle +#define sqlite3_extended_result_codes sqlite3_api->extended_result_codes +#define sqlite3_limit sqlite3_api->limit +#define sqlite3_next_stmt sqlite3_api->next_stmt +#define sqlite3_sql sqlite3_api->sql +#define sqlite3_status sqlite3_api->status +#define sqlite3_backup_finish sqlite3_api->backup_finish +#define sqlite3_backup_init sqlite3_api->backup_init +#define sqlite3_backup_pagecount sqlite3_api->backup_pagecount +#define sqlite3_backup_remaining sqlite3_api->backup_remaining +#define sqlite3_backup_step sqlite3_api->backup_step +#define sqlite3_compileoption_get sqlite3_api->compileoption_get +#define sqlite3_compileoption_used sqlite3_api->compileoption_used +#define sqlite3_create_function_v2 sqlite3_api->create_function_v2 +#define sqlite3_db_config sqlite3_api->db_config +#define sqlite3_db_mutex sqlite3_api->db_mutex +#define sqlite3_db_status sqlite3_api->db_status +#define sqlite3_extended_errcode sqlite3_api->extended_errcode +#define sqlite3_log sqlite3_api->log +#define sqlite3_soft_heap_limit64 sqlite3_api->soft_heap_limit64 +#define sqlite3_sourceid sqlite3_api->sourceid +#define sqlite3_stmt_status sqlite3_api->stmt_status +#define sqlite3_strnicmp sqlite3_api->strnicmp +#define sqlite3_unlock_notify sqlite3_api->unlock_notify +#define sqlite3_wal_autocheckpoint sqlite3_api->wal_autocheckpoint +#define sqlite3_wal_checkpoint sqlite3_api->wal_checkpoint +#define sqlite3_wal_hook sqlite3_api->wal_hook +#define sqlite3_blob_reopen sqlite3_api->blob_reopen +#define sqlite3_vtab_config sqlite3_api->vtab_config +#define sqlite3_vtab_on_conflict sqlite3_api->vtab_on_conflict +/* Version 3.7.16 and later */ +#define sqlite3_close_v2 sqlite3_api->close_v2 +#define sqlite3_db_filename sqlite3_api->db_filename +#define sqlite3_db_readonly sqlite3_api->db_readonly +#define sqlite3_db_release_memory sqlite3_api->db_release_memory +#define sqlite3_errstr sqlite3_api->errstr +#define sqlite3_stmt_busy sqlite3_api->stmt_busy +#define sqlite3_stmt_readonly sqlite3_api->stmt_readonly +#define sqlite3_stricmp sqlite3_api->stricmp +#define sqlite3_uri_boolean sqlite3_api->uri_boolean +#define sqlite3_uri_int64 sqlite3_api->uri_int64 +#define sqlite3_uri_parameter sqlite3_api->uri_parameter +#define sqlite3_uri_vsnprintf sqlite3_api->vsnprintf +#define sqlite3_wal_checkpoint_v2 sqlite3_api->wal_checkpoint_v2 +/* Version 3.8.7 and later */ +#define sqlite3_auto_extension sqlite3_api->auto_extension +#define sqlite3_bind_blob64 sqlite3_api->bind_blob64 +#define sqlite3_bind_text64 sqlite3_api->bind_text64 +#define sqlite3_cancel_auto_extension sqlite3_api->cancel_auto_extension +#define sqlite3_load_extension sqlite3_api->load_extension +#define sqlite3_malloc64 sqlite3_api->malloc64 +#define sqlite3_msize sqlite3_api->msize +#define sqlite3_realloc64 sqlite3_api->realloc64 +#define sqlite3_reset_auto_extension sqlite3_api->reset_auto_extension +#define sqlite3_result_blob64 sqlite3_api->result_blob64 +#define sqlite3_result_text64 sqlite3_api->result_text64 +#define sqlite3_strglob sqlite3_api->strglob +/* Version 3.8.11 and later */ +#define sqlite3_value_dup sqlite3_api->value_dup +#define sqlite3_value_free sqlite3_api->value_free +#define sqlite3_result_zeroblob64 sqlite3_api->result_zeroblob64 +#define sqlite3_bind_zeroblob64 sqlite3_api->bind_zeroblob64 +/* Version 3.9.0 and later */ +#define sqlite3_value_subtype sqlite3_api->value_subtype +#define sqlite3_result_subtype sqlite3_api->result_subtype +#endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */ + +#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) + /* This case when the file really is being compiled as a loadable + ** extension */ +# define SQLITE_EXTENSION_INIT1 const sqlite3_api_routines *sqlite3_api=0; +# define SQLITE_EXTENSION_INIT2(v) sqlite3_api=v; +# define SQLITE_EXTENSION_INIT3 \ + extern const sqlite3_api_routines *sqlite3_api; +#else + /* This case when the file is being statically linked into the + ** application */ +# define SQLITE_EXTENSION_INIT1 /*no-op*/ +# define SQLITE_EXTENSION_INIT2(v) (void)v; /* unused parameter */ +# define SQLITE_EXTENSION_INIT3 /*no-op*/ +#endif + +#endif /* _SQLITE3EXT_H_ */ + +/************** End of sqlite3ext.h ******************************************/ +/************** Continuing where we left off in loadext.c ********************/ +/* #include "sqliteInt.h" */ +/* #include */ + +#ifndef SQLITE_OMIT_LOAD_EXTENSION + +/* +** Some API routines are omitted when various features are +** excluded from a build of SQLite. Substitute a NULL pointer +** for any missing APIs. +*/ +#ifndef SQLITE_ENABLE_COLUMN_METADATA +# define sqlite3_column_database_name 0 +# define sqlite3_column_database_name16 0 +# define sqlite3_column_table_name 0 +# define sqlite3_column_table_name16 0 +# define sqlite3_column_origin_name 0 +# define sqlite3_column_origin_name16 0 +#endif + +#ifdef SQLITE_OMIT_AUTHORIZATION +# define sqlite3_set_authorizer 0 +#endif + +#ifdef SQLITE_OMIT_UTF16 +# define sqlite3_bind_text16 0 +# define sqlite3_collation_needed16 0 +# define sqlite3_column_decltype16 0 +# define sqlite3_column_name16 0 +# define sqlite3_column_text16 0 +# define sqlite3_complete16 0 +# define sqlite3_create_collation16 0 +# define sqlite3_create_function16 0 +# define sqlite3_errmsg16 0 +# define sqlite3_open16 0 +# define sqlite3_prepare16 0 +# define sqlite3_prepare16_v2 0 +# define sqlite3_result_error16 0 +# define sqlite3_result_text16 0 +# define sqlite3_result_text16be 0 +# define sqlite3_result_text16le 0 +# define sqlite3_value_text16 0 +# define sqlite3_value_text16be 0 +# define sqlite3_value_text16le 0 +# define sqlite3_column_database_name16 0 +# define sqlite3_column_table_name16 0 +# define sqlite3_column_origin_name16 0 +#endif + +#ifdef SQLITE_OMIT_COMPLETE +# define sqlite3_complete 0 +# define sqlite3_complete16 0 +#endif + +#ifdef SQLITE_OMIT_DECLTYPE +# define sqlite3_column_decltype16 0 +# define sqlite3_column_decltype 0 +#endif + +#ifdef SQLITE_OMIT_PROGRESS_CALLBACK +# define sqlite3_progress_handler 0 +#endif + +#ifdef SQLITE_OMIT_VIRTUALTABLE +# define sqlite3_create_module 0 +# define sqlite3_create_module_v2 0 +# define sqlite3_declare_vtab 0 +# define sqlite3_vtab_config 0 +# define sqlite3_vtab_on_conflict 0 +#endif + +#ifdef SQLITE_OMIT_SHARED_CACHE +# define sqlite3_enable_shared_cache 0 +#endif + +#ifdef SQLITE_OMIT_TRACE +# define sqlite3_profile 0 +# define sqlite3_trace 0 +#endif + +#ifdef SQLITE_OMIT_GET_TABLE +# define sqlite3_free_table 0 +# define sqlite3_get_table 0 +#endif + +#ifdef SQLITE_OMIT_INCRBLOB +#define sqlite3_bind_zeroblob 0 +#define sqlite3_blob_bytes 0 +#define sqlite3_blob_close 0 +#define sqlite3_blob_open 0 +#define sqlite3_blob_read 0 +#define sqlite3_blob_write 0 +#define sqlite3_blob_reopen 0 +#endif + +/* +** The following structure contains pointers to all SQLite API routines. +** A pointer to this structure is passed into extensions when they are +** loaded so that the extension can make calls back into the SQLite +** library. +** +** When adding new APIs, add them to the bottom of this structure +** in order to preserve backwards compatibility. +** +** Extensions that use newer APIs should first call the +** sqlite3_libversion_number() to make sure that the API they +** intend to use is supported by the library. Extensions should +** also check to make sure that the pointer to the function is +** not NULL before calling it. +*/ +static const sqlite3_api_routines sqlite3Apis = { + sqlite3_aggregate_context, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_aggregate_count, +#else + 0, +#endif + sqlite3_bind_blob, + sqlite3_bind_double, + sqlite3_bind_int, + sqlite3_bind_int64, + sqlite3_bind_null, + sqlite3_bind_parameter_count, + sqlite3_bind_parameter_index, + sqlite3_bind_parameter_name, + sqlite3_bind_text, + sqlite3_bind_text16, + sqlite3_bind_value, + sqlite3_busy_handler, + sqlite3_busy_timeout, + sqlite3_changes, + sqlite3_close, + sqlite3_collation_needed, + sqlite3_collation_needed16, + sqlite3_column_blob, + sqlite3_column_bytes, + sqlite3_column_bytes16, + sqlite3_column_count, + sqlite3_column_database_name, + sqlite3_column_database_name16, + sqlite3_column_decltype, + sqlite3_column_decltype16, + sqlite3_column_double, + sqlite3_column_int, + sqlite3_column_int64, + sqlite3_column_name, + sqlite3_column_name16, + sqlite3_column_origin_name, + sqlite3_column_origin_name16, + sqlite3_column_table_name, + sqlite3_column_table_name16, + sqlite3_column_text, + sqlite3_column_text16, + sqlite3_column_type, + sqlite3_column_value, + sqlite3_commit_hook, + sqlite3_complete, + sqlite3_complete16, + sqlite3_create_collation, + sqlite3_create_collation16, + sqlite3_create_function, + sqlite3_create_function16, + sqlite3_create_module, + sqlite3_data_count, + sqlite3_db_handle, + sqlite3_declare_vtab, + sqlite3_enable_shared_cache, + sqlite3_errcode, + sqlite3_errmsg, + sqlite3_errmsg16, + sqlite3_exec, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_expired, +#else + 0, +#endif + sqlite3_finalize, + sqlite3_free, + sqlite3_free_table, + sqlite3_get_autocommit, + sqlite3_get_auxdata, + sqlite3_get_table, + 0, /* Was sqlite3_global_recover(), but that function is deprecated */ + sqlite3_interrupt, + sqlite3_last_insert_rowid, + sqlite3_libversion, + sqlite3_libversion_number, + sqlite3_malloc, + sqlite3_mprintf, + sqlite3_open, + sqlite3_open16, + sqlite3_prepare, + sqlite3_prepare16, + sqlite3_profile, + sqlite3_progress_handler, + sqlite3_realloc, + sqlite3_reset, + sqlite3_result_blob, + sqlite3_result_double, + sqlite3_result_error, + sqlite3_result_error16, + sqlite3_result_int, + sqlite3_result_int64, + sqlite3_result_null, + sqlite3_result_text, + sqlite3_result_text16, + sqlite3_result_text16be, + sqlite3_result_text16le, + sqlite3_result_value, + sqlite3_rollback_hook, + sqlite3_set_authorizer, + sqlite3_set_auxdata, + sqlite3_snprintf, + sqlite3_step, + sqlite3_table_column_metadata, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_thread_cleanup, +#else + 0, +#endif + sqlite3_total_changes, + sqlite3_trace, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_transfer_bindings, +#else + 0, +#endif + sqlite3_update_hook, + sqlite3_user_data, + sqlite3_value_blob, + sqlite3_value_bytes, + sqlite3_value_bytes16, + sqlite3_value_double, + sqlite3_value_int, + sqlite3_value_int64, + sqlite3_value_numeric_type, + sqlite3_value_text, + sqlite3_value_text16, + sqlite3_value_text16be, + sqlite3_value_text16le, + sqlite3_value_type, + sqlite3_vmprintf, + /* + ** The original API set ends here. All extensions can call any + ** of the APIs above provided that the pointer is not NULL. But + ** before calling APIs that follow, extension should check the + ** sqlite3_libversion_number() to make sure they are dealing with + ** a library that is new enough to support that API. + ************************************************************************* + */ + sqlite3_overload_function, + + /* + ** Added after 3.3.13 + */ + sqlite3_prepare_v2, + sqlite3_prepare16_v2, + sqlite3_clear_bindings, + + /* + ** Added for 3.4.1 + */ + sqlite3_create_module_v2, + + /* + ** Added for 3.5.0 + */ + sqlite3_bind_zeroblob, + sqlite3_blob_bytes, + sqlite3_blob_close, + sqlite3_blob_open, + sqlite3_blob_read, + sqlite3_blob_write, + sqlite3_create_collation_v2, + sqlite3_file_control, + sqlite3_memory_highwater, + sqlite3_memory_used, +#ifdef SQLITE_MUTEX_OMIT + 0, + 0, + 0, + 0, + 0, +#else + sqlite3_mutex_alloc, + sqlite3_mutex_enter, + sqlite3_mutex_free, + sqlite3_mutex_leave, + sqlite3_mutex_try, +#endif + sqlite3_open_v2, + sqlite3_release_memory, + sqlite3_result_error_nomem, + sqlite3_result_error_toobig, + sqlite3_sleep, + sqlite3_soft_heap_limit, + sqlite3_vfs_find, + sqlite3_vfs_register, + sqlite3_vfs_unregister, + + /* + ** Added for 3.5.8 + */ + sqlite3_threadsafe, + sqlite3_result_zeroblob, + sqlite3_result_error_code, + sqlite3_test_control, + sqlite3_randomness, + sqlite3_context_db_handle, + + /* + ** Added for 3.6.0 + */ + sqlite3_extended_result_codes, + sqlite3_limit, + sqlite3_next_stmt, + sqlite3_sql, + sqlite3_status, + + /* + ** Added for 3.7.4 + */ + sqlite3_backup_finish, + sqlite3_backup_init, + sqlite3_backup_pagecount, + sqlite3_backup_remaining, + sqlite3_backup_step, +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS + sqlite3_compileoption_get, + sqlite3_compileoption_used, +#else + 0, + 0, +#endif + sqlite3_create_function_v2, + sqlite3_db_config, + sqlite3_db_mutex, + sqlite3_db_status, + sqlite3_extended_errcode, + sqlite3_log, + sqlite3_soft_heap_limit64, + sqlite3_sourceid, + sqlite3_stmt_status, + sqlite3_strnicmp, +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY + sqlite3_unlock_notify, +#else + 0, +#endif +#ifndef SQLITE_OMIT_WAL + sqlite3_wal_autocheckpoint, + sqlite3_wal_checkpoint, + sqlite3_wal_hook, +#else + 0, + 0, + 0, +#endif + sqlite3_blob_reopen, + sqlite3_vtab_config, + sqlite3_vtab_on_conflict, + sqlite3_close_v2, + sqlite3_db_filename, + sqlite3_db_readonly, + sqlite3_db_release_memory, + sqlite3_errstr, + sqlite3_stmt_busy, + sqlite3_stmt_readonly, + sqlite3_stricmp, + sqlite3_uri_boolean, + sqlite3_uri_int64, + sqlite3_uri_parameter, + sqlite3_vsnprintf, + sqlite3_wal_checkpoint_v2, + /* Version 3.8.7 and later */ + sqlite3_auto_extension, + sqlite3_bind_blob64, + sqlite3_bind_text64, + sqlite3_cancel_auto_extension, + sqlite3_load_extension, + sqlite3_malloc64, + sqlite3_msize, + sqlite3_realloc64, + sqlite3_reset_auto_extension, + sqlite3_result_blob64, + sqlite3_result_text64, + sqlite3_strglob, + /* Version 3.8.11 and later */ + (sqlite3_value*(*)(const sqlite3_value*))sqlite3_value_dup, + sqlite3_value_free, + sqlite3_result_zeroblob64, + sqlite3_bind_zeroblob64, + /* Version 3.9.0 and later */ + sqlite3_value_subtype, + sqlite3_result_subtype +}; + +/* +** Attempt to load an SQLite extension library contained in the file +** zFile. The entry point is zProc. zProc may be 0 in which case a +** default entry point name (sqlite3_extension_init) is used. Use +** of the default name is recommended. +** +** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong. +** +** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with +** error message text. The calling function should free this memory +** by calling sqlite3DbFree(db, ). +*/ +static int sqlite3LoadExtension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +){ + sqlite3_vfs *pVfs = db->pVfs; + void *handle; + int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*); + char *zErrmsg = 0; + const char *zEntry; + char *zAltEntry = 0; + void **aHandle; + u64 nMsg = 300 + sqlite3Strlen30(zFile); + int ii; + + /* Shared library endings to try if zFile cannot be loaded as written */ + static const char *azEndings[] = { +#if SQLITE_OS_WIN + "dll" +#elif defined(__APPLE__) + "dylib" +#else + "so" +#endif + }; + + + if( pzErrMsg ) *pzErrMsg = 0; + + /* Ticket #1863. To avoid a creating security problems for older + ** applications that relink against newer versions of SQLite, the + ** ability to run load_extension is turned off by default. One + ** must call sqlite3_enable_load_extension() to turn on extension + ** loading. Otherwise you get the following error. + */ + if( (db->flags & SQLITE_LoadExtension)==0 ){ + if( pzErrMsg ){ + *pzErrMsg = sqlite3_mprintf("not authorized"); + } + return SQLITE_ERROR; + } + + zEntry = zProc ? zProc : "sqlite3_extension_init"; + + handle = sqlite3OsDlOpen(pVfs, zFile); +#if SQLITE_OS_UNIX || SQLITE_OS_WIN + for(ii=0; ii sqlite3_example_init + ** C:/lib/mathfuncs.dll ==> sqlite3_mathfuncs_init + */ + if( xInit==0 && zProc==0 ){ + int iFile, iEntry, c; + int ncFile = sqlite3Strlen30(zFile); + zAltEntry = sqlite3_malloc64(ncFile+30); + if( zAltEntry==0 ){ + sqlite3OsDlClose(pVfs, handle); + return SQLITE_NOMEM; + } + memcpy(zAltEntry, "sqlite3_", 8); + for(iFile=ncFile-1; iFile>=0 && zFile[iFile]!='/'; iFile--){} + iFile++; + if( sqlite3_strnicmp(zFile+iFile, "lib", 3)==0 ) iFile += 3; + for(iEntry=8; (c = zFile[iFile])!=0 && c!='.'; iFile++){ + if( sqlite3Isalpha(c) ){ + zAltEntry[iEntry++] = (char)sqlite3UpperToLower[(unsigned)c]; + } + } + memcpy(zAltEntry+iEntry, "_init", 6); + zEntry = zAltEntry; + xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*)) + sqlite3OsDlSym(pVfs, handle, zEntry); + } + if( xInit==0 ){ + if( pzErrMsg ){ + nMsg += sqlite3Strlen30(zEntry); + *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg); + if( zErrmsg ){ + sqlite3_snprintf(nMsg, zErrmsg, + "no entry point [%s] in shared library [%s]", zEntry, zFile); + sqlite3OsDlError(pVfs, nMsg-1, zErrmsg); + } + } + sqlite3OsDlClose(pVfs, handle); + sqlite3_free(zAltEntry); + return SQLITE_ERROR; + } + sqlite3_free(zAltEntry); + if( xInit(db, &zErrmsg, &sqlite3Apis) ){ + if( pzErrMsg ){ + *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg); + } + sqlite3_free(zErrmsg); + sqlite3OsDlClose(pVfs, handle); + return SQLITE_ERROR; + } + + /* Append the new shared library handle to the db->aExtension array. */ + aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1)); + if( aHandle==0 ){ + return SQLITE_NOMEM; + } + if( db->nExtension>0 ){ + memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension); + } + sqlite3DbFree(db, db->aExtension); + db->aExtension = aHandle; + + db->aExtension[db->nExtension++] = handle; + return SQLITE_OK; +} +SQLITE_API int SQLITE_STDCALL sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +){ + int rc; + sqlite3_mutex_enter(db->mutex); + rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Call this routine when the database connection is closing in order +** to clean up loaded extensions +*/ +SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3 *db){ + int i; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inExtension; i++){ + sqlite3OsDlClose(db->pVfs, db->aExtension[i]); + } + sqlite3DbFree(db, db->aExtension); +} + +/* +** Enable or disable extension loading. Extension loading is disabled by +** default so as not to open security holes in older applications. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_enable_load_extension(sqlite3 *db, int onoff){ + sqlite3_mutex_enter(db->mutex); + if( onoff ){ + db->flags |= SQLITE_LoadExtension; + }else{ + db->flags &= ~SQLITE_LoadExtension; + } + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#endif /* SQLITE_OMIT_LOAD_EXTENSION */ + +/* +** The auto-extension code added regardless of whether or not extension +** loading is supported. We need a dummy sqlite3Apis pointer for that +** code if regular extension loading is not available. This is that +** dummy pointer. +*/ +#ifdef SQLITE_OMIT_LOAD_EXTENSION +static const sqlite3_api_routines sqlite3Apis; +#endif + + +/* +** The following object holds the list of automatically loaded +** extensions. +** +** This list is shared across threads. The SQLITE_MUTEX_STATIC_MASTER +** mutex must be held while accessing this list. +*/ +typedef struct sqlite3AutoExtList sqlite3AutoExtList; +static SQLITE_WSD struct sqlite3AutoExtList { + u32 nExt; /* Number of entries in aExt[] */ + void (**aExt)(void); /* Pointers to the extension init functions */ +} sqlite3Autoext = { 0, 0 }; + +/* The "wsdAutoext" macro will resolve to the autoextension +** state vector. If writable static data is unsupported on the target, +** we have to locate the state vector at run-time. In the more common +** case where writable static data is supported, wsdStat can refer directly +** to the "sqlite3Autoext" state vector declared above. +*/ +#ifdef SQLITE_OMIT_WSD +# define wsdAutoextInit \ + sqlite3AutoExtList *x = &GLOBAL(sqlite3AutoExtList,sqlite3Autoext) +# define wsdAutoext x[0] +#else +# define wsdAutoextInit +# define wsdAutoext sqlite3Autoext +#endif + + +/* +** Register a statically linked extension that is automatically +** loaded by every new database connection. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_auto_extension(void (*xInit)(void)){ + int rc = SQLITE_OK; +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ){ + return rc; + }else +#endif + { + u32 i; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); +#endif + wsdAutoextInit; + sqlite3_mutex_enter(mutex); + for(i=0; i=0; i--){ + if( wsdAutoext.aExt[i]==xInit ){ + wsdAutoext.nExt--; + wsdAutoext.aExt[i] = wsdAutoext.aExt[wsdAutoext.nExt]; + n++; + break; + } + } + sqlite3_mutex_leave(mutex); + return n; +} + +/* +** Reset the automatic extension loading mechanism. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_reset_auto_extension(void){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize()==SQLITE_OK ) +#endif + { +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); +#endif + wsdAutoextInit; + sqlite3_mutex_enter(mutex); + sqlite3_free(wsdAutoext.aExt); + wsdAutoext.aExt = 0; + wsdAutoext.nExt = 0; + sqlite3_mutex_leave(mutex); + } +} + +/* +** Load all automatic extensions. +** +** If anything goes wrong, set an error in the database connection. +*/ +SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){ + u32 i; + int go = 1; + int rc; + int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*); + + wsdAutoextInit; + if( wsdAutoext.nExt==0 ){ + /* Common case: early out without every having to acquire a mutex */ + return; + } + for(i=0; go; i++){ + char *zErrmsg; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); +#endif + sqlite3_mutex_enter(mutex); + if( i>=wsdAutoext.nExt ){ + xInit = 0; + go = 0; + }else{ + xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*)) + wsdAutoext.aExt[i]; + } + sqlite3_mutex_leave(mutex); + zErrmsg = 0; + if( xInit && (rc = xInit(db, &zErrmsg, &sqlite3Apis))!=0 ){ + sqlite3ErrorWithMsg(db, rc, + "automatic extension loading failed: %s", zErrmsg); + go = 0; + } + sqlite3_free(zErrmsg); + } +} + +/************** End of loadext.c *********************************************/ +/************** Begin file pragma.c ******************************************/ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the PRAGMA command. +*/ +/* #include "sqliteInt.h" */ + +#if !defined(SQLITE_ENABLE_LOCKING_STYLE) +# if defined(__APPLE__) +# define SQLITE_ENABLE_LOCKING_STYLE 1 +# else +# define SQLITE_ENABLE_LOCKING_STYLE 0 +# endif +#endif + +/*************************************************************************** +** The "pragma.h" include file is an automatically generated file that +** that includes the PragType_XXXX macro definitions and the aPragmaName[] +** object. This ensures that the aPragmaName[] table is arranged in +** lexicographical order to facility a binary search of the pragma name. +** Do not edit pragma.h directly. Edit and rerun the script in at +** ../tool/mkpragmatab.tcl. */ +/************** Include pragma.h in the middle of pragma.c *******************/ +/************** Begin file pragma.h ******************************************/ +/* DO NOT EDIT! +** This file is automatically generated by the script at +** ../tool/mkpragmatab.tcl. To update the set of pragmas, edit +** that script and rerun it. +*/ +#define PragTyp_HEADER_VALUE 0 +#define PragTyp_AUTO_VACUUM 1 +#define PragTyp_FLAG 2 +#define PragTyp_BUSY_TIMEOUT 3 +#define PragTyp_CACHE_SIZE 4 +#define PragTyp_CASE_SENSITIVE_LIKE 5 +#define PragTyp_COLLATION_LIST 6 +#define PragTyp_COMPILE_OPTIONS 7 +#define PragTyp_DATA_STORE_DIRECTORY 8 +#define PragTyp_DATABASE_LIST 9 +#define PragTyp_DEFAULT_CACHE_SIZE 10 +#define PragTyp_ENCODING 11 +#define PragTyp_FOREIGN_KEY_CHECK 12 +#define PragTyp_FOREIGN_KEY_LIST 13 +#define PragTyp_INCREMENTAL_VACUUM 14 +#define PragTyp_INDEX_INFO 15 +#define PragTyp_INDEX_LIST 16 +#define PragTyp_INTEGRITY_CHECK 17 +#define PragTyp_JOURNAL_MODE 18 +#define PragTyp_JOURNAL_SIZE_LIMIT 19 +#define PragTyp_LOCK_PROXY_FILE 20 +#define PragTyp_LOCKING_MODE 21 +#define PragTyp_PAGE_COUNT 22 +#define PragTyp_MMAP_SIZE 23 +#define PragTyp_PAGE_SIZE 24 +#define PragTyp_SECURE_DELETE 25 +#define PragTyp_SHRINK_MEMORY 26 +#define PragTyp_SOFT_HEAP_LIMIT 27 +#define PragTyp_STATS 28 +#define PragTyp_SYNCHRONOUS 29 +#define PragTyp_TABLE_INFO 30 +#define PragTyp_TEMP_STORE 31 +#define PragTyp_TEMP_STORE_DIRECTORY 32 +#define PragTyp_THREADS 33 +#define PragTyp_WAL_AUTOCHECKPOINT 34 +#define PragTyp_WAL_CHECKPOINT 35 +#define PragTyp_ACTIVATE_EXTENSIONS 36 +#define PragTyp_HEXKEY 37 +#define PragTyp_KEY 38 +#define PragTyp_REKEY 39 +#define PragTyp_LOCK_STATUS 40 +#define PragTyp_PARSER_TRACE 41 +#define PragFlag_NeedSchema 0x01 +#define PragFlag_ReadOnly 0x02 +static const struct sPragmaNames { + const char *const zName; /* Name of pragma */ + u8 ePragTyp; /* PragTyp_XXX value */ + u8 mPragFlag; /* Zero or more PragFlag_XXX values */ + u32 iArg; /* Extra argument */ +} aPragmaNames[] = { +#if defined(SQLITE_HAS_CODEC) || defined(SQLITE_ENABLE_CEROD) + { /* zName: */ "activate_extensions", + /* ePragTyp: */ PragTyp_ACTIVATE_EXTENSIONS, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + { /* zName: */ "application_id", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlag: */ 0, + /* iArg: */ BTREE_APPLICATION_ID }, +#endif +#if !defined(SQLITE_OMIT_AUTOVACUUM) + { /* zName: */ "auto_vacuum", + /* ePragTyp: */ PragTyp_AUTO_VACUUM, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_AUTOMATIC_INDEX) + { /* zName: */ "automatic_index", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_AutoIndex }, +#endif +#endif + { /* zName: */ "busy_timeout", + /* ePragTyp: */ PragTyp_BUSY_TIMEOUT, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + { /* zName: */ "cache_size", + /* ePragTyp: */ PragTyp_CACHE_SIZE, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "cache_spill", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_CacheSpill }, +#endif + { /* zName: */ "case_sensitive_like", + /* ePragTyp: */ PragTyp_CASE_SENSITIVE_LIKE, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, + { /* zName: */ "cell_size_check", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_CellSizeCk }, +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "checkpoint_fullfsync", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_CkptFullFSync }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + { /* zName: */ "collation_list", + /* ePragTyp: */ PragTyp_COLLATION_LIST, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS) + { /* zName: */ "compile_options", + /* ePragTyp: */ PragTyp_COMPILE_OPTIONS, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "count_changes", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_CountRows }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_OS_WIN + { /* zName: */ "data_store_directory", + /* ePragTyp: */ PragTyp_DATA_STORE_DIRECTORY, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + { /* zName: */ "data_version", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlag: */ PragFlag_ReadOnly, + /* iArg: */ BTREE_DATA_VERSION }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + { /* zName: */ "database_list", + /* ePragTyp: */ PragTyp_DATABASE_LIST, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED) + { /* zName: */ "default_cache_size", + /* ePragTyp: */ PragTyp_DEFAULT_CACHE_SIZE, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + { /* zName: */ "defer_foreign_keys", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_DeferFKs }, +#endif +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "empty_result_callbacks", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_NullCallback }, +#endif +#if !defined(SQLITE_OMIT_UTF16) + { /* zName: */ "encoding", + /* ePragTyp: */ PragTyp_ENCODING, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + { /* zName: */ "foreign_key_check", + /* ePragTyp: */ PragTyp_FOREIGN_KEY_CHECK, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FOREIGN_KEY) + { /* zName: */ "foreign_key_list", + /* ePragTyp: */ PragTyp_FOREIGN_KEY_LIST, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + { /* zName: */ "foreign_keys", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_ForeignKeys }, +#endif +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + { /* zName: */ "freelist_count", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlag: */ PragFlag_ReadOnly, + /* iArg: */ BTREE_FREE_PAGE_COUNT }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "full_column_names", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_FullColNames }, + { /* zName: */ "fullfsync", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_FullFSync }, +#endif +#if defined(SQLITE_HAS_CODEC) + { /* zName: */ "hexkey", + /* ePragTyp: */ PragTyp_HEXKEY, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, + { /* zName: */ "hexrekey", + /* ePragTyp: */ PragTyp_HEXKEY, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_CHECK) + { /* zName: */ "ignore_check_constraints", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_IgnoreChecks }, +#endif +#endif +#if !defined(SQLITE_OMIT_AUTOVACUUM) + { /* zName: */ "incremental_vacuum", + /* ePragTyp: */ PragTyp_INCREMENTAL_VACUUM, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + { /* zName: */ "index_info", + /* ePragTyp: */ PragTyp_INDEX_INFO, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, + { /* zName: */ "index_list", + /* ePragTyp: */ PragTyp_INDEX_LIST, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, + { /* zName: */ "index_xinfo", + /* ePragTyp: */ PragTyp_INDEX_INFO, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 1 }, +#endif +#if !defined(SQLITE_OMIT_INTEGRITY_CHECK) + { /* zName: */ "integrity_check", + /* ePragTyp: */ PragTyp_INTEGRITY_CHECK, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + { /* zName: */ "journal_mode", + /* ePragTyp: */ PragTyp_JOURNAL_MODE, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, + { /* zName: */ "journal_size_limit", + /* ePragTyp: */ PragTyp_JOURNAL_SIZE_LIMIT, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if defined(SQLITE_HAS_CODEC) + { /* zName: */ "key", + /* ePragTyp: */ PragTyp_KEY, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "legacy_file_format", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_LegacyFileFmt }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE + { /* zName: */ "lock_proxy_file", + /* ePragTyp: */ PragTyp_LOCK_PROXY_FILE, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + { /* zName: */ "lock_status", + /* ePragTyp: */ PragTyp_LOCK_STATUS, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + { /* zName: */ "locking_mode", + /* ePragTyp: */ PragTyp_LOCKING_MODE, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, + { /* zName: */ "max_page_count", + /* ePragTyp: */ PragTyp_PAGE_COUNT, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, + { /* zName: */ "mmap_size", + /* ePragTyp: */ PragTyp_MMAP_SIZE, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, + { /* zName: */ "page_count", + /* ePragTyp: */ PragTyp_PAGE_COUNT, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, + { /* zName: */ "page_size", + /* ePragTyp: */ PragTyp_PAGE_SIZE, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if defined(SQLITE_DEBUG) + { /* zName: */ "parser_trace", + /* ePragTyp: */ PragTyp_PARSER_TRACE, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "query_only", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_QueryOnly }, +#endif +#if !defined(SQLITE_OMIT_INTEGRITY_CHECK) + { /* zName: */ "quick_check", + /* ePragTyp: */ PragTyp_INTEGRITY_CHECK, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "read_uncommitted", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_ReadUncommitted }, + { /* zName: */ "recursive_triggers", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_RecTriggers }, +#endif +#if defined(SQLITE_HAS_CODEC) + { /* zName: */ "rekey", + /* ePragTyp: */ PragTyp_REKEY, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "reverse_unordered_selects", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_ReverseOrder }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + { /* zName: */ "schema_version", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlag: */ 0, + /* iArg: */ BTREE_SCHEMA_VERSION }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + { /* zName: */ "secure_delete", + /* ePragTyp: */ PragTyp_SECURE_DELETE, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "short_column_names", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_ShortColNames }, +#endif + { /* zName: */ "shrink_memory", + /* ePragTyp: */ PragTyp_SHRINK_MEMORY, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, + { /* zName: */ "soft_heap_limit", + /* ePragTyp: */ PragTyp_SOFT_HEAP_LIMIT, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if defined(SQLITE_DEBUG) + { /* zName: */ "sql_trace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_SqlTrace }, +#endif +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + { /* zName: */ "stats", + /* ePragTyp: */ PragTyp_STATS, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + { /* zName: */ "synchronous", + /* ePragTyp: */ PragTyp_SYNCHRONOUS, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + { /* zName: */ "table_info", + /* ePragTyp: */ PragTyp_TABLE_INFO, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + { /* zName: */ "temp_store", + /* ePragTyp: */ PragTyp_TEMP_STORE, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, + { /* zName: */ "temp_store_directory", + /* ePragTyp: */ PragTyp_TEMP_STORE_DIRECTORY, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#endif + { /* zName: */ "threads", + /* ePragTyp: */ PragTyp_THREADS, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + { /* zName: */ "user_version", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlag: */ 0, + /* iArg: */ BTREE_USER_VERSION }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if defined(SQLITE_DEBUG) + { /* zName: */ "vdbe_addoptrace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_VdbeAddopTrace }, + { /* zName: */ "vdbe_debug", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_SqlTrace|SQLITE_VdbeListing|SQLITE_VdbeTrace }, + { /* zName: */ "vdbe_eqp", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_VdbeEQP }, + { /* zName: */ "vdbe_listing", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_VdbeListing }, + { /* zName: */ "vdbe_trace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_VdbeTrace }, +#endif +#endif +#if !defined(SQLITE_OMIT_WAL) + { /* zName: */ "wal_autocheckpoint", + /* ePragTyp: */ PragTyp_WAL_AUTOCHECKPOINT, + /* ePragFlag: */ 0, + /* iArg: */ 0 }, + { /* zName: */ "wal_checkpoint", + /* ePragTyp: */ PragTyp_WAL_CHECKPOINT, + /* ePragFlag: */ PragFlag_NeedSchema, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + { /* zName: */ "writable_schema", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlag: */ 0, + /* iArg: */ SQLITE_WriteSchema|SQLITE_RecoveryMode }, +#endif +}; +/* Number of pragmas: 60 on by default, 73 total. */ + +/************** End of pragma.h **********************************************/ +/************** Continuing where we left off in pragma.c *********************/ + +/* +** Interpret the given string as a safety level. Return 0 for OFF, +** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or +** unrecognized string argument. The FULL option is disallowed +** if the omitFull parameter it 1. +** +** Note that the values returned are one less that the values that +** should be passed into sqlite3BtreeSetSafetyLevel(). The is done +** to support legacy SQL code. The safety level used to be boolean +** and older scripts may have used numbers 0 for OFF and 1 for ON. +*/ +static u8 getSafetyLevel(const char *z, int omitFull, u8 dflt){ + /* 123456789 123456789 */ + static const char zText[] = "onoffalseyestruefull"; + static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16}; + static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4}; + static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2}; + int i, n; + if( sqlite3Isdigit(*z) ){ + return (u8)sqlite3Atoi(z); + } + n = sqlite3Strlen30(z); + for(i=0; i=0&&i<=2)?i:0); +} +#endif /* ifndef SQLITE_OMIT_AUTOVACUUM */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** Interpret the given string as a temp db location. Return 1 for file +** backed temporary databases, 2 for the Red-Black tree in memory database +** and 0 to use the compile-time default. +*/ +static int getTempStore(const char *z){ + if( z[0]>='0' && z[0]<='2' ){ + return z[0] - '0'; + }else if( sqlite3StrICmp(z, "file")==0 ){ + return 1; + }else if( sqlite3StrICmp(z, "memory")==0 ){ + return 2; + }else{ + return 0; + } +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** Invalidate temp storage, either when the temp storage is changed +** from default, or when 'file' and the temp_store_directory has changed +*/ +static int invalidateTempStorage(Parse *pParse){ + sqlite3 *db = pParse->db; + if( db->aDb[1].pBt!=0 ){ + if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){ + sqlite3ErrorMsg(pParse, "temporary storage cannot be changed " + "from within a transaction"); + return SQLITE_ERROR; + } + sqlite3BtreeClose(db->aDb[1].pBt); + db->aDb[1].pBt = 0; + sqlite3ResetAllSchemasOfConnection(db); + } + return SQLITE_OK; +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** If the TEMP database is open, close it and mark the database schema +** as needing reloading. This must be done when using the SQLITE_TEMP_STORE +** or DEFAULT_TEMP_STORE pragmas. +*/ +static int changeTempStorage(Parse *pParse, const char *zStorageType){ + int ts = getTempStore(zStorageType); + sqlite3 *db = pParse->db; + if( db->temp_store==ts ) return SQLITE_OK; + if( invalidateTempStorage( pParse ) != SQLITE_OK ){ + return SQLITE_ERROR; + } + db->temp_store = (u8)ts; + return SQLITE_OK; +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +/* +** Set the names of the first N columns to the values in azCol[] +*/ +static void setAllColumnNames( + Vdbe *v, /* The query under construction */ + int N, /* Number of columns */ + const char **azCol /* Names of columns */ +){ + int i; + sqlite3VdbeSetNumCols(v, N); + for(i=0; iautoCommit ){ + Db *pDb = db->aDb; + int n = db->nDb; + assert( SQLITE_FullFSync==PAGER_FULLFSYNC ); + assert( SQLITE_CkptFullFSync==PAGER_CKPT_FULLFSYNC ); + assert( SQLITE_CacheSpill==PAGER_CACHESPILL ); + assert( (PAGER_FULLFSYNC | PAGER_CKPT_FULLFSYNC | PAGER_CACHESPILL) + == PAGER_FLAGS_MASK ); + assert( (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)==pDb->safety_level ); + while( (n--) > 0 ){ + if( pDb->pBt ){ + sqlite3BtreeSetPagerFlags(pDb->pBt, + pDb->safety_level | (db->flags & PAGER_FLAGS_MASK) ); + } + pDb++; + } + } +} +#else +# define setAllPagerFlags(X) /* no-op */ +#endif + + +/* +** Return a human-readable name for a constraint resolution action. +*/ +#ifndef SQLITE_OMIT_FOREIGN_KEY +static const char *actionName(u8 action){ + const char *zName; + switch( action ){ + case OE_SetNull: zName = "SET NULL"; break; + case OE_SetDflt: zName = "SET DEFAULT"; break; + case OE_Cascade: zName = "CASCADE"; break; + case OE_Restrict: zName = "RESTRICT"; break; + default: zName = "NO ACTION"; + assert( action==OE_None ); break; + } + return zName; +} +#endif + + +/* +** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants +** defined in pager.h. This function returns the associated lowercase +** journal-mode name. +*/ +SQLITE_PRIVATE const char *sqlite3JournalModename(int eMode){ + static char * const azModeName[] = { + "delete", "persist", "off", "truncate", "memory" +#ifndef SQLITE_OMIT_WAL + , "wal" +#endif + }; + assert( PAGER_JOURNALMODE_DELETE==0 ); + assert( PAGER_JOURNALMODE_PERSIST==1 ); + assert( PAGER_JOURNALMODE_OFF==2 ); + assert( PAGER_JOURNALMODE_TRUNCATE==3 ); + assert( PAGER_JOURNALMODE_MEMORY==4 ); + assert( PAGER_JOURNALMODE_WAL==5 ); + assert( eMode>=0 && eMode<=ArraySize(azModeName) ); + + if( eMode==ArraySize(azModeName) ) return 0; + return azModeName[eMode]; +} + +/* +** Process a pragma statement. +** +** Pragmas are of this form: +** +** PRAGMA [database.]id [= value] +** +** The identifier might also be a string. The value is a string, and +** identifier, or a number. If minusFlag is true, then the value is +** a number that was preceded by a minus sign. +** +** If the left side is "database.id" then pId1 is the database name +** and pId2 is the id. If the left side is just "id" then pId1 is the +** id and pId2 is any empty string. +*/ +SQLITE_PRIVATE void sqlite3Pragma( + Parse *pParse, + Token *pId1, /* First part of [database.]id field */ + Token *pId2, /* Second part of [database.]id field, or NULL */ + Token *pValue, /* Token for , or NULL */ + int minusFlag /* True if a '-' sign preceded */ +){ + char *zLeft = 0; /* Nul-terminated UTF-8 string */ + char *zRight = 0; /* Nul-terminated UTF-8 string , or NULL */ + const char *zDb = 0; /* The database name */ + Token *pId; /* Pointer to token */ + char *aFcntl[4]; /* Argument to SQLITE_FCNTL_PRAGMA */ + int iDb; /* Database index for */ + int lwr, upr, mid = 0; /* Binary search bounds */ + int rc; /* return value form SQLITE_FCNTL_PRAGMA */ + sqlite3 *db = pParse->db; /* The database connection */ + Db *pDb; /* The specific database being pragmaed */ + Vdbe *v = sqlite3GetVdbe(pParse); /* Prepared statement */ + const struct sPragmaNames *pPragma; + + if( v==0 ) return; + sqlite3VdbeRunOnlyOnce(v); + pParse->nMem = 2; + + /* Interpret the [database.] part of the pragma statement. iDb is the + ** index of the database this pragma is being applied to in db.aDb[]. */ + iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId); + if( iDb<0 ) return; + pDb = &db->aDb[iDb]; + + /* If the temp database has been explicitly named as part of the + ** pragma, make sure it is open. + */ + if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){ + return; + } + + zLeft = sqlite3NameFromToken(db, pId); + if( !zLeft ) return; + if( minusFlag ){ + zRight = sqlite3MPrintf(db, "-%T", pValue); + }else{ + zRight = sqlite3NameFromToken(db, pValue); + } + + assert( pId2 ); + zDb = pId2->n>0 ? pDb->zName : 0; + if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){ + goto pragma_out; + } + + /* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS + ** connection. If it returns SQLITE_OK, then assume that the VFS + ** handled the pragma and generate a no-op prepared statement. + ** + ** IMPLEMENTATION-OF: R-12238-55120 Whenever a PRAGMA statement is parsed, + ** an SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file + ** object corresponding to the database file to which the pragma + ** statement refers. + ** + ** IMPLEMENTATION-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA + ** file control is an array of pointers to strings (char**) in which the + ** second element of the array is the name of the pragma and the third + ** element is the argument to the pragma or NULL if the pragma has no + ** argument. + */ + aFcntl[0] = 0; + aFcntl[1] = zLeft; + aFcntl[2] = zRight; + aFcntl[3] = 0; + db->busyHandler.nBusy = 0; + rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl); + if( rc==SQLITE_OK ){ + returnSingleText(v, "result", aFcntl[0]); + sqlite3_free(aFcntl[0]); + goto pragma_out; + } + if( rc!=SQLITE_NOTFOUND ){ + if( aFcntl[0] ){ + sqlite3ErrorMsg(pParse, "%s", aFcntl[0]); + sqlite3_free(aFcntl[0]); + } + pParse->nErr++; + pParse->rc = rc; + goto pragma_out; + } + + /* Locate the pragma in the lookup table */ + lwr = 0; + upr = ArraySize(aPragmaNames)-1; + while( lwr<=upr ){ + mid = (lwr+upr)/2; + rc = sqlite3_stricmp(zLeft, aPragmaNames[mid].zName); + if( rc==0 ) break; + if( rc<0 ){ + upr = mid - 1; + }else{ + lwr = mid + 1; + } + } + if( lwr>upr ) goto pragma_out; + pPragma = &aPragmaNames[mid]; + + /* Make sure the database schema is loaded if the pragma requires that */ + if( (pPragma->mPragFlag & PragFlag_NeedSchema)!=0 ){ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + } + + /* Jump to the appropriate pragma handler */ + switch( pPragma->ePragTyp ){ + +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED) + /* + ** PRAGMA [database.]default_cache_size + ** PRAGMA [database.]default_cache_size=N + ** + ** The first form reports the current persistent setting for the + ** page cache size. The value returned is the maximum number of + ** pages in the page cache. The second form sets both the current + ** page cache size value and the persistent page cache size value + ** stored in the database file. + ** + ** Older versions of SQLite would set the default cache size to a + ** negative number to indicate synchronous=OFF. These days, synchronous + ** is always on by default regardless of the sign of the default cache + ** size. But continue to take the absolute value of the default cache + ** size of historical compatibility. + */ + case PragTyp_DEFAULT_CACHE_SIZE: { + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList getCacheSize[] = { + { OP_Transaction, 0, 0, 0}, /* 0 */ + { OP_ReadCookie, 0, 1, BTREE_DEFAULT_CACHE_SIZE}, /* 1 */ + { OP_IfPos, 1, 8, 0}, + { OP_Integer, 0, 2, 0}, + { OP_Subtract, 1, 2, 1}, + { OP_IfPos, 1, 8, 0}, + { OP_Integer, 0, 1, 0}, /* 6 */ + { OP_Noop, 0, 0, 0}, + { OP_ResultRow, 1, 1, 0}, + }; + int addr; + sqlite3VdbeUsesBtree(v, iDb); + if( !zRight ){ + setOneColumnName(v, "cache_size"); + pParse->nMem += 2; + addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize,iLn); + sqlite3VdbeChangeP1(v, addr, iDb); + sqlite3VdbeChangeP1(v, addr+1, iDb); + sqlite3VdbeChangeP1(v, addr+6, SQLITE_DEFAULT_CACHE_SIZE); + }else{ + int size = sqlite3AbsInt32(sqlite3Atoi(zRight)); + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3VdbeAddOp2(v, OP_Integer, size, 1); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, 1); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + } + break; + } +#endif /* !SQLITE_OMIT_PAGER_PRAGMAS && !SQLITE_OMIT_DEPRECATED */ + +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + /* + ** PRAGMA [database.]page_size + ** PRAGMA [database.]page_size=N + ** + ** The first form reports the current setting for the + ** database page size in bytes. The second form sets the + ** database page size value. The value can only be set if + ** the database has not yet been created. + */ + case PragTyp_PAGE_SIZE: { + Btree *pBt = pDb->pBt; + assert( pBt!=0 ); + if( !zRight ){ + int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0; + returnSingleInt(v, "page_size", size); + }else{ + /* Malloc may fail when setting the page-size, as there is an internal + ** buffer that the pager module resizes using sqlite3_realloc(). + */ + db->nextPagesize = sqlite3Atoi(zRight); + if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){ + db->mallocFailed = 1; + } + } + break; + } + + /* + ** PRAGMA [database.]secure_delete + ** PRAGMA [database.]secure_delete=ON/OFF + ** + ** The first form reports the current setting for the + ** secure_delete flag. The second form changes the secure_delete + ** flag setting and reports thenew value. + */ + case PragTyp_SECURE_DELETE: { + Btree *pBt = pDb->pBt; + int b = -1; + assert( pBt!=0 ); + if( zRight ){ + b = sqlite3GetBoolean(zRight, 0); + } + if( pId2->n==0 && b>=0 ){ + int ii; + for(ii=0; iinDb; ii++){ + sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b); + } + } + b = sqlite3BtreeSecureDelete(pBt, b); + returnSingleInt(v, "secure_delete", b); + break; + } + + /* + ** PRAGMA [database.]max_page_count + ** PRAGMA [database.]max_page_count=N + ** + ** The first form reports the current setting for the + ** maximum number of pages in the database file. The + ** second form attempts to change this setting. Both + ** forms return the current setting. + ** + ** The absolute value of N is used. This is undocumented and might + ** change. The only purpose is to provide an easy way to test + ** the sqlite3AbsInt32() function. + ** + ** PRAGMA [database.]page_count + ** + ** Return the number of pages in the specified database. + */ + case PragTyp_PAGE_COUNT: { + int iReg; + sqlite3CodeVerifySchema(pParse, iDb); + iReg = ++pParse->nMem; + if( sqlite3Tolower(zLeft[0])=='p' ){ + sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg); + }else{ + sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, + sqlite3AbsInt32(sqlite3Atoi(zRight))); + } + sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT); + break; + } + + /* + ** PRAGMA [database.]locking_mode + ** PRAGMA [database.]locking_mode = (normal|exclusive) + */ + case PragTyp_LOCKING_MODE: { + const char *zRet = "normal"; + int eMode = getLockingMode(zRight); + + if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){ + /* Simple "PRAGMA locking_mode;" statement. This is a query for + ** the current default locking mode (which may be different to + ** the locking-mode of the main database). + */ + eMode = db->dfltLockMode; + }else{ + Pager *pPager; + if( pId2->n==0 ){ + /* This indicates that no database name was specified as part + ** of the PRAGMA command. In this case the locking-mode must be + ** set on all attached databases, as well as the main db file. + ** + ** Also, the sqlite3.dfltLockMode variable is set so that + ** any subsequently attached databases also use the specified + ** locking mode. + */ + int ii; + assert(pDb==&db->aDb[0]); + for(ii=2; iinDb; ii++){ + pPager = sqlite3BtreePager(db->aDb[ii].pBt); + sqlite3PagerLockingMode(pPager, eMode); + } + db->dfltLockMode = (u8)eMode; + } + pPager = sqlite3BtreePager(pDb->pBt); + eMode = sqlite3PagerLockingMode(pPager, eMode); + } + + assert( eMode==PAGER_LOCKINGMODE_NORMAL + || eMode==PAGER_LOCKINGMODE_EXCLUSIVE ); + if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){ + zRet = "exclusive"; + } + returnSingleText(v, "locking_mode", zRet); + break; + } + + /* + ** PRAGMA [database.]journal_mode + ** PRAGMA [database.]journal_mode = + ** (delete|persist|off|truncate|memory|wal|off) + */ + case PragTyp_JOURNAL_MODE: { + int eMode; /* One of the PAGER_JOURNALMODE_XXX symbols */ + int ii; /* Loop counter */ + + setOneColumnName(v, "journal_mode"); + if( zRight==0 ){ + /* If there is no "=MODE" part of the pragma, do a query for the + ** current mode */ + eMode = PAGER_JOURNALMODE_QUERY; + }else{ + const char *zMode; + int n = sqlite3Strlen30(zRight); + for(eMode=0; (zMode = sqlite3JournalModename(eMode))!=0; eMode++){ + if( sqlite3StrNICmp(zRight, zMode, n)==0 ) break; + } + if( !zMode ){ + /* If the "=MODE" part does not match any known journal mode, + ** then do a query */ + eMode = PAGER_JOURNALMODE_QUERY; + } + } + if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){ + /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */ + iDb = 0; + pId2->n = 1; + } + for(ii=db->nDb-1; ii>=0; ii--){ + if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){ + sqlite3VdbeUsesBtree(v, ii); + sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode); + } + } + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + break; + } + + /* + ** PRAGMA [database.]journal_size_limit + ** PRAGMA [database.]journal_size_limit=N + ** + ** Get or set the size limit on rollback journal files. + */ + case PragTyp_JOURNAL_SIZE_LIMIT: { + Pager *pPager = sqlite3BtreePager(pDb->pBt); + i64 iLimit = -2; + if( zRight ){ + sqlite3DecOrHexToI64(zRight, &iLimit); + if( iLimit<-1 ) iLimit = -1; + } + iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit); + returnSingleInt(v, "journal_size_limit", iLimit); + break; + } + +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + + /* + ** PRAGMA [database.]auto_vacuum + ** PRAGMA [database.]auto_vacuum=N + ** + ** Get or set the value of the database 'auto-vacuum' parameter. + ** The value is one of: 0 NONE 1 FULL 2 INCREMENTAL + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + case PragTyp_AUTO_VACUUM: { + Btree *pBt = pDb->pBt; + assert( pBt!=0 ); + if( !zRight ){ + returnSingleInt(v, "auto_vacuum", sqlite3BtreeGetAutoVacuum(pBt)); + }else{ + int eAuto = getAutoVacuum(zRight); + assert( eAuto>=0 && eAuto<=2 ); + db->nextAutovac = (u8)eAuto; + /* Call SetAutoVacuum() to set initialize the internal auto and + ** incr-vacuum flags. This is required in case this connection + ** creates the database file. It is important that it is created + ** as an auto-vacuum capable db. + */ + rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto); + if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){ + /* When setting the auto_vacuum mode to either "full" or + ** "incremental", write the value of meta[6] in the database + ** file. Before writing to meta[6], check that meta[3] indicates + ** that this really is an auto-vacuum capable database. + */ + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList setMeta6[] = { + { OP_Transaction, 0, 1, 0}, /* 0 */ + { OP_ReadCookie, 0, 1, BTREE_LARGEST_ROOT_PAGE}, + { OP_If, 1, 0, 0}, /* 2 */ + { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */ + { OP_Integer, 0, 1, 0}, /* 4 */ + { OP_SetCookie, 0, BTREE_INCR_VACUUM, 1}, /* 5 */ + }; + int iAddr; + iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn); + sqlite3VdbeChangeP1(v, iAddr, iDb); + sqlite3VdbeChangeP1(v, iAddr+1, iDb); + sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4); + sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1); + sqlite3VdbeChangeP1(v, iAddr+5, iDb); + sqlite3VdbeUsesBtree(v, iDb); + } + } + break; + } +#endif + + /* + ** PRAGMA [database.]incremental_vacuum(N) + ** + ** Do N steps of incremental vacuuming on a database. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + case PragTyp_INCREMENTAL_VACUUM: { + int iLimit, addr; + if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){ + iLimit = 0x7fffffff; + } + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1); + addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v); + sqlite3VdbeAddOp1(v, OP_ResultRow, 1); + sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); + sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr); + break; + } +#endif + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + /* + ** PRAGMA [database.]cache_size + ** PRAGMA [database.]cache_size=N + ** + ** The first form reports the current local setting for the + ** page cache size. The second form sets the local + ** page cache size value. If N is positive then that is the + ** number of pages in the cache. If N is negative, then the + ** number of pages is adjusted so that the cache uses -N kibibytes + ** of memory. + */ + case PragTyp_CACHE_SIZE: { + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( !zRight ){ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + returnSingleInt(v, "cache_size", pDb->pSchema->cache_size); + }else{ + int size = sqlite3Atoi(zRight); + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + } + break; + } + + /* + ** PRAGMA [database.]mmap_size(N) + ** + ** Used to set mapping size limit. The mapping size limit is + ** used to limit the aggregate size of all memory mapped regions of the + ** database file. If this parameter is set to zero, then memory mapping + ** is not used at all. If N is negative, then the default memory map + ** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set. + ** The parameter N is measured in bytes. + ** + ** This value is advisory. The underlying VFS is free to memory map + ** as little or as much as it wants. Except, if N is set to 0 then the + ** upper layers will never invoke the xFetch interfaces to the VFS. + */ + case PragTyp_MMAP_SIZE: { + sqlite3_int64 sz; +#if SQLITE_MAX_MMAP_SIZE>0 + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( zRight ){ + int ii; + sqlite3DecOrHexToI64(zRight, &sz); + if( sz<0 ) sz = sqlite3GlobalConfig.szMmap; + if( pId2->n==0 ) db->szMmap = sz; + for(ii=db->nDb-1; ii>=0; ii--){ + if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){ + sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz); + } + } + } + sz = -1; + rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_MMAP_SIZE, &sz); +#else + sz = 0; + rc = SQLITE_OK; +#endif + if( rc==SQLITE_OK ){ + returnSingleInt(v, "mmap_size", sz); + }else if( rc!=SQLITE_NOTFOUND ){ + pParse->nErr++; + pParse->rc = rc; + } + break; + } + + /* + ** PRAGMA temp_store + ** PRAGMA temp_store = "default"|"memory"|"file" + ** + ** Return or set the local value of the temp_store flag. Changing + ** the local value does not make changes to the disk file and the default + ** value will be restored the next time the database is opened. + ** + ** Note that it is possible for the library compile-time options to + ** override this setting + */ + case PragTyp_TEMP_STORE: { + if( !zRight ){ + returnSingleInt(v, "temp_store", db->temp_store); + }else{ + changeTempStorage(pParse, zRight); + } + break; + } + + /* + ** PRAGMA temp_store_directory + ** PRAGMA temp_store_directory = ""|"directory_name" + ** + ** Return or set the local value of the temp_store_directory flag. Changing + ** the value sets a specific directory to be used for temporary files. + ** Setting to a null string reverts to the default temporary directory search. + ** If temporary directory is changed, then invalidateTempStorage. + ** + */ + case PragTyp_TEMP_STORE_DIRECTORY: { + if( !zRight ){ + returnSingleText(v, "temp_store_directory", sqlite3_temp_directory); + }else{ +#ifndef SQLITE_OMIT_WSD + if( zRight[0] ){ + int res; + rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res); + if( rc!=SQLITE_OK || res==0 ){ + sqlite3ErrorMsg(pParse, "not a writable directory"); + goto pragma_out; + } + } + if( SQLITE_TEMP_STORE==0 + || (SQLITE_TEMP_STORE==1 && db->temp_store<=1) + || (SQLITE_TEMP_STORE==2 && db->temp_store==1) + ){ + invalidateTempStorage(pParse); + } + sqlite3_free(sqlite3_temp_directory); + if( zRight[0] ){ + sqlite3_temp_directory = sqlite3_mprintf("%s", zRight); + }else{ + sqlite3_temp_directory = 0; + } +#endif /* SQLITE_OMIT_WSD */ + } + break; + } + +#if SQLITE_OS_WIN + /* + ** PRAGMA data_store_directory + ** PRAGMA data_store_directory = ""|"directory_name" + ** + ** Return or set the local value of the data_store_directory flag. Changing + ** the value sets a specific directory to be used for database files that + ** were specified with a relative pathname. Setting to a null string reverts + ** to the default database directory, which for database files specified with + ** a relative path will probably be based on the current directory for the + ** process. Database file specified with an absolute path are not impacted + ** by this setting, regardless of its value. + ** + */ + case PragTyp_DATA_STORE_DIRECTORY: { + if( !zRight ){ + returnSingleText(v, "data_store_directory", sqlite3_data_directory); + }else{ +#ifndef SQLITE_OMIT_WSD + if( zRight[0] ){ + int res; + rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res); + if( rc!=SQLITE_OK || res==0 ){ + sqlite3ErrorMsg(pParse, "not a writable directory"); + goto pragma_out; + } + } + sqlite3_free(sqlite3_data_directory); + if( zRight[0] ){ + sqlite3_data_directory = sqlite3_mprintf("%s", zRight); + }else{ + sqlite3_data_directory = 0; + } +#endif /* SQLITE_OMIT_WSD */ + } + break; + } +#endif + +#if SQLITE_ENABLE_LOCKING_STYLE + /* + ** PRAGMA [database.]lock_proxy_file + ** PRAGMA [database.]lock_proxy_file = ":auto:"|"lock_file_path" + ** + ** Return or set the value of the lock_proxy_file flag. Changing + ** the value sets a specific file to be used for database access locks. + ** + */ + case PragTyp_LOCK_PROXY_FILE: { + if( !zRight ){ + Pager *pPager = sqlite3BtreePager(pDb->pBt); + char *proxy_file_path = NULL; + sqlite3_file *pFile = sqlite3PagerFile(pPager); + sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE, + &proxy_file_path); + returnSingleText(v, "lock_proxy_file", proxy_file_path); + }else{ + Pager *pPager = sqlite3BtreePager(pDb->pBt); + sqlite3_file *pFile = sqlite3PagerFile(pPager); + int res; + if( zRight[0] ){ + res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE, + zRight); + } else { + res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE, + NULL); + } + if( res!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "failed to set lock proxy file"); + goto pragma_out; + } + } + break; + } +#endif /* SQLITE_ENABLE_LOCKING_STYLE */ + + /* + ** PRAGMA [database.]synchronous + ** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL + ** + ** Return or set the local value of the synchronous flag. Changing + ** the local value does not make changes to the disk file and the + ** default value will be restored the next time the database is + ** opened. + */ + case PragTyp_SYNCHRONOUS: { + if( !zRight ){ + returnSingleInt(v, "synchronous", pDb->safety_level-1); + }else{ + if( !db->autoCommit ){ + sqlite3ErrorMsg(pParse, + "Safety level may not be changed inside a transaction"); + }else{ + int iLevel = (getSafetyLevel(zRight,0,1)+1) & PAGER_SYNCHRONOUS_MASK; + if( iLevel==0 ) iLevel = 1; + pDb->safety_level = iLevel; + setAllPagerFlags(db); + } + } + break; + } +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_FLAG_PRAGMAS + case PragTyp_FLAG: { + if( zRight==0 ){ + returnSingleInt(v, pPragma->zName, (db->flags & pPragma->iArg)!=0 ); + }else{ + int mask = pPragma->iArg; /* Mask of bits to set or clear. */ + if( db->autoCommit==0 ){ + /* Foreign key support may not be enabled or disabled while not + ** in auto-commit mode. */ + mask &= ~(SQLITE_ForeignKeys); + } +#if SQLITE_USER_AUTHENTICATION + if( db->auth.authLevel==UAUTH_User ){ + /* Do not allow non-admin users to modify the schema arbitrarily */ + mask &= ~(SQLITE_WriteSchema); + } +#endif + + if( sqlite3GetBoolean(zRight, 0) ){ + db->flags |= mask; + }else{ + db->flags &= ~mask; + if( mask==SQLITE_DeferFKs ) db->nDeferredImmCons = 0; + } + + /* Many of the flag-pragmas modify the code generated by the SQL + ** compiler (eg. count_changes). So add an opcode to expire all + ** compiled SQL statements after modifying a pragma value. + */ + sqlite3VdbeAddOp2(v, OP_Expire, 0, 0); + setAllPagerFlags(db); + } + break; + } +#endif /* SQLITE_OMIT_FLAG_PRAGMAS */ + +#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS + /* + ** PRAGMA table_info(
    ) + ** + ** Return a single row for each column of the named table. The columns of + ** the returned data set are: + ** + ** cid: Column id (numbered from left to right, starting at 0) + ** name: Column name + ** type: Column declaration type. + ** notnull: True if 'NOT NULL' is part of column declaration + ** dflt_value: The default value for the column, if any. + */ + case PragTyp_TABLE_INFO: if( zRight ){ + Table *pTab; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + static const char *azCol[] = { + "cid", "name", "type", "notnull", "dflt_value", "pk" + }; + int i, k; + int nHidden = 0; + Column *pCol; + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + pParse->nMem = 6; + sqlite3CodeVerifySchema(pParse, iDb); + setAllColumnNames(v, 6, azCol); assert( 6==ArraySize(azCol) ); + sqlite3ViewGetColumnNames(pParse, pTab); + for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ + if( IsHiddenColumn(pCol) ){ + nHidden++; + continue; + } + if( (pCol->colFlags & COLFLAG_PRIMKEY)==0 ){ + k = 0; + }else if( pPk==0 ){ + k = 1; + }else{ + for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){} + } + sqlite3VdbeMultiLoad(v, 1, "issisi", + i-nHidden, + pCol->zName, + pCol->zType ? pCol->zType : "", + pCol->notNull ? 1 : 0, + pCol->zDflt, + k); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 6); + } + } + } + break; + + case PragTyp_STATS: { + static const char *azCol[] = { "table", "index", "width", "height" }; + Index *pIdx; + HashElem *i; + v = sqlite3GetVdbe(pParse); + pParse->nMem = 4; + sqlite3CodeVerifySchema(pParse, iDb); + setAllColumnNames(v, 4, azCol); assert( 4==ArraySize(azCol) ); + for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){ + Table *pTab = sqliteHashData(i); + sqlite3VdbeMultiLoad(v, 1, "ssii", + pTab->zName, + 0, + (int)sqlite3LogEstToInt(pTab->szTabRow), + (int)sqlite3LogEstToInt(pTab->nRowLogEst)); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 4); + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + sqlite3VdbeMultiLoad(v, 2, "sii", + pIdx->zName, + (int)sqlite3LogEstToInt(pIdx->szIdxRow), + (int)sqlite3LogEstToInt(pIdx->aiRowLogEst[0])); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 4); + } + } + } + break; + + case PragTyp_INDEX_INFO: if( zRight ){ + Index *pIdx; + Table *pTab; + pIdx = sqlite3FindIndex(db, zRight, zDb); + if( pIdx ){ + static const char *azCol[] = { + "seqno", "cid", "name", "desc", "coll", "key" + }; + int i; + int mx; + if( pPragma->iArg ){ + /* PRAGMA index_xinfo (newer version with more rows and columns) */ + mx = pIdx->nColumn; + pParse->nMem = 6; + }else{ + /* PRAGMA index_info (legacy version) */ + mx = pIdx->nKeyCol; + pParse->nMem = 3; + } + pTab = pIdx->pTable; + sqlite3CodeVerifySchema(pParse, iDb); + assert( pParse->nMem<=ArraySize(azCol) ); + setAllColumnNames(v, pParse->nMem, azCol); + for(i=0; iaiColumn[i]; + sqlite3VdbeMultiLoad(v, 1, "iis", i, cnum, + cnum<0 ? 0 : pTab->aCol[cnum].zName); + if( pPragma->iArg ){ + sqlite3VdbeMultiLoad(v, 4, "isi", + pIdx->aSortOrder[i], + pIdx->azColl[i], + inKeyCol); + } + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, pParse->nMem); + } + } + } + break; + + case PragTyp_INDEX_LIST: if( zRight ){ + Index *pIdx; + Table *pTab; + int i; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + static const char *azCol[] = { + "seq", "name", "unique", "origin", "partial" + }; + v = sqlite3GetVdbe(pParse); + pParse->nMem = 5; + sqlite3CodeVerifySchema(pParse, iDb); + setAllColumnNames(v, 5, azCol); assert( 5==ArraySize(azCol) ); + for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){ + const char *azOrigin[] = { "c", "u", "pk" }; + sqlite3VdbeMultiLoad(v, 1, "isisi", + i, + pIdx->zName, + IsUniqueIndex(pIdx), + azOrigin[pIdx->idxType], + pIdx->pPartIdxWhere!=0); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5); + } + } + } + break; + + case PragTyp_DATABASE_LIST: { + static const char *azCol[] = { "seq", "name", "file" }; + int i; + pParse->nMem = 3; + setAllColumnNames(v, 3, azCol); assert( 3==ArraySize(azCol) ); + for(i=0; inDb; i++){ + if( db->aDb[i].pBt==0 ) continue; + assert( db->aDb[i].zName!=0 ); + sqlite3VdbeMultiLoad(v, 1, "iss", + i, + db->aDb[i].zName, + sqlite3BtreeGetFilename(db->aDb[i].pBt)); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3); + } + } + break; + + case PragTyp_COLLATION_LIST: { + static const char *azCol[] = { "seq", "name" }; + int i = 0; + HashElem *p; + pParse->nMem = 2; + setAllColumnNames(v, 2, azCol); assert( 2==ArraySize(azCol) ); + for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){ + CollSeq *pColl = (CollSeq *)sqliteHashData(p); + sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2); + } + } + break; +#endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY + case PragTyp_FOREIGN_KEY_LIST: if( zRight ){ + FKey *pFK; + Table *pTab; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + v = sqlite3GetVdbe(pParse); + pFK = pTab->pFKey; + if( pFK ){ + static const char *azCol[] = { + "id", "seq", "table", "from", "to", "on_update", "on_delete", + "match" + }; + int i = 0; + pParse->nMem = 8; + sqlite3CodeVerifySchema(pParse, iDb); + setAllColumnNames(v, 8, azCol); assert( 8==ArraySize(azCol) ); + while(pFK){ + int j; + for(j=0; jnCol; j++){ + sqlite3VdbeMultiLoad(v, 1, "iissssss", + i, + j, + pFK->zTo, + pTab->aCol[pFK->aCol[j].iFrom].zName, + pFK->aCol[j].zCol, + actionName(pFK->aAction[1]), /* ON UPDATE */ + actionName(pFK->aAction[0]), /* ON DELETE */ + "NONE"); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 8); + } + ++i; + pFK = pFK->pNextFrom; + } + } + } + } + break; +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY +#ifndef SQLITE_OMIT_TRIGGER + case PragTyp_FOREIGN_KEY_CHECK: { + FKey *pFK; /* A foreign key constraint */ + Table *pTab; /* Child table contain "REFERENCES" keyword */ + Table *pParent; /* Parent table that child points to */ + Index *pIdx; /* Index in the parent table */ + int i; /* Loop counter: Foreign key number for pTab */ + int j; /* Loop counter: Field of the foreign key */ + HashElem *k; /* Loop counter: Next table in schema */ + int x; /* result variable */ + int regResult; /* 3 registers to hold a result row */ + int regKey; /* Register to hold key for checking the FK */ + int regRow; /* Registers to hold a row from pTab */ + int addrTop; /* Top of a loop checking foreign keys */ + int addrOk; /* Jump here if the key is OK */ + int *aiCols; /* child to parent column mapping */ + static const char *azCol[] = { "table", "rowid", "parent", "fkid" }; + + regResult = pParse->nMem+1; + pParse->nMem += 4; + regKey = ++pParse->nMem; + regRow = ++pParse->nMem; + v = sqlite3GetVdbe(pParse); + setAllColumnNames(v, 4, azCol); assert( 4==ArraySize(azCol) ); + sqlite3CodeVerifySchema(pParse, iDb); + k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash); + while( k ){ + if( zRight ){ + pTab = sqlite3LocateTable(pParse, 0, zRight, zDb); + k = 0; + }else{ + pTab = (Table*)sqliteHashData(k); + k = sqliteHashNext(k); + } + if( pTab==0 || pTab->pFKey==0 ) continue; + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow; + sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead); + sqlite3VdbeLoadString(v, regResult, pTab->zName); + for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){ + pParent = sqlite3FindTable(db, pFK->zTo, zDb); + if( pParent==0 ) continue; + pIdx = 0; + sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName); + x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, 0); + if( x==0 ){ + if( pIdx==0 ){ + sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead); + }else{ + sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + } + }else{ + k = 0; + break; + } + } + assert( pParse->nErr>0 || pFK==0 ); + if( pFK ) break; + if( pParse->nTabnTab = i; + addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v); + for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){ + pParent = sqlite3FindTable(db, pFK->zTo, zDb); + pIdx = 0; + aiCols = 0; + if( pParent ){ + x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, &aiCols); + assert( x==0 ); + } + addrOk = sqlite3VdbeMakeLabel(v); + if( pParent && pIdx==0 ){ + int iKey = pFK->aCol[0].iFrom; + assert( iKey>=0 && iKeynCol ); + if( iKey!=pTab->iPKey ){ + sqlite3VdbeAddOp3(v, OP_Column, 0, iKey, regRow); + sqlite3ColumnDefault(v, pTab, iKey, regRow); + sqlite3VdbeAddOp2(v, OP_IsNull, regRow, addrOk); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_MustBeInt, regRow, + sqlite3VdbeCurrentAddr(v)+3); VdbeCoverage(v); + }else{ + sqlite3VdbeAddOp2(v, OP_Rowid, 0, regRow); + } + sqlite3VdbeAddOp3(v, OP_NotExists, i, 0, regRow); VdbeCoverage(v); + sqlite3VdbeGoto(v, addrOk); + sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); + }else{ + for(j=0; jnCol; j++){ + sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, + aiCols ? aiCols[j] : pFK->aCol[j].iFrom, regRow+j); + sqlite3VdbeAddOp2(v, OP_IsNull, regRow+j, addrOk); VdbeCoverage(v); + } + if( pParent ){ + sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey, + sqlite3IndexAffinityStr(db,pIdx), pFK->nCol); + sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regKey, 0); + VdbeCoverage(v); + } + } + sqlite3VdbeAddOp2(v, OP_Rowid, 0, regResult+1); + sqlite3VdbeMultiLoad(v, regResult+2, "si", pFK->zTo, i-1); + sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, 4); + sqlite3VdbeResolveLabel(v, addrOk); + sqlite3DbFree(db, aiCols); + } + sqlite3VdbeAddOp2(v, OP_Next, 0, addrTop+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrTop); + } + } + break; +#endif /* !defined(SQLITE_OMIT_TRIGGER) */ +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + +#ifndef NDEBUG + case PragTyp_PARSER_TRACE: { + if( zRight ){ + if( sqlite3GetBoolean(zRight, 0) ){ + sqlite3ParserTrace(stderr, "parser: "); + }else{ + sqlite3ParserTrace(0, 0); + } + } + } + break; +#endif + + /* Reinstall the LIKE and GLOB functions. The variant of LIKE + ** used will be case sensitive or not depending on the RHS. + */ + case PragTyp_CASE_SENSITIVE_LIKE: { + if( zRight ){ + sqlite3RegisterLikeFunctions(db, sqlite3GetBoolean(zRight, 0)); + } + } + break; + +#ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX +# define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100 +#endif + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK + /* Pragma "quick_check" is reduced version of + ** integrity_check designed to detect most database corruption + ** without most of the overhead of a full integrity-check. + */ + case PragTyp_INTEGRITY_CHECK: { + int i, j, addr, mxErr; + + /* Code that appears at the end of the integrity check. If no error + ** messages have been generated, output OK. Otherwise output the + ** error message + */ + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList endCode[] = { + { OP_AddImm, 1, 0, 0}, /* 0 */ + { OP_If, 1, 0, 0}, /* 1 */ + { OP_String8, 0, 3, 0}, /* 2 */ + { OP_ResultRow, 3, 1, 0}, + }; + + int isQuick = (sqlite3Tolower(zLeft[0])=='q'); + + /* If the PRAGMA command was of the form "PRAGMA .integrity_check", + ** then iDb is set to the index of the database identified by . + ** In this case, the integrity of database iDb only is verified by + ** the VDBE created below. + ** + ** Otherwise, if the command was simply "PRAGMA integrity_check" (or + ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb + ** to -1 here, to indicate that the VDBE should verify the integrity + ** of all attached databases. */ + assert( iDb>=0 ); + assert( iDb==0 || pId2->z ); + if( pId2->z==0 ) iDb = -1; + + /* Initialize the VDBE program */ + pParse->nMem = 6; + setOneColumnName(v, "integrity_check"); + + /* Set the maximum error count */ + mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX; + if( zRight ){ + sqlite3GetInt32(zRight, &mxErr); + if( mxErr<=0 ){ + mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX; + } + } + sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1); /* reg[1] holds errors left */ + + /* Do an integrity check on each database file */ + for(i=0; inDb; i++){ + HashElem *x; + Hash *pTbls; + int cnt = 0; + + if( OMIT_TEMPDB && i==1 ) continue; + if( iDb>=0 && i!=iDb ) continue; + + sqlite3CodeVerifySchema(pParse, i); + addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */ + VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Halt, 0, 0); + sqlite3VdbeJumpHere(v, addr); + + /* Do an integrity check of the B-Tree + ** + ** Begin by filling registers 2, 3, ... with the root pages numbers + ** for all tables and indices in the database. + */ + assert( sqlite3SchemaMutexHeld(db, i, 0) ); + pTbls = &db->aDb[i].pSchema->tblHash; + for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ + Table *pTab = sqliteHashData(x); + Index *pIdx; + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt); + VdbeComment((v, "%s", pTab->zName)); + cnt++; + } + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + sqlite3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt); + VdbeComment((v, "%s", pIdx->zName)); + cnt++; + } + } + + /* Make sure sufficient number of registers have been allocated */ + pParse->nMem = MAX( pParse->nMem, cnt+8 ); + + /* Do the b-tree integrity checks */ + sqlite3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1); + sqlite3VdbeChangeP5(v, (u8)i); + addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2); VdbeCoverage(v); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, + sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName), + P4_DYNAMIC); + sqlite3VdbeAddOp3(v, OP_Move, 2, 4, 1); + sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2); + sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1); + sqlite3VdbeJumpHere(v, addr); + + /* Make sure all the indices are constructed correctly. + */ + for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){ + Table *pTab = sqliteHashData(x); + Index *pIdx, *pPk; + Index *pPrior = 0; + int loopTop; + int iDataCur, iIdxCur; + int r1 = -1; + + if( pTab->pIndex==0 ) continue; + pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); + addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Stop if out of errors */ + VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Halt, 0, 0); + sqlite3VdbeJumpHere(v, addr); + sqlite3ExprCacheClear(pParse); + sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, + 1, 0, &iDataCur, &iIdxCur); + sqlite3VdbeAddOp2(v, OP_Integer, 0, 7); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, 8+j); /* index entries counter */ + } + pParse->nMem = MAX(pParse->nMem, 8+j); + sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v); + loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1); + /* Verify that all NOT NULL columns really are NOT NULL */ + for(j=0; jnCol; j++){ + char *zErr; + int jmp2, jmp3; + if( j==pTab->iPKey ) continue; + if( pTab->aCol[j].notNull==0 ) continue; + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3); + sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG); + jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */ + zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName, + pTab->aCol[j].zName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1); + jmp3 = sqlite3VdbeAddOp1(v, OP_IfPos, 1); VdbeCoverage(v); + sqlite3VdbeAddOp0(v, OP_Halt); + sqlite3VdbeJumpHere(v, jmp2); + sqlite3VdbeJumpHere(v, jmp3); + } + /* Validate index entries for the current row */ + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + int jmp2, jmp3, jmp4, jmp5; + int ckUniq = sqlite3VdbeMakeLabel(v); + if( pPk==pIdx ) continue; + r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3, + pPrior, r1); + pPrior = pIdx; + sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1); /* increment entry count */ + /* Verify that an index entry exists for the current table row */ + jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1, + pIdx->nColumn); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */ + sqlite3VdbeLoadString(v, 3, "row "); + sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3); + sqlite3VdbeLoadString(v, 4, " missing from index "); + sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3); + jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName); + sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3); + sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1); + jmp4 = sqlite3VdbeAddOp1(v, OP_IfPos, 1); VdbeCoverage(v); + sqlite3VdbeAddOp0(v, OP_Halt); + sqlite3VdbeJumpHere(v, jmp2); + /* For UNIQUE indexes, verify that only one entry exists with the + ** current key. The entry is unique if (1) any column is NULL + ** or (2) the next entry has a different key */ + if( IsUniqueIndex(pIdx) ){ + int uniqOk = sqlite3VdbeMakeLabel(v); + int jmp6; + int kk; + for(kk=0; kknKeyCol; kk++){ + int iCol = pIdx->aiColumn[kk]; + assert( iCol!=XN_ROWID && iColnCol ); + if( iCol>=0 && pTab->aCol[iCol].notNull ) continue; + sqlite3VdbeAddOp2(v, OP_IsNull, r1+kk, uniqOk); + VdbeCoverage(v); + } + jmp6 = sqlite3VdbeAddOp1(v, OP_Next, iIdxCur+j); VdbeCoverage(v); + sqlite3VdbeGoto(v, uniqOk); + sqlite3VdbeJumpHere(v, jmp6); + sqlite3VdbeAddOp4Int(v, OP_IdxGT, iIdxCur+j, uniqOk, r1, + pIdx->nKeyCol); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */ + sqlite3VdbeLoadString(v, 3, "non-unique entry in index "); + sqlite3VdbeGoto(v, jmp5); + sqlite3VdbeResolveLabel(v, uniqOk); + } + sqlite3VdbeJumpHere(v, jmp4); + sqlite3ResolvePartIdxLabel(pParse, jmp3); + } + sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, loopTop-1); +#ifndef SQLITE_OMIT_BTREECOUNT + sqlite3VdbeLoadString(v, 2, "wrong # of entries in index "); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + if( pPk==pIdx ) continue; + addr = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr+2); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Halt, 0, 0); + sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3); + sqlite3VdbeAddOp3(v, OP_Eq, 8+j, addr+8, 3); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); + sqlite3VdbeLoadString(v, 3, pIdx->zName); + sqlite3VdbeAddOp3(v, OP_Concat, 3, 2, 7); + sqlite3VdbeAddOp2(v, OP_ResultRow, 7, 1); + } +#endif /* SQLITE_OMIT_BTREECOUNT */ + } + } + addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn); + sqlite3VdbeChangeP2(v, addr, -mxErr); + sqlite3VdbeJumpHere(v, addr+1); + sqlite3VdbeChangeP4(v, addr+2, "ok", P4_STATIC); + } + break; +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_UTF16 + /* + ** PRAGMA encoding + ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be" + ** + ** In its first form, this pragma returns the encoding of the main + ** database. If the database is not initialized, it is initialized now. + ** + ** The second form of this pragma is a no-op if the main database file + ** has not already been initialized. In this case it sets the default + ** encoding that will be used for the main database file if a new file + ** is created. If an existing main database file is opened, then the + ** default text encoding for the existing database is used. + ** + ** In all cases new databases created using the ATTACH command are + ** created to use the same default text encoding as the main database. If + ** the main database has not been initialized and/or created when ATTACH + ** is executed, this is done before the ATTACH operation. + ** + ** In the second form this pragma sets the text encoding to be used in + ** new database files created using this database handle. It is only + ** useful if invoked immediately after the main database i + */ + case PragTyp_ENCODING: { + static const struct EncName { + char *zName; + u8 enc; + } encnames[] = { + { "UTF8", SQLITE_UTF8 }, + { "UTF-8", SQLITE_UTF8 }, /* Must be element [1] */ + { "UTF-16le", SQLITE_UTF16LE }, /* Must be element [2] */ + { "UTF-16be", SQLITE_UTF16BE }, /* Must be element [3] */ + { "UTF16le", SQLITE_UTF16LE }, + { "UTF16be", SQLITE_UTF16BE }, + { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */ + { "UTF16", 0 }, /* SQLITE_UTF16NATIVE */ + { 0, 0 } + }; + const struct EncName *pEnc; + if( !zRight ){ /* "PRAGMA encoding" */ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 ); + assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE ); + assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE ); + returnSingleText(v, "encoding", encnames[ENC(pParse->db)].zName); + }else{ /* "PRAGMA encoding = XXX" */ + /* Only change the value of sqlite.enc if the database handle is not + ** initialized. If the main database exists, the new sqlite.enc value + ** will be overwritten when the schema is next loaded. If it does not + ** already exists, it will be created to use the new encoding value. + */ + if( + !(DbHasProperty(db, 0, DB_SchemaLoaded)) || + DbHasProperty(db, 0, DB_Empty) + ){ + for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ + if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){ + SCHEMA_ENC(db) = ENC(db) = + pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE; + break; + } + } + if( !pEnc->zName ){ + sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight); + } + } + } + } + break; +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS + /* + ** PRAGMA [database.]schema_version + ** PRAGMA [database.]schema_version = + ** + ** PRAGMA [database.]user_version + ** PRAGMA [database.]user_version = + ** + ** PRAGMA [database.]freelist_count = + ** + ** PRAGMA [database.]application_id + ** PRAGMA [database.]application_id = + ** + ** The pragma's schema_version and user_version are used to set or get + ** the value of the schema-version and user-version, respectively. Both + ** the schema-version and the user-version are 32-bit signed integers + ** stored in the database header. + ** + ** The schema-cookie is usually only manipulated internally by SQLite. It + ** is incremented by SQLite whenever the database schema is modified (by + ** creating or dropping a table or index). The schema version is used by + ** SQLite each time a query is executed to ensure that the internal cache + ** of the schema used when compiling the SQL query matches the schema of + ** the database against which the compiled query is actually executed. + ** Subverting this mechanism by using "PRAGMA schema_version" to modify + ** the schema-version is potentially dangerous and may lead to program + ** crashes or database corruption. Use with caution! + ** + ** The user-version is not used internally by SQLite. It may be used by + ** applications for any purpose. + */ + case PragTyp_HEADER_VALUE: { + int iCookie = pPragma->iArg; /* Which cookie to read or write */ + sqlite3VdbeUsesBtree(v, iDb); + if( zRight && (pPragma->mPragFlag & PragFlag_ReadOnly)==0 ){ + /* Write the specified cookie value */ + static const VdbeOpList setCookie[] = { + { OP_Transaction, 0, 1, 0}, /* 0 */ + { OP_Integer, 0, 1, 0}, /* 1 */ + { OP_SetCookie, 0, 0, 1}, /* 2 */ + }; + int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie, 0); + sqlite3VdbeChangeP1(v, addr, iDb); + sqlite3VdbeChangeP1(v, addr+1, sqlite3Atoi(zRight)); + sqlite3VdbeChangeP1(v, addr+2, iDb); + sqlite3VdbeChangeP2(v, addr+2, iCookie); + }else{ + /* Read the specified cookie value */ + static const VdbeOpList readCookie[] = { + { OP_Transaction, 0, 0, 0}, /* 0 */ + { OP_ReadCookie, 0, 1, 0}, /* 1 */ + { OP_ResultRow, 1, 1, 0} + }; + int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie, 0); + sqlite3VdbeChangeP1(v, addr, iDb); + sqlite3VdbeChangeP1(v, addr+1, iDb); + sqlite3VdbeChangeP3(v, addr+1, iCookie); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT); + } + } + break; +#endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */ + +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS + /* + ** PRAGMA compile_options + ** + ** Return the names of all compile-time options used in this build, + ** one option per row. + */ + case PragTyp_COMPILE_OPTIONS: { + int i = 0; + const char *zOpt; + pParse->nMem = 1; + setOneColumnName(v, "compile_option"); + while( (zOpt = sqlite3_compileoption_get(i++))!=0 ){ + sqlite3VdbeLoadString(v, 1, zOpt); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + } + } + break; +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +#ifndef SQLITE_OMIT_WAL + /* + ** PRAGMA [database.]wal_checkpoint = passive|full|restart|truncate + ** + ** Checkpoint the database. + */ + case PragTyp_WAL_CHECKPOINT: { + static const char *azCol[] = { "busy", "log", "checkpointed" }; + int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED); + int eMode = SQLITE_CHECKPOINT_PASSIVE; + if( zRight ){ + if( sqlite3StrICmp(zRight, "full")==0 ){ + eMode = SQLITE_CHECKPOINT_FULL; + }else if( sqlite3StrICmp(zRight, "restart")==0 ){ + eMode = SQLITE_CHECKPOINT_RESTART; + }else if( sqlite3StrICmp(zRight, "truncate")==0 ){ + eMode = SQLITE_CHECKPOINT_TRUNCATE; + } + } + setAllColumnNames(v, 3, azCol); assert( 3==ArraySize(azCol) ); + pParse->nMem = 3; + sqlite3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3); + } + break; + + /* + ** PRAGMA wal_autocheckpoint + ** PRAGMA wal_autocheckpoint = N + ** + ** Configure a database connection to automatically checkpoint a database + ** after accumulating N frames in the log. Or query for the current value + ** of N. + */ + case PragTyp_WAL_AUTOCHECKPOINT: { + if( zRight ){ + sqlite3_wal_autocheckpoint(db, sqlite3Atoi(zRight)); + } + returnSingleInt(v, "wal_autocheckpoint", + db->xWalCallback==sqlite3WalDefaultHook ? + SQLITE_PTR_TO_INT(db->pWalArg) : 0); + } + break; +#endif + + /* + ** PRAGMA shrink_memory + ** + ** IMPLEMENTATION-OF: R-23445-46109 This pragma causes the database + ** connection on which it is invoked to free up as much memory as it + ** can, by calling sqlite3_db_release_memory(). + */ + case PragTyp_SHRINK_MEMORY: { + sqlite3_db_release_memory(db); + break; + } + + /* + ** PRAGMA busy_timeout + ** PRAGMA busy_timeout = N + ** + ** Call sqlite3_busy_timeout(db, N). Return the current timeout value + ** if one is set. If no busy handler or a different busy handler is set + ** then 0 is returned. Setting the busy_timeout to 0 or negative + ** disables the timeout. + */ + /*case PragTyp_BUSY_TIMEOUT*/ default: { + assert( pPragma->ePragTyp==PragTyp_BUSY_TIMEOUT ); + if( zRight ){ + sqlite3_busy_timeout(db, sqlite3Atoi(zRight)); + } + returnSingleInt(v, "timeout", db->busyTimeout); + break; + } + + /* + ** PRAGMA soft_heap_limit + ** PRAGMA soft_heap_limit = N + ** + ** IMPLEMENTATION-OF: R-26343-45930 This pragma invokes the + ** sqlite3_soft_heap_limit64() interface with the argument N, if N is + ** specified and is a non-negative integer. + ** IMPLEMENTATION-OF: R-64451-07163 The soft_heap_limit pragma always + ** returns the same integer that would be returned by the + ** sqlite3_soft_heap_limit64(-1) C-language function. + */ + case PragTyp_SOFT_HEAP_LIMIT: { + sqlite3_int64 N; + if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){ + sqlite3_soft_heap_limit64(N); + } + returnSingleInt(v, "soft_heap_limit", sqlite3_soft_heap_limit64(-1)); + break; + } + + /* + ** PRAGMA threads + ** PRAGMA threads = N + ** + ** Configure the maximum number of worker threads. Return the new + ** maximum, which might be less than requested. + */ + case PragTyp_THREADS: { + sqlite3_int64 N; + if( zRight + && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK + && N>=0 + ){ + sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, (int)(N&0x7fffffff)); + } + returnSingleInt(v, "threads", + sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, -1)); + break; + } + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* + ** Report the current state of file logs for all databases + */ + case PragTyp_LOCK_STATUS: { + static const char *const azLockName[] = { + "unlocked", "shared", "reserved", "pending", "exclusive" + }; + static const char *azCol[] = { "database", "status" }; + int i; + setAllColumnNames(v, 2, azCol); assert( 2==ArraySize(azCol) ); + pParse->nMem = 2; + for(i=0; inDb; i++){ + Btree *pBt; + const char *zState = "unknown"; + int j; + if( db->aDb[i].zName==0 ) continue; + pBt = db->aDb[i].pBt; + if( pBt==0 || sqlite3BtreePager(pBt)==0 ){ + zState = "closed"; + }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0, + SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){ + zState = azLockName[j]; + } + sqlite3VdbeMultiLoad(v, 1, "ss", db->aDb[i].zName, zState); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2); + } + break; + } +#endif + +#ifdef SQLITE_HAS_CODEC + case PragTyp_KEY: { + if( zRight ) sqlite3_key_v2(db, zDb, zRight, sqlite3Strlen30(zRight)); + break; + } + case PragTyp_REKEY: { + if( zRight ) sqlite3_rekey_v2(db, zDb, zRight, sqlite3Strlen30(zRight)); + break; + } + case PragTyp_HEXKEY: { + if( zRight ){ + u8 iByte; + int i; + char zKey[40]; + for(i=0, iByte=0; idb; + if( !db->mallocFailed && (db->flags & SQLITE_RecoveryMode)==0 ){ + char *z; + if( zObj==0 ) zObj = "?"; + z = sqlite3_mprintf("malformed database schema (%s)", zObj); + if( z && zExtra ) z = sqlite3_mprintf("%z - %s", z, zExtra); + sqlite3DbFree(db, *pData->pzErrMsg); + *pData->pzErrMsg = z; + if( z==0 ) db->mallocFailed = 1; + } + pData->rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_CORRUPT_BKPT; +} + +/* +** This is the callback routine for the code that initializes the +** database. See sqlite3Init() below for additional information. +** This routine is also called from the OP_ParseSchema opcode of the VDBE. +** +** Each callback contains the following information: +** +** argv[0] = name of thing being created +** argv[1] = root page number for table or index. 0 for trigger or view. +** argv[2] = SQL text for the CREATE statement. +** +*/ +SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){ + InitData *pData = (InitData*)pInit; + sqlite3 *db = pData->db; + int iDb = pData->iDb; + + assert( argc==3 ); + UNUSED_PARAMETER2(NotUsed, argc); + assert( sqlite3_mutex_held(db->mutex) ); + DbClearProperty(db, iDb, DB_Empty); + if( db->mallocFailed ){ + corruptSchema(pData, argv[0], 0); + return 1; + } + + assert( iDb>=0 && iDbnDb ); + if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ + if( argv[1]==0 ){ + corruptSchema(pData, argv[0], 0); + }else if( sqlite3_strnicmp(argv[2],"create ",7)==0 ){ + /* Call the parser to process a CREATE TABLE, INDEX or VIEW. + ** But because db->init.busy is set to 1, no VDBE code is generated + ** or executed. All the parser does is build the internal data + ** structures that describe the table, index, or view. + */ + int rc; + sqlite3_stmt *pStmt; + TESTONLY(int rcp); /* Return code from sqlite3_prepare() */ + + assert( db->init.busy ); + db->init.iDb = iDb; + db->init.newTnum = sqlite3Atoi(argv[1]); + db->init.orphanTrigger = 0; + TESTONLY(rcp = ) sqlite3_prepare(db, argv[2], -1, &pStmt, 0); + rc = db->errCode; + assert( (rc&0xFF)==(rcp&0xFF) ); + db->init.iDb = 0; + if( SQLITE_OK!=rc ){ + if( db->init.orphanTrigger ){ + assert( iDb==1 ); + }else{ + pData->rc = rc; + if( rc==SQLITE_NOMEM ){ + db->mallocFailed = 1; + }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){ + corruptSchema(pData, argv[0], sqlite3_errmsg(db)); + } + } + } + sqlite3_finalize(pStmt); + }else if( argv[0]==0 || (argv[2]!=0 && argv[2][0]!=0) ){ + corruptSchema(pData, argv[0], 0); + }else{ + /* If the SQL column is blank it means this is an index that + ** was created to be the PRIMARY KEY or to fulfill a UNIQUE + ** constraint for a CREATE TABLE. The index should have already + ** been created when we processed the CREATE TABLE. All we have + ** to do here is record the root page number for that index. + */ + Index *pIndex; + pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName); + if( pIndex==0 ){ + /* This can occur if there exists an index on a TEMP table which + ** has the same name as another index on a permanent index. Since + ** the permanent table is hidden by the TEMP table, we can also + ** safely ignore the index on the permanent table. + */ + /* Do Nothing */; + }else if( sqlite3GetInt32(argv[1], &pIndex->tnum)==0 ){ + corruptSchema(pData, argv[0], "invalid rootpage"); + } + } + return 0; +} + +/* +** Attempt to read the database schema and initialize internal +** data structures for a single database file. The index of the +** database file is given by iDb. iDb==0 is used for the main +** database. iDb==1 should never be used. iDb>=2 is used for +** auxiliary databases. Return one of the SQLITE_ error codes to +** indicate success or failure. +*/ +static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){ + int rc; + int i; +#ifndef SQLITE_OMIT_DEPRECATED + int size; +#endif + Table *pTab; + Db *pDb; + char const *azArg[4]; + int meta[5]; + InitData initData; + char const *zMasterSchema; + char const *zMasterName; + int openedTransaction = 0; + + /* + ** The master database table has a structure like this + */ + static const char master_schema[] = + "CREATE TABLE sqlite_master(\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")" + ; +#ifndef SQLITE_OMIT_TEMPDB + static const char temp_master_schema[] = + "CREATE TEMP TABLE sqlite_temp_master(\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")" + ; +#else + #define temp_master_schema 0 +#endif + + assert( iDb>=0 && iDbnDb ); + assert( db->aDb[iDb].pSchema ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); + + /* zMasterSchema and zInitScript are set to point at the master schema + ** and initialisation script appropriate for the database being + ** initialized. zMasterName is the name of the master table. + */ + if( !OMIT_TEMPDB && iDb==1 ){ + zMasterSchema = temp_master_schema; + }else{ + zMasterSchema = master_schema; + } + zMasterName = SCHEMA_TABLE(iDb); + + /* Construct the schema tables. */ + azArg[0] = zMasterName; + azArg[1] = "1"; + azArg[2] = zMasterSchema; + azArg[3] = 0; + initData.db = db; + initData.iDb = iDb; + initData.rc = SQLITE_OK; + initData.pzErrMsg = pzErrMsg; + sqlite3InitCallback(&initData, 3, (char **)azArg, 0); + if( initData.rc ){ + rc = initData.rc; + goto error_out; + } + pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName); + if( ALWAYS(pTab) ){ + pTab->tabFlags |= TF_Readonly; + } + + /* Create a cursor to hold the database open + */ + pDb = &db->aDb[iDb]; + if( pDb->pBt==0 ){ + if( !OMIT_TEMPDB && ALWAYS(iDb==1) ){ + DbSetProperty(db, 1, DB_SchemaLoaded); + } + return SQLITE_OK; + } + + /* If there is not already a read-only (or read-write) transaction opened + ** on the b-tree database, open one now. If a transaction is opened, it + ** will be closed before this function returns. */ + sqlite3BtreeEnter(pDb->pBt); + if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){ + rc = sqlite3BtreeBeginTrans(pDb->pBt, 0); + if( rc!=SQLITE_OK ){ + sqlite3SetString(pzErrMsg, db, sqlite3ErrStr(rc)); + goto initone_error_out; + } + openedTransaction = 1; + } + + /* Get the database meta information. + ** + ** Meta values are as follows: + ** meta[0] Schema cookie. Changes with each schema change. + ** meta[1] File format of schema layer. + ** meta[2] Size of the page cache. + ** meta[3] Largest rootpage (auto/incr_vacuum mode) + ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE + ** meta[5] User version + ** meta[6] Incremental vacuum mode + ** meta[7] unused + ** meta[8] unused + ** meta[9] unused + ** + ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to + ** the possible values of meta[4]. + */ + for(i=0; ipBt, i+1, (u32 *)&meta[i]); + } + pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1]; + + /* If opening a non-empty database, check the text encoding. For the + ** main database, set sqlite3.enc to the encoding of the main database. + ** For an attached db, it is an error if the encoding is not the same + ** as sqlite3.enc. + */ + if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */ + if( iDb==0 ){ +#ifndef SQLITE_OMIT_UTF16 + u8 encoding; + /* If opening the main database, set ENC(db). */ + encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3; + if( encoding==0 ) encoding = SQLITE_UTF8; + ENC(db) = encoding; +#else + ENC(db) = SQLITE_UTF8; +#endif + }else{ + /* If opening an attached database, the encoding much match ENC(db) */ + if( meta[BTREE_TEXT_ENCODING-1]!=ENC(db) ){ + sqlite3SetString(pzErrMsg, db, "attached databases must use the same" + " text encoding as main database"); + rc = SQLITE_ERROR; + goto initone_error_out; + } + } + }else{ + DbSetProperty(db, iDb, DB_Empty); + } + pDb->pSchema->enc = ENC(db); + + if( pDb->pSchema->cache_size==0 ){ +#ifndef SQLITE_OMIT_DEPRECATED + size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]); + if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; } + pDb->pSchema->cache_size = size; +#else + pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE; +#endif + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + } + + /* + ** file_format==1 Version 3.0.0. + ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN + ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults + ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants + */ + pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1]; + if( pDb->pSchema->file_format==0 ){ + pDb->pSchema->file_format = 1; + } + if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){ + sqlite3SetString(pzErrMsg, db, "unsupported file format"); + rc = SQLITE_ERROR; + goto initone_error_out; + } + + /* Ticket #2804: When we open a database in the newer file format, + ** clear the legacy_file_format pragma flag so that a VACUUM will + ** not downgrade the database and thus invalidate any descending + ** indices that the user might have created. + */ + if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){ + db->flags &= ~SQLITE_LegacyFileFmt; + } + + /* Read the schema information out of the schema tables + */ + assert( db->init.busy ); + { + char *zSql; + zSql = sqlite3MPrintf(db, + "SELECT name, rootpage, sql FROM '%q'.%s ORDER BY rowid", + db->aDb[iDb].zName, zMasterName); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + sqlite3_xauth xAuth; + xAuth = db->xAuth; + db->xAuth = 0; +#endif + rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; + } +#endif + if( rc==SQLITE_OK ) rc = initData.rc; + sqlite3DbFree(db, zSql); +#ifndef SQLITE_OMIT_ANALYZE + if( rc==SQLITE_OK ){ + sqlite3AnalysisLoad(db, iDb); + } +#endif + } + if( db->mallocFailed ){ + rc = SQLITE_NOMEM; + sqlite3ResetAllSchemasOfConnection(db); + } + if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){ + /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider + ** the schema loaded, even if errors occurred. In this situation the + ** current sqlite3_prepare() operation will fail, but the following one + ** will attempt to compile the supplied statement against whatever subset + ** of the schema was loaded before the error occurred. The primary + ** purpose of this is to allow access to the sqlite_master table + ** even when its contents have been corrupted. + */ + DbSetProperty(db, iDb, DB_SchemaLoaded); + rc = SQLITE_OK; + } + + /* Jump here for an error that occurs after successfully allocating + ** curMain and calling sqlite3BtreeEnter(). For an error that occurs + ** before that point, jump to error_out. + */ +initone_error_out: + if( openedTransaction ){ + sqlite3BtreeCommit(pDb->pBt); + } + sqlite3BtreeLeave(pDb->pBt); + +error_out: + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + db->mallocFailed = 1; + } + return rc; +} + +/* +** Initialize all database files - the main database file, the file +** used to store temporary tables, and any additional database files +** created using ATTACH statements. Return a success code. If an +** error occurs, write an error message into *pzErrMsg. +** +** After a database is initialized, the DB_SchemaLoaded bit is set +** bit is set in the flags field of the Db structure. If the database +** file was of zero-length, then the DB_Empty flag is also set. +*/ +SQLITE_PRIVATE int sqlite3Init(sqlite3 *db, char **pzErrMsg){ + int i, rc; + int commit_internal = !(db->flags&SQLITE_InternChanges); + + assert( sqlite3_mutex_held(db->mutex) ); + assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) ); + assert( db->init.busy==0 ); + rc = SQLITE_OK; + db->init.busy = 1; + ENC(db) = SCHEMA_ENC(db); + for(i=0; rc==SQLITE_OK && inDb; i++){ + if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue; + rc = sqlite3InitOne(db, i, pzErrMsg); + if( rc ){ + sqlite3ResetOneSchema(db, i); + } + } + + /* Once all the other databases have been initialized, load the schema + ** for the TEMP database. This is loaded last, as the TEMP database + ** schema may contain references to objects in other databases. + */ +#ifndef SQLITE_OMIT_TEMPDB + assert( db->nDb>1 ); + if( rc==SQLITE_OK && !DbHasProperty(db, 1, DB_SchemaLoaded) ){ + rc = sqlite3InitOne(db, 1, pzErrMsg); + if( rc ){ + sqlite3ResetOneSchema(db, 1); + } + } +#endif + + db->init.busy = 0; + if( rc==SQLITE_OK && commit_internal ){ + sqlite3CommitInternalChanges(db); + } + + return rc; +} + +/* +** This routine is a no-op if the database schema is already initialized. +** Otherwise, the schema is loaded. An error code is returned. +*/ +SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse){ + int rc = SQLITE_OK; + sqlite3 *db = pParse->db; + assert( sqlite3_mutex_held(db->mutex) ); + if( !db->init.busy ){ + rc = sqlite3Init(db, &pParse->zErrMsg); + } + if( rc!=SQLITE_OK ){ + pParse->rc = rc; + pParse->nErr++; + } + return rc; +} + + +/* +** Check schema cookies in all databases. If any cookie is out +** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies +** make no changes to pParse->rc. +*/ +static void schemaIsValid(Parse *pParse){ + sqlite3 *db = pParse->db; + int iDb; + int rc; + int cookie; + + assert( pParse->checkSchema ); + assert( sqlite3_mutex_held(db->mutex) ); + for(iDb=0; iDbnDb; iDb++){ + int openedTransaction = 0; /* True if a transaction is opened */ + Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */ + if( pBt==0 ) continue; + + /* If there is not already a read-only (or read-write) transaction opened + ** on the b-tree database, open one now. If a transaction is opened, it + ** will be closed immediately after reading the meta-value. */ + if( !sqlite3BtreeIsInReadTrans(pBt) ){ + rc = sqlite3BtreeBeginTrans(pBt, 0); + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + db->mallocFailed = 1; + } + if( rc!=SQLITE_OK ) return; + openedTransaction = 1; + } + + /* Read the schema cookie from the database. If it does not match the + ** value stored as part of the in-memory schema representation, + ** set Parse.rc to SQLITE_SCHEMA. */ + sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){ + sqlite3ResetOneSchema(db, iDb); + pParse->rc = SQLITE_SCHEMA; + } + + /* Close the transaction, if one was opened. */ + if( openedTransaction ){ + sqlite3BtreeCommit(pBt); + } + } +} + +/* +** Convert a schema pointer into the iDb index that indicates +** which database file in db->aDb[] the schema refers to. +** +** If the same database is attached more than once, the first +** attached database is returned. +*/ +SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){ + int i = -1000000; + + /* If pSchema is NULL, then return -1000000. This happens when code in + ** expr.c is trying to resolve a reference to a transient table (i.e. one + ** created by a sub-select). In this case the return value of this + ** function should never be used. + ** + ** We return -1000000 instead of the more usual -1 simply because using + ** -1000000 as the incorrect index into db->aDb[] is much + ** more likely to cause a segfault than -1 (of course there are assert() + ** statements too, but it never hurts to play the odds). + */ + assert( sqlite3_mutex_held(db->mutex) ); + if( pSchema ){ + for(i=0; ALWAYS(inDb); i++){ + if( db->aDb[i].pSchema==pSchema ){ + break; + } + } + assert( i>=0 && inDb ); + } + return i; +} + +/* +** Free all memory allocations in the pParse object +*/ +SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){ + if( pParse ){ + sqlite3 *db = pParse->db; + sqlite3DbFree(db, pParse->aLabel); + sqlite3ExprListDelete(db, pParse->pConstExpr); + } +} + +/* +** Compile the UTF-8 encoded SQL statement zSql into a statement handle. +*/ +static int sqlite3Prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */ + Vdbe *pReprepare, /* VM being reprepared */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + Parse *pParse; /* Parsing context */ + char *zErrMsg = 0; /* Error message */ + int rc = SQLITE_OK; /* Result code */ + int i; /* Loop counter */ + + /* Allocate the parsing context */ + pParse = sqlite3StackAllocZero(db, sizeof(*pParse)); + if( pParse==0 ){ + rc = SQLITE_NOMEM; + goto end_prepare; + } + pParse->pReprepare = pReprepare; + assert( ppStmt && *ppStmt==0 ); + assert( !db->mallocFailed ); + assert( sqlite3_mutex_held(db->mutex) ); + + /* Check to verify that it is possible to get a read lock on all + ** database schemas. The inability to get a read lock indicates that + ** some other database connection is holding a write-lock, which in + ** turn means that the other connection has made uncommitted changes + ** to the schema. + ** + ** Were we to proceed and prepare the statement against the uncommitted + ** schema changes and if those schema changes are subsequently rolled + ** back and different changes are made in their place, then when this + ** prepared statement goes to run the schema cookie would fail to detect + ** the schema change. Disaster would follow. + ** + ** This thread is currently holding mutexes on all Btrees (because + ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it + ** is not possible for another thread to start a new schema change + ** while this routine is running. Hence, we do not need to hold + ** locks on the schema, we just need to make sure nobody else is + ** holding them. + ** + ** Note that setting READ_UNCOMMITTED overrides most lock detection, + ** but it does *not* override schema lock detection, so this all still + ** works even if READ_UNCOMMITTED is set. + */ + for(i=0; inDb; i++) { + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + assert( sqlite3BtreeHoldsMutex(pBt) ); + rc = sqlite3BtreeSchemaLocked(pBt); + if( rc ){ + const char *zDb = db->aDb[i].zName; + sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb); + testcase( db->flags & SQLITE_ReadUncommitted ); + goto end_prepare; + } + } + } + + sqlite3VtabUnlockList(db); + + pParse->db = db; + pParse->nQueryLoop = 0; /* Logarithmic, so 0 really means 1 */ + if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){ + char *zSqlCopy; + int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; + testcase( nBytes==mxLen ); + testcase( nBytes==mxLen+1 ); + if( nBytes>mxLen ){ + sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long"); + rc = sqlite3ApiExit(db, SQLITE_TOOBIG); + goto end_prepare; + } + zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes); + if( zSqlCopy ){ + sqlite3RunParser(pParse, zSqlCopy, &zErrMsg); + sqlite3DbFree(db, zSqlCopy); + pParse->zTail = &zSql[pParse->zTail-zSqlCopy]; + }else{ + pParse->zTail = &zSql[nBytes]; + } + }else{ + sqlite3RunParser(pParse, zSql, &zErrMsg); + } + assert( 0==pParse->nQueryLoop ); + + if( db->mallocFailed ){ + pParse->rc = SQLITE_NOMEM; + } + if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK; + if( pParse->checkSchema ){ + schemaIsValid(pParse); + } + if( db->mallocFailed ){ + pParse->rc = SQLITE_NOMEM; + } + if( pzTail ){ + *pzTail = pParse->zTail; + } + rc = pParse->rc; + +#ifndef SQLITE_OMIT_EXPLAIN + if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){ + static const char * const azColName[] = { + "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment", + "selectid", "order", "from", "detail" + }; + int iFirst, mx; + if( pParse->explain==2 ){ + sqlite3VdbeSetNumCols(pParse->pVdbe, 4); + iFirst = 8; + mx = 12; + }else{ + sqlite3VdbeSetNumCols(pParse->pVdbe, 8); + iFirst = 0; + mx = 8; + } + for(i=iFirst; ipVdbe, i-iFirst, COLNAME_NAME, + azColName[i], SQLITE_STATIC); + } + } +#endif + + if( db->init.busy==0 ){ + Vdbe *pVdbe = pParse->pVdbe; + sqlite3VdbeSetSql(pVdbe, zSql, (int)(pParse->zTail-zSql), saveSqlFlag); + } + if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){ + sqlite3VdbeFinalize(pParse->pVdbe); + assert(!(*ppStmt)); + }else{ + *ppStmt = (sqlite3_stmt*)pParse->pVdbe; + } + + if( zErrMsg ){ + sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg); + sqlite3DbFree(db, zErrMsg); + }else{ + sqlite3Error(db, rc); + } + + /* Delete any TriggerPrg structures allocated while parsing this statement. */ + while( pParse->pTriggerPrg ){ + TriggerPrg *pT = pParse->pTriggerPrg; + pParse->pTriggerPrg = pT->pNext; + sqlite3DbFree(db, pT); + } + +end_prepare: + + sqlite3ParserReset(pParse); + sqlite3StackFree(db, pParse); + rc = sqlite3ApiExit(db, rc); + assert( (rc&db->errMask)==rc ); + return rc; +} +static int sqlite3LockAndPrepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */ + Vdbe *pOld, /* VM being reprepared */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppStmt = 0; + if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ + return SQLITE_MISUSE_BKPT; + } + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail); + if( rc==SQLITE_SCHEMA ){ + sqlite3_finalize(*ppStmt); + rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail); + } + sqlite3BtreeLeaveAll(db); + sqlite3_mutex_leave(db->mutex); + assert( rc==SQLITE_OK || *ppStmt==0 ); + return rc; +} + +/* +** Rerun the compilation of a statement after a schema change. +** +** If the statement is successfully recompiled, return SQLITE_OK. Otherwise, +** if the statement cannot be recompiled because another connection has +** locked the sqlite3_master table, return SQLITE_LOCKED. If any other error +** occurs, return SQLITE_SCHEMA. +*/ +SQLITE_PRIVATE int sqlite3Reprepare(Vdbe *p){ + int rc; + sqlite3_stmt *pNew; + const char *zSql; + sqlite3 *db; + + assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) ); + zSql = sqlite3_sql((sqlite3_stmt *)p); + assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */ + db = sqlite3VdbeDb(p); + assert( sqlite3_mutex_held(db->mutex) ); + rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0); + if( rc ){ + if( rc==SQLITE_NOMEM ){ + db->mallocFailed = 1; + } + assert( pNew==0 ); + return rc; + }else{ + assert( pNew!=0 ); + } + sqlite3VdbeSwap((Vdbe*)pNew, p); + sqlite3TransferBindings(pNew, (sqlite3_stmt*)p); + sqlite3VdbeResetStepResult((Vdbe*)pNew); + sqlite3VdbeFinalize((Vdbe*)pNew); + return SQLITE_OK; +} + + +/* +** Two versions of the official API. Legacy and new use. In the legacy +** version, the original SQL text is not saved in the prepared statement +** and so if a schema change occurs, SQLITE_SCHEMA is returned by +** sqlite3_step(). In the new version, the original SQL text is retained +** and the statement is automatically recompiled if an schema change +** occurs. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} +SQLITE_API int SQLITE_STDCALL sqlite3_prepare_v2( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} + + +#ifndef SQLITE_OMIT_UTF16 +/* +** Compile the UTF-16 encoded SQL statement zSql into a statement handle. +*/ +static int sqlite3Prepare16( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + /* This function currently works by first transforming the UTF-16 + ** encoded string to UTF-8, then invoking sqlite3_prepare(). The + ** tricky bit is figuring out the pointer to return in *pzTail. + */ + char *zSql8; + const char *zTail8 = 0; + int rc = SQLITE_OK; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppStmt = 0; + if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ + return SQLITE_MISUSE_BKPT; + } + if( nBytes>=0 ){ + int sz; + const char *z = (const char*)zSql; + for(sz=0; szmutex); + zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE); + if( zSql8 ){ + rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, 0, ppStmt, &zTail8); + } + + if( zTail8 && pzTail ){ + /* If sqlite3_prepare returns a tail pointer, we calculate the + ** equivalent pointer into the UTF-16 string by counting the unicode + ** characters between zSql8 and zTail8, and then returning a pointer + ** the same number of characters into the UTF-16 string. + */ + int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8)); + *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed); + } + sqlite3DbFree(db, zSql8); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Two versions of the official API. Legacy and new use. In the legacy +** version, the original SQL text is not saved in the prepared statement +** and so if a schema change occurs, SQLITE_SCHEMA is returned by +** sqlite3_step(). In the new version, the original SQL text is retained +** and the statement is automatically recompiled if an schema change +** occurs. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_prepare16( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} +SQLITE_API int SQLITE_STDCALL sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} + +#endif /* SQLITE_OMIT_UTF16 */ + +/************** End of prepare.c *********************************************/ +/************** Begin file select.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle SELECT statements in SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* +** Trace output macros +*/ +#if SELECTTRACE_ENABLED +/***/ int sqlite3SelectTrace = 0; +# define SELECTTRACE(K,P,S,X) \ + if(sqlite3SelectTrace&(K)) \ + sqlite3DebugPrintf("%*s%s.%p: ",(P)->nSelectIndent*2-2,"",\ + (S)->zSelName,(S)),\ + sqlite3DebugPrintf X +#else +# define SELECTTRACE(K,P,S,X) +#endif + + +/* +** An instance of the following object is used to record information about +** how to process the DISTINCT keyword, to simplify passing that information +** into the selectInnerLoop() routine. +*/ +typedef struct DistinctCtx DistinctCtx; +struct DistinctCtx { + u8 isTnct; /* True if the DISTINCT keyword is present */ + u8 eTnctType; /* One of the WHERE_DISTINCT_* operators */ + int tabTnct; /* Ephemeral table used for DISTINCT processing */ + int addrTnct; /* Address of OP_OpenEphemeral opcode for tabTnct */ +}; + +/* +** An instance of the following object is used to record information about +** the ORDER BY (or GROUP BY) clause of query is being coded. +*/ +typedef struct SortCtx SortCtx; +struct SortCtx { + ExprList *pOrderBy; /* The ORDER BY (or GROUP BY clause) */ + int nOBSat; /* Number of ORDER BY terms satisfied by indices */ + int iECursor; /* Cursor number for the sorter */ + int regReturn; /* Register holding block-output return address */ + int labelBkOut; /* Start label for the block-output subroutine */ + int addrSortIndex; /* Address of the OP_SorterOpen or OP_OpenEphemeral */ + u8 sortFlags; /* Zero or more SORTFLAG_* bits */ +}; +#define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */ + +/* +** Delete all the content of a Select structure. Deallocate the structure +** itself only if bFree is true. +*/ +static void clearSelect(sqlite3 *db, Select *p, int bFree){ + while( p ){ + Select *pPrior = p->pPrior; + sqlite3ExprListDelete(db, p->pEList); + sqlite3SrcListDelete(db, p->pSrc); + sqlite3ExprDelete(db, p->pWhere); + sqlite3ExprListDelete(db, p->pGroupBy); + sqlite3ExprDelete(db, p->pHaving); + sqlite3ExprListDelete(db, p->pOrderBy); + sqlite3ExprDelete(db, p->pLimit); + sqlite3ExprDelete(db, p->pOffset); + sqlite3WithDelete(db, p->pWith); + if( bFree ) sqlite3DbFree(db, p); + p = pPrior; + bFree = 1; + } +} + +/* +** Initialize a SelectDest structure. +*/ +SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){ + pDest->eDest = (u8)eDest; + pDest->iSDParm = iParm; + pDest->affSdst = 0; + pDest->iSdst = 0; + pDest->nSdst = 0; +} + + +/* +** Allocate a new Select structure and return a pointer to that +** structure. +*/ +SQLITE_PRIVATE Select *sqlite3SelectNew( + Parse *pParse, /* Parsing context */ + ExprList *pEList, /* which columns to include in the result */ + SrcList *pSrc, /* the FROM clause -- which tables to scan */ + Expr *pWhere, /* the WHERE clause */ + ExprList *pGroupBy, /* the GROUP BY clause */ + Expr *pHaving, /* the HAVING clause */ + ExprList *pOrderBy, /* the ORDER BY clause */ + u16 selFlags, /* Flag parameters, such as SF_Distinct */ + Expr *pLimit, /* LIMIT value. NULL means not used */ + Expr *pOffset /* OFFSET value. NULL means no offset */ +){ + Select *pNew; + Select standin; + sqlite3 *db = pParse->db; + pNew = sqlite3DbMallocZero(db, sizeof(*pNew) ); + if( pNew==0 ){ + assert( db->mallocFailed ); + pNew = &standin; + memset(pNew, 0, sizeof(*pNew)); + } + if( pEList==0 ){ + pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0)); + } + pNew->pEList = pEList; + if( pSrc==0 ) pSrc = sqlite3DbMallocZero(db, sizeof(*pSrc)); + pNew->pSrc = pSrc; + pNew->pWhere = pWhere; + pNew->pGroupBy = pGroupBy; + pNew->pHaving = pHaving; + pNew->pOrderBy = pOrderBy; + pNew->selFlags = selFlags; + pNew->op = TK_SELECT; + pNew->pLimit = pLimit; + pNew->pOffset = pOffset; + assert( pOffset==0 || pLimit!=0 || pParse->nErr>0 || db->mallocFailed!=0 ); + pNew->addrOpenEphm[0] = -1; + pNew->addrOpenEphm[1] = -1; + if( db->mallocFailed ) { + clearSelect(db, pNew, pNew!=&standin); + pNew = 0; + }else{ + assert( pNew->pSrc!=0 || pParse->nErr>0 ); + } + assert( pNew!=&standin ); + return pNew; +} + +#if SELECTTRACE_ENABLED +/* +** Set the name of a Select object +*/ +SQLITE_PRIVATE void sqlite3SelectSetName(Select *p, const char *zName){ + if( p && zName ){ + sqlite3_snprintf(sizeof(p->zSelName), p->zSelName, "%s", zName); + } +} +#endif + + +/* +** Delete the given Select structure and all of its substructures. +*/ +SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3 *db, Select *p){ + clearSelect(db, p, 1); +} + +/* +** Return a pointer to the right-most SELECT statement in a compound. +*/ +static Select *findRightmost(Select *p){ + while( p->pNext ) p = p->pNext; + return p; +} + +/* +** Given 1 to 3 identifiers preceding the JOIN keyword, determine the +** type of join. Return an integer constant that expresses that type +** in terms of the following bit values: +** +** JT_INNER +** JT_CROSS +** JT_OUTER +** JT_NATURAL +** JT_LEFT +** JT_RIGHT +** +** A full outer join is the combination of JT_LEFT and JT_RIGHT. +** +** If an illegal or unsupported join type is seen, then still return +** a join type, but put an error in the pParse structure. +*/ +SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ + int jointype = 0; + Token *apAll[3]; + Token *p; + /* 0123456789 123456789 123456789 123 */ + static const char zKeyText[] = "naturaleftouterightfullinnercross"; + static const struct { + u8 i; /* Beginning of keyword text in zKeyText[] */ + u8 nChar; /* Length of the keyword in characters */ + u8 code; /* Join type mask */ + } aKeyword[] = { + /* natural */ { 0, 7, JT_NATURAL }, + /* left */ { 6, 4, JT_LEFT|JT_OUTER }, + /* outer */ { 10, 5, JT_OUTER }, + /* right */ { 14, 5, JT_RIGHT|JT_OUTER }, + /* full */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER }, + /* inner */ { 23, 5, JT_INNER }, + /* cross */ { 28, 5, JT_INNER|JT_CROSS }, + }; + int i, j; + apAll[0] = pA; + apAll[1] = pB; + apAll[2] = pC; + for(i=0; i<3 && apAll[i]; i++){ + p = apAll[i]; + for(j=0; jn==aKeyword[j].nChar + && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){ + jointype |= aKeyword[j].code; + break; + } + } + testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 ); + if( j>=ArraySize(aKeyword) ){ + jointype |= JT_ERROR; + break; + } + } + if( + (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) || + (jointype & JT_ERROR)!=0 + ){ + const char *zSp = " "; + assert( pB!=0 ); + if( pC==0 ){ zSp++; } + sqlite3ErrorMsg(pParse, "unknown or unsupported join type: " + "%T %T%s%T", pA, pB, zSp, pC); + jointype = JT_INNER; + }else if( (jointype & JT_OUTER)!=0 + && (jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ){ + sqlite3ErrorMsg(pParse, + "RIGHT and FULL OUTER JOINs are not currently supported"); + jointype = JT_INNER; + } + return jointype; +} + +/* +** Return the index of a column in a table. Return -1 if the column +** is not contained in the table. +*/ +static int columnIndex(Table *pTab, const char *zCol){ + int i; + for(i=0; inCol; i++){ + if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i; + } + return -1; +} + +/* +** Search the first N tables in pSrc, from left to right, looking for a +** table that has a column named zCol. +** +** When found, set *piTab and *piCol to the table index and column index +** of the matching column and return TRUE. +** +** If not found, return FALSE. +*/ +static int tableAndColumnIndex( + SrcList *pSrc, /* Array of tables to search */ + int N, /* Number of tables in pSrc->a[] to search */ + const char *zCol, /* Name of the column we are looking for */ + int *piTab, /* Write index of pSrc->a[] here */ + int *piCol /* Write index of pSrc->a[*piTab].pTab->aCol[] here */ +){ + int i; /* For looping over tables in pSrc */ + int iCol; /* Index of column matching zCol */ + + assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */ + for(i=0; ia[i].pTab, zCol); + if( iCol>=0 ){ + if( piTab ){ + *piTab = i; + *piCol = iCol; + } + return 1; + } + } + return 0; +} + +/* +** This function is used to add terms implied by JOIN syntax to the +** WHERE clause expression of a SELECT statement. The new term, which +** is ANDed with the existing WHERE clause, is of the form: +** +** (tab1.col1 = tab2.col2) +** +** where tab1 is the iSrc'th table in SrcList pSrc and tab2 is the +** (iSrc+1)'th. Column col1 is column iColLeft of tab1, and col2 is +** column iColRight of tab2. +*/ +static void addWhereTerm( + Parse *pParse, /* Parsing context */ + SrcList *pSrc, /* List of tables in FROM clause */ + int iLeft, /* Index of first table to join in pSrc */ + int iColLeft, /* Index of column in first table */ + int iRight, /* Index of second table in pSrc */ + int iColRight, /* Index of column in second table */ + int isOuterJoin, /* True if this is an OUTER join */ + Expr **ppWhere /* IN/OUT: The WHERE clause to add to */ +){ + sqlite3 *db = pParse->db; + Expr *pE1; + Expr *pE2; + Expr *pEq; + + assert( iLeftnSrc>iRight ); + assert( pSrc->a[iLeft].pTab ); + assert( pSrc->a[iRight].pTab ); + + pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iColLeft); + pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight); + + pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2, 0); + if( pEq && isOuterJoin ){ + ExprSetProperty(pEq, EP_FromJoin); + assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) ); + ExprSetVVAProperty(pEq, EP_NoReduce); + pEq->iRightJoinTable = (i16)pE2->iTable; + } + *ppWhere = sqlite3ExprAnd(db, *ppWhere, pEq); +} + +/* +** Set the EP_FromJoin property on all terms of the given expression. +** And set the Expr.iRightJoinTable to iTable for every term in the +** expression. +** +** The EP_FromJoin property is used on terms of an expression to tell +** the LEFT OUTER JOIN processing logic that this term is part of the +** join restriction specified in the ON or USING clause and not a part +** of the more general WHERE clause. These terms are moved over to the +** WHERE clause during join processing but we need to remember that they +** originated in the ON or USING clause. +** +** The Expr.iRightJoinTable tells the WHERE clause processing that the +** expression depends on table iRightJoinTable even if that table is not +** explicitly mentioned in the expression. That information is needed +** for cases like this: +** +** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5 +** +** The where clause needs to defer the handling of the t1.x=5 +** term until after the t2 loop of the join. In that way, a +** NULL t2 row will be inserted whenever t1.x!=5. If we do not +** defer the handling of t1.x=5, it will be processed immediately +** after the t1 loop and rows with t1.x!=5 will never appear in +** the output, which is incorrect. +*/ +static void setJoinExpr(Expr *p, int iTable){ + while( p ){ + ExprSetProperty(p, EP_FromJoin); + assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) ); + ExprSetVVAProperty(p, EP_NoReduce); + p->iRightJoinTable = (i16)iTable; + if( p->op==TK_FUNCTION && p->x.pList ){ + int i; + for(i=0; ix.pList->nExpr; i++){ + setJoinExpr(p->x.pList->a[i].pExpr, iTable); + } + } + setJoinExpr(p->pLeft, iTable); + p = p->pRight; + } +} + +/* +** This routine processes the join information for a SELECT statement. +** ON and USING clauses are converted into extra terms of the WHERE clause. +** NATURAL joins also create extra WHERE clause terms. +** +** The terms of a FROM clause are contained in the Select.pSrc structure. +** The left most table is the first entry in Select.pSrc. The right-most +** table is the last entry. The join operator is held in the entry to +** the left. Thus entry 0 contains the join operator for the join between +** entries 0 and 1. Any ON or USING clauses associated with the join are +** also attached to the left entry. +** +** This routine returns the number of errors encountered. +*/ +static int sqliteProcessJoin(Parse *pParse, Select *p){ + SrcList *pSrc; /* All tables in the FROM clause */ + int i, j; /* Loop counters */ + struct SrcList_item *pLeft; /* Left table being joined */ + struct SrcList_item *pRight; /* Right table being joined */ + + pSrc = p->pSrc; + pLeft = &pSrc->a[0]; + pRight = &pLeft[1]; + for(i=0; inSrc-1; i++, pRight++, pLeft++){ + Table *pLeftTab = pLeft->pTab; + Table *pRightTab = pRight->pTab; + int isOuter; + + if( NEVER(pLeftTab==0 || pRightTab==0) ) continue; + isOuter = (pRight->fg.jointype & JT_OUTER)!=0; + + /* When the NATURAL keyword is present, add WHERE clause terms for + ** every column that the two tables have in common. + */ + if( pRight->fg.jointype & JT_NATURAL ){ + if( pRight->pOn || pRight->pUsing ){ + sqlite3ErrorMsg(pParse, "a NATURAL join may not have " + "an ON or USING clause", 0); + return 1; + } + for(j=0; jnCol; j++){ + char *zName; /* Name of column in the right table */ + int iLeft; /* Matching left table */ + int iLeftCol; /* Matching column in the left table */ + + zName = pRightTab->aCol[j].zName; + if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) ){ + addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j, + isOuter, &p->pWhere); + } + } + } + + /* Disallow both ON and USING clauses in the same join + */ + if( pRight->pOn && pRight->pUsing ){ + sqlite3ErrorMsg(pParse, "cannot have both ON and USING " + "clauses in the same join"); + return 1; + } + + /* Add the ON clause to the end of the WHERE clause, connected by + ** an AND operator. + */ + if( pRight->pOn ){ + if( isOuter ) setJoinExpr(pRight->pOn, pRight->iCursor); + p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn); + pRight->pOn = 0; + } + + /* Create extra terms on the WHERE clause for each column named + ** in the USING clause. Example: If the two tables to be joined are + ** A and B and the USING clause names X, Y, and Z, then add this + ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z + ** Report an error if any column mentioned in the USING clause is + ** not contained in both tables to be joined. + */ + if( pRight->pUsing ){ + IdList *pList = pRight->pUsing; + for(j=0; jnId; j++){ + char *zName; /* Name of the term in the USING clause */ + int iLeft; /* Table on the left with matching column name */ + int iLeftCol; /* Column number of matching column on the left */ + int iRightCol; /* Column number of matching column on the right */ + + zName = pList->a[j].zName; + iRightCol = columnIndex(pRightTab, zName); + if( iRightCol<0 + || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) + ){ + sqlite3ErrorMsg(pParse, "cannot join using column %s - column " + "not present in both tables", zName); + return 1; + } + addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol, + isOuter, &p->pWhere); + } + } + } + return 0; +} + +/* Forward reference */ +static KeyInfo *keyInfoFromExprList( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* Form the KeyInfo object from this ExprList */ + int iStart, /* Begin with this column of pList */ + int nExtra /* Add this many extra columns to the end */ +); + +/* +** Generate code that will push the record in registers regData +** through regData+nData-1 onto the sorter. +*/ +static void pushOntoSorter( + Parse *pParse, /* Parser context */ + SortCtx *pSort, /* Information about the ORDER BY clause */ + Select *pSelect, /* The whole SELECT statement */ + int regData, /* First register holding data to be sorted */ + int regOrigData, /* First register holding data before packing */ + int nData, /* Number of elements in the data array */ + int nPrefixReg /* No. of reg prior to regData available for use */ +){ + Vdbe *v = pParse->pVdbe; /* Stmt under construction */ + int bSeq = ((pSort->sortFlags & SORTFLAG_UseSorter)==0); + int nExpr = pSort->pOrderBy->nExpr; /* No. of ORDER BY terms */ + int nBase = nExpr + bSeq + nData; /* Fields in sorter record */ + int regBase; /* Regs for sorter record */ + int regRecord = ++pParse->nMem; /* Assembled sorter record */ + int nOBSat = pSort->nOBSat; /* ORDER BY terms to skip */ + int op; /* Opcode to add sorter record to sorter */ + + assert( bSeq==0 || bSeq==1 ); + assert( nData==1 || regData==regOrigData ); + if( nPrefixReg ){ + assert( nPrefixReg==nExpr+bSeq ); + regBase = regData - nExpr - bSeq; + }else{ + regBase = pParse->nMem + 1; + pParse->nMem += nBase; + } + sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData, + SQLITE_ECEL_DUP|SQLITE_ECEL_REF); + if( bSeq ){ + sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr); + } + if( nPrefixReg==0 ){ + sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+bSeq, nData); + } + + sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regRecord); + if( nOBSat>0 ){ + int regPrevKey; /* The first nOBSat columns of the previous row */ + int addrFirst; /* Address of the OP_IfNot opcode */ + int addrJmp; /* Address of the OP_Jump opcode */ + VdbeOp *pOp; /* Opcode that opens the sorter */ + int nKey; /* Number of sorting key columns, including OP_Sequence */ + KeyInfo *pKI; /* Original KeyInfo on the sorter table */ + + regPrevKey = pParse->nMem+1; + pParse->nMem += pSort->nOBSat; + nKey = nExpr - pSort->nOBSat + bSeq; + if( bSeq ){ + addrFirst = sqlite3VdbeAddOp1(v, OP_IfNot, regBase+nExpr); + }else{ + addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor); + } + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat); + pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex); + if( pParse->db->mallocFailed ) return; + pOp->p2 = nKey + nData; + pKI = pOp->p4.pKeyInfo; + memset(pKI->aSortOrder, 0, pKI->nField); /* Makes OP_Jump below testable */ + sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO); + testcase( pKI->nXField>2 ); + pOp->p4.pKeyInfo = keyInfoFromExprList(pParse, pSort->pOrderBy, nOBSat, + pKI->nXField-1); + addrJmp = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v); + pSort->labelBkOut = sqlite3VdbeMakeLabel(v); + pSort->regReturn = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut); + sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor); + sqlite3VdbeJumpHere(v, addrFirst); + sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat); + sqlite3VdbeJumpHere(v, addrJmp); + } + if( pSort->sortFlags & SORTFLAG_UseSorter ){ + op = OP_SorterInsert; + }else{ + op = OP_IdxInsert; + } + sqlite3VdbeAddOp2(v, op, pSort->iECursor, regRecord); + if( pSelect->iLimit ){ + int addr; + int iLimit; + if( pSelect->iOffset ){ + iLimit = pSelect->iOffset+1; + }else{ + iLimit = pSelect->iLimit; + } + addr = sqlite3VdbeAddOp3(v, OP_IfNotZero, iLimit, 0, 1); VdbeCoverage(v); + sqlite3VdbeAddOp1(v, OP_Last, pSort->iECursor); + sqlite3VdbeAddOp1(v, OP_Delete, pSort->iECursor); + sqlite3VdbeJumpHere(v, addr); + } +} + +/* +** Add code to implement the OFFSET +*/ +static void codeOffset( + Vdbe *v, /* Generate code into this VM */ + int iOffset, /* Register holding the offset counter */ + int iContinue /* Jump here to skip the current record */ +){ + if( iOffset>0 ){ + sqlite3VdbeAddOp3(v, OP_IfPos, iOffset, iContinue, 1); VdbeCoverage(v); + VdbeComment((v, "OFFSET")); + } +} + +/* +** Add code that will check to make sure the N registers starting at iMem +** form a distinct entry. iTab is a sorting index that holds previously +** seen combinations of the N values. A new entry is made in iTab +** if the current N values are new. +** +** A jump to addrRepeat is made and the N+1 values are popped from the +** stack if the top N elements are not distinct. +*/ +static void codeDistinct( + Parse *pParse, /* Parsing and code generating context */ + int iTab, /* A sorting index used to test for distinctness */ + int addrRepeat, /* Jump to here if not distinct */ + int N, /* Number of elements */ + int iMem /* First element */ +){ + Vdbe *v; + int r1; + + v = pParse->pVdbe; + r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1); + sqlite3VdbeAddOp2(v, OP_IdxInsert, iTab, r1); + sqlite3ReleaseTempReg(pParse, r1); +} + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Generate an error message when a SELECT is used within a subexpression +** (example: "a IN (SELECT * FROM table)") but it has more than 1 result +** column. We do this in a subroutine because the error used to occur +** in multiple places. (The error only occurs in one place now, but we +** retain the subroutine to minimize code disruption.) +*/ +static int checkForMultiColumnSelectError( + Parse *pParse, /* Parse context. */ + SelectDest *pDest, /* Destination of SELECT results */ + int nExpr /* Number of result columns returned by SELECT */ +){ + int eDest = pDest->eDest; + if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){ + sqlite3ErrorMsg(pParse, "only a single result allowed for " + "a SELECT that is part of an expression"); + return 1; + }else{ + return 0; + } +} +#endif + +/* +** This routine generates the code for the inside of the inner loop +** of a SELECT. +** +** If srcTab is negative, then the pEList expressions +** are evaluated in order to get the data for this row. If srcTab is +** zero or more, then data is pulled from srcTab and pEList is used only +** to get number columns and the datatype for each column. +*/ +static void selectInnerLoop( + Parse *pParse, /* The parser context */ + Select *p, /* The complete select statement being coded */ + ExprList *pEList, /* List of values being extracted */ + int srcTab, /* Pull data from this table */ + SortCtx *pSort, /* If not NULL, info on how to process ORDER BY */ + DistinctCtx *pDistinct, /* If not NULL, info on how to process DISTINCT */ + SelectDest *pDest, /* How to dispose of the results */ + int iContinue, /* Jump here to continue with next row */ + int iBreak /* Jump here to break out of the inner loop */ +){ + Vdbe *v = pParse->pVdbe; + int i; + int hasDistinct; /* True if the DISTINCT keyword is present */ + int regResult; /* Start of memory holding result set */ + int eDest = pDest->eDest; /* How to dispose of results */ + int iParm = pDest->iSDParm; /* First argument to disposal method */ + int nResultCol; /* Number of result columns */ + int nPrefixReg = 0; /* Number of extra registers before regResult */ + + assert( v ); + assert( pEList!=0 ); + hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP; + if( pSort && pSort->pOrderBy==0 ) pSort = 0; + if( pSort==0 && !hasDistinct ){ + assert( iContinue!=0 ); + codeOffset(v, p->iOffset, iContinue); + } + + /* Pull the requested columns. + */ + nResultCol = pEList->nExpr; + + if( pDest->iSdst==0 ){ + if( pSort ){ + nPrefixReg = pSort->pOrderBy->nExpr; + if( !(pSort->sortFlags & SORTFLAG_UseSorter) ) nPrefixReg++; + pParse->nMem += nPrefixReg; + } + pDest->iSdst = pParse->nMem+1; + pParse->nMem += nResultCol; + }else if( pDest->iSdst+nResultCol > pParse->nMem ){ + /* This is an error condition that can result, for example, when a SELECT + ** on the right-hand side of an INSERT contains more result columns than + ** there are columns in the table on the left. The error will be caught + ** and reported later. But we need to make sure enough memory is allocated + ** to avoid other spurious errors in the meantime. */ + pParse->nMem += nResultCol; + } + pDest->nSdst = nResultCol; + regResult = pDest->iSdst; + if( srcTab>=0 ){ + for(i=0; ia[i].zName)); + } + }else if( eDest!=SRT_Exists ){ + /* If the destination is an EXISTS(...) expression, the actual + ** values returned by the SELECT are not required. + */ + u8 ecelFlags; + if( eDest==SRT_Mem || eDest==SRT_Output || eDest==SRT_Coroutine ){ + ecelFlags = SQLITE_ECEL_DUP; + }else{ + ecelFlags = 0; + } + sqlite3ExprCodeExprList(pParse, pEList, regResult, 0, ecelFlags); + } + + /* If the DISTINCT keyword was present on the SELECT statement + ** and this row has been seen before, then do not make this row + ** part of the result. + */ + if( hasDistinct ){ + switch( pDistinct->eTnctType ){ + case WHERE_DISTINCT_ORDERED: { + VdbeOp *pOp; /* No longer required OpenEphemeral instr. */ + int iJump; /* Jump destination */ + int regPrev; /* Previous row content */ + + /* Allocate space for the previous row */ + regPrev = pParse->nMem+1; + pParse->nMem += nResultCol; + + /* Change the OP_OpenEphemeral coded earlier to an OP_Null + ** sets the MEM_Cleared bit on the first register of the + ** previous value. This will cause the OP_Ne below to always + ** fail on the first iteration of the loop even if the first + ** row is all NULLs. + */ + sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct); + pOp = sqlite3VdbeGetOp(v, pDistinct->addrTnct); + pOp->opcode = OP_Null; + pOp->p1 = 1; + pOp->p2 = regPrev; + + iJump = sqlite3VdbeCurrentAddr(v) + nResultCol; + for(i=0; ia[i].pExpr); + if( idb->mallocFailed ); + sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nResultCol-1); + break; + } + + case WHERE_DISTINCT_UNIQUE: { + sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct); + break; + } + + default: { + assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED ); + codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol, + regResult); + break; + } + } + if( pSort==0 ){ + codeOffset(v, p->iOffset, iContinue); + } + } + + switch( eDest ){ + /* In this mode, write each query result to the key of the temporary + ** table iParm. + */ +#ifndef SQLITE_OMIT_COMPOUND_SELECT + case SRT_Union: { + int r1; + r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1); + sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1); + sqlite3ReleaseTempReg(pParse, r1); + break; + } + + /* Construct a record from the query result, but instead of + ** saving that record, use it as a key to delete elements from + ** the temporary table iParm. + */ + case SRT_Except: { + sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol); + break; + } +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + + /* Store the result as data using a unique key. + */ + case SRT_Fifo: + case SRT_DistFifo: + case SRT_Table: + case SRT_EphemTab: { + int r1 = sqlite3GetTempRange(pParse, nPrefixReg+1); + testcase( eDest==SRT_Table ); + testcase( eDest==SRT_EphemTab ); + testcase( eDest==SRT_Fifo ); + testcase( eDest==SRT_DistFifo ); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg); +#ifndef SQLITE_OMIT_CTE + if( eDest==SRT_DistFifo ){ + /* If the destination is DistFifo, then cursor (iParm+1) is open + ** on an ephemeral index. If the current row is already present + ** in the index, do not write it to the output. If not, add the + ** current row to the index and proceed with writing it to the + ** output table as well. */ + int addr = sqlite3VdbeCurrentAddr(v) + 4; + sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0); + VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r1); + assert( pSort==0 ); + } +#endif + if( pSort ){ + pushOntoSorter(pParse, pSort, p, r1+nPrefixReg,regResult,1,nPrefixReg); + }else{ + int r2 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2); + sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3ReleaseTempReg(pParse, r2); + } + sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1); + break; + } + +#ifndef SQLITE_OMIT_SUBQUERY + /* If we are creating a set for an "expr IN (SELECT ...)" construct, + ** then there should be a single item on the stack. Write this + ** item into the set table with bogus data. + */ + case SRT_Set: { + assert( nResultCol==1 ); + pDest->affSdst = + sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affSdst); + if( pSort ){ + /* At first glance you would think we could optimize out the + ** ORDER BY in this case since the order of entries in the set + ** does not matter. But there might be a LIMIT clause, in which + ** case the order does matter */ + pushOntoSorter(pParse, pSort, p, regResult, regResult, 1, nPrefixReg); + }else{ + int r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult,1,r1, &pDest->affSdst, 1); + sqlite3ExprCacheAffinityChange(pParse, regResult, 1); + sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1); + sqlite3ReleaseTempReg(pParse, r1); + } + break; + } + + /* If any row exist in the result set, record that fact and abort. + */ + case SRT_Exists: { + sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm); + /* The LIMIT clause will terminate the loop for us */ + break; + } + + /* If this is a scalar select that is part of an expression, then + ** store the results in the appropriate memory cell and break out + ** of the scan loop. + */ + case SRT_Mem: { + assert( nResultCol==1 ); + if( pSort ){ + pushOntoSorter(pParse, pSort, p, regResult, regResult, 1, nPrefixReg); + }else{ + assert( regResult==iParm ); + /* The LIMIT clause will jump out of the loop for us */ + } + break; + } +#endif /* #ifndef SQLITE_OMIT_SUBQUERY */ + + case SRT_Coroutine: /* Send data to a co-routine */ + case SRT_Output: { /* Return the results */ + testcase( eDest==SRT_Coroutine ); + testcase( eDest==SRT_Output ); + if( pSort ){ + pushOntoSorter(pParse, pSort, p, regResult, regResult, nResultCol, + nPrefixReg); + }else if( eDest==SRT_Coroutine ){ + sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm); + }else{ + sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol); + sqlite3ExprCacheAffinityChange(pParse, regResult, nResultCol); + } + break; + } + +#ifndef SQLITE_OMIT_CTE + /* Write the results into a priority queue that is order according to + ** pDest->pOrderBy (in pSO). pDest->iSDParm (in iParm) is the cursor for an + ** index with pSO->nExpr+2 columns. Build a key using pSO for the first + ** pSO->nExpr columns, then make sure all keys are unique by adding a + ** final OP_Sequence column. The last column is the record as a blob. + */ + case SRT_DistQueue: + case SRT_Queue: { + int nKey; + int r1, r2, r3; + int addrTest = 0; + ExprList *pSO; + pSO = pDest->pOrderBy; + assert( pSO ); + nKey = pSO->nExpr; + r1 = sqlite3GetTempReg(pParse); + r2 = sqlite3GetTempRange(pParse, nKey+2); + r3 = r2+nKey+1; + if( eDest==SRT_DistQueue ){ + /* If the destination is DistQueue, then cursor (iParm+1) is open + ** on a second ephemeral index that holds all values every previously + ** added to the queue. */ + addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0, + regResult, nResultCol); + VdbeCoverage(v); + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3); + if( eDest==SRT_DistQueue ){ + sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + } + for(i=0; ia[i].u.x.iOrderByCol - 1, + r2+i); + } + sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey); + sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1); + sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1); + if( addrTest ) sqlite3VdbeJumpHere(v, addrTest); + sqlite3ReleaseTempReg(pParse, r1); + sqlite3ReleaseTempRange(pParse, r2, nKey+2); + break; + } +#endif /* SQLITE_OMIT_CTE */ + + + +#if !defined(SQLITE_OMIT_TRIGGER) + /* Discard the results. This is used for SELECT statements inside + ** the body of a TRIGGER. The purpose of such selects is to call + ** user-defined functions that have side effects. We do not care + ** about the actual results of the select. + */ + default: { + assert( eDest==SRT_Discard ); + break; + } +#endif + } + + /* Jump to the end of the loop if the LIMIT is reached. Except, if + ** there is a sorter, in which case the sorter has already limited + ** the output for us. + */ + if( pSort==0 && p->iLimit ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v); + } +} + +/* +** Allocate a KeyInfo object sufficient for an index of N key columns and +** X extra columns. +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){ + KeyInfo *p = sqlite3DbMallocZero(0, + sizeof(KeyInfo) + (N+X)*(sizeof(CollSeq*)+1)); + if( p ){ + p->aSortOrder = (u8*)&p->aColl[N+X]; + p->nField = (u16)N; + p->nXField = (u16)X; + p->enc = ENC(db); + p->db = db; + p->nRef = 1; + }else{ + db->mallocFailed = 1; + } + return p; +} + +/* +** Deallocate a KeyInfo object +*/ +SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo *p){ + if( p ){ + assert( p->nRef>0 ); + p->nRef--; + if( p->nRef==0 ) sqlite3DbFree(0, p); + } +} + +/* +** Make a new pointer to a KeyInfo object +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo *p){ + if( p ){ + assert( p->nRef>0 ); + p->nRef++; + } + return p; +} + +#ifdef SQLITE_DEBUG +/* +** Return TRUE if a KeyInfo object can be change. The KeyInfo object +** can only be changed if this is just a single reference to the object. +** +** This routine is used only inside of assert() statements. +*/ +SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; } +#endif /* SQLITE_DEBUG */ + +/* +** Given an expression list, generate a KeyInfo structure that records +** the collating sequence for each expression in that expression list. +** +** If the ExprList is an ORDER BY or GROUP BY clause then the resulting +** KeyInfo structure is appropriate for initializing a virtual index to +** implement that clause. If the ExprList is the result set of a SELECT +** then the KeyInfo structure is appropriate for initializing a virtual +** index to implement a DISTINCT test. +** +** Space to hold the KeyInfo structure is obtained from malloc. The calling +** function is responsible for seeing that this structure is eventually +** freed. +*/ +static KeyInfo *keyInfoFromExprList( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* Form the KeyInfo object from this ExprList */ + int iStart, /* Begin with this column of pList */ + int nExtra /* Add this many extra columns to the end */ +){ + int nExpr; + KeyInfo *pInfo; + struct ExprList_item *pItem; + sqlite3 *db = pParse->db; + int i; + + nExpr = pList->nExpr; + pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1); + if( pInfo ){ + assert( sqlite3KeyInfoIsWriteable(pInfo) ); + for(i=iStart, pItem=pList->a+iStart; ipExpr); + if( !pColl ) pColl = db->pDfltColl; + pInfo->aColl[i-iStart] = pColl; + pInfo->aSortOrder[i-iStart] = pItem->sortOrder; + } + } + return pInfo; +} + +/* +** Name of the connection operator, used for error messages. +*/ +static const char *selectOpName(int id){ + char *z; + switch( id ){ + case TK_ALL: z = "UNION ALL"; break; + case TK_INTERSECT: z = "INTERSECT"; break; + case TK_EXCEPT: z = "EXCEPT"; break; + default: z = "UNION"; break; + } + return z; +} + +#ifndef SQLITE_OMIT_EXPLAIN +/* +** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function +** is a no-op. Otherwise, it adds a single row of output to the EQP result, +** where the caption is of the form: +** +** "USE TEMP B-TREE FOR xxx" +** +** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which +** is determined by the zUsage argument. +*/ +static void explainTempTable(Parse *pParse, const char *zUsage){ + if( pParse->explain==2 ){ + Vdbe *v = pParse->pVdbe; + char *zMsg = sqlite3MPrintf(pParse->db, "USE TEMP B-TREE FOR %s", zUsage); + sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC); + } +} + +/* +** Assign expression b to lvalue a. A second, no-op, version of this macro +** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code +** in sqlite3Select() to assign values to structure member variables that +** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the +** code with #ifndef directives. +*/ +# define explainSetInteger(a, b) a = b + +#else +/* No-op versions of the explainXXX() functions and macros. */ +# define explainTempTable(y,z) +# define explainSetInteger(y,z) +#endif + +#if !defined(SQLITE_OMIT_EXPLAIN) && !defined(SQLITE_OMIT_COMPOUND_SELECT) +/* +** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function +** is a no-op. Otherwise, it adds a single row of output to the EQP result, +** where the caption is of one of the two forms: +** +** "COMPOSITE SUBQUERIES iSub1 and iSub2 (op)" +** "COMPOSITE SUBQUERIES iSub1 and iSub2 USING TEMP B-TREE (op)" +** +** where iSub1 and iSub2 are the integers passed as the corresponding +** function parameters, and op is the text representation of the parameter +** of the same name. The parameter "op" must be one of TK_UNION, TK_EXCEPT, +** TK_INTERSECT or TK_ALL. The first form is used if argument bUseTmp is +** false, or the second form if it is true. +*/ +static void explainComposite( + Parse *pParse, /* Parse context */ + int op, /* One of TK_UNION, TK_EXCEPT etc. */ + int iSub1, /* Subquery id 1 */ + int iSub2, /* Subquery id 2 */ + int bUseTmp /* True if a temp table was used */ +){ + assert( op==TK_UNION || op==TK_EXCEPT || op==TK_INTERSECT || op==TK_ALL ); + if( pParse->explain==2 ){ + Vdbe *v = pParse->pVdbe; + char *zMsg = sqlite3MPrintf( + pParse->db, "COMPOUND SUBQUERIES %d AND %d %s(%s)", iSub1, iSub2, + bUseTmp?"USING TEMP B-TREE ":"", selectOpName(op) + ); + sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC); + } +} +#else +/* No-op versions of the explainXXX() functions and macros. */ +# define explainComposite(v,w,x,y,z) +#endif + +/* +** If the inner loop was generated using a non-null pOrderBy argument, +** then the results were placed in a sorter. After the loop is terminated +** we need to run the sorter and output the results. The following +** routine generates the code needed to do that. +*/ +static void generateSortTail( + Parse *pParse, /* Parsing context */ + Select *p, /* The SELECT statement */ + SortCtx *pSort, /* Information on the ORDER BY clause */ + int nColumn, /* Number of columns of data */ + SelectDest *pDest /* Write the sorted results here */ +){ + Vdbe *v = pParse->pVdbe; /* The prepared statement */ + int addrBreak = sqlite3VdbeMakeLabel(v); /* Jump here to exit loop */ + int addrContinue = sqlite3VdbeMakeLabel(v); /* Jump here for next cycle */ + int addr; + int addrOnce = 0; + int iTab; + ExprList *pOrderBy = pSort->pOrderBy; + int eDest = pDest->eDest; + int iParm = pDest->iSDParm; + int regRow; + int regRowid; + int nKey; + int iSortTab; /* Sorter cursor to read from */ + int nSortData; /* Trailing values to read from sorter */ + int i; + int bSeq; /* True if sorter record includes seq. no. */ +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + struct ExprList_item *aOutEx = p->pEList->a; +#endif + + if( pSort->labelBkOut ){ + sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut); + sqlite3VdbeGoto(v, addrBreak); + sqlite3VdbeResolveLabel(v, pSort->labelBkOut); + } + iTab = pSort->iECursor; + if( eDest==SRT_Output || eDest==SRT_Coroutine ){ + regRowid = 0; + regRow = pDest->iSdst; + nSortData = nColumn; + }else{ + regRowid = sqlite3GetTempReg(pParse); + regRow = sqlite3GetTempReg(pParse); + nSortData = 1; + } + nKey = pOrderBy->nExpr - pSort->nOBSat; + if( pSort->sortFlags & SORTFLAG_UseSorter ){ + int regSortOut = ++pParse->nMem; + iSortTab = pParse->nTab++; + if( pSort->labelBkOut ){ + addrOnce = sqlite3CodeOnce(pParse); VdbeCoverage(v); + } + sqlite3VdbeAddOp3(v, OP_OpenPseudo, iSortTab, regSortOut, nKey+1+nSortData); + if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce); + addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak); + VdbeCoverage(v); + codeOffset(v, p->iOffset, addrContinue); + sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab); + bSeq = 0; + }else{ + addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v); + codeOffset(v, p->iOffset, addrContinue); + iSortTab = iTab; + bSeq = 1; + } + for(i=0; iaffSdst, 1); + sqlite3ExprCacheAffinityChange(pParse, regRow, 1); + sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, regRowid); + break; + } + case SRT_Mem: { + assert( nColumn==1 ); + sqlite3ExprCodeMove(pParse, regRow, iParm, 1); + /* The LIMIT clause will terminate the loop for us */ + break; + } +#endif + default: { + assert( eDest==SRT_Output || eDest==SRT_Coroutine ); + testcase( eDest==SRT_Output ); + testcase( eDest==SRT_Coroutine ); + if( eDest==SRT_Output ){ + sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn); + sqlite3ExprCacheAffinityChange(pParse, pDest->iSdst, nColumn); + }else{ + sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm); + } + break; + } + } + if( regRowid ){ + sqlite3ReleaseTempReg(pParse, regRow); + sqlite3ReleaseTempReg(pParse, regRowid); + } + /* The bottom of the loop + */ + sqlite3VdbeResolveLabel(v, addrContinue); + if( pSort->sortFlags & SORTFLAG_UseSorter ){ + sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v); + }else{ + sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v); + } + if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn); + sqlite3VdbeResolveLabel(v, addrBreak); +} + +/* +** Return a pointer to a string containing the 'declaration type' of the +** expression pExpr. The string may be treated as static by the caller. +** +** Also try to estimate the size of the returned value and return that +** result in *pEstWidth. +** +** The declaration type is the exact datatype definition extracted from the +** original CREATE TABLE statement if the expression is a column. The +** declaration type for a ROWID field is INTEGER. Exactly when an expression +** is considered a column can be complex in the presence of subqueries. The +** result-set expression in all of the following SELECT statements is +** considered a column by this function. +** +** SELECT col FROM tbl; +** SELECT (SELECT col FROM tbl; +** SELECT (SELECT col FROM tbl); +** SELECT abc FROM (SELECT col AS abc FROM tbl); +** +** The declaration type for any expression other than a column is NULL. +** +** This routine has either 3 or 6 parameters depending on whether or not +** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used. +*/ +#ifdef SQLITE_ENABLE_COLUMN_METADATA +# define columnType(A,B,C,D,E,F) columnTypeImpl(A,B,C,D,E,F) +#else /* if !defined(SQLITE_ENABLE_COLUMN_METADATA) */ +# define columnType(A,B,C,D,E,F) columnTypeImpl(A,B,F) +#endif +static const char *columnTypeImpl( + NameContext *pNC, + Expr *pExpr, +#ifdef SQLITE_ENABLE_COLUMN_METADATA + const char **pzOrigDb, + const char **pzOrigTab, + const char **pzOrigCol, +#endif + u8 *pEstWidth +){ + char const *zType = 0; + int j; + u8 estWidth = 1; +#ifdef SQLITE_ENABLE_COLUMN_METADATA + char const *zOrigDb = 0; + char const *zOrigTab = 0; + char const *zOrigCol = 0; +#endif + + if( NEVER(pExpr==0) || pNC->pSrcList==0 ) return 0; + switch( pExpr->op ){ + case TK_AGG_COLUMN: + case TK_COLUMN: { + /* The expression is a column. Locate the table the column is being + ** extracted from in NameContext.pSrcList. This table may be real + ** database table or a subquery. + */ + Table *pTab = 0; /* Table structure column is extracted from */ + Select *pS = 0; /* Select the column is extracted from */ + int iCol = pExpr->iColumn; /* Index of column in pTab */ + testcase( pExpr->op==TK_AGG_COLUMN ); + testcase( pExpr->op==TK_COLUMN ); + while( pNC && !pTab ){ + SrcList *pTabList = pNC->pSrcList; + for(j=0;jnSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++); + if( jnSrc ){ + pTab = pTabList->a[j].pTab; + pS = pTabList->a[j].pSelect; + }else{ + pNC = pNC->pNext; + } + } + + if( pTab==0 ){ + /* At one time, code such as "SELECT new.x" within a trigger would + ** cause this condition to run. Since then, we have restructured how + ** trigger code is generated and so this condition is no longer + ** possible. However, it can still be true for statements like + ** the following: + ** + ** CREATE TABLE t1(col INTEGER); + ** SELECT (SELECT t1.col) FROM FROM t1; + ** + ** when columnType() is called on the expression "t1.col" in the + ** sub-select. In this case, set the column type to NULL, even + ** though it should really be "INTEGER". + ** + ** This is not a problem, as the column type of "t1.col" is never + ** used. When columnType() is called on the expression + ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT + ** branch below. */ + break; + } + + assert( pTab && pExpr->pTab==pTab ); + if( pS ){ + /* The "table" is actually a sub-select or a view in the FROM clause + ** of the SELECT statement. Return the declaration type and origin + ** data for the result-set column of the sub-select. + */ + if( iCol>=0 && ALWAYS(iColpEList->nExpr) ){ + /* If iCol is less than zero, then the expression requests the + ** rowid of the sub-select or view. This expression is legal (see + ** test case misc2.2.2) - it always evaluates to NULL. + ** + ** The ALWAYS() is because iCol>=pS->pEList->nExpr will have been + ** caught already by name resolution. + */ + NameContext sNC; + Expr *p = pS->pEList->a[iCol].pExpr; + sNC.pSrcList = pS->pSrc; + sNC.pNext = pNC; + sNC.pParse = pNC->pParse; + zType = columnType(&sNC, p,&zOrigDb,&zOrigTab,&zOrigCol, &estWidth); + } + }else if( pTab->pSchema ){ + /* A real table */ + assert( !pS ); + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==-1 || (iCol>=0 && iColnCol) ); +#ifdef SQLITE_ENABLE_COLUMN_METADATA + if( iCol<0 ){ + zType = "INTEGER"; + zOrigCol = "rowid"; + }else{ + zType = pTab->aCol[iCol].zType; + zOrigCol = pTab->aCol[iCol].zName; + estWidth = pTab->aCol[iCol].szEst; + } + zOrigTab = pTab->zName; + if( pNC->pParse ){ + int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema); + zOrigDb = pNC->pParse->db->aDb[iDb].zName; + } +#else + if( iCol<0 ){ + zType = "INTEGER"; + }else{ + zType = pTab->aCol[iCol].zType; + estWidth = pTab->aCol[iCol].szEst; + } +#endif + } + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: { + /* The expression is a sub-select. Return the declaration type and + ** origin info for the single column in the result set of the SELECT + ** statement. + */ + NameContext sNC; + Select *pS = pExpr->x.pSelect; + Expr *p = pS->pEList->a[0].pExpr; + assert( ExprHasProperty(pExpr, EP_xIsSelect) ); + sNC.pSrcList = pS->pSrc; + sNC.pNext = pNC; + sNC.pParse = pNC->pParse; + zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol, &estWidth); + break; + } +#endif + } + +#ifdef SQLITE_ENABLE_COLUMN_METADATA + if( pzOrigDb ){ + assert( pzOrigTab && pzOrigCol ); + *pzOrigDb = zOrigDb; + *pzOrigTab = zOrigTab; + *pzOrigCol = zOrigCol; + } +#endif + if( pEstWidth ) *pEstWidth = estWidth; + return zType; +} + +/* +** Generate code that will tell the VDBE the declaration types of columns +** in the result set. +*/ +static void generateColumnTypes( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* List of tables */ + ExprList *pEList /* Expressions defining the result set */ +){ +#ifndef SQLITE_OMIT_DECLTYPE + Vdbe *v = pParse->pVdbe; + int i; + NameContext sNC; + sNC.pSrcList = pTabList; + sNC.pParse = pParse; + for(i=0; inExpr; i++){ + Expr *p = pEList->a[i].pExpr; + const char *zType; +#ifdef SQLITE_ENABLE_COLUMN_METADATA + const char *zOrigDb = 0; + const char *zOrigTab = 0; + const char *zOrigCol = 0; + zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol, 0); + + /* The vdbe must make its own copy of the column-type and other + ** column specific strings, in case the schema is reset before this + ** virtual machine is deleted. + */ + sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT); +#else + zType = columnType(&sNC, p, 0, 0, 0, 0); +#endif + sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLITE_TRANSIENT); + } +#endif /* !defined(SQLITE_OMIT_DECLTYPE) */ +} + +/* +** Generate code that will tell the VDBE the names of columns +** in the result set. This information is used to provide the +** azCol[] values in the callback. +*/ +static void generateColumnNames( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* List of tables */ + ExprList *pEList /* Expressions defining the result set */ +){ + Vdbe *v = pParse->pVdbe; + int i, j; + sqlite3 *db = pParse->db; + int fullNames, shortNames; + +#ifndef SQLITE_OMIT_EXPLAIN + /* If this is an EXPLAIN, skip this step */ + if( pParse->explain ){ + return; + } +#endif + + if( pParse->colNamesSet || NEVER(v==0) || db->mallocFailed ) return; + pParse->colNamesSet = 1; + fullNames = (db->flags & SQLITE_FullColNames)!=0; + shortNames = (db->flags & SQLITE_ShortColNames)!=0; + sqlite3VdbeSetNumCols(v, pEList->nExpr); + for(i=0; inExpr; i++){ + Expr *p; + p = pEList->a[i].pExpr; + if( NEVER(p==0) ) continue; + if( pEList->a[i].zName ){ + char *zName = pEList->a[i].zName; + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT); + }else if( (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN) && pTabList ){ + Table *pTab; + char *zCol; + int iCol = p->iColumn; + for(j=0; ALWAYS(jnSrc); j++){ + if( pTabList->a[j].iCursor==p->iTable ) break; + } + assert( jnSrc ); + pTab = pTabList->a[j].pTab; + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==-1 || (iCol>=0 && iColnCol) ); + if( iCol<0 ){ + zCol = "rowid"; + }else{ + zCol = pTab->aCol[iCol].zName; + } + if( !shortNames && !fullNames ){ + sqlite3VdbeSetColName(v, i, COLNAME_NAME, + sqlite3DbStrDup(db, pEList->a[i].zSpan), SQLITE_DYNAMIC); + }else if( fullNames ){ + char *zName = 0; + zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC); + }else{ + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT); + } + }else{ + const char *z = pEList->a[i].zSpan; + z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC); + } + } + generateColumnTypes(pParse, pTabList, pEList); +} + +/* +** Given an expression list (which is really the list of expressions +** that form the result set of a SELECT statement) compute appropriate +** column names for a table that would hold the expression list. +** +** All column names will be unique. +** +** Only the column names are computed. Column.zType, Column.zColl, +** and other fields of Column are zeroed. +** +** Return SQLITE_OK on success. If a memory allocation error occurs, +** store NULL in *paCol and 0 in *pnCol and return SQLITE_NOMEM. +*/ +SQLITE_PRIVATE int sqlite3ColumnsFromExprList( + Parse *pParse, /* Parsing context */ + ExprList *pEList, /* Expr list from which to derive column names */ + i16 *pnCol, /* Write the number of columns here */ + Column **paCol /* Write the new column list here */ +){ + sqlite3 *db = pParse->db; /* Database connection */ + int i, j; /* Loop counters */ + int cnt; /* Index added to make the name unique */ + Column *aCol, *pCol; /* For looping over result columns */ + int nCol; /* Number of columns in the result set */ + Expr *p; /* Expression for a single result column */ + char *zName; /* Column name */ + int nName; /* Size of name in zName[] */ + + if( pEList ){ + nCol = pEList->nExpr; + aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol); + testcase( aCol==0 ); + }else{ + nCol = 0; + aCol = 0; + } + *pnCol = nCol; + *paCol = aCol; + + for(i=0, pCol=aCol; ia[i].pExpr); + if( (zName = pEList->a[i].zName)!=0 ){ + /* If the column contains an "AS " phrase, use as the name */ + zName = sqlite3DbStrDup(db, zName); + }else{ + Expr *pColExpr = p; /* The expression that is the result column name */ + Table *pTab; /* Table associated with this expression */ + while( pColExpr->op==TK_DOT ){ + pColExpr = pColExpr->pRight; + assert( pColExpr!=0 ); + } + if( pColExpr->op==TK_COLUMN && ALWAYS(pColExpr->pTab!=0) ){ + /* For columns use the column name name */ + int iCol = pColExpr->iColumn; + pTab = pColExpr->pTab; + if( iCol<0 ) iCol = pTab->iPKey; + zName = sqlite3MPrintf(db, "%s", + iCol>=0 ? pTab->aCol[iCol].zName : "rowid"); + }else if( pColExpr->op==TK_ID ){ + assert( !ExprHasProperty(pColExpr, EP_IntValue) ); + zName = sqlite3MPrintf(db, "%s", pColExpr->u.zToken); + }else{ + /* Use the original text of the column expression as its name */ + zName = sqlite3MPrintf(db, "%s", pEList->a[i].zSpan); + } + } + if( db->mallocFailed ){ + sqlite3DbFree(db, zName); + break; + } + + /* Make sure the column name is unique. If the name is not unique, + ** append an integer to the name so that it becomes unique. + */ + nName = sqlite3Strlen30(zName); + for(j=cnt=0; j1 && sqlite3Isdigit(zName[k]); k--){} + if( k>=0 && zName[k]==':' ) nName = k; + zName[nName] = 0; + zNewName = sqlite3MPrintf(db, "%s:%d", zName, ++cnt); + sqlite3DbFree(db, zName); + zName = zNewName; + j = -1; + if( zName==0 ) break; + } + } + pCol->zName = zName; + } + if( db->mallocFailed ){ + for(j=0; jdb; + NameContext sNC; + Column *pCol; + CollSeq *pColl; + int i; + Expr *p; + struct ExprList_item *a; + u64 szAll = 0; + + assert( pSelect!=0 ); + assert( (pSelect->selFlags & SF_Resolved)!=0 ); + assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed ); + if( db->mallocFailed ) return; + memset(&sNC, 0, sizeof(sNC)); + sNC.pSrcList = pSelect->pSrc; + a = pSelect->pEList->a; + for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ + p = a[i].pExpr; + if( pCol->zType==0 ){ + pCol->zType = sqlite3DbStrDup(db, + columnType(&sNC, p,0,0,0, &pCol->szEst)); + } + szAll += pCol->szEst; + pCol->affinity = sqlite3ExprAffinity(p); + if( pCol->affinity==0 ) pCol->affinity = SQLITE_AFF_BLOB; + pColl = sqlite3ExprCollSeq(pParse, p); + if( pColl && pCol->zColl==0 ){ + pCol->zColl = sqlite3DbStrDup(db, pColl->zName); + } + } + pTab->szTabRow = sqlite3LogEst(szAll*4); +} + +/* +** Given a SELECT statement, generate a Table structure that describes +** the result set of that SELECT. +*/ +SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect){ + Table *pTab; + sqlite3 *db = pParse->db; + int savedFlags; + + savedFlags = db->flags; + db->flags &= ~SQLITE_FullColNames; + db->flags |= SQLITE_ShortColNames; + sqlite3SelectPrep(pParse, pSelect, 0); + if( pParse->nErr ) return 0; + while( pSelect->pPrior ) pSelect = pSelect->pPrior; + db->flags = savedFlags; + pTab = sqlite3DbMallocZero(db, sizeof(Table) ); + if( pTab==0 ){ + return 0; + } + /* The sqlite3ResultSetOfSelect() is only used n contexts where lookaside + ** is disabled */ + assert( db->lookaside.bEnabled==0 ); + pTab->nRef = 1; + pTab->zName = 0; + pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); + sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol); + selectAddColumnTypeAndCollation(pParse, pTab, pSelect); + pTab->iPKey = -1; + if( db->mallocFailed ){ + sqlite3DeleteTable(db, pTab); + return 0; + } + return pTab; +} + +/* +** Get a VDBE for the given parser context. Create a new one if necessary. +** If an error occurs, return NULL and leave a message in pParse. +*/ +SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){ + Vdbe *v = pParse->pVdbe; + if( v==0 ){ + v = pParse->pVdbe = sqlite3VdbeCreate(pParse); + if( v ) sqlite3VdbeAddOp0(v, OP_Init); + if( pParse->pToplevel==0 + && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst) + ){ + pParse->okConstFactor = 1; + } + + } + return v; +} + + +/* +** Compute the iLimit and iOffset fields of the SELECT based on the +** pLimit and pOffset expressions. pLimit and pOffset hold the expressions +** that appear in the original SQL statement after the LIMIT and OFFSET +** keywords. Or NULL if those keywords are omitted. iLimit and iOffset +** are the integer memory register numbers for counters used to compute +** the limit and offset. If there is no limit and/or offset, then +** iLimit and iOffset are negative. +** +** This routine changes the values of iLimit and iOffset only if +** a limit or offset is defined by pLimit and pOffset. iLimit and +** iOffset should have been preset to appropriate default values (zero) +** prior to calling this routine. +** +** The iOffset register (if it exists) is initialized to the value +** of the OFFSET. The iLimit register is initialized to LIMIT. Register +** iOffset+1 is initialized to LIMIT+OFFSET. +** +** Only if pLimit!=0 or pOffset!=0 do the limit registers get +** redefined. The UNION ALL operator uses this property to force +** the reuse of the same limit and offset registers across multiple +** SELECT statements. +*/ +static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){ + Vdbe *v = 0; + int iLimit = 0; + int iOffset; + int n; + if( p->iLimit ) return; + + /* + ** "LIMIT -1" always shows all rows. There is some + ** controversy about what the correct behavior should be. + ** The current implementation interprets "LIMIT 0" to mean + ** no rows. + */ + sqlite3ExprCacheClear(pParse); + assert( p->pOffset==0 || p->pLimit!=0 ); + if( p->pLimit ){ + p->iLimit = iLimit = ++pParse->nMem; + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + if( sqlite3ExprIsInteger(p->pLimit, &n) ){ + sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit); + VdbeComment((v, "LIMIT counter")); + if( n==0 ){ + sqlite3VdbeGoto(v, iBreak); + }else if( n>=0 && p->nSelectRow>(u64)n ){ + p->nSelectRow = n; + } + }else{ + sqlite3ExprCode(pParse, p->pLimit, iLimit); + sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v); + VdbeComment((v, "LIMIT counter")); + sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v); + } + if( p->pOffset ){ + p->iOffset = iOffset = ++pParse->nMem; + pParse->nMem++; /* Allocate an extra register for limit+offset */ + sqlite3ExprCode(pParse, p->pOffset, iOffset); + sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v); + VdbeComment((v, "OFFSET counter")); + sqlite3VdbeAddOp3(v, OP_SetIfNotPos, iOffset, iOffset, 0); + sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1); + VdbeComment((v, "LIMIT+OFFSET")); + sqlite3VdbeAddOp3(v, OP_SetIfNotPos, iLimit, iOffset+1, -1); + } + } +} + +#ifndef SQLITE_OMIT_COMPOUND_SELECT +/* +** Return the appropriate collating sequence for the iCol-th column of +** the result set for the compound-select statement "p". Return NULL if +** the column has no default collating sequence. +** +** The collating sequence for the compound select is taken from the +** left-most term of the select that has a collating sequence. +*/ +static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){ + CollSeq *pRet; + if( p->pPrior ){ + pRet = multiSelectCollSeq(pParse, p->pPrior, iCol); + }else{ + pRet = 0; + } + assert( iCol>=0 ); + /* iCol must be less than p->pEList->nExpr. Otherwise an error would + ** have been thrown during name resolution and we would not have gotten + ** this far */ + if( pRet==0 && ALWAYS(iColpEList->nExpr) ){ + pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr); + } + return pRet; +} + +/* +** The select statement passed as the second parameter is a compound SELECT +** with an ORDER BY clause. This function allocates and returns a KeyInfo +** structure suitable for implementing the ORDER BY. +** +** Space to hold the KeyInfo structure is obtained from malloc. The calling +** function is responsible for ensuring that this structure is eventually +** freed. +*/ +static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){ + ExprList *pOrderBy = p->pOrderBy; + int nOrderBy = p->pOrderBy->nExpr; + sqlite3 *db = pParse->db; + KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1); + if( pRet ){ + int i; + for(i=0; ia[i]; + Expr *pTerm = pItem->pExpr; + CollSeq *pColl; + + if( pTerm->flags & EP_Collate ){ + pColl = sqlite3ExprCollSeq(pParse, pTerm); + }else{ + pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1); + if( pColl==0 ) pColl = db->pDfltColl; + pOrderBy->a[i].pExpr = + sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName); + } + assert( sqlite3KeyInfoIsWriteable(pRet) ); + pRet->aColl[i] = pColl; + pRet->aSortOrder[i] = pOrderBy->a[i].sortOrder; + } + } + + return pRet; +} + +#ifndef SQLITE_OMIT_CTE +/* +** This routine generates VDBE code to compute the content of a WITH RECURSIVE +** query of the form: +** +** AS ( UNION [ALL] ) +** \___________/ \_______________/ +** p->pPrior p +** +** +** There is exactly one reference to the recursive-table in the FROM clause +** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag. +** +** The setup-query runs once to generate an initial set of rows that go +** into a Queue table. Rows are extracted from the Queue table one by +** one. Each row extracted from Queue is output to pDest. Then the single +** extracted row (now in the iCurrent table) becomes the content of the +** recursive-table for a recursive-query run. The output of the recursive-query +** is added back into the Queue table. Then another row is extracted from Queue +** and the iteration continues until the Queue table is empty. +** +** If the compound query operator is UNION then no duplicate rows are ever +** inserted into the Queue table. The iDistinct table keeps a copy of all rows +** that have ever been inserted into Queue and causes duplicates to be +** discarded. If the operator is UNION ALL, then duplicates are allowed. +** +** If the query has an ORDER BY, then entries in the Queue table are kept in +** ORDER BY order and the first entry is extracted for each cycle. Without +** an ORDER BY, the Queue table is just a FIFO. +** +** If a LIMIT clause is provided, then the iteration stops after LIMIT rows +** have been output to pDest. A LIMIT of zero means to output no rows and a +** negative LIMIT means to output all rows. If there is also an OFFSET clause +** with a positive value, then the first OFFSET outputs are discarded rather +** than being sent to pDest. The LIMIT count does not begin until after OFFSET +** rows have been skipped. +*/ +static void generateWithRecursiveQuery( + Parse *pParse, /* Parsing context */ + Select *p, /* The recursive SELECT to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + SrcList *pSrc = p->pSrc; /* The FROM clause of the recursive query */ + int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */ + Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */ + Select *pSetup = p->pPrior; /* The setup query */ + int addrTop; /* Top of the loop */ + int addrCont, addrBreak; /* CONTINUE and BREAK addresses */ + int iCurrent = 0; /* The Current table */ + int regCurrent; /* Register holding Current table */ + int iQueue; /* The Queue table */ + int iDistinct = 0; /* To ensure unique results if UNION */ + int eDest = SRT_Fifo; /* How to write to Queue */ + SelectDest destQueue; /* SelectDest targetting the Queue table */ + int i; /* Loop counter */ + int rc; /* Result code */ + ExprList *pOrderBy; /* The ORDER BY clause */ + Expr *pLimit, *pOffset; /* Saved LIMIT and OFFSET */ + int regLimit, regOffset; /* Registers used by LIMIT and OFFSET */ + + /* Obtain authorization to do a recursive query */ + if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return; + + /* Process the LIMIT and OFFSET clauses, if they exist */ + addrBreak = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, addrBreak); + pLimit = p->pLimit; + pOffset = p->pOffset; + regLimit = p->iLimit; + regOffset = p->iOffset; + p->pLimit = p->pOffset = 0; + p->iLimit = p->iOffset = 0; + pOrderBy = p->pOrderBy; + + /* Locate the cursor number of the Current table */ + for(i=0; ALWAYS(inSrc); i++){ + if( pSrc->a[i].fg.isRecursive ){ + iCurrent = pSrc->a[i].iCursor; + break; + } + } + + /* Allocate cursors numbers for Queue and Distinct. The cursor number for + ** the Distinct table must be exactly one greater than Queue in order + ** for the SRT_DistFifo and SRT_DistQueue destinations to work. */ + iQueue = pParse->nTab++; + if( p->op==TK_UNION ){ + eDest = pOrderBy ? SRT_DistQueue : SRT_DistFifo; + iDistinct = pParse->nTab++; + }else{ + eDest = pOrderBy ? SRT_Queue : SRT_Fifo; + } + sqlite3SelectDestInit(&destQueue, eDest, iQueue); + + /* Allocate cursors for Current, Queue, and Distinct. */ + regCurrent = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol); + if( pOrderBy ){ + KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1); + sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0, + (char*)pKeyInfo, P4_KEYINFO); + destQueue.pOrderBy = pOrderBy; + }else{ + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol); + } + VdbeComment((v, "Queue table")); + if( iDistinct ){ + p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0); + p->selFlags |= SF_UsesEphemeral; + } + + /* Detach the ORDER BY clause from the compound SELECT */ + p->pOrderBy = 0; + + /* Store the results of the setup-query in Queue. */ + pSetup->pNext = 0; + rc = sqlite3Select(pParse, pSetup, &destQueue); + pSetup->pNext = p; + if( rc ) goto end_of_recursive_query; + + /* Find the next row in the Queue and output that row */ + addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak); VdbeCoverage(v); + + /* Transfer the next row in Queue over to Current */ + sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */ + if( pOrderBy ){ + sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent); + }else{ + sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent); + } + sqlite3VdbeAddOp1(v, OP_Delete, iQueue); + + /* Output the single row in Current */ + addrCont = sqlite3VdbeMakeLabel(v); + codeOffset(v, regOffset, addrCont); + selectInnerLoop(pParse, p, p->pEList, iCurrent, + 0, 0, pDest, addrCont, addrBreak); + if( regLimit ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, regLimit, addrBreak); + VdbeCoverage(v); + } + sqlite3VdbeResolveLabel(v, addrCont); + + /* Execute the recursive SELECT taking the single row in Current as + ** the value for the recursive-table. Store the results in the Queue. + */ + if( p->selFlags & SF_Aggregate ){ + sqlite3ErrorMsg(pParse, "recursive aggregate queries not supported"); + }else{ + p->pPrior = 0; + sqlite3Select(pParse, p, &destQueue); + assert( p->pPrior==0 ); + p->pPrior = pSetup; + } + + /* Keep running the loop until the Queue is empty */ + sqlite3VdbeGoto(v, addrTop); + sqlite3VdbeResolveLabel(v, addrBreak); + +end_of_recursive_query: + sqlite3ExprListDelete(pParse->db, p->pOrderBy); + p->pOrderBy = pOrderBy; + p->pLimit = pLimit; + p->pOffset = pOffset; + return; +} +#endif /* SQLITE_OMIT_CTE */ + +/* Forward references */ +static int multiSelectOrderBy( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +); + +/* +** Handle the special case of a compound-select that originates from a +** VALUES clause. By handling this as a special case, we avoid deep +** recursion, and thus do not need to enforce the SQLITE_LIMIT_COMPOUND_SELECT +** on a VALUES clause. +** +** Because the Select object originates from a VALUES clause: +** (1) It has no LIMIT or OFFSET +** (2) All terms are UNION ALL +** (3) There is no ORDER BY clause +*/ +static int multiSelectValues( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + Select *pPrior; + int nRow = 1; + int rc = 0; + assert( p->selFlags & SF_MultiValue ); + do{ + assert( p->selFlags & SF_Values ); + assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) ); + assert( p->pLimit==0 ); + assert( p->pOffset==0 ); + assert( p->pNext==0 || p->pEList->nExpr==p->pNext->pEList->nExpr ); + if( p->pPrior==0 ) break; + assert( p->pPrior->pNext==p ); + p = p->pPrior; + nRow++; + }while(1); + while( p ){ + pPrior = p->pPrior; + p->pPrior = 0; + rc = sqlite3Select(pParse, p, pDest); + p->pPrior = pPrior; + if( rc ) break; + p->nSelectRow = nRow; + p = p->pNext; + } + return rc; +} + +/* +** This routine is called to process a compound query form from +** two or more separate queries using UNION, UNION ALL, EXCEPT, or +** INTERSECT +** +** "p" points to the right-most of the two queries. the query on the +** left is p->pPrior. The left query could also be a compound query +** in which case this routine will be called recursively. +** +** The results of the total query are to be written into a destination +** of type eDest with parameter iParm. +** +** Example 1: Consider a three-way compound SQL statement. +** +** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3 +** +** This statement is parsed up as follows: +** +** SELECT c FROM t3 +** | +** `-----> SELECT b FROM t2 +** | +** `------> SELECT a FROM t1 +** +** The arrows in the diagram above represent the Select.pPrior pointer. +** So if this routine is called with p equal to the t3 query, then +** pPrior will be the t2 query. p->op will be TK_UNION in this case. +** +** Notice that because of the way SQLite parses compound SELECTs, the +** individual selects always group from left to right. +*/ +static int multiSelect( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + int rc = SQLITE_OK; /* Success code from a subroutine */ + Select *pPrior; /* Another SELECT immediately to our left */ + Vdbe *v; /* Generate code to this VDBE */ + SelectDest dest; /* Alternative data destination */ + Select *pDelete = 0; /* Chain of simple selects to delete */ + sqlite3 *db; /* Database connection */ +#ifndef SQLITE_OMIT_EXPLAIN + int iSub1 = 0; /* EQP id of left-hand query */ + int iSub2 = 0; /* EQP id of right-hand query */ +#endif + + /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only + ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT. + */ + assert( p && p->pPrior ); /* Calling function guarantees this much */ + assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION ); + db = pParse->db; + pPrior = p->pPrior; + dest = *pDest; + if( pPrior->pOrderBy ){ + sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before", + selectOpName(p->op)); + rc = 1; + goto multi_select_end; + } + if( pPrior->pLimit ){ + sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before", + selectOpName(p->op)); + rc = 1; + goto multi_select_end; + } + + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); /* The VDBE already created by calling function */ + + /* Create the destination temporary table if necessary + */ + if( dest.eDest==SRT_EphemTab ){ + assert( p->pEList ); + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr); + sqlite3VdbeChangeP5(v, BTREE_UNORDERED); + dest.eDest = SRT_Table; + } + + /* Special handling for a compound-select that originates as a VALUES clause. + */ + if( p->selFlags & SF_MultiValue ){ + rc = multiSelectValues(pParse, p, &dest); + goto multi_select_end; + } + + /* Make sure all SELECTs in the statement have the same number of elements + ** in their result sets. + */ + assert( p->pEList && pPrior->pEList ); + assert( p->pEList->nExpr==pPrior->pEList->nExpr ); + +#ifndef SQLITE_OMIT_CTE + if( p->selFlags & SF_Recursive ){ + generateWithRecursiveQuery(pParse, p, &dest); + }else +#endif + + /* Compound SELECTs that have an ORDER BY clause are handled separately. + */ + if( p->pOrderBy ){ + return multiSelectOrderBy(pParse, p, pDest); + }else + + /* Generate code for the left and right SELECT statements. + */ + switch( p->op ){ + case TK_ALL: { + int addr = 0; + int nLimit; + assert( !pPrior->pLimit ); + pPrior->iLimit = p->iLimit; + pPrior->iOffset = p->iOffset; + pPrior->pLimit = p->pLimit; + pPrior->pOffset = p->pOffset; + explainSetInteger(iSub1, pParse->iNextSelectId); + rc = sqlite3Select(pParse, pPrior, &dest); + p->pLimit = 0; + p->pOffset = 0; + if( rc ){ + goto multi_select_end; + } + p->pPrior = 0; + p->iLimit = pPrior->iLimit; + p->iOffset = pPrior->iOffset; + if( p->iLimit ){ + addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v); + VdbeComment((v, "Jump ahead if LIMIT reached")); + if( p->iOffset ){ + sqlite3VdbeAddOp3(v, OP_SetIfNotPos, p->iOffset, p->iOffset, 0); + sqlite3VdbeAddOp3(v, OP_Add, p->iLimit, p->iOffset, p->iOffset+1); + sqlite3VdbeAddOp3(v, OP_SetIfNotPos, p->iLimit, p->iOffset+1, -1); + } + } + explainSetInteger(iSub2, pParse->iNextSelectId); + rc = sqlite3Select(pParse, p, &dest); + testcase( rc!=SQLITE_OK ); + pDelete = p->pPrior; + p->pPrior = pPrior; + p->nSelectRow += pPrior->nSelectRow; + if( pPrior->pLimit + && sqlite3ExprIsInteger(pPrior->pLimit, &nLimit) + && nLimit>0 && p->nSelectRow > (u64)nLimit + ){ + p->nSelectRow = nLimit; + } + if( addr ){ + sqlite3VdbeJumpHere(v, addr); + } + break; + } + case TK_EXCEPT: + case TK_UNION: { + int unionTab; /* Cursor number of the temporary table holding result */ + u8 op = 0; /* One of the SRT_ operations to apply to self */ + int priorOp; /* The SRT_ operation to apply to prior selects */ + Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */ + int addr; + SelectDest uniondest; + + testcase( p->op==TK_EXCEPT ); + testcase( p->op==TK_UNION ); + priorOp = SRT_Union; + if( dest.eDest==priorOp ){ + /* We can reuse a temporary table generated by a SELECT to our + ** right. + */ + assert( p->pLimit==0 ); /* Not allowed on leftward elements */ + assert( p->pOffset==0 ); /* Not allowed on leftward elements */ + unionTab = dest.iSDParm; + }else{ + /* We will need to create our own temporary table to hold the + ** intermediate results. + */ + unionTab = pParse->nTab++; + assert( p->pOrderBy==0 ); + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0); + assert( p->addrOpenEphm[0] == -1 ); + p->addrOpenEphm[0] = addr; + findRightmost(p)->selFlags |= SF_UsesEphemeral; + assert( p->pEList ); + } + + /* Code the SELECT statements to our left + */ + assert( !pPrior->pOrderBy ); + sqlite3SelectDestInit(&uniondest, priorOp, unionTab); + explainSetInteger(iSub1, pParse->iNextSelectId); + rc = sqlite3Select(pParse, pPrior, &uniondest); + if( rc ){ + goto multi_select_end; + } + + /* Code the current SELECT statement + */ + if( p->op==TK_EXCEPT ){ + op = SRT_Except; + }else{ + assert( p->op==TK_UNION ); + op = SRT_Union; + } + p->pPrior = 0; + pLimit = p->pLimit; + p->pLimit = 0; + pOffset = p->pOffset; + p->pOffset = 0; + uniondest.eDest = op; + explainSetInteger(iSub2, pParse->iNextSelectId); + rc = sqlite3Select(pParse, p, &uniondest); + testcase( rc!=SQLITE_OK ); + /* Query flattening in sqlite3Select() might refill p->pOrderBy. + ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */ + sqlite3ExprListDelete(db, p->pOrderBy); + pDelete = p->pPrior; + p->pPrior = pPrior; + p->pOrderBy = 0; + if( p->op==TK_UNION ) p->nSelectRow += pPrior->nSelectRow; + sqlite3ExprDelete(db, p->pLimit); + p->pLimit = pLimit; + p->pOffset = pOffset; + p->iLimit = 0; + p->iOffset = 0; + + /* Convert the data in the temporary table into whatever form + ** it is that we currently need. + */ + assert( unionTab==dest.iSDParm || dest.eDest!=priorOp ); + if( dest.eDest!=priorOp ){ + int iCont, iBreak, iStart; + assert( p->pEList ); + if( dest.eDest==SRT_Output ){ + Select *pFirst = p; + while( pFirst->pPrior ) pFirst = pFirst->pPrior; + generateColumnNames(pParse, 0, pFirst->pEList); + } + iBreak = sqlite3VdbeMakeLabel(v); + iCont = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, iBreak); + sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v); + iStart = sqlite3VdbeCurrentAddr(v); + selectInnerLoop(pParse, p, p->pEList, unionTab, + 0, 0, &dest, iCont, iBreak); + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0); + } + break; + } + default: assert( p->op==TK_INTERSECT ); { + int tab1, tab2; + int iCont, iBreak, iStart; + Expr *pLimit, *pOffset; + int addr; + SelectDest intersectdest; + int r1; + + /* INTERSECT is different from the others since it requires + ** two temporary tables. Hence it has its own case. Begin + ** by allocating the tables we will need. + */ + tab1 = pParse->nTab++; + tab2 = pParse->nTab++; + assert( p->pOrderBy==0 ); + + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0); + assert( p->addrOpenEphm[0] == -1 ); + p->addrOpenEphm[0] = addr; + findRightmost(p)->selFlags |= SF_UsesEphemeral; + assert( p->pEList ); + + /* Code the SELECTs to our left into temporary table "tab1". + */ + sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1); + explainSetInteger(iSub1, pParse->iNextSelectId); + rc = sqlite3Select(pParse, pPrior, &intersectdest); + if( rc ){ + goto multi_select_end; + } + + /* Code the current SELECT into temporary table "tab2" + */ + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0); + assert( p->addrOpenEphm[1] == -1 ); + p->addrOpenEphm[1] = addr; + p->pPrior = 0; + pLimit = p->pLimit; + p->pLimit = 0; + pOffset = p->pOffset; + p->pOffset = 0; + intersectdest.iSDParm = tab2; + explainSetInteger(iSub2, pParse->iNextSelectId); + rc = sqlite3Select(pParse, p, &intersectdest); + testcase( rc!=SQLITE_OK ); + pDelete = p->pPrior; + p->pPrior = pPrior; + if( p->nSelectRow>pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow; + sqlite3ExprDelete(db, p->pLimit); + p->pLimit = pLimit; + p->pOffset = pOffset; + + /* Generate code to take the intersection of the two temporary + ** tables. + */ + assert( p->pEList ); + if( dest.eDest==SRT_Output ){ + Select *pFirst = p; + while( pFirst->pPrior ) pFirst = pFirst->pPrior; + generateColumnNames(pParse, 0, pFirst->pEList); + } + iBreak = sqlite3VdbeMakeLabel(v); + iCont = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, iBreak); + sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v); + r1 = sqlite3GetTempReg(pParse); + iStart = sqlite3VdbeAddOp2(v, OP_RowKey, tab1, r1); + sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0); VdbeCoverage(v); + sqlite3ReleaseTempReg(pParse, r1); + selectInnerLoop(pParse, p, p->pEList, tab1, + 0, 0, &dest, iCont, iBreak); + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp2(v, OP_Close, tab2, 0); + sqlite3VdbeAddOp2(v, OP_Close, tab1, 0); + break; + } + } + + explainComposite(pParse, p->op, iSub1, iSub2, p->op!=TK_ALL); + + /* Compute collating sequences used by + ** temporary tables needed to implement the compound select. + ** Attach the KeyInfo structure to all temporary tables. + ** + ** This section is run by the right-most SELECT statement only. + ** SELECT statements to the left always skip this part. The right-most + ** SELECT might also skip this part if it has no ORDER BY clause and + ** no temp tables are required. + */ + if( p->selFlags & SF_UsesEphemeral ){ + int i; /* Loop counter */ + KeyInfo *pKeyInfo; /* Collating sequence for the result set */ + Select *pLoop; /* For looping through SELECT statements */ + CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */ + int nCol; /* Number of columns in result set */ + + assert( p->pNext==0 ); + nCol = p->pEList->nExpr; + pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1); + if( !pKeyInfo ){ + rc = SQLITE_NOMEM; + goto multi_select_end; + } + for(i=0, apColl=pKeyInfo->aColl; ipDfltColl; + } + } + + for(pLoop=p; pLoop; pLoop=pLoop->pPrior){ + for(i=0; i<2; i++){ + int addr = pLoop->addrOpenEphm[i]; + if( addr<0 ){ + /* If [0] is unused then [1] is also unused. So we can + ** always safely abort as soon as the first unused slot is found */ + assert( pLoop->addrOpenEphm[1]<0 ); + break; + } + sqlite3VdbeChangeP2(v, addr, nCol); + sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo), + P4_KEYINFO); + pLoop->addrOpenEphm[i] = -1; + } + } + sqlite3KeyInfoUnref(pKeyInfo); + } + +multi_select_end: + pDest->iSdst = dest.iSdst; + pDest->nSdst = dest.nSdst; + sqlite3SelectDelete(db, pDelete); + return rc; +} +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + +/* +** Error message for when two or more terms of a compound select have different +** size result sets. +*/ +SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p){ + if( p->selFlags & SF_Values ){ + sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms"); + }else{ + sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s" + " do not have the same number of result columns", selectOpName(p->op)); + } +} + +/* +** Code an output subroutine for a coroutine implementation of a +** SELECT statment. +** +** The data to be output is contained in pIn->iSdst. There are +** pIn->nSdst columns to be output. pDest is where the output should +** be sent. +** +** regReturn is the number of the register holding the subroutine +** return address. +** +** If regPrev>0 then it is the first register in a vector that +** records the previous output. mem[regPrev] is a flag that is false +** if there has been no previous output. If regPrev>0 then code is +** generated to suppress duplicates. pKeyInfo is used for comparing +** keys. +** +** If the LIMIT found in p->iLimit is reached, jump immediately to +** iBreak. +*/ +static int generateOutputSubroutine( + Parse *pParse, /* Parsing context */ + Select *p, /* The SELECT statement */ + SelectDest *pIn, /* Coroutine supplying data */ + SelectDest *pDest, /* Where to send the data */ + int regReturn, /* The return address register */ + int regPrev, /* Previous result register. No uniqueness if 0 */ + KeyInfo *pKeyInfo, /* For comparing with previous entry */ + int iBreak /* Jump here if we hit the LIMIT */ +){ + Vdbe *v = pParse->pVdbe; + int iContinue; + int addr; + + addr = sqlite3VdbeCurrentAddr(v); + iContinue = sqlite3VdbeMakeLabel(v); + + /* Suppress duplicates for UNION, EXCEPT, and INTERSECT + */ + if( regPrev ){ + int addr1, addr2; + addr1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); VdbeCoverage(v); + addr2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst, + (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO); + sqlite3VdbeAddOp3(v, OP_Jump, addr2+2, iContinue, addr2+2); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1); + sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev); + } + if( pParse->db->mallocFailed ) return 0; + + /* Suppress the first OFFSET entries if there is an OFFSET clause + */ + codeOffset(v, p->iOffset, iContinue); + + assert( pDest->eDest!=SRT_Exists ); + assert( pDest->eDest!=SRT_Table ); + switch( pDest->eDest ){ + /* Store the result as data using a unique key. + */ + case SRT_EphemTab: { + int r1 = sqlite3GetTempReg(pParse); + int r2 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1); + sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2); + sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3ReleaseTempReg(pParse, r2); + sqlite3ReleaseTempReg(pParse, r1); + break; + } + +#ifndef SQLITE_OMIT_SUBQUERY + /* If we are creating a set for an "expr IN (SELECT ...)" construct, + ** then there should be a single item on the stack. Write this + ** item into the set table with bogus data. + */ + case SRT_Set: { + int r1; + assert( pIn->nSdst==1 || pParse->nErr>0 ); + pDest->affSdst = + sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affSdst); + r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, 1, r1, &pDest->affSdst,1); + sqlite3ExprCacheAffinityChange(pParse, pIn->iSdst, 1); + sqlite3VdbeAddOp2(v, OP_IdxInsert, pDest->iSDParm, r1); + sqlite3ReleaseTempReg(pParse, r1); + break; + } + + /* If this is a scalar select that is part of an expression, then + ** store the results in the appropriate memory cell and break out + ** of the scan loop. + */ + case SRT_Mem: { + assert( pIn->nSdst==1 || pParse->nErr>0 ); testcase( pIn->nSdst!=1 ); + sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, 1); + /* The LIMIT clause will jump out of the loop for us */ + break; + } +#endif /* #ifndef SQLITE_OMIT_SUBQUERY */ + + /* The results are stored in a sequence of registers + ** starting at pDest->iSdst. Then the co-routine yields. + */ + case SRT_Coroutine: { + if( pDest->iSdst==0 ){ + pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst); + pDest->nSdst = pIn->nSdst; + } + sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pIn->nSdst); + sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm); + break; + } + + /* If none of the above, then the result destination must be + ** SRT_Output. This routine is never called with any other + ** destination other than the ones handled above or SRT_Output. + ** + ** For SRT_Output, results are stored in a sequence of registers. + ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to + ** return the next row of result. + */ + default: { + assert( pDest->eDest==SRT_Output ); + sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst); + sqlite3ExprCacheAffinityChange(pParse, pIn->iSdst, pIn->nSdst); + break; + } + } + + /* Jump to the end of the loop if the LIMIT is reached. + */ + if( p->iLimit ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v); + } + + /* Generate the subroutine return + */ + sqlite3VdbeResolveLabel(v, iContinue); + sqlite3VdbeAddOp1(v, OP_Return, regReturn); + + return addr; +} + +/* +** Alternative compound select code generator for cases when there +** is an ORDER BY clause. +** +** We assume a query of the following form: +** +** ORDER BY +** +** is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea +** is to code both and with the ORDER BY clause as +** co-routines. Then run the co-routines in parallel and merge the results +** into the output. In addition to the two coroutines (called selectA and +** selectB) there are 7 subroutines: +** +** outA: Move the output of the selectA coroutine into the output +** of the compound query. +** +** outB: Move the output of the selectB coroutine into the output +** of the compound query. (Only generated for UNION and +** UNION ALL. EXCEPT and INSERTSECT never output a row that +** appears only in B.) +** +** AltB: Called when there is data from both coroutines and AB. +** +** EofA: Called when data is exhausted from selectA. +** +** EofB: Called when data is exhausted from selectB. +** +** The implementation of the latter five subroutines depend on which +** is used: +** +** +** UNION ALL UNION EXCEPT INTERSECT +** ------------- ----------------- -------------- ----------------- +** AltB: outA, nextA outA, nextA outA, nextA nextA +** +** AeqB: outA, nextA nextA nextA outA, nextA +** +** AgtB: outB, nextB outB, nextB nextB nextB +** +** EofA: outB, nextB outB, nextB halt halt +** +** EofB: outA, nextA outA, nextA outA, nextA halt +** +** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA +** causes an immediate jump to EofA and an EOF on B following nextB causes +** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or +** following nextX causes a jump to the end of the select processing. +** +** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled +** within the output subroutine. The regPrev register set holds the previously +** output value. A comparison is made against this value and the output +** is skipped if the next results would be the same as the previous. +** +** The implementation plan is to implement the two coroutines and seven +** subroutines first, then put the control logic at the bottom. Like this: +** +** goto Init +** coA: coroutine for left query (A) +** coB: coroutine for right query (B) +** outA: output one row of A +** outB: output one row of B (UNION and UNION ALL only) +** EofA: ... +** EofB: ... +** AltB: ... +** AeqB: ... +** AgtB: ... +** Init: initialize coroutine registers +** yield coA +** if eof(A) goto EofA +** yield coB +** if eof(B) goto EofB +** Cmpr: Compare A, B +** Jump AltB, AeqB, AgtB +** End: ... +** +** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not +** actually called using Gosub and they do not Return. EofA and EofB loop +** until all data is exhausted then jump to the "end" labe. AltB, AeqB, +** and AgtB jump to either L2 or to one of EofA or EofB. +*/ +#ifndef SQLITE_OMIT_COMPOUND_SELECT +static int multiSelectOrderBy( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + int i, j; /* Loop counters */ + Select *pPrior; /* Another SELECT immediately to our left */ + Vdbe *v; /* Generate code to this VDBE */ + SelectDest destA; /* Destination for coroutine A */ + SelectDest destB; /* Destination for coroutine B */ + int regAddrA; /* Address register for select-A coroutine */ + int regAddrB; /* Address register for select-B coroutine */ + int addrSelectA; /* Address of the select-A coroutine */ + int addrSelectB; /* Address of the select-B coroutine */ + int regOutA; /* Address register for the output-A subroutine */ + int regOutB; /* Address register for the output-B subroutine */ + int addrOutA; /* Address of the output-A subroutine */ + int addrOutB = 0; /* Address of the output-B subroutine */ + int addrEofA; /* Address of the select-A-exhausted subroutine */ + int addrEofA_noB; /* Alternate addrEofA if B is uninitialized */ + int addrEofB; /* Address of the select-B-exhausted subroutine */ + int addrAltB; /* Address of the AB subroutine */ + int regLimitA; /* Limit register for select-A */ + int regLimitB; /* Limit register for select-A */ + int regPrev; /* A range of registers to hold previous output */ + int savedLimit; /* Saved value of p->iLimit */ + int savedOffset; /* Saved value of p->iOffset */ + int labelCmpr; /* Label for the start of the merge algorithm */ + int labelEnd; /* Label for the end of the overall SELECT stmt */ + int addr1; /* Jump instructions that get retargetted */ + int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */ + KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */ + KeyInfo *pKeyMerge; /* Comparison information for merging rows */ + sqlite3 *db; /* Database connection */ + ExprList *pOrderBy; /* The ORDER BY clause */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + int *aPermute; /* Mapping from ORDER BY terms to result set columns */ +#ifndef SQLITE_OMIT_EXPLAIN + int iSub1; /* EQP id of left-hand query */ + int iSub2; /* EQP id of right-hand query */ +#endif + + assert( p->pOrderBy!=0 ); + assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */ + db = pParse->db; + v = pParse->pVdbe; + assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */ + labelEnd = sqlite3VdbeMakeLabel(v); + labelCmpr = sqlite3VdbeMakeLabel(v); + + + /* Patch up the ORDER BY clause + */ + op = p->op; + pPrior = p->pPrior; + assert( pPrior->pOrderBy==0 ); + pOrderBy = p->pOrderBy; + assert( pOrderBy ); + nOrderBy = pOrderBy->nExpr; + + /* For operators other than UNION ALL we have to make sure that + ** the ORDER BY clause covers every term of the result set. Add + ** terms to the ORDER BY clause as necessary. + */ + if( op!=TK_ALL ){ + for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){ + struct ExprList_item *pItem; + for(j=0, pItem=pOrderBy->a; ju.x.iOrderByCol>0 ); + if( pItem->u.x.iOrderByCol==i ) break; + } + if( j==nOrderBy ){ + Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); + if( pNew==0 ) return SQLITE_NOMEM; + pNew->flags |= EP_IntValue; + pNew->u.iValue = i; + pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew); + if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i; + } + } + } + + /* Compute the comparison permutation and keyinfo that is used with + ** the permutation used to determine if the next + ** row of results comes from selectA or selectB. Also add explicit + ** collations to the ORDER BY clause terms so that when the subqueries + ** to the right and the left are evaluated, they use the correct + ** collation. + */ + aPermute = sqlite3DbMallocRaw(db, sizeof(int)*nOrderBy); + if( aPermute ){ + struct ExprList_item *pItem; + for(i=0, pItem=pOrderBy->a; iu.x.iOrderByCol>0 ); + assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr ); + aPermute[i] = pItem->u.x.iOrderByCol - 1; + } + pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1); + }else{ + pKeyMerge = 0; + } + + /* Reattach the ORDER BY clause to the query. + */ + p->pOrderBy = pOrderBy; + pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0); + + /* Allocate a range of temporary registers and the KeyInfo needed + ** for the logic that removes duplicate result rows when the + ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL). + */ + if( op==TK_ALL ){ + regPrev = 0; + }else{ + int nExpr = p->pEList->nExpr; + assert( nOrderBy>=nExpr || db->mallocFailed ); + regPrev = pParse->nMem+1; + pParse->nMem += nExpr+1; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev); + pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1); + if( pKeyDup ){ + assert( sqlite3KeyInfoIsWriteable(pKeyDup) ); + for(i=0; iaColl[i] = multiSelectCollSeq(pParse, p, i); + pKeyDup->aSortOrder[i] = 0; + } + } + } + + /* Separate the left and the right query from one another + */ + p->pPrior = 0; + pPrior->pNext = 0; + sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER"); + if( pPrior->pPrior==0 ){ + sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER"); + } + + /* Compute the limit registers */ + computeLimitRegisters(pParse, p, labelEnd); + if( p->iLimit && op==TK_ALL ){ + regLimitA = ++pParse->nMem; + regLimitB = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit, + regLimitA); + sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB); + }else{ + regLimitA = regLimitB = 0; + } + sqlite3ExprDelete(db, p->pLimit); + p->pLimit = 0; + sqlite3ExprDelete(db, p->pOffset); + p->pOffset = 0; + + regAddrA = ++pParse->nMem; + regAddrB = ++pParse->nMem; + regOutA = ++pParse->nMem; + regOutB = ++pParse->nMem; + sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA); + sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB); + + /* Generate a coroutine to evaluate the SELECT statement to the + ** left of the compound operator - the "A" select. + */ + addrSelectA = sqlite3VdbeCurrentAddr(v) + 1; + addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA); + VdbeComment((v, "left SELECT")); + pPrior->iLimit = regLimitA; + explainSetInteger(iSub1, pParse->iNextSelectId); + sqlite3Select(pParse, pPrior, &destA); + sqlite3VdbeAddOp1(v, OP_EndCoroutine, regAddrA); + sqlite3VdbeJumpHere(v, addr1); + + /* Generate a coroutine to evaluate the SELECT statement on + ** the right - the "B" select + */ + addrSelectB = sqlite3VdbeCurrentAddr(v) + 1; + addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB); + VdbeComment((v, "right SELECT")); + savedLimit = p->iLimit; + savedOffset = p->iOffset; + p->iLimit = regLimitB; + p->iOffset = 0; + explainSetInteger(iSub2, pParse->iNextSelectId); + sqlite3Select(pParse, p, &destB); + p->iLimit = savedLimit; + p->iOffset = savedOffset; + sqlite3VdbeAddOp1(v, OP_EndCoroutine, regAddrB); + + /* Generate a subroutine that outputs the current row of the A + ** select as the next output row of the compound select. + */ + VdbeNoopComment((v, "Output routine for A")); + addrOutA = generateOutputSubroutine(pParse, + p, &destA, pDest, regOutA, + regPrev, pKeyDup, labelEnd); + + /* Generate a subroutine that outputs the current row of the B + ** select as the next output row of the compound select. + */ + if( op==TK_ALL || op==TK_UNION ){ + VdbeNoopComment((v, "Output routine for B")); + addrOutB = generateOutputSubroutine(pParse, + p, &destB, pDest, regOutB, + regPrev, pKeyDup, labelEnd); + } + sqlite3KeyInfoUnref(pKeyDup); + + /* Generate a subroutine to run when the results from select A + ** are exhausted and only data in select B remains. + */ + if( op==TK_EXCEPT || op==TK_INTERSECT ){ + addrEofA_noB = addrEofA = labelEnd; + }else{ + VdbeNoopComment((v, "eof-A subroutine")); + addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB); + addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd); + VdbeCoverage(v); + sqlite3VdbeGoto(v, addrEofA); + p->nSelectRow += pPrior->nSelectRow; + } + + /* Generate a subroutine to run when the results from select B + ** are exhausted and only data in select A remains. + */ + if( op==TK_INTERSECT ){ + addrEofB = addrEofA; + if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow; + }else{ + VdbeNoopComment((v, "eof-B subroutine")); + addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA); + sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v); + sqlite3VdbeGoto(v, addrEofB); + } + + /* Generate code to handle the case of AB + */ + VdbeNoopComment((v, "A-gt-B subroutine")); + addrAgtB = sqlite3VdbeCurrentAddr(v); + if( op==TK_ALL || op==TK_UNION ){ + sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB); + } + sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v); + sqlite3VdbeGoto(v, labelCmpr); + + /* This code runs once to initialize everything. + */ + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v); + + /* Implement the main merge loop + */ + sqlite3VdbeResolveLabel(v, labelCmpr); + sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY); + sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy, + (char*)pKeyMerge, P4_KEYINFO); + sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE); + sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v); + + /* Jump to the this point in order to terminate the query. + */ + sqlite3VdbeResolveLabel(v, labelEnd); + + /* Set the number of output columns + */ + if( pDest->eDest==SRT_Output ){ + Select *pFirst = pPrior; + while( pFirst->pPrior ) pFirst = pFirst->pPrior; + generateColumnNames(pParse, 0, pFirst->pEList); + } + + /* Reassembly the compound query so that it will be freed correctly + ** by the calling function */ + if( p->pPrior ){ + sqlite3SelectDelete(db, p->pPrior); + } + p->pPrior = pPrior; + pPrior->pNext = p; + + /*** TBD: Insert subroutine calls to close cursors on incomplete + **** subqueries ****/ + explainComposite(pParse, p->op, iSub1, iSub2, 0); + return pParse->nErr!=0; +} +#endif + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* Forward Declarations */ +static void substExprList(sqlite3*, ExprList*, int, ExprList*); +static void substSelect(sqlite3*, Select *, int, ExprList*, int); + +/* +** Scan through the expression pExpr. Replace every reference to +** a column in table number iTable with a copy of the iColumn-th +** entry in pEList. (But leave references to the ROWID column +** unchanged.) +** +** This routine is part of the flattening procedure. A subquery +** whose result set is defined by pEList appears as entry in the +** FROM clause of a SELECT such that the VDBE cursor assigned to that +** FORM clause entry is iTable. This routine make the necessary +** changes to pExpr so that it refers directly to the source table +** of the subquery rather the result set of the subquery. +*/ +static Expr *substExpr( + sqlite3 *db, /* Report malloc errors to this connection */ + Expr *pExpr, /* Expr in which substitution occurs */ + int iTable, /* Table to be substituted */ + ExprList *pEList /* Substitute expressions */ +){ + if( pExpr==0 ) return 0; + if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){ + if( pExpr->iColumn<0 ){ + pExpr->op = TK_NULL; + }else{ + Expr *pNew; + assert( pEList!=0 && pExpr->iColumnnExpr ); + assert( pExpr->pLeft==0 && pExpr->pRight==0 ); + pNew = sqlite3ExprDup(db, pEList->a[pExpr->iColumn].pExpr, 0); + sqlite3ExprDelete(db, pExpr); + pExpr = pNew; + } + }else{ + pExpr->pLeft = substExpr(db, pExpr->pLeft, iTable, pEList); + pExpr->pRight = substExpr(db, pExpr->pRight, iTable, pEList); + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + substSelect(db, pExpr->x.pSelect, iTable, pEList, 1); + }else{ + substExprList(db, pExpr->x.pList, iTable, pEList); + } + } + return pExpr; +} +static void substExprList( + sqlite3 *db, /* Report malloc errors here */ + ExprList *pList, /* List to scan and in which to make substitutes */ + int iTable, /* Table to be substituted */ + ExprList *pEList /* Substitute values */ +){ + int i; + if( pList==0 ) return; + for(i=0; inExpr; i++){ + pList->a[i].pExpr = substExpr(db, pList->a[i].pExpr, iTable, pEList); + } +} +static void substSelect( + sqlite3 *db, /* Report malloc errors here */ + Select *p, /* SELECT statement in which to make substitutions */ + int iTable, /* Table to be replaced */ + ExprList *pEList, /* Substitute values */ + int doPrior /* Do substitutes on p->pPrior too */ +){ + SrcList *pSrc; + struct SrcList_item *pItem; + int i; + if( !p ) return; + do{ + substExprList(db, p->pEList, iTable, pEList); + substExprList(db, p->pGroupBy, iTable, pEList); + substExprList(db, p->pOrderBy, iTable, pEList); + p->pHaving = substExpr(db, p->pHaving, iTable, pEList); + p->pWhere = substExpr(db, p->pWhere, iTable, pEList); + pSrc = p->pSrc; + assert( pSrc!=0 ); + for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ + substSelect(db, pItem->pSelect, iTable, pEList, 1); + if( pItem->fg.isTabFunc ){ + substExprList(db, pItem->u1.pFuncArg, iTable, pEList); + } + } + }while( doPrior && (p = p->pPrior)!=0 ); +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* +** This routine attempts to flatten subqueries as a performance optimization. +** This routine returns 1 if it makes changes and 0 if no flattening occurs. +** +** To understand the concept of flattening, consider the following +** query: +** +** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5 +** +** The default way of implementing this query is to execute the +** subquery first and store the results in a temporary table, then +** run the outer query on that temporary table. This requires two +** passes over the data. Furthermore, because the temporary table +** has no indices, the WHERE clause on the outer query cannot be +** optimized. +** +** This routine attempts to rewrite queries such as the above into +** a single flat select, like this: +** +** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5 +** +** The code generated for this simplification gives the same result +** but only has to scan the data once. And because indices might +** exist on the table t1, a complete scan of the data might be +** avoided. +** +** Flattening is only attempted if all of the following are true: +** +** (1) The subquery and the outer query do not both use aggregates. +** +** (2) The subquery is not an aggregate or (2a) the outer query is not a join +** and (2b) the outer query does not use subqueries other than the one +** FROM-clause subquery that is a candidate for flattening. (2b is +** due to ticket [2f7170d73bf9abf80] from 2015-02-09.) +** +** (3) The subquery is not the right operand of a left outer join +** (Originally ticket #306. Strengthened by ticket #3300) +** +** (4) The subquery is not DISTINCT. +** +** (**) At one point restrictions (4) and (5) defined a subset of DISTINCT +** sub-queries that were excluded from this optimization. Restriction +** (4) has since been expanded to exclude all DISTINCT subqueries. +** +** (6) The subquery does not use aggregates or the outer query is not +** DISTINCT. +** +** (7) The subquery has a FROM clause. TODO: For subqueries without +** A FROM clause, consider adding a FROM close with the special +** table sqlite_once that consists of a single row containing a +** single NULL. +** +** (8) The subquery does not use LIMIT or the outer query is not a join. +** +** (9) The subquery does not use LIMIT or the outer query does not use +** aggregates. +** +** (**) Restriction (10) was removed from the code on 2005-02-05 but we +** accidently carried the comment forward until 2014-09-15. Original +** text: "The subquery does not use aggregates or the outer query +** does not use LIMIT." +** +** (11) The subquery and the outer query do not both have ORDER BY clauses. +** +** (**) Not implemented. Subsumed into restriction (3). Was previously +** a separate restriction deriving from ticket #350. +** +** (13) The subquery and outer query do not both use LIMIT. +** +** (14) The subquery does not use OFFSET. +** +** (15) The outer query is not part of a compound select or the +** subquery does not have a LIMIT clause. +** (See ticket #2339 and ticket [02a8e81d44]). +** +** (16) The outer query is not an aggregate or the subquery does +** not contain ORDER BY. (Ticket #2942) This used to not matter +** until we introduced the group_concat() function. +** +** (17) The sub-query is not a compound select, or it is a UNION ALL +** compound clause made up entirely of non-aggregate queries, and +** the parent query: +** +** * is not itself part of a compound select, +** * is not an aggregate or DISTINCT query, and +** * is not a join +** +** The parent and sub-query may contain WHERE clauses. Subject to +** rules (11), (13) and (14), they may also contain ORDER BY, +** LIMIT and OFFSET clauses. The subquery cannot use any compound +** operator other than UNION ALL because all the other compound +** operators have an implied DISTINCT which is disallowed by +** restriction (4). +** +** Also, each component of the sub-query must return the same number +** of result columns. This is actually a requirement for any compound +** SELECT statement, but all the code here does is make sure that no +** such (illegal) sub-query is flattened. The caller will detect the +** syntax error and return a detailed message. +** +** (18) If the sub-query is a compound select, then all terms of the +** ORDER by clause of the parent must be simple references to +** columns of the sub-query. +** +** (19) The subquery does not use LIMIT or the outer query does not +** have a WHERE clause. +** +** (20) If the sub-query is a compound select, then it must not use +** an ORDER BY clause. Ticket #3773. We could relax this constraint +** somewhat by saying that the terms of the ORDER BY clause must +** appear as unmodified result columns in the outer query. But we +** have other optimizations in mind to deal with that case. +** +** (21) The subquery does not use LIMIT or the outer query is not +** DISTINCT. (See ticket [752e1646fc]). +** +** (22) The subquery is not a recursive CTE. +** +** (23) The parent is not a recursive CTE, or the sub-query is not a +** compound query. This restriction is because transforming the +** parent to a compound query confuses the code that handles +** recursive queries in multiSelect(). +** +** (24) The subquery is not an aggregate that uses the built-in min() or +** or max() functions. (Without this restriction, a query like: +** "SELECT x FROM (SELECT max(y), x FROM t1)" would not necessarily +** return the value X for which Y was maximal.) +** +** +** In this routine, the "p" parameter is a pointer to the outer query. +** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query +** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates. +** +** If flattening is not attempted, this routine is a no-op and returns 0. +** If flattening is attempted this routine returns 1. +** +** All of the expression analysis must occur on both the outer query and +** the subquery before this routine runs. +*/ +static int flattenSubquery( + Parse *pParse, /* Parsing context */ + Select *p, /* The parent or outer SELECT statement */ + int iFrom, /* Index in p->pSrc->a[] of the inner subquery */ + int isAgg, /* True if outer SELECT uses aggregate functions */ + int subqueryIsAgg /* True if the subquery uses aggregate functions */ +){ + const char *zSavedAuthContext = pParse->zAuthContext; + Select *pParent; /* Current UNION ALL term of the other query */ + Select *pSub; /* The inner query or "subquery" */ + Select *pSub1; /* Pointer to the rightmost select in sub-query */ + SrcList *pSrc; /* The FROM clause of the outer query */ + SrcList *pSubSrc; /* The FROM clause of the subquery */ + ExprList *pList; /* The result set of the outer query */ + int iParent; /* VDBE cursor number of the pSub result set temp table */ + int i; /* Loop counter */ + Expr *pWhere; /* The WHERE clause */ + struct SrcList_item *pSubitem; /* The subquery */ + sqlite3 *db = pParse->db; + + /* Check to see if flattening is permitted. Return 0 if not. + */ + assert( p!=0 ); + assert( p->pPrior==0 ); /* Unable to flatten compound queries */ + if( OptimizationDisabled(db, SQLITE_QueryFlattener) ) return 0; + pSrc = p->pSrc; + assert( pSrc && iFrom>=0 && iFromnSrc ); + pSubitem = &pSrc->a[iFrom]; + iParent = pSubitem->iCursor; + pSub = pSubitem->pSelect; + assert( pSub!=0 ); + if( subqueryIsAgg ){ + if( isAgg ) return 0; /* Restriction (1) */ + if( pSrc->nSrc>1 ) return 0; /* Restriction (2a) */ + if( (p->pWhere && ExprHasProperty(p->pWhere,EP_Subquery)) + || (sqlite3ExprListFlags(p->pEList) & EP_Subquery)!=0 + || (sqlite3ExprListFlags(p->pOrderBy) & EP_Subquery)!=0 + ){ + return 0; /* Restriction (2b) */ + } + } + + pSubSrc = pSub->pSrc; + assert( pSubSrc ); + /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants, + ** not arbitrary expressions, we allowed some combining of LIMIT and OFFSET + ** because they could be computed at compile-time. But when LIMIT and OFFSET + ** became arbitrary expressions, we were forced to add restrictions (13) + ** and (14). */ + if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */ + if( pSub->pOffset ) return 0; /* Restriction (14) */ + if( (p->selFlags & SF_Compound)!=0 && pSub->pLimit ){ + return 0; /* Restriction (15) */ + } + if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */ + if( pSub->selFlags & SF_Distinct ) return 0; /* Restriction (5) */ + if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){ + return 0; /* Restrictions (8)(9) */ + } + if( (p->selFlags & SF_Distinct)!=0 && subqueryIsAgg ){ + return 0; /* Restriction (6) */ + } + if( p->pOrderBy && pSub->pOrderBy ){ + return 0; /* Restriction (11) */ + } + if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */ + if( pSub->pLimit && p->pWhere ) return 0; /* Restriction (19) */ + if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){ + return 0; /* Restriction (21) */ + } + testcase( pSub->selFlags & SF_Recursive ); + testcase( pSub->selFlags & SF_MinMaxAgg ); + if( pSub->selFlags & (SF_Recursive|SF_MinMaxAgg) ){ + return 0; /* Restrictions (22) and (24) */ + } + if( (p->selFlags & SF_Recursive) && pSub->pPrior ){ + return 0; /* Restriction (23) */ + } + + /* OBSOLETE COMMENT 1: + ** Restriction 3: If the subquery is a join, make sure the subquery is + ** not used as the right operand of an outer join. Examples of why this + ** is not allowed: + ** + ** t1 LEFT OUTER JOIN (t2 JOIN t3) + ** + ** If we flatten the above, we would get + ** + ** (t1 LEFT OUTER JOIN t2) JOIN t3 + ** + ** which is not at all the same thing. + ** + ** OBSOLETE COMMENT 2: + ** Restriction 12: If the subquery is the right operand of a left outer + ** join, make sure the subquery has no WHERE clause. + ** An examples of why this is not allowed: + ** + ** t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0) + ** + ** If we flatten the above, we would get + ** + ** (t1 LEFT OUTER JOIN t2) WHERE t2.x>0 + ** + ** But the t2.x>0 test will always fail on a NULL row of t2, which + ** effectively converts the OUTER JOIN into an INNER JOIN. + ** + ** THIS OVERRIDES OBSOLETE COMMENTS 1 AND 2 ABOVE: + ** Ticket #3300 shows that flattening the right term of a LEFT JOIN + ** is fraught with danger. Best to avoid the whole thing. If the + ** subquery is the right term of a LEFT JOIN, then do not flatten. + */ + if( (pSubitem->fg.jointype & JT_OUTER)!=0 ){ + return 0; + } + + /* Restriction 17: If the sub-query is a compound SELECT, then it must + ** use only the UNION ALL operator. And none of the simple select queries + ** that make up the compound SELECT are allowed to be aggregate or distinct + ** queries. + */ + if( pSub->pPrior ){ + if( pSub->pOrderBy ){ + return 0; /* Restriction 20 */ + } + if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){ + return 0; + } + for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){ + testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct ); + testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate ); + assert( pSub->pSrc!=0 ); + assert( pSub->pEList->nExpr==pSub1->pEList->nExpr ); + if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0 + || (pSub1->pPrior && pSub1->op!=TK_ALL) + || pSub1->pSrc->nSrc<1 + ){ + return 0; + } + testcase( pSub1->pSrc->nSrc>1 ); + } + + /* Restriction 18. */ + if( p->pOrderBy ){ + int ii; + for(ii=0; iipOrderBy->nExpr; ii++){ + if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0; + } + } + } + + /***** If we reach this point, flattening is permitted. *****/ + SELECTTRACE(1,pParse,p,("flatten %s.%p from term %d\n", + pSub->zSelName, pSub, iFrom)); + + /* Authorize the subquery */ + pParse->zAuthContext = pSubitem->zName; + TESTONLY(i =) sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0); + testcase( i==SQLITE_DENY ); + pParse->zAuthContext = zSavedAuthContext; + + /* If the sub-query is a compound SELECT statement, then (by restrictions + ** 17 and 18 above) it must be a UNION ALL and the parent query must + ** be of the form: + ** + ** SELECT FROM () + ** + ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block + ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or + ** OFFSET clauses and joins them to the left-hand-side of the original + ** using UNION ALL operators. In this case N is the number of simple + ** select statements in the compound sub-query. + ** + ** Example: + ** + ** SELECT a+1 FROM ( + ** SELECT x FROM tab + ** UNION ALL + ** SELECT y FROM tab + ** UNION ALL + ** SELECT abs(z*2) FROM tab2 + ** ) WHERE a!=5 ORDER BY 1 + ** + ** Transformed into: + ** + ** SELECT x+1 FROM tab WHERE x+1!=5 + ** UNION ALL + ** SELECT y+1 FROM tab WHERE y+1!=5 + ** UNION ALL + ** SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5 + ** ORDER BY 1 + ** + ** We call this the "compound-subquery flattening". + */ + for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){ + Select *pNew; + ExprList *pOrderBy = p->pOrderBy; + Expr *pLimit = p->pLimit; + Expr *pOffset = p->pOffset; + Select *pPrior = p->pPrior; + p->pOrderBy = 0; + p->pSrc = 0; + p->pPrior = 0; + p->pLimit = 0; + p->pOffset = 0; + pNew = sqlite3SelectDup(db, p, 0); + sqlite3SelectSetName(pNew, pSub->zSelName); + p->pOffset = pOffset; + p->pLimit = pLimit; + p->pOrderBy = pOrderBy; + p->pSrc = pSrc; + p->op = TK_ALL; + if( pNew==0 ){ + p->pPrior = pPrior; + }else{ + pNew->pPrior = pPrior; + if( pPrior ) pPrior->pNext = pNew; + pNew->pNext = p; + p->pPrior = pNew; + SELECTTRACE(2,pParse,p, + ("compound-subquery flattener creates %s.%p as peer\n", + pNew->zSelName, pNew)); + } + if( db->mallocFailed ) return 1; + } + + /* Begin flattening the iFrom-th entry of the FROM clause + ** in the outer query. + */ + pSub = pSub1 = pSubitem->pSelect; + + /* Delete the transient table structure associated with the + ** subquery + */ + sqlite3DbFree(db, pSubitem->zDatabase); + sqlite3DbFree(db, pSubitem->zName); + sqlite3DbFree(db, pSubitem->zAlias); + pSubitem->zDatabase = 0; + pSubitem->zName = 0; + pSubitem->zAlias = 0; + pSubitem->pSelect = 0; + + /* Defer deleting the Table object associated with the + ** subquery until code generation is + ** complete, since there may still exist Expr.pTab entries that + ** refer to the subquery even after flattening. Ticket #3346. + ** + ** pSubitem->pTab is always non-NULL by test restrictions and tests above. + */ + if( ALWAYS(pSubitem->pTab!=0) ){ + Table *pTabToDel = pSubitem->pTab; + if( pTabToDel->nRef==1 ){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + pTabToDel->pNextZombie = pToplevel->pZombieTab; + pToplevel->pZombieTab = pTabToDel; + }else{ + pTabToDel->nRef--; + } + pSubitem->pTab = 0; + } + + /* The following loop runs once for each term in a compound-subquery + ** flattening (as described above). If we are doing a different kind + ** of flattening - a flattening other than a compound-subquery flattening - + ** then this loop only runs once. + ** + ** This loop moves all of the FROM elements of the subquery into the + ** the FROM clause of the outer query. Before doing this, remember + ** the cursor number for the original outer query FROM element in + ** iParent. The iParent cursor will never be used. Subsequent code + ** will scan expressions looking for iParent references and replace + ** those references with expressions that resolve to the subquery FROM + ** elements we are now copying in. + */ + for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){ + int nSubSrc; + u8 jointype = 0; + pSubSrc = pSub->pSrc; /* FROM clause of subquery */ + nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */ + pSrc = pParent->pSrc; /* FROM clause of the outer query */ + + if( pSrc ){ + assert( pParent==p ); /* First time through the loop */ + jointype = pSubitem->fg.jointype; + }else{ + assert( pParent!=p ); /* 2nd and subsequent times through the loop */ + pSrc = pParent->pSrc = sqlite3SrcListAppend(db, 0, 0, 0); + if( pSrc==0 ){ + assert( db->mallocFailed ); + break; + } + } + + /* The subquery uses a single slot of the FROM clause of the outer + ** query. If the subquery has more than one element in its FROM clause, + ** then expand the outer query to make space for it to hold all elements + ** of the subquery. + ** + ** Example: + ** + ** SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB; + ** + ** The outer query has 3 slots in its FROM clause. One slot of the + ** outer query (the middle slot) is used by the subquery. The next + ** block of code will expand the outer query FROM clause to 4 slots. + ** The middle slot is expanded to two slots in order to make space + ** for the two elements in the FROM clause of the subquery. + */ + if( nSubSrc>1 ){ + pParent->pSrc = pSrc = sqlite3SrcListEnlarge(db, pSrc, nSubSrc-1,iFrom+1); + if( db->mallocFailed ){ + break; + } + } + + /* Transfer the FROM clause terms from the subquery into the + ** outer query. + */ + for(i=0; ia[i+iFrom].pUsing); + pSrc->a[i+iFrom] = pSubSrc->a[i]; + memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i])); + } + pSrc->a[iFrom].fg.jointype = jointype; + + /* Now begin substituting subquery result set expressions for + ** references to the iParent in the outer query. + ** + ** Example: + ** + ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b; + ** \ \_____________ subquery __________/ / + ** \_____________________ outer query ______________________________/ + ** + ** We look at every expression in the outer query and every place we see + ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10". + */ + pList = pParent->pEList; + for(i=0; inExpr; i++){ + if( pList->a[i].zName==0 ){ + char *zName = sqlite3DbStrDup(db, pList->a[i].zSpan); + sqlite3Dequote(zName); + pList->a[i].zName = zName; + } + } + if( pSub->pOrderBy ){ + /* At this point, any non-zero iOrderByCol values indicate that the + ** ORDER BY column expression is identical to the iOrderByCol'th + ** expression returned by SELECT statement pSub. Since these values + ** do not necessarily correspond to columns in SELECT statement pParent, + ** zero them before transfering the ORDER BY clause. + ** + ** Not doing this may cause an error if a subsequent call to this + ** function attempts to flatten a compound sub-query into pParent + ** (the only way this can happen is if the compound sub-query is + ** currently part of pSub->pSrc). See ticket [d11a6e908f]. */ + ExprList *pOrderBy = pSub->pOrderBy; + for(i=0; inExpr; i++){ + pOrderBy->a[i].u.x.iOrderByCol = 0; + } + assert( pParent->pOrderBy==0 ); + assert( pSub->pPrior==0 ); + pParent->pOrderBy = pOrderBy; + pSub->pOrderBy = 0; + } + pWhere = sqlite3ExprDup(db, pSub->pWhere, 0); + if( subqueryIsAgg ){ + assert( pParent->pHaving==0 ); + pParent->pHaving = pParent->pWhere; + pParent->pWhere = pWhere; + pParent->pHaving = sqlite3ExprAnd(db, pParent->pHaving, + sqlite3ExprDup(db, pSub->pHaving, 0)); + assert( pParent->pGroupBy==0 ); + pParent->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy, 0); + }else{ + pParent->pWhere = sqlite3ExprAnd(db, pParent->pWhere, pWhere); + } + substSelect(db, pParent, iParent, pSub->pEList, 0); + + /* The flattened query is distinct if either the inner or the + ** outer query is distinct. + */ + pParent->selFlags |= pSub->selFlags & SF_Distinct; + + /* + ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y; + ** + ** One is tempted to try to add a and b to combine the limits. But this + ** does not work if either limit is negative. + */ + if( pSub->pLimit ){ + pParent->pLimit = pSub->pLimit; + pSub->pLimit = 0; + } + } + + /* Finially, delete what is left of the subquery and return + ** success. + */ + sqlite3SelectDelete(db, pSub1); + +#if SELECTTRACE_ENABLED + if( sqlite3SelectTrace & 0x100 ){ + SELECTTRACE(0x100,pParse,p,("After flattening:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + return 1; +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + + + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* +** Make copies of relevant WHERE clause terms of the outer query into +** the WHERE clause of subquery. Example: +** +** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1) WHERE x=5 AND y=10; +** +** Transformed into: +** +** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1 WHERE a=5 AND c-d=10) +** WHERE x=5 AND y=10; +** +** The hope is that the terms added to the inner query will make it more +** efficient. +** +** Do not attempt this optimization if: +** +** (1) The inner query is an aggregate. (In that case, we'd really want +** to copy the outer WHERE-clause terms onto the HAVING clause of the +** inner query. But they probably won't help there so do not bother.) +** +** (2) The inner query is the recursive part of a common table expression. +** +** (3) The inner query has a LIMIT clause (since the changes to the WHERE +** close would change the meaning of the LIMIT). +** +** (4) The inner query is the right operand of a LEFT JOIN. (The caller +** enforces this restriction since this routine does not have enough +** information to know.) +** +** (5) The WHERE clause expression originates in the ON or USING clause +** of a LEFT JOIN. +** +** Return 0 if no changes are made and non-zero if one or more WHERE clause +** terms are duplicated into the subquery. +*/ +static int pushDownWhereTerms( + sqlite3 *db, /* The database connection (for malloc()) */ + Select *pSubq, /* The subquery whose WHERE clause is to be augmented */ + Expr *pWhere, /* The WHERE clause of the outer query */ + int iCursor /* Cursor number of the subquery */ +){ + Expr *pNew; + int nChng = 0; + if( pWhere==0 ) return 0; + if( (pSubq->selFlags & (SF_Aggregate|SF_Recursive))!=0 ){ + return 0; /* restrictions (1) and (2) */ + } + if( pSubq->pLimit!=0 ){ + return 0; /* restriction (3) */ + } + while( pWhere->op==TK_AND ){ + nChng += pushDownWhereTerms(db, pSubq, pWhere->pRight, iCursor); + pWhere = pWhere->pLeft; + } + if( ExprHasProperty(pWhere,EP_FromJoin) ) return 0; /* restriction 5 */ + if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){ + nChng++; + while( pSubq ){ + pNew = sqlite3ExprDup(db, pWhere, 0); + pNew = substExpr(db, pNew, iCursor, pSubq->pEList); + pSubq->pWhere = sqlite3ExprAnd(db, pSubq->pWhere, pNew); + pSubq = pSubq->pPrior; + } + } + return nChng; +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +/* +** Based on the contents of the AggInfo structure indicated by the first +** argument, this function checks if the following are true: +** +** * the query contains just a single aggregate function, +** * the aggregate function is either min() or max(), and +** * the argument to the aggregate function is a column value. +** +** If all of the above are true, then WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX +** is returned as appropriate. Also, *ppMinMax is set to point to the +** list of arguments passed to the aggregate before returning. +** +** Or, if the conditions above are not met, *ppMinMax is set to 0 and +** WHERE_ORDERBY_NORMAL is returned. +*/ +static u8 minMaxQuery(AggInfo *pAggInfo, ExprList **ppMinMax){ + int eRet = WHERE_ORDERBY_NORMAL; /* Return value */ + + *ppMinMax = 0; + if( pAggInfo->nFunc==1 ){ + Expr *pExpr = pAggInfo->aFunc[0].pExpr; /* Aggregate function */ + ExprList *pEList = pExpr->x.pList; /* Arguments to agg function */ + + assert( pExpr->op==TK_AGG_FUNCTION ); + if( pEList && pEList->nExpr==1 && pEList->a[0].pExpr->op==TK_AGG_COLUMN ){ + const char *zFunc = pExpr->u.zToken; + if( sqlite3StrICmp(zFunc, "min")==0 ){ + eRet = WHERE_ORDERBY_MIN; + *ppMinMax = pEList; + }else if( sqlite3StrICmp(zFunc, "max")==0 ){ + eRet = WHERE_ORDERBY_MAX; + *ppMinMax = pEList; + } + } + } + + assert( *ppMinMax==0 || (*ppMinMax)->nExpr==1 ); + return eRet; +} + +/* +** The select statement passed as the first argument is an aggregate query. +** The second argument is the associated aggregate-info object. This +** function tests if the SELECT is of the form: +** +** SELECT count(*) FROM +** +** where table is a database table, not a sub-select or view. If the query +** does match this pattern, then a pointer to the Table object representing +** is returned. Otherwise, 0 is returned. +*/ +static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){ + Table *pTab; + Expr *pExpr; + + assert( !p->pGroupBy ); + + if( p->pWhere || p->pEList->nExpr!=1 + || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect + ){ + return 0; + } + pTab = p->pSrc->a[0].pTab; + pExpr = p->pEList->a[0].pExpr; + assert( pTab && !pTab->pSelect && pExpr ); + + if( IsVirtual(pTab) ) return 0; + if( pExpr->op!=TK_AGG_FUNCTION ) return 0; + if( NEVER(pAggInfo->nFunc==0) ) return 0; + if( (pAggInfo->aFunc[0].pFunc->funcFlags&SQLITE_FUNC_COUNT)==0 ) return 0; + if( pExpr->flags&EP_Distinct ) return 0; + + return pTab; +} + +/* +** If the source-list item passed as an argument was augmented with an +** INDEXED BY clause, then try to locate the specified index. If there +** was such a clause and the named index cannot be found, return +** SQLITE_ERROR and leave an error in pParse. Otherwise, populate +** pFrom->pIndex and return SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){ + if( pFrom->pTab && pFrom->fg.isIndexedBy ){ + Table *pTab = pFrom->pTab; + char *zIndexedBy = pFrom->u1.zIndexedBy; + Index *pIdx; + for(pIdx=pTab->pIndex; + pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy); + pIdx=pIdx->pNext + ); + if( !pIdx ){ + sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0); + pParse->checkSchema = 1; + return SQLITE_ERROR; + } + pFrom->pIBIndex = pIdx; + } + return SQLITE_OK; +} +/* +** Detect compound SELECT statements that use an ORDER BY clause with +** an alternative collating sequence. +** +** SELECT ... FROM t1 EXCEPT SELECT ... FROM t2 ORDER BY .. COLLATE ... +** +** These are rewritten as a subquery: +** +** SELECT * FROM (SELECT ... FROM t1 EXCEPT SELECT ... FROM t2) +** ORDER BY ... COLLATE ... +** +** This transformation is necessary because the multiSelectOrderBy() routine +** above that generates the code for a compound SELECT with an ORDER BY clause +** uses a merge algorithm that requires the same collating sequence on the +** result columns as on the ORDER BY clause. See ticket +** http://www.sqlite.org/src/info/6709574d2a +** +** This transformation is only needed for EXCEPT, INTERSECT, and UNION. +** The UNION ALL operator works fine with multiSelectOrderBy() even when +** there are COLLATE terms in the ORDER BY. +*/ +static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){ + int i; + Select *pNew; + Select *pX; + sqlite3 *db; + struct ExprList_item *a; + SrcList *pNewSrc; + Parse *pParse; + Token dummy; + + if( p->pPrior==0 ) return WRC_Continue; + if( p->pOrderBy==0 ) return WRC_Continue; + for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){} + if( pX==0 ) return WRC_Continue; + a = p->pOrderBy->a; + for(i=p->pOrderBy->nExpr-1; i>=0; i--){ + if( a[i].pExpr->flags & EP_Collate ) break; + } + if( i<0 ) return WRC_Continue; + + /* If we reach this point, that means the transformation is required. */ + + pParse = pWalker->pParse; + db = pParse->db; + pNew = sqlite3DbMallocZero(db, sizeof(*pNew) ); + if( pNew==0 ) return WRC_Abort; + memset(&dummy, 0, sizeof(dummy)); + pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0,0); + if( pNewSrc==0 ) return WRC_Abort; + *pNew = *p; + p->pSrc = pNewSrc; + p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ALL, 0)); + p->op = TK_SELECT; + p->pWhere = 0; + pNew->pGroupBy = 0; + pNew->pHaving = 0; + pNew->pOrderBy = 0; + p->pPrior = 0; + p->pNext = 0; + p->pWith = 0; + p->selFlags &= ~SF_Compound; + assert( (p->selFlags & SF_Converted)==0 ); + p->selFlags |= SF_Converted; + assert( pNew->pPrior!=0 ); + pNew->pPrior->pNext = pNew; + pNew->pLimit = 0; + pNew->pOffset = 0; + return WRC_Continue; +} + +#ifndef SQLITE_OMIT_CTE +/* +** Argument pWith (which may be NULL) points to a linked list of nested +** WITH contexts, from inner to outermost. If the table identified by +** FROM clause element pItem is really a common-table-expression (CTE) +** then return a pointer to the CTE definition for that table. Otherwise +** return NULL. +** +** If a non-NULL value is returned, set *ppContext to point to the With +** object that the returned CTE belongs to. +*/ +static struct Cte *searchWith( + With *pWith, /* Current outermost WITH clause */ + struct SrcList_item *pItem, /* FROM clause element to resolve */ + With **ppContext /* OUT: WITH clause return value belongs to */ +){ + const char *zName; + if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){ + With *p; + for(p=pWith; p; p=p->pOuter){ + int i; + for(i=0; inCte; i++){ + if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){ + *ppContext = p; + return &p->a[i]; + } + } + } + } + return 0; +} + +/* The code generator maintains a stack of active WITH clauses +** with the inner-most WITH clause being at the top of the stack. +** +** This routine pushes the WITH clause passed as the second argument +** onto the top of the stack. If argument bFree is true, then this +** WITH clause will never be popped from the stack. In this case it +** should be freed along with the Parse object. In other cases, when +** bFree==0, the With object will be freed along with the SELECT +** statement with which it is associated. +*/ +SQLITE_PRIVATE void sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){ + assert( bFree==0 || pParse->pWith==0 ); + if( pWith ){ + pWith->pOuter = pParse->pWith; + pParse->pWith = pWith; + pParse->bFreeWith = bFree; + } +} + +/* +** This function checks if argument pFrom refers to a CTE declared by +** a WITH clause on the stack currently maintained by the parser. And, +** if currently processing a CTE expression, if it is a recursive +** reference to the current CTE. +** +** If pFrom falls into either of the two categories above, pFrom->pTab +** and other fields are populated accordingly. The caller should check +** (pFrom->pTab!=0) to determine whether or not a successful match +** was found. +** +** Whether or not a match is found, SQLITE_OK is returned if no error +** occurs. If an error does occur, an error message is stored in the +** parser and some error code other than SQLITE_OK returned. +*/ +static int withExpand( + Walker *pWalker, + struct SrcList_item *pFrom +){ + Parse *pParse = pWalker->pParse; + sqlite3 *db = pParse->db; + struct Cte *pCte; /* Matched CTE (or NULL if no match) */ + With *pWith; /* WITH clause that pCte belongs to */ + + assert( pFrom->pTab==0 ); + + pCte = searchWith(pParse->pWith, pFrom, &pWith); + if( pCte ){ + Table *pTab; + ExprList *pEList; + Select *pSel; + Select *pLeft; /* Left-most SELECT statement */ + int bMayRecursive; /* True if compound joined by UNION [ALL] */ + With *pSavedWith; /* Initial value of pParse->pWith */ + + /* If pCte->zCteErr is non-NULL at this point, then this is an illegal + ** recursive reference to CTE pCte. Leave an error in pParse and return + ** early. If pCte->zCteErr is NULL, then this is not a recursive reference. + ** In this case, proceed. */ + if( pCte->zCteErr ){ + sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName); + return SQLITE_ERROR; + } + + assert( pFrom->pTab==0 ); + pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTab==0 ) return WRC_Abort; + pTab->nRef = 1; + pTab->zName = sqlite3DbStrDup(db, pCte->zName); + pTab->iPKey = -1; + pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); + pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid; + pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0); + if( db->mallocFailed ) return SQLITE_NOMEM; + assert( pFrom->pSelect ); + + /* Check if this is a recursive CTE. */ + pSel = pFrom->pSelect; + bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION ); + if( bMayRecursive ){ + int i; + SrcList *pSrc = pFrom->pSelect->pSrc; + for(i=0; inSrc; i++){ + struct SrcList_item *pItem = &pSrc->a[i]; + if( pItem->zDatabase==0 + && pItem->zName!=0 + && 0==sqlite3StrICmp(pItem->zName, pCte->zName) + ){ + pItem->pTab = pTab; + pItem->fg.isRecursive = 1; + pTab->nRef++; + pSel->selFlags |= SF_Recursive; + } + } + } + + /* Only one recursive reference is permitted. */ + if( pTab->nRef>2 ){ + sqlite3ErrorMsg( + pParse, "multiple references to recursive table: %s", pCte->zName + ); + return SQLITE_ERROR; + } + assert( pTab->nRef==1 || ((pSel->selFlags&SF_Recursive) && pTab->nRef==2 )); + + pCte->zCteErr = "circular reference: %s"; + pSavedWith = pParse->pWith; + pParse->pWith = pWith; + sqlite3WalkSelect(pWalker, bMayRecursive ? pSel->pPrior : pSel); + + for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior); + pEList = pLeft->pEList; + if( pCte->pCols ){ + if( pEList && pEList->nExpr!=pCte->pCols->nExpr ){ + sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns", + pCte->zName, pEList->nExpr, pCte->pCols->nExpr + ); + pParse->pWith = pSavedWith; + return SQLITE_ERROR; + } + pEList = pCte->pCols; + } + + sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol); + if( bMayRecursive ){ + if( pSel->selFlags & SF_Recursive ){ + pCte->zCteErr = "multiple recursive references: %s"; + }else{ + pCte->zCteErr = "recursive reference in a subquery: %s"; + } + sqlite3WalkSelect(pWalker, pSel); + } + pCte->zCteErr = 0; + pParse->pWith = pSavedWith; + } + + return SQLITE_OK; +} +#endif + +#ifndef SQLITE_OMIT_CTE +/* +** If the SELECT passed as the second argument has an associated WITH +** clause, pop it from the stack stored as part of the Parse object. +** +** This function is used as the xSelectCallback2() callback by +** sqlite3SelectExpand() when walking a SELECT tree to resolve table +** names and other FROM clause elements. +*/ +static void selectPopWith(Walker *pWalker, Select *p){ + Parse *pParse = pWalker->pParse; + With *pWith = findRightmost(p)->pWith; + if( pWith!=0 ){ + assert( pParse->pWith==pWith ); + pParse->pWith = pWith->pOuter; + } +} +#else +#define selectPopWith 0 +#endif + +/* +** This routine is a Walker callback for "expanding" a SELECT statement. +** "Expanding" means to do the following: +** +** (1) Make sure VDBE cursor numbers have been assigned to every +** element of the FROM clause. +** +** (2) Fill in the pTabList->a[].pTab fields in the SrcList that +** defines FROM clause. When views appear in the FROM clause, +** fill pTabList->a[].pSelect with a copy of the SELECT statement +** that implements the view. A copy is made of the view's SELECT +** statement so that we can freely modify or delete that statement +** without worrying about messing up the persistent representation +** of the view. +** +** (3) Add terms to the WHERE clause to accommodate the NATURAL keyword +** on joins and the ON and USING clause of joins. +** +** (4) Scan the list of columns in the result set (pEList) looking +** for instances of the "*" operator or the TABLE.* operator. +** If found, expand each "*" to be every column in every table +** and TABLE.* to be every column in TABLE. +** +*/ +static int selectExpander(Walker *pWalker, Select *p){ + Parse *pParse = pWalker->pParse; + int i, j, k; + SrcList *pTabList; + ExprList *pEList; + struct SrcList_item *pFrom; + sqlite3 *db = pParse->db; + Expr *pE, *pRight, *pExpr; + u16 selFlags = p->selFlags; + + p->selFlags |= SF_Expanded; + if( db->mallocFailed ){ + return WRC_Abort; + } + if( NEVER(p->pSrc==0) || (selFlags & SF_Expanded)!=0 ){ + return WRC_Prune; + } + pTabList = p->pSrc; + pEList = p->pEList; + if( pWalker->xSelectCallback2==selectPopWith ){ + sqlite3WithPush(pParse, findRightmost(p)->pWith, 0); + } + + /* Make sure cursor numbers have been assigned to all entries in + ** the FROM clause of the SELECT statement. + */ + sqlite3SrcListAssignCursors(pParse, pTabList); + + /* Look up every table named in the FROM clause of the select. If + ** an entry of the FROM clause is a subquery instead of a table or view, + ** then create a transient table structure to describe the subquery. + */ + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab; + assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 ); + if( pFrom->fg.isRecursive ) continue; + assert( pFrom->pTab==0 ); +#ifndef SQLITE_OMIT_CTE + if( withExpand(pWalker, pFrom) ) return WRC_Abort; + if( pFrom->pTab ) {} else +#endif + if( pFrom->zName==0 ){ +#ifndef SQLITE_OMIT_SUBQUERY + Select *pSel = pFrom->pSelect; + /* A sub-query in the FROM clause of a SELECT */ + assert( pSel!=0 ); + assert( pFrom->pTab==0 ); + if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort; + pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTab==0 ) return WRC_Abort; + pTab->nRef = 1; + pTab->zName = sqlite3MPrintf(db, "sqlite_sq_%p", (void*)pTab); + while( pSel->pPrior ){ pSel = pSel->pPrior; } + sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol); + pTab->iPKey = -1; + pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); + pTab->tabFlags |= TF_Ephemeral; +#endif + }else{ + /* An ordinary table or view name in the FROM clause */ + assert( pFrom->pTab==0 ); + pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom); + if( pTab==0 ) return WRC_Abort; + if( pTab->nRef==0xffff ){ + sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535", + pTab->zName); + pFrom->pTab = 0; + return WRC_Abort; + } + pTab->nRef++; +#if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE) + if( pTab->pSelect || IsVirtual(pTab) ){ + i16 nCol; + if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort; + assert( pFrom->pSelect==0 ); + if( pFrom->fg.isTabFunc && !IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "'%s' is not a function", pTab->zName); + return WRC_Abort; + } + pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0); + sqlite3SelectSetName(pFrom->pSelect, pTab->zName); + nCol = pTab->nCol; + pTab->nCol = -1; + sqlite3WalkSelect(pWalker, pFrom->pSelect); + pTab->nCol = nCol; + } +#endif + } + + /* Locate the index named by the INDEXED BY clause, if any. */ + if( sqlite3IndexedByLookup(pParse, pFrom) ){ + return WRC_Abort; + } + } + + /* Process NATURAL keywords, and ON and USING clauses of joins. + */ + if( db->mallocFailed || sqliteProcessJoin(pParse, p) ){ + return WRC_Abort; + } + + /* For every "*" that occurs in the column list, insert the names of + ** all columns in all tables. And for every TABLE.* insert the names + ** of all columns in TABLE. The parser inserted a special expression + ** with the TK_ALL operator for each "*" that it found in the column list. + ** The following code just has to locate the TK_ALL expressions and expand + ** each one to the list of all columns in all tables. + ** + ** The first loop just checks to see if there are any "*" operators + ** that need expanding. + */ + for(k=0; knExpr; k++){ + pE = pEList->a[k].pExpr; + if( pE->op==TK_ALL ) break; + assert( pE->op!=TK_DOT || pE->pRight!=0 ); + assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) ); + if( pE->op==TK_DOT && pE->pRight->op==TK_ALL ) break; + } + if( knExpr ){ + /* + ** If we get here it means the result set contains one or more "*" + ** operators that need to be expanded. Loop through each expression + ** in the result set and expand them one by one. + */ + struct ExprList_item *a = pEList->a; + ExprList *pNew = 0; + int flags = pParse->db->flags; + int longNames = (flags & SQLITE_FullColNames)!=0 + && (flags & SQLITE_ShortColNames)==0; + + for(k=0; knExpr; k++){ + pE = a[k].pExpr; + pRight = pE->pRight; + assert( pE->op!=TK_DOT || pRight!=0 ); + if( pE->op!=TK_ALL && (pE->op!=TK_DOT || pRight->op!=TK_ALL) ){ + /* This particular expression does not need to be expanded. + */ + pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr); + if( pNew ){ + pNew->a[pNew->nExpr-1].zName = a[k].zName; + pNew->a[pNew->nExpr-1].zSpan = a[k].zSpan; + a[k].zName = 0; + a[k].zSpan = 0; + } + a[k].pExpr = 0; + }else{ + /* This expression is a "*" or a "TABLE.*" and needs to be + ** expanded. */ + int tableSeen = 0; /* Set to 1 when TABLE matches */ + char *zTName = 0; /* text of name of TABLE */ + if( pE->op==TK_DOT ){ + assert( pE->pLeft!=0 ); + assert( !ExprHasProperty(pE->pLeft, EP_IntValue) ); + zTName = pE->pLeft->u.zToken; + } + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab = pFrom->pTab; + Select *pSub = pFrom->pSelect; + char *zTabName = pFrom->zAlias; + const char *zSchemaName = 0; + int iDb; + if( zTabName==0 ){ + zTabName = pTab->zName; + } + if( db->mallocFailed ) break; + if( pSub==0 || (pSub->selFlags & SF_NestedFrom)==0 ){ + pSub = 0; + if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){ + continue; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + zSchemaName = iDb>=0 ? db->aDb[iDb].zName : "*"; + } + for(j=0; jnCol; j++){ + char *zName = pTab->aCol[j].zName; + char *zColname; /* The computed column name */ + char *zToFree; /* Malloced string that needs to be freed */ + Token sColname; /* Computed column name as a token */ + + assert( zName ); + if( zTName && pSub + && sqlite3MatchSpanName(pSub->pEList->a[j].zSpan, 0, zTName, 0)==0 + ){ + continue; + } + + /* If a column is marked as 'hidden' (currently only possible + ** for virtual tables), do not include it in the expanded + ** result-set list. + */ + if( IsHiddenColumn(&pTab->aCol[j]) ){ + assert(IsVirtual(pTab)); + continue; + } + tableSeen = 1; + + if( i>0 && zTName==0 ){ + if( (pFrom->fg.jointype & JT_NATURAL)!=0 + && tableAndColumnIndex(pTabList, i, zName, 0, 0) + ){ + /* In a NATURAL join, omit the join columns from the + ** table to the right of the join */ + continue; + } + if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){ + /* In a join with a USING clause, omit columns in the + ** using clause from the table on the right. */ + continue; + } + } + pRight = sqlite3Expr(db, TK_ID, zName); + zColname = zName; + zToFree = 0; + if( longNames || pTabList->nSrc>1 ){ + Expr *pLeft; + pLeft = sqlite3Expr(db, TK_ID, zTabName); + pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0); + if( zSchemaName ){ + pLeft = sqlite3Expr(db, TK_ID, zSchemaName); + pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr, 0); + } + if( longNames ){ + zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName); + zToFree = zColname; + } + }else{ + pExpr = pRight; + } + pNew = sqlite3ExprListAppend(pParse, pNew, pExpr); + sColname.z = zColname; + sColname.n = sqlite3Strlen30(zColname); + sqlite3ExprListSetName(pParse, pNew, &sColname, 0); + if( pNew && (p->selFlags & SF_NestedFrom)!=0 ){ + struct ExprList_item *pX = &pNew->a[pNew->nExpr-1]; + if( pSub ){ + pX->zSpan = sqlite3DbStrDup(db, pSub->pEList->a[j].zSpan); + testcase( pX->zSpan==0 ); + }else{ + pX->zSpan = sqlite3MPrintf(db, "%s.%s.%s", + zSchemaName, zTabName, zColname); + testcase( pX->zSpan==0 ); + } + pX->bSpanIsTab = 1; + } + sqlite3DbFree(db, zToFree); + } + } + if( !tableSeen ){ + if( zTName ){ + sqlite3ErrorMsg(pParse, "no such table: %s", zTName); + }else{ + sqlite3ErrorMsg(pParse, "no tables specified"); + } + } + } + } + sqlite3ExprListDelete(db, pEList); + p->pEList = pNew; + } +#if SQLITE_MAX_COLUMN + if( p->pEList && p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many columns in result set"); + } +#endif + return WRC_Continue; +} + +/* +** No-op routine for the parse-tree walker. +** +** When this routine is the Walker.xExprCallback then expression trees +** are walked without any actions being taken at each node. Presumably, +** when this routine is used for Walker.xExprCallback then +** Walker.xSelectCallback is set to do something useful for every +** subquery in the parser tree. +*/ +static int exprWalkNoop(Walker *NotUsed, Expr *NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return WRC_Continue; +} + +/* +** This routine "expands" a SELECT statement and all of its subqueries. +** For additional information on what it means to "expand" a SELECT +** statement, see the comment on the selectExpand worker callback above. +** +** Expanding a SELECT statement is the first step in processing a +** SELECT statement. The SELECT statement must be expanded before +** name resolution is performed. +** +** If anything goes wrong, an error message is written into pParse. +** The calling function can detect the problem by looking at pParse->nErr +** and/or pParse->db->mallocFailed. +*/ +static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){ + Walker w; + memset(&w, 0, sizeof(w)); + w.xExprCallback = exprWalkNoop; + w.pParse = pParse; + if( pParse->hasCompound ){ + w.xSelectCallback = convertCompoundSelectToSubquery; + sqlite3WalkSelect(&w, pSelect); + } + w.xSelectCallback = selectExpander; + if( (pSelect->selFlags & SF_MultiValue)==0 ){ + w.xSelectCallback2 = selectPopWith; + } + sqlite3WalkSelect(&w, pSelect); +} + + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo() +** interface. +** +** For each FROM-clause subquery, add Column.zType and Column.zColl +** information to the Table structure that represents the result set +** of that subquery. +** +** The Table structure that represents the result set was constructed +** by selectExpander() but the type and collation information was omitted +** at that point because identifiers had not yet been resolved. This +** routine is called after identifier resolution. +*/ +static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){ + Parse *pParse; + int i; + SrcList *pTabList; + struct SrcList_item *pFrom; + + assert( p->selFlags & SF_Resolved ); + assert( (p->selFlags & SF_HasTypeInfo)==0 ); + p->selFlags |= SF_HasTypeInfo; + pParse = pWalker->pParse; + pTabList = p->pSrc; + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab = pFrom->pTab; + assert( pTab!=0 ); + if( (pTab->tabFlags & TF_Ephemeral)!=0 ){ + /* A sub-query in the FROM clause of a SELECT */ + Select *pSel = pFrom->pSelect; + if( pSel ){ + while( pSel->pPrior ) pSel = pSel->pPrior; + selectAddColumnTypeAndCollation(pParse, pTab, pSel); + } + } + } +} +#endif + + +/* +** This routine adds datatype and collating sequence information to +** the Table structures of all FROM-clause subqueries in a +** SELECT statement. +** +** Use this routine after name resolution. +*/ +static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){ +#ifndef SQLITE_OMIT_SUBQUERY + Walker w; + memset(&w, 0, sizeof(w)); + w.xSelectCallback2 = selectAddSubqueryTypeInfo; + w.xExprCallback = exprWalkNoop; + w.pParse = pParse; + sqlite3WalkSelect(&w, pSelect); +#endif +} + + +/* +** This routine sets up a SELECT statement for processing. The +** following is accomplished: +** +** * VDBE Cursor numbers are assigned to all FROM-clause terms. +** * Ephemeral Table objects are created for all FROM-clause subqueries. +** * ON and USING clauses are shifted into WHERE statements +** * Wildcards "*" and "TABLE.*" in result sets are expanded. +** * Identifiers in expression are matched to tables. +** +** This routine acts recursively on all subqueries within the SELECT. +*/ +SQLITE_PRIVATE void sqlite3SelectPrep( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + NameContext *pOuterNC /* Name context for container */ +){ + sqlite3 *db; + if( NEVER(p==0) ) return; + db = pParse->db; + if( db->mallocFailed ) return; + if( p->selFlags & SF_HasTypeInfo ) return; + sqlite3SelectExpand(pParse, p); + if( pParse->nErr || db->mallocFailed ) return; + sqlite3ResolveSelectNames(pParse, p, pOuterNC); + if( pParse->nErr || db->mallocFailed ) return; + sqlite3SelectAddTypeInfo(pParse, p); +} + +/* +** Reset the aggregate accumulator. +** +** The aggregate accumulator is a set of memory cells that hold +** intermediate results while calculating an aggregate. This +** routine generates code that stores NULLs in all of those memory +** cells. +*/ +static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + struct AggInfo_func *pFunc; + int nReg = pAggInfo->nFunc + pAggInfo->nColumn; + if( nReg==0 ) return; +#ifdef SQLITE_DEBUG + /* Verify that all AggInfo registers are within the range specified by + ** AggInfo.mnReg..AggInfo.mxReg */ + assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 ); + for(i=0; inColumn; i++){ + assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg + && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg ); + } + for(i=0; inFunc; i++){ + assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg + && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg ); + } +#endif + sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg); + for(pFunc=pAggInfo->aFunc, i=0; inFunc; i++, pFunc++){ + if( pFunc->iDistinct>=0 ){ + Expr *pE = pFunc->pExpr; + assert( !ExprHasProperty(pE, EP_xIsSelect) ); + if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){ + sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one " + "argument"); + pFunc->iDistinct = -1; + }else{ + KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->x.pList, 0, 0); + sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0, + (char*)pKeyInfo, P4_KEYINFO); + } + } + } +} + +/* +** Invoke the OP_AggFinalize opcode for every aggregate function +** in the AggInfo structure. +*/ +static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + struct AggInfo_func *pF; + for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ + ExprList *pList = pF->pExpr->x.pList; + assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) ); + sqlite3VdbeAddOp4(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0, 0, + (void*)pF->pFunc, P4_FUNCDEF); + } +} + +/* +** Update the accumulator memory cells for an aggregate based on +** the current cursor position. +*/ +static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + int regHit = 0; + int addrHitTest = 0; + struct AggInfo_func *pF; + struct AggInfo_col *pC; + + pAggInfo->directMode = 1; + for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ + int nArg; + int addrNext = 0; + int regAgg; + ExprList *pList = pF->pExpr->x.pList; + assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) ); + if( pList ){ + nArg = pList->nExpr; + regAgg = sqlite3GetTempRange(pParse, nArg); + sqlite3ExprCodeExprList(pParse, pList, regAgg, 0, SQLITE_ECEL_DUP); + }else{ + nArg = 0; + regAgg = 0; + } + if( pF->iDistinct>=0 ){ + addrNext = sqlite3VdbeMakeLabel(v); + testcase( nArg==0 ); /* Error condition */ + testcase( nArg>1 ); /* Also an error */ + codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg); + } + if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){ + CollSeq *pColl = 0; + struct ExprList_item *pItem; + int j; + assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */ + for(j=0, pItem=pList->a; !pColl && jpExpr); + } + if( !pColl ){ + pColl = pParse->db->pDfltColl; + } + if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem; + sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0, (char *)pColl, P4_COLLSEQ); + } + sqlite3VdbeAddOp4(v, OP_AggStep0, 0, regAgg, pF->iMem, + (void*)pF->pFunc, P4_FUNCDEF); + sqlite3VdbeChangeP5(v, (u8)nArg); + sqlite3ExprCacheAffinityChange(pParse, regAgg, nArg); + sqlite3ReleaseTempRange(pParse, regAgg, nArg); + if( addrNext ){ + sqlite3VdbeResolveLabel(v, addrNext); + sqlite3ExprCacheClear(pParse); + } + } + + /* Before populating the accumulator registers, clear the column cache. + ** Otherwise, if any of the required column values are already present + ** in registers, sqlite3ExprCode() may use OP_SCopy to copy the value + ** to pC->iMem. But by the time the value is used, the original register + ** may have been used, invalidating the underlying buffer holding the + ** text or blob value. See ticket [883034dcb5]. + ** + ** Another solution would be to change the OP_SCopy used to copy cached + ** values to an OP_Copy. + */ + if( regHit ){ + addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v); + } + sqlite3ExprCacheClear(pParse); + for(i=0, pC=pAggInfo->aCol; inAccumulator; i++, pC++){ + sqlite3ExprCode(pParse, pC->pExpr, pC->iMem); + } + pAggInfo->directMode = 0; + sqlite3ExprCacheClear(pParse); + if( addrHitTest ){ + sqlite3VdbeJumpHere(v, addrHitTest); + } +} + +/* +** Add a single OP_Explain instruction to the VDBE to explain a simple +** count(*) query ("SELECT count(*) FROM pTab"). +*/ +#ifndef SQLITE_OMIT_EXPLAIN +static void explainSimpleCount( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being queried */ + Index *pIdx /* Index used to optimize scan, or NULL */ +){ + if( pParse->explain==2 ){ + int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx))); + char *zEqp = sqlite3MPrintf(pParse->db, "SCAN TABLE %s%s%s", + pTab->zName, + bCover ? " USING COVERING INDEX " : "", + bCover ? pIdx->zName : "" + ); + sqlite3VdbeAddOp4( + pParse->pVdbe, OP_Explain, pParse->iSelectId, 0, 0, zEqp, P4_DYNAMIC + ); + } +} +#else +# define explainSimpleCount(a,b,c) +#endif + +/* +** Generate code for the SELECT statement given in the p argument. +** +** The results are returned according to the SelectDest structure. +** See comments in sqliteInt.h for further information. +** +** This routine returns the number of errors. If any errors are +** encountered, then an appropriate error message is left in +** pParse->zErrMsg. +** +** This routine does NOT free the Select structure passed in. The +** calling function needs to do that. +*/ +SQLITE_PRIVATE int sqlite3Select( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + SelectDest *pDest /* What to do with the query results */ +){ + int i, j; /* Loop counters */ + WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */ + Vdbe *v; /* The virtual machine under construction */ + int isAgg; /* True for select lists like "count(*)" */ + ExprList *pEList = 0; /* List of columns to extract. */ + SrcList *pTabList; /* List of tables to select from */ + Expr *pWhere; /* The WHERE clause. May be NULL */ + ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */ + Expr *pHaving; /* The HAVING clause. May be NULL */ + int rc = 1; /* Value to return from this function */ + DistinctCtx sDistinct; /* Info on how to code the DISTINCT keyword */ + SortCtx sSort; /* Info on how to code the ORDER BY clause */ + AggInfo sAggInfo; /* Information used by aggregate queries */ + int iEnd; /* Address of the end of the query */ + sqlite3 *db; /* The database connection */ + +#ifndef SQLITE_OMIT_EXPLAIN + int iRestoreSelectId = pParse->iSelectId; + pParse->iSelectId = pParse->iNextSelectId++; +#endif + + db = pParse->db; + if( p==0 || db->mallocFailed || pParse->nErr ){ + return 1; + } + if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; + memset(&sAggInfo, 0, sizeof(sAggInfo)); +#if SELECTTRACE_ENABLED + pParse->nSelectIndent++; + SELECTTRACE(1,pParse,p, ("begin processing:\n")); + if( sqlite3SelectTrace & 0x100 ){ + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo ); + assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo ); + assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue ); + assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue ); + if( IgnorableOrderby(pDest) ){ + assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union || + pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard || + pDest->eDest==SRT_Queue || pDest->eDest==SRT_DistFifo || + pDest->eDest==SRT_DistQueue || pDest->eDest==SRT_Fifo); + /* If ORDER BY makes no difference in the output then neither does + ** DISTINCT so it can be removed too. */ + sqlite3ExprListDelete(db, p->pOrderBy); + p->pOrderBy = 0; + p->selFlags &= ~SF_Distinct; + } + sqlite3SelectPrep(pParse, p, 0); + memset(&sSort, 0, sizeof(sSort)); + sSort.pOrderBy = p->pOrderBy; + pTabList = p->pSrc; + if( pParse->nErr || db->mallocFailed ){ + goto select_end; + } + assert( p->pEList!=0 ); + isAgg = (p->selFlags & SF_Aggregate)!=0; +#if SELECTTRACE_ENABLED + if( sqlite3SelectTrace & 0x100 ){ + SELECTTRACE(0x100,pParse,p, ("after name resolution:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + + /* If writing to memory or generating a set + ** only a single column may be output. + */ +#ifndef SQLITE_OMIT_SUBQUERY + if( checkForMultiColumnSelectError(pParse, pDest, p->pEList->nExpr) ){ + goto select_end; + } +#endif + + /* Try to flatten subqueries in the FROM clause up into the main query + */ +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + for(i=0; !p->pPrior && inSrc; i++){ + struct SrcList_item *pItem = &pTabList->a[i]; + Select *pSub = pItem->pSelect; + int isAggSub; + Table *pTab = pItem->pTab; + if( pSub==0 ) continue; + + /* Catch mismatch in the declared columns of a view and the number of + ** columns in the SELECT on the RHS */ + if( pTab->nCol!=pSub->pEList->nExpr ){ + sqlite3ErrorMsg(pParse, "expected %d columns for '%s' but got %d", + pTab->nCol, pTab->zName, pSub->pEList->nExpr); + goto select_end; + } + + isAggSub = (pSub->selFlags & SF_Aggregate)!=0; + if( flattenSubquery(pParse, p, i, isAgg, isAggSub) ){ + /* This subquery can be absorbed into its parent. */ + if( isAggSub ){ + isAgg = 1; + p->selFlags |= SF_Aggregate; + } + i = -1; + } + pTabList = p->pSrc; + if( db->mallocFailed ) goto select_end; + if( !IgnorableOrderby(pDest) ){ + sSort.pOrderBy = p->pOrderBy; + } + } +#endif + + /* Get a pointer the VDBE under construction, allocating a new VDBE if one + ** does not already exist */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto select_end; + +#ifndef SQLITE_OMIT_COMPOUND_SELECT + /* Handle compound SELECT statements using the separate multiSelect() + ** procedure. + */ + if( p->pPrior ){ + rc = multiSelect(pParse, p, pDest); + explainSetInteger(pParse->iSelectId, iRestoreSelectId); +#if SELECTTRACE_ENABLED + SELECTTRACE(1,pParse,p,("end compound-select processing\n")); + pParse->nSelectIndent--; +#endif + return rc; + } +#endif + + /* Generate code for all sub-queries in the FROM clause + */ +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + for(i=0; inSrc; i++){ + struct SrcList_item *pItem = &pTabList->a[i]; + SelectDest dest; + Select *pSub = pItem->pSelect; + if( pSub==0 ) continue; + + /* Sometimes the code for a subquery will be generated more than + ** once, if the subquery is part of the WHERE clause in a LEFT JOIN, + ** for example. In that case, do not regenerate the code to manifest + ** a view or the co-routine to implement a view. The first instance + ** is sufficient, though the subroutine to manifest the view does need + ** to be invoked again. */ + if( pItem->addrFillSub ){ + if( pItem->fg.viaCoroutine==0 ){ + sqlite3VdbeAddOp2(v, OP_Gosub, pItem->regReturn, pItem->addrFillSub); + } + continue; + } + + /* Increment Parse.nHeight by the height of the largest expression + ** tree referred to by this, the parent select. The child select + ** may contain expression trees of at most + ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit + ** more conservative than necessary, but much easier than enforcing + ** an exact limit. + */ + pParse->nHeight += sqlite3SelectExprHeight(p); + + /* Make copies of constant WHERE-clause terms in the outer query down + ** inside the subquery. This can help the subquery to run more efficiently. + */ + if( (pItem->fg.jointype & JT_OUTER)==0 + && pushDownWhereTerms(db, pSub, p->pWhere, pItem->iCursor) + ){ +#if SELECTTRACE_ENABLED + if( sqlite3SelectTrace & 0x100 ){ + SELECTTRACE(0x100,pParse,p,("After WHERE-clause push-down:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + } + + /* Generate code to implement the subquery + */ + if( pTabList->nSrc==1 + && (p->selFlags & SF_All)==0 + && OptimizationEnabled(db, SQLITE_SubqCoroutine) + ){ + /* Implement a co-routine that will return a single row of the result + ** set on each invocation. + */ + int addrTop = sqlite3VdbeCurrentAddr(v)+1; + pItem->regReturn = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop); + VdbeComment((v, "%s", pItem->pTab->zName)); + pItem->addrFillSub = addrTop; + sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn); + explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId); + sqlite3Select(pParse, pSub, &dest); + pItem->pTab->nRowLogEst = sqlite3LogEst(pSub->nSelectRow); + pItem->fg.viaCoroutine = 1; + pItem->regResult = dest.iSdst; + sqlite3VdbeAddOp1(v, OP_EndCoroutine, pItem->regReturn); + sqlite3VdbeJumpHere(v, addrTop-1); + sqlite3ClearTempRegCache(pParse); + }else{ + /* Generate a subroutine that will fill an ephemeral table with + ** the content of this subquery. pItem->addrFillSub will point + ** to the address of the generated subroutine. pItem->regReturn + ** is a register allocated to hold the subroutine return address + */ + int topAddr; + int onceAddr = 0; + int retAddr; + assert( pItem->addrFillSub==0 ); + pItem->regReturn = ++pParse->nMem; + topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn); + pItem->addrFillSub = topAddr+1; + if( pItem->fg.isCorrelated==0 ){ + /* If the subquery is not correlated and if we are not inside of + ** a trigger, then we only need to compute the value of the subquery + ** once. */ + onceAddr = sqlite3CodeOnce(pParse); VdbeCoverage(v); + VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName)); + }else{ + VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName)); + } + sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor); + explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId); + sqlite3Select(pParse, pSub, &dest); + pItem->pTab->nRowLogEst = sqlite3LogEst(pSub->nSelectRow); + if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr); + retAddr = sqlite3VdbeAddOp1(v, OP_Return, pItem->regReturn); + VdbeComment((v, "end %s", pItem->pTab->zName)); + sqlite3VdbeChangeP1(v, topAddr, retAddr); + sqlite3ClearTempRegCache(pParse); + } + if( db->mallocFailed ) goto select_end; + pParse->nHeight -= sqlite3SelectExprHeight(p); + } +#endif + + /* Various elements of the SELECT copied into local variables for + ** convenience */ + pEList = p->pEList; + pWhere = p->pWhere; + pGroupBy = p->pGroupBy; + pHaving = p->pHaving; + sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0; + +#if SELECTTRACE_ENABLED + if( sqlite3SelectTrace & 0x400 ){ + SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and + ** if the select-list is the same as the ORDER BY list, then this query + ** can be rewritten as a GROUP BY. In other words, this: + ** + ** SELECT DISTINCT xyz FROM ... ORDER BY xyz + ** + ** is transformed to: + ** + ** SELECT xyz FROM ... GROUP BY xyz ORDER BY xyz + ** + ** The second form is preferred as a single index (or temp-table) may be + ** used for both the ORDER BY and DISTINCT processing. As originally + ** written the query must use a temp-table for at least one of the ORDER + ** BY and DISTINCT, and an index or separate temp-table for the other. + */ + if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct + && sqlite3ExprListCompare(sSort.pOrderBy, pEList, -1)==0 + ){ + p->selFlags &= ~SF_Distinct; + pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0); + /* Notice that even thought SF_Distinct has been cleared from p->selFlags, + ** the sDistinct.isTnct is still set. Hence, isTnct represents the + ** original setting of the SF_Distinct flag, not the current setting */ + assert( sDistinct.isTnct ); + } + + /* If there is an ORDER BY clause, then create an ephemeral index to + ** do the sorting. But this sorting ephemeral index might end up + ** being unused if the data can be extracted in pre-sorted order. + ** If that is the case, then the OP_OpenEphemeral instruction will be + ** changed to an OP_Noop once we figure out that the sorting index is + ** not needed. The sSort.addrSortIndex variable is used to facilitate + ** that change. + */ + if( sSort.pOrderBy ){ + KeyInfo *pKeyInfo; + pKeyInfo = keyInfoFromExprList(pParse, sSort.pOrderBy, 0, pEList->nExpr); + sSort.iECursor = pParse->nTab++; + sSort.addrSortIndex = + sqlite3VdbeAddOp4(v, OP_OpenEphemeral, + sSort.iECursor, sSort.pOrderBy->nExpr+1+pEList->nExpr, 0, + (char*)pKeyInfo, P4_KEYINFO + ); + }else{ + sSort.addrSortIndex = -1; + } + + /* If the output is destined for a temporary table, open that table. + */ + if( pDest->eDest==SRT_EphemTab ){ + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr); + } + + /* Set the limiter. + */ + iEnd = sqlite3VdbeMakeLabel(v); + p->nSelectRow = LARGEST_INT64; + computeLimitRegisters(pParse, p, iEnd); + if( p->iLimit==0 && sSort.addrSortIndex>=0 ){ + sqlite3VdbeChangeOpcode(v, sSort.addrSortIndex, OP_SorterOpen); + sSort.sortFlags |= SORTFLAG_UseSorter; + } + + /* Open an ephemeral index to use for the distinct set. + */ + if( p->selFlags & SF_Distinct ){ + sDistinct.tabTnct = pParse->nTab++; + sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral, + sDistinct.tabTnct, 0, 0, + (char*)keyInfoFromExprList(pParse, p->pEList,0,0), + P4_KEYINFO); + sqlite3VdbeChangeP5(v, BTREE_UNORDERED); + sDistinct.eTnctType = WHERE_DISTINCT_UNORDERED; + }else{ + sDistinct.eTnctType = WHERE_DISTINCT_NOOP; + } + + if( !isAgg && pGroupBy==0 ){ + /* No aggregate functions and no GROUP BY clause */ + u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0); + + /* Begin the database scan. */ + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy, + p->pEList, wctrlFlags, 0); + if( pWInfo==0 ) goto select_end; + if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){ + p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo); + } + if( sDistinct.isTnct && sqlite3WhereIsDistinct(pWInfo) ){ + sDistinct.eTnctType = sqlite3WhereIsDistinct(pWInfo); + } + if( sSort.pOrderBy ){ + sSort.nOBSat = sqlite3WhereIsOrdered(pWInfo); + if( sSort.nOBSat==sSort.pOrderBy->nExpr ){ + sSort.pOrderBy = 0; + } + } + + /* If sorting index that was created by a prior OP_OpenEphemeral + ** instruction ended up not being needed, then change the OP_OpenEphemeral + ** into an OP_Noop. + */ + if( sSort.addrSortIndex>=0 && sSort.pOrderBy==0 ){ + sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex); + } + + /* Use the standard inner loop. */ + selectInnerLoop(pParse, p, pEList, -1, &sSort, &sDistinct, pDest, + sqlite3WhereContinueLabel(pWInfo), + sqlite3WhereBreakLabel(pWInfo)); + + /* End the database scan loop. + */ + sqlite3WhereEnd(pWInfo); + }else{ + /* This case when there exist aggregate functions or a GROUP BY clause + ** or both */ + NameContext sNC; /* Name context for processing aggregate information */ + int iAMem; /* First Mem address for storing current GROUP BY */ + int iBMem; /* First Mem address for previous GROUP BY */ + int iUseFlag; /* Mem address holding flag indicating that at least + ** one row of the input to the aggregator has been + ** processed */ + int iAbortFlag; /* Mem address which causes query abort if positive */ + int groupBySort; /* Rows come from source in GROUP BY order */ + int addrEnd; /* End of processing for this SELECT */ + int sortPTab = 0; /* Pseudotable used to decode sorting results */ + int sortOut = 0; /* Output register from the sorter */ + int orderByGrp = 0; /* True if the GROUP BY and ORDER BY are the same */ + + /* Remove any and all aliases between the result set and the + ** GROUP BY clause. + */ + if( pGroupBy ){ + int k; /* Loop counter */ + struct ExprList_item *pItem; /* For looping over expression in a list */ + + for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){ + pItem->u.x.iAlias = 0; + } + for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){ + pItem->u.x.iAlias = 0; + } + if( p->nSelectRow>100 ) p->nSelectRow = 100; + }else{ + p->nSelectRow = 1; + } + + /* If there is both a GROUP BY and an ORDER BY clause and they are + ** identical, then it may be possible to disable the ORDER BY clause + ** on the grounds that the GROUP BY will cause elements to come out + ** in the correct order. It also may not - the GROUP BY might use a + ** database index that causes rows to be grouped together as required + ** but not actually sorted. Either way, record the fact that the + ** ORDER BY and GROUP BY clauses are the same by setting the orderByGrp + ** variable. */ + if( sqlite3ExprListCompare(pGroupBy, sSort.pOrderBy, -1)==0 ){ + orderByGrp = 1; + } + + /* Create a label to jump to when we want to abort the query */ + addrEnd = sqlite3VdbeMakeLabel(v); + + /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in + ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the + ** SELECT statement. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + sNC.pAggInfo = &sAggInfo; + sAggInfo.mnReg = pParse->nMem+1; + sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr : 0; + sAggInfo.pGroupBy = pGroupBy; + sqlite3ExprAnalyzeAggList(&sNC, pEList); + sqlite3ExprAnalyzeAggList(&sNC, sSort.pOrderBy); + if( pHaving ){ + sqlite3ExprAnalyzeAggregates(&sNC, pHaving); + } + sAggInfo.nAccumulator = sAggInfo.nColumn; + for(i=0; ix.pList); + sNC.ncFlags &= ~NC_InAggFunc; + } + sAggInfo.mxReg = pParse->nMem; + if( db->mallocFailed ) goto select_end; + + /* Processing for aggregates with GROUP BY is very different and + ** much more complex than aggregates without a GROUP BY. + */ + if( pGroupBy ){ + KeyInfo *pKeyInfo; /* Keying information for the group by clause */ + int addr1; /* A-vs-B comparision jump */ + int addrOutputRow; /* Start of subroutine that outputs a result row */ + int regOutputRow; /* Return address register for output subroutine */ + int addrSetAbort; /* Set the abort flag and return */ + int addrTopOfLoop; /* Top of the input loop */ + int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */ + int addrReset; /* Subroutine for resetting the accumulator */ + int regReset; /* Return address register for reset subroutine */ + + /* If there is a GROUP BY clause we might need a sorting index to + ** implement it. Allocate that sorting index now. If it turns out + ** that we do not need it after all, the OP_SorterOpen instruction + ** will be converted into a Noop. + */ + sAggInfo.sortingIdx = pParse->nTab++; + pKeyInfo = keyInfoFromExprList(pParse, pGroupBy, 0, sAggInfo.nColumn); + addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen, + sAggInfo.sortingIdx, sAggInfo.nSortingColumn, + 0, (char*)pKeyInfo, P4_KEYINFO); + + /* Initialize memory locations used by GROUP BY aggregate processing + */ + iUseFlag = ++pParse->nMem; + iAbortFlag = ++pParse->nMem; + regOutputRow = ++pParse->nMem; + addrOutputRow = sqlite3VdbeMakeLabel(v); + regReset = ++pParse->nMem; + addrReset = sqlite3VdbeMakeLabel(v); + iAMem = pParse->nMem + 1; + pParse->nMem += pGroupBy->nExpr; + iBMem = pParse->nMem + 1; + pParse->nMem += pGroupBy->nExpr; + sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag); + VdbeComment((v, "clear abort flag")); + sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag); + VdbeComment((v, "indicate accumulator empty")); + sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1); + + /* Begin a loop that will extract all source rows in GROUP BY order. + ** This might involve two separate loops with an OP_Sort in between, or + ** it might be a single loop that uses an index to extract information + ** in the right order to begin with. + */ + sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0, + WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0), 0 + ); + if( pWInfo==0 ) goto select_end; + if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){ + /* The optimizer is able to deliver rows in group by order so + ** we do not have to sort. The OP_OpenEphemeral table will be + ** cancelled later because we still need to use the pKeyInfo + */ + groupBySort = 0; + }else{ + /* Rows are coming out in undetermined order. We have to push + ** each row into a sorting index, terminate the first loop, + ** then loop over the sorting index in order to get the output + ** in sorted order + */ + int regBase; + int regRecord; + int nCol; + int nGroupBy; + + explainTempTable(pParse, + (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ? + "DISTINCT" : "GROUP BY"); + + groupBySort = 1; + nGroupBy = pGroupBy->nExpr; + nCol = nGroupBy; + j = nGroupBy; + for(i=0; i=j ){ + nCol++; + j++; + } + } + regBase = sqlite3GetTempRange(pParse, nCol); + sqlite3ExprCacheClear(pParse); + sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0, 0); + j = nGroupBy; + for(i=0; iiSorterColumn>=j ){ + int r1 = j + regBase; + int r2; + + r2 = sqlite3ExprCodeGetColumn(pParse, + pCol->pTab, pCol->iColumn, pCol->iTable, r1, 0); + if( r1!=r2 ){ + sqlite3VdbeAddOp2(v, OP_SCopy, r2, r1); + } + j++; + } + } + regRecord = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord); + sqlite3VdbeAddOp2(v, OP_SorterInsert, sAggInfo.sortingIdx, regRecord); + sqlite3ReleaseTempReg(pParse, regRecord); + sqlite3ReleaseTempRange(pParse, regBase, nCol); + sqlite3WhereEnd(pWInfo); + sAggInfo.sortingIdxPTab = sortPTab = pParse->nTab++; + sortOut = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol); + sqlite3VdbeAddOp2(v, OP_SorterSort, sAggInfo.sortingIdx, addrEnd); + VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v); + sAggInfo.useSortingIdx = 1; + sqlite3ExprCacheClear(pParse); + + } + + /* If the index or temporary table used by the GROUP BY sort + ** will naturally deliver rows in the order required by the ORDER BY + ** clause, cancel the ephemeral table open coded earlier. + ** + ** This is an optimization - the correct answer should result regardless. + ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to + ** disable this optimization for testing purposes. */ + if( orderByGrp && OptimizationEnabled(db, SQLITE_GroupByOrder) + && (groupBySort || sqlite3WhereIsSorted(pWInfo)) + ){ + sSort.pOrderBy = 0; + sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex); + } + + /* Evaluate the current GROUP BY terms and store in b0, b1, b2... + ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth) + ** Then compare the current GROUP BY terms against the GROUP BY terms + ** from the previous row currently stored in a0, a1, a2... + */ + addrTopOfLoop = sqlite3VdbeCurrentAddr(v); + sqlite3ExprCacheClear(pParse); + if( groupBySort ){ + sqlite3VdbeAddOp3(v, OP_SorterData, sAggInfo.sortingIdx, + sortOut, sortPTab); + } + for(j=0; jnExpr; j++){ + if( groupBySort ){ + sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j); + }else{ + sAggInfo.directMode = 1; + sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j); + } + } + sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr, + (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO); + addr1 = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp3(v, OP_Jump, addr1+1, 0, addr1+1); VdbeCoverage(v); + + /* Generate code that runs whenever the GROUP BY changes. + ** Changes in the GROUP BY are detected by the previous code + ** block. If there were no changes, this block is skipped. + ** + ** This code copies current group by terms in b0,b1,b2,... + ** over to a0,a1,a2. It then calls the output subroutine + ** and resets the aggregate accumulator registers in preparation + ** for the next GROUP BY batch. + */ + sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr); + sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow); + VdbeComment((v, "output one row")); + sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v); + VdbeComment((v, "check abort flag")); + sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset); + VdbeComment((v, "reset accumulator")); + + /* Update the aggregate accumulators based on the content of + ** the current row + */ + sqlite3VdbeJumpHere(v, addr1); + updateAccumulator(pParse, &sAggInfo); + sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag); + VdbeComment((v, "indicate data in accumulator")); + + /* End of the loop + */ + if( groupBySort ){ + sqlite3VdbeAddOp2(v, OP_SorterNext, sAggInfo.sortingIdx, addrTopOfLoop); + VdbeCoverage(v); + }else{ + sqlite3WhereEnd(pWInfo); + sqlite3VdbeChangeToNoop(v, addrSortingIdx); + } + + /* Output the final row of result + */ + sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow); + VdbeComment((v, "output final row")); + + /* Jump over the subroutines + */ + sqlite3VdbeGoto(v, addrEnd); + + /* Generate a subroutine that outputs a single row of the result + ** set. This subroutine first looks at the iUseFlag. If iUseFlag + ** is less than or equal to zero, the subroutine is a no-op. If + ** the processing calls for the query to abort, this subroutine + ** increments the iAbortFlag memory location before returning in + ** order to signal the caller to abort. + */ + addrSetAbort = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag); + VdbeComment((v, "set abort flag")); + sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); + sqlite3VdbeResolveLabel(v, addrOutputRow); + addrOutputRow = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2); + VdbeCoverage(v); + VdbeComment((v, "Groupby result generator entry point")); + sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); + finalizeAggFunctions(pParse, &sAggInfo); + sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL); + selectInnerLoop(pParse, p, p->pEList, -1, &sSort, + &sDistinct, pDest, + addrOutputRow+1, addrSetAbort); + sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); + VdbeComment((v, "end groupby result generator")); + + /* Generate a subroutine that will reset the group-by accumulator + */ + sqlite3VdbeResolveLabel(v, addrReset); + resetAccumulator(pParse, &sAggInfo); + sqlite3VdbeAddOp1(v, OP_Return, regReset); + + } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */ + else { + ExprList *pDel = 0; +#ifndef SQLITE_OMIT_BTREECOUNT + Table *pTab; + if( (pTab = isSimpleCount(p, &sAggInfo))!=0 ){ + /* If isSimpleCount() returns a pointer to a Table structure, then + ** the SQL statement is of the form: + ** + ** SELECT count(*) FROM + ** + ** where the Table structure returned represents table . + ** + ** This statement is so common that it is optimized specially. The + ** OP_Count instruction is executed either on the intkey table that + ** contains the data for table or on one of its indexes. It + ** is better to execute the op on an index, as indexes are almost + ** always spread across less pages than their corresponding tables. + */ + const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */ + Index *pIdx; /* Iterator variable */ + KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */ + Index *pBest = 0; /* Best index found so far */ + int iRoot = pTab->tnum; /* Root page of scanned b-tree */ + + sqlite3CodeVerifySchema(pParse, iDb); + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + + /* Search for the index that has the lowest scan cost. + ** + ** (2011-04-15) Do not do a full scan of an unordered index. + ** + ** (2013-10-03) Do not count the entries in a partial index. + ** + ** In practice the KeyInfo structure will not be used. It is only + ** passed to keep OP_OpenRead happy. + */ + if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab); + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->bUnordered==0 + && pIdx->szIdxRowszTabRow + && pIdx->pPartIdxWhere==0 + && (!pBest || pIdx->szIdxRowszIdxRow) + ){ + pBest = pIdx; + } + } + if( pBest ){ + iRoot = pBest->tnum; + pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest); + } + + /* Open a read-only cursor, execute the OP_Count, close the cursor. */ + sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, iRoot, iDb, 1); + if( pKeyInfo ){ + sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO); + } + sqlite3VdbeAddOp2(v, OP_Count, iCsr, sAggInfo.aFunc[0].iMem); + sqlite3VdbeAddOp1(v, OP_Close, iCsr); + explainSimpleCount(pParse, pTab, pBest); + }else +#endif /* SQLITE_OMIT_BTREECOUNT */ + { + /* Check if the query is of one of the following forms: + ** + ** SELECT min(x) FROM ... + ** SELECT max(x) FROM ... + ** + ** If it is, then ask the code in where.c to attempt to sort results + ** as if there was an "ORDER ON x" or "ORDER ON x DESC" clause. + ** If where.c is able to produce results sorted in this order, then + ** add vdbe code to break out of the processing loop after the + ** first iteration (since the first iteration of the loop is + ** guaranteed to operate on the row with the minimum or maximum + ** value of x, the only row required). + ** + ** A special flag must be passed to sqlite3WhereBegin() to slightly + ** modify behavior as follows: + ** + ** + If the query is a "SELECT min(x)", then the loop coded by + ** where.c should not iterate over any values with a NULL value + ** for x. + ** + ** + The optimizer code in where.c (the thing that decides which + ** index or indices to use) should place a different priority on + ** satisfying the 'ORDER BY' clause than it does in other cases. + ** Refer to code and comments in where.c for details. + */ + ExprList *pMinMax = 0; + u8 flag = WHERE_ORDERBY_NORMAL; + + assert( p->pGroupBy==0 ); + assert( flag==0 ); + if( p->pHaving==0 ){ + flag = minMaxQuery(&sAggInfo, &pMinMax); + } + assert( flag==0 || (pMinMax!=0 && pMinMax->nExpr==1) ); + + if( flag ){ + pMinMax = sqlite3ExprListDup(db, pMinMax, 0); + pDel = pMinMax; + if( pMinMax && !db->mallocFailed ){ + pMinMax->a[0].sortOrder = flag!=WHERE_ORDERBY_MIN ?1:0; + pMinMax->a[0].pExpr->op = TK_COLUMN; + } + } + + /* This case runs if the aggregate has no GROUP BY clause. The + ** processing is much simpler since there is only a single row + ** of output. + */ + resetAccumulator(pParse, &sAggInfo); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMax,0,flag,0); + if( pWInfo==0 ){ + sqlite3ExprListDelete(db, pDel); + goto select_end; + } + updateAccumulator(pParse, &sAggInfo); + assert( pMinMax==0 || pMinMax->nExpr==1 ); + if( sqlite3WhereIsOrdered(pWInfo)>0 ){ + sqlite3VdbeGoto(v, sqlite3WhereBreakLabel(pWInfo)); + VdbeComment((v, "%s() by index", + (flag==WHERE_ORDERBY_MIN?"min":"max"))); + } + sqlite3WhereEnd(pWInfo); + finalizeAggFunctions(pParse, &sAggInfo); + } + + sSort.pOrderBy = 0; + sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL); + selectInnerLoop(pParse, p, p->pEList, -1, 0, 0, + pDest, addrEnd, addrEnd); + sqlite3ExprListDelete(db, pDel); + } + sqlite3VdbeResolveLabel(v, addrEnd); + + } /* endif aggregate query */ + + if( sDistinct.eTnctType==WHERE_DISTINCT_UNORDERED ){ + explainTempTable(pParse, "DISTINCT"); + } + + /* If there is an ORDER BY clause, then we need to sort the results + ** and send them to the callback one by one. + */ + if( sSort.pOrderBy ){ + explainTempTable(pParse, + sSort.nOBSat>0 ? "RIGHT PART OF ORDER BY":"ORDER BY"); + generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest); + } + + /* Jump here to skip this query + */ + sqlite3VdbeResolveLabel(v, iEnd); + + /* The SELECT has been coded. If there is an error in the Parse structure, + ** set the return code to 1. Otherwise 0. */ + rc = (pParse->nErr>0); + + /* Control jumps to here if an error is encountered above, or upon + ** successful coding of the SELECT. + */ +select_end: + explainSetInteger(pParse->iSelectId, iRestoreSelectId); + + /* Identify column names if results of the SELECT are to be output. + */ + if( rc==SQLITE_OK && pDest->eDest==SRT_Output ){ + generateColumnNames(pParse, pTabList, pEList); + } + + sqlite3DbFree(db, sAggInfo.aCol); + sqlite3DbFree(db, sAggInfo.aFunc); +#if SELECTTRACE_ENABLED + SELECTTRACE(1,pParse,p,("end processing\n")); + pParse->nSelectIndent--; +#endif + return rc; +} + +/************** End of select.c **********************************************/ +/************** Begin file table.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the sqlite3_get_table() and sqlite3_free_table() +** interface routines. These are just wrappers around the main +** interface routine of sqlite3_exec(). +** +** These routines are in a separate files so that they will not be linked +** if they are not used. +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ + +#ifndef SQLITE_OMIT_GET_TABLE + +/* +** This structure is used to pass data from sqlite3_get_table() through +** to the callback function is uses to build the result. +*/ +typedef struct TabResult { + char **azResult; /* Accumulated output */ + char *zErrMsg; /* Error message text, if an error occurs */ + u32 nAlloc; /* Slots allocated for azResult[] */ + u32 nRow; /* Number of rows in the result */ + u32 nColumn; /* Number of columns in the result */ + u32 nData; /* Slots used in azResult[]. (nRow+1)*nColumn */ + int rc; /* Return code from sqlite3_exec() */ +} TabResult; + +/* +** This routine is called once for each row in the result table. Its job +** is to fill in the TabResult structure appropriately, allocating new +** memory as necessary. +*/ +static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){ + TabResult *p = (TabResult*)pArg; /* Result accumulator */ + int need; /* Slots needed in p->azResult[] */ + int i; /* Loop counter */ + char *z; /* A single column of result */ + + /* Make sure there is enough space in p->azResult to hold everything + ** we need to remember from this invocation of the callback. + */ + if( p->nRow==0 && argv!=0 ){ + need = nCol*2; + }else{ + need = nCol; + } + if( p->nData + need > p->nAlloc ){ + char **azNew; + p->nAlloc = p->nAlloc*2 + need; + azNew = sqlite3_realloc64( p->azResult, sizeof(char*)*p->nAlloc ); + if( azNew==0 ) goto malloc_failed; + p->azResult = azNew; + } + + /* If this is the first row, then generate an extra row containing + ** the names of all columns. + */ + if( p->nRow==0 ){ + p->nColumn = nCol; + for(i=0; iazResult[p->nData++] = z; + } + }else if( (int)p->nColumn!=nCol ){ + sqlite3_free(p->zErrMsg); + p->zErrMsg = sqlite3_mprintf( + "sqlite3_get_table() called with two or more incompatible queries" + ); + p->rc = SQLITE_ERROR; + return 1; + } + + /* Copy over the row data + */ + if( argv!=0 ){ + for(i=0; iazResult[p->nData++] = z; + } + p->nRow++; + } + return 0; + +malloc_failed: + p->rc = SQLITE_NOMEM; + return 1; +} + +/* +** Query the database. But instead of invoking a callback for each row, +** malloc() for space to hold the result and return the entire results +** at the conclusion of the call. +** +** The result that is written to ***pazResult is held in memory obtained +** from malloc(). But the caller cannot free this memory directly. +** Instead, the entire table should be passed to sqlite3_free_table() when +** the calling procedure is finished using it. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_get_table( + sqlite3 *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + char ***pazResult, /* Write the result table here */ + int *pnRow, /* Write the number of rows in the result here */ + int *pnColumn, /* Write the number of columns of result here */ + char **pzErrMsg /* Write error messages here */ +){ + int rc; + TabResult res; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || pazResult==0 ) return SQLITE_MISUSE_BKPT; +#endif + *pazResult = 0; + if( pnColumn ) *pnColumn = 0; + if( pnRow ) *pnRow = 0; + if( pzErrMsg ) *pzErrMsg = 0; + res.zErrMsg = 0; + res.nRow = 0; + res.nColumn = 0; + res.nData = 1; + res.nAlloc = 20; + res.rc = SQLITE_OK; + res.azResult = sqlite3_malloc64(sizeof(char*)*res.nAlloc ); + if( res.azResult==0 ){ + db->errCode = SQLITE_NOMEM; + return SQLITE_NOMEM; + } + res.azResult[0] = 0; + rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg); + assert( sizeof(res.azResult[0])>= sizeof(res.nData) ); + res.azResult[0] = SQLITE_INT_TO_PTR(res.nData); + if( (rc&0xff)==SQLITE_ABORT ){ + sqlite3_free_table(&res.azResult[1]); + if( res.zErrMsg ){ + if( pzErrMsg ){ + sqlite3_free(*pzErrMsg); + *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg); + } + sqlite3_free(res.zErrMsg); + } + db->errCode = res.rc; /* Assume 32-bit assignment is atomic */ + return res.rc; + } + sqlite3_free(res.zErrMsg); + if( rc!=SQLITE_OK ){ + sqlite3_free_table(&res.azResult[1]); + return rc; + } + if( res.nAlloc>res.nData ){ + char **azNew; + azNew = sqlite3_realloc64( res.azResult, sizeof(char*)*res.nData ); + if( azNew==0 ){ + sqlite3_free_table(&res.azResult[1]); + db->errCode = SQLITE_NOMEM; + return SQLITE_NOMEM; + } + res.azResult = azNew; + } + *pazResult = &res.azResult[1]; + if( pnColumn ) *pnColumn = res.nColumn; + if( pnRow ) *pnRow = res.nRow; + return rc; +} + +/* +** This routine frees the space the sqlite3_get_table() malloced. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_free_table( + char **azResult /* Result returned from sqlite3_get_table() */ +){ + if( azResult ){ + int i, n; + azResult--; + assert( azResult!=0 ); + n = SQLITE_PTR_TO_INT(azResult[0]); + for(i=1; ipNext; + + sqlite3ExprDelete(db, pTmp->pWhere); + sqlite3ExprListDelete(db, pTmp->pExprList); + sqlite3SelectDelete(db, pTmp->pSelect); + sqlite3IdListDelete(db, pTmp->pIdList); + + sqlite3DbFree(db, pTmp); + } +} + +/* +** Given table pTab, return a list of all the triggers attached to +** the table. The list is connected by Trigger.pNext pointers. +** +** All of the triggers on pTab that are in the same database as pTab +** are already attached to pTab->pTrigger. But there might be additional +** triggers on pTab in the TEMP schema. This routine prepends all +** TEMP triggers on pTab to the beginning of the pTab->pTrigger list +** and returns the combined list. +** +** To state it another way: This routine returns a list of all triggers +** that fire off of pTab. The list will include any TEMP triggers on +** pTab as well as the triggers lised in pTab->pTrigger. +*/ +SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){ + Schema * const pTmpSchema = pParse->db->aDb[1].pSchema; + Trigger *pList = 0; /* List of triggers to return */ + + if( pParse->disableTriggers ){ + return 0; + } + + if( pTmpSchema!=pTab->pSchema ){ + HashElem *p; + assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) ); + for(p=sqliteHashFirst(&pTmpSchema->trigHash); p; p=sqliteHashNext(p)){ + Trigger *pTrig = (Trigger *)sqliteHashData(p); + if( pTrig->pTabSchema==pTab->pSchema + && 0==sqlite3StrICmp(pTrig->table, pTab->zName) + ){ + pTrig->pNext = (pList ? pList : pTab->pTrigger); + pList = pTrig; + } + } + } + + return (pList ? pList : pTab->pTrigger); +} + +/* +** This is called by the parser when it sees a CREATE TRIGGER statement +** up to the point of the BEGIN before the trigger actions. A Trigger +** structure is generated based on the information available and stored +** in pParse->pNewTrigger. After the trigger actions have been parsed, the +** sqlite3FinishTrigger() function is called to complete the trigger +** construction process. +*/ +SQLITE_PRIVATE void sqlite3BeginTrigger( + Parse *pParse, /* The parse context of the CREATE TRIGGER statement */ + Token *pName1, /* The name of the trigger */ + Token *pName2, /* The name of the trigger */ + int tr_tm, /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */ + int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */ + IdList *pColumns, /* column list if this is an UPDATE OF trigger */ + SrcList *pTableName,/* The name of the table/view the trigger applies to */ + Expr *pWhen, /* WHEN clause */ + int isTemp, /* True if the TEMPORARY keyword is present */ + int noErr /* Suppress errors if the trigger already exists */ +){ + Trigger *pTrigger = 0; /* The new trigger */ + Table *pTab; /* Table that the trigger fires off of */ + char *zName = 0; /* Name of the trigger */ + sqlite3 *db = pParse->db; /* The database connection */ + int iDb; /* The database to store the trigger in */ + Token *pName; /* The unqualified db name */ + DbFixer sFix; /* State vector for the DB fixer */ + int iTabDb; /* Index of the database holding pTab */ + + assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */ + assert( pName2!=0 ); + assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE ); + assert( op>0 && op<0xff ); + if( isTemp ){ + /* If TEMP was specified, then the trigger name may not be qualified. */ + if( pName2->n>0 ){ + sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name"); + goto trigger_cleanup; + } + iDb = 1; + pName = pName1; + }else{ + /* Figure out the db that the trigger will be created in */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ){ + goto trigger_cleanup; + } + } + if( !pTableName || db->mallocFailed ){ + goto trigger_cleanup; + } + + /* A long-standing parser bug is that this syntax was allowed: + ** + ** CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab .... + ** ^^^^^^^^ + ** + ** To maintain backwards compatibility, ignore the database + ** name on pTableName if we are reparsing out of SQLITE_MASTER. + */ + if( db->init.busy && iDb!=1 ){ + sqlite3DbFree(db, pTableName->a[0].zDatabase); + pTableName->a[0].zDatabase = 0; + } + + /* If the trigger name was unqualified, and the table is a temp table, + ** then set iDb to 1 to create the trigger in the temporary database. + ** If sqlite3SrcListLookup() returns 0, indicating the table does not + ** exist, the error is caught by the block below. + */ + pTab = sqlite3SrcListLookup(pParse, pTableName); + if( db->init.busy==0 && pName2->n==0 && pTab + && pTab->pSchema==db->aDb[1].pSchema ){ + iDb = 1; + } + + /* Ensure the table name matches database name and that the table exists */ + if( db->mallocFailed ) goto trigger_cleanup; + assert( pTableName->nSrc==1 ); + sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName); + if( sqlite3FixSrcList(&sFix, pTableName) ){ + goto trigger_cleanup; + } + pTab = sqlite3SrcListLookup(pParse, pTableName); + if( !pTab ){ + /* The table does not exist. */ + if( db->init.iDb==1 ){ + /* Ticket #3810. + ** Normally, whenever a table is dropped, all associated triggers are + ** dropped too. But if a TEMP trigger is created on a non-TEMP table + ** and the table is dropped by a different database connection, the + ** trigger is not visible to the database connection that does the + ** drop so the trigger cannot be dropped. This results in an + ** "orphaned trigger" - a trigger whose associated table is missing. + */ + db->init.orphanTrigger = 1; + } + goto trigger_cleanup; + } + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables"); + goto trigger_cleanup; + } + + /* Check that the trigger name is not reserved and that no trigger of the + ** specified name exists */ + zName = sqlite3NameFromToken(db, pName); + if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ + goto trigger_cleanup; + } + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "trigger %T already exists", pName); + }else{ + assert( !db->init.busy ); + sqlite3CodeVerifySchema(pParse, iDb); + } + goto trigger_cleanup; + } + + /* Do not create a trigger on a system table */ + if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){ + sqlite3ErrorMsg(pParse, "cannot create trigger on system table"); + goto trigger_cleanup; + } + + /* INSTEAD of triggers are only for views and views only support INSTEAD + ** of triggers. + */ + if( pTab->pSelect && tr_tm!=TK_INSTEAD ){ + sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S", + (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0); + goto trigger_cleanup; + } + if( !pTab->pSelect && tr_tm==TK_INSTEAD ){ + sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF" + " trigger on table: %S", pTableName, 0); + goto trigger_cleanup; + } + iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); + +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code = SQLITE_CREATE_TRIGGER; + const char *zDb = db->aDb[iTabDb].zName; + const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb; + if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER; + if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){ + goto trigger_cleanup; + } + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){ + goto trigger_cleanup; + } + } +#endif + + /* INSTEAD OF triggers can only appear on views and BEFORE triggers + ** cannot appear on views. So we might as well translate every + ** INSTEAD OF trigger into a BEFORE trigger. It simplifies code + ** elsewhere. + */ + if (tr_tm == TK_INSTEAD){ + tr_tm = TK_BEFORE; + } + + /* Build the Trigger object */ + pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger)); + if( pTrigger==0 ) goto trigger_cleanup; + pTrigger->zName = zName; + zName = 0; + pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName); + pTrigger->pSchema = db->aDb[iDb].pSchema; + pTrigger->pTabSchema = pTab->pSchema; + pTrigger->op = (u8)op; + pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER; + pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE); + pTrigger->pColumns = sqlite3IdListDup(db, pColumns); + assert( pParse->pNewTrigger==0 ); + pParse->pNewTrigger = pTrigger; + +trigger_cleanup: + sqlite3DbFree(db, zName); + sqlite3SrcListDelete(db, pTableName); + sqlite3IdListDelete(db, pColumns); + sqlite3ExprDelete(db, pWhen); + if( !pParse->pNewTrigger ){ + sqlite3DeleteTrigger(db, pTrigger); + }else{ + assert( pParse->pNewTrigger==pTrigger ); + } +} + +/* +** This routine is called after all of the trigger actions have been parsed +** in order to complete the process of building the trigger. +*/ +SQLITE_PRIVATE void sqlite3FinishTrigger( + Parse *pParse, /* Parser context */ + TriggerStep *pStepList, /* The triggered program */ + Token *pAll /* Token that describes the complete CREATE TRIGGER */ +){ + Trigger *pTrig = pParse->pNewTrigger; /* Trigger being finished */ + char *zName; /* Name of trigger */ + sqlite3 *db = pParse->db; /* The database */ + DbFixer sFix; /* Fixer object */ + int iDb; /* Database containing the trigger */ + Token nameToken; /* Trigger name for error reporting */ + + pParse->pNewTrigger = 0; + if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup; + zName = pTrig->zName; + iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema); + pTrig->step_list = pStepList; + while( pStepList ){ + pStepList->pTrig = pTrig; + pStepList = pStepList->pNext; + } + nameToken.z = pTrig->zName; + nameToken.n = sqlite3Strlen30(nameToken.z); + sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken); + if( sqlite3FixTriggerStep(&sFix, pTrig->step_list) + || sqlite3FixExpr(&sFix, pTrig->pWhen) + ){ + goto triggerfinish_cleanup; + } + + /* if we are not initializing, + ** build the sqlite_master entry + */ + if( !db->init.busy ){ + Vdbe *v; + char *z; + + /* Make an entry in the sqlite_master table */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto triggerfinish_cleanup; + sqlite3BeginWriteOperation(pParse, 0, iDb); + z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n); + sqlite3NestedParse(pParse, + "INSERT INTO %Q.%s VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), zName, + pTrig->table, z); + sqlite3DbFree(db, z); + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddParseSchemaOp(v, iDb, + sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName)); + } + + if( db->init.busy ){ + Trigger *pLink = pTrig; + Hash *pHash = &db->aDb[iDb].pSchema->trigHash; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pTrig = sqlite3HashInsert(pHash, zName, pTrig); + if( pTrig ){ + db->mallocFailed = 1; + }else if( pLink->pSchema==pLink->pTabSchema ){ + Table *pTab; + pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table); + assert( pTab!=0 ); + pLink->pNext = pTab->pTrigger; + pTab->pTrigger = pLink; + } + } + +triggerfinish_cleanup: + sqlite3DeleteTrigger(db, pTrig); + assert( !pParse->pNewTrigger ); + sqlite3DeleteTriggerStep(db, pStepList); +} + +/* +** Turn a SELECT statement (that the pSelect parameter points to) into +** a trigger step. Return a pointer to a TriggerStep structure. +** +** The parser calls this routine when it finds a SELECT statement in +** body of a TRIGGER. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(sqlite3 *db, Select *pSelect){ + TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep)); + if( pTriggerStep==0 ) { + sqlite3SelectDelete(db, pSelect); + return 0; + } + pTriggerStep->op = TK_SELECT; + pTriggerStep->pSelect = pSelect; + pTriggerStep->orconf = OE_Default; + return pTriggerStep; +} + +/* +** Allocate space to hold a new trigger step. The allocated space +** holds both the TriggerStep object and the TriggerStep.target.z string. +** +** If an OOM error occurs, NULL is returned and db->mallocFailed is set. +*/ +static TriggerStep *triggerStepAllocate( + sqlite3 *db, /* Database connection */ + u8 op, /* Trigger opcode */ + Token *pName /* The target name */ +){ + TriggerStep *pTriggerStep; + + pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1); + if( pTriggerStep ){ + char *z = (char*)&pTriggerStep[1]; + memcpy(z, pName->z, pName->n); + sqlite3Dequote(z); + pTriggerStep->zTarget = z; + pTriggerStep->op = op; + } + return pTriggerStep; +} + +/* +** Build a trigger step out of an INSERT statement. Return a pointer +** to the new trigger step. +** +** The parser calls this routine when it sees an INSERT inside the +** body of a trigger. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep( + sqlite3 *db, /* The database connection */ + Token *pTableName, /* Name of the table into which we insert */ + IdList *pColumn, /* List of columns in pTableName to insert into */ + Select *pSelect, /* A SELECT statement that supplies values */ + u8 orconf /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */ +){ + TriggerStep *pTriggerStep; + + assert(pSelect != 0 || db->mallocFailed); + + pTriggerStep = triggerStepAllocate(db, TK_INSERT, pTableName); + if( pTriggerStep ){ + pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); + pTriggerStep->pIdList = pColumn; + pTriggerStep->orconf = orconf; + }else{ + sqlite3IdListDelete(db, pColumn); + } + sqlite3SelectDelete(db, pSelect); + + return pTriggerStep; +} + +/* +** Construct a trigger step that implements an UPDATE statement and return +** a pointer to that trigger step. The parser calls this routine when it +** sees an UPDATE statement inside the body of a CREATE TRIGGER. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep( + sqlite3 *db, /* The database connection */ + Token *pTableName, /* Name of the table to be updated */ + ExprList *pEList, /* The SET clause: list of column and new values */ + Expr *pWhere, /* The WHERE clause */ + u8 orconf /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */ +){ + TriggerStep *pTriggerStep; + + pTriggerStep = triggerStepAllocate(db, TK_UPDATE, pTableName); + if( pTriggerStep ){ + pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE); + pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); + pTriggerStep->orconf = orconf; + } + sqlite3ExprListDelete(db, pEList); + sqlite3ExprDelete(db, pWhere); + return pTriggerStep; +} + +/* +** Construct a trigger step that implements a DELETE statement and return +** a pointer to that trigger step. The parser calls this routine when it +** sees a DELETE statement inside the body of a CREATE TRIGGER. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep( + sqlite3 *db, /* Database connection */ + Token *pTableName, /* The table from which rows are deleted */ + Expr *pWhere /* The WHERE clause */ +){ + TriggerStep *pTriggerStep; + + pTriggerStep = triggerStepAllocate(db, TK_DELETE, pTableName); + if( pTriggerStep ){ + pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); + pTriggerStep->orconf = OE_Default; + } + sqlite3ExprDelete(db, pWhere); + return pTriggerStep; +} + +/* +** Recursively delete a Trigger structure +*/ +SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){ + if( pTrigger==0 ) return; + sqlite3DeleteTriggerStep(db, pTrigger->step_list); + sqlite3DbFree(db, pTrigger->zName); + sqlite3DbFree(db, pTrigger->table); + sqlite3ExprDelete(db, pTrigger->pWhen); + sqlite3IdListDelete(db, pTrigger->pColumns); + sqlite3DbFree(db, pTrigger); +} + +/* +** This function is called to drop a trigger from the database schema. +** +** This may be called directly from the parser and therefore identifies +** the trigger by name. The sqlite3DropTriggerPtr() routine does the +** same job as this routine except it takes a pointer to the trigger +** instead of the trigger name. +**/ +SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){ + Trigger *pTrigger = 0; + int i; + const char *zDb; + const char *zName; + sqlite3 *db = pParse->db; + + if( db->mallocFailed ) goto drop_trigger_cleanup; + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto drop_trigger_cleanup; + } + + assert( pName->nSrc==1 ); + zDb = pName->a[0].zDatabase; + zName = pName->a[0].zName; + assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) ); + for(i=OMIT_TEMPDB; inDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + if( zDb && sqlite3StrICmp(db->aDb[j].zName, zDb) ) continue; + assert( sqlite3SchemaMutexHeld(db, j, 0) ); + pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName); + if( pTrigger ) break; + } + if( !pTrigger ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0); + }else{ + sqlite3CodeVerifyNamedSchema(pParse, zDb); + } + pParse->checkSchema = 1; + goto drop_trigger_cleanup; + } + sqlite3DropTriggerPtr(pParse, pTrigger); + +drop_trigger_cleanup: + sqlite3SrcListDelete(db, pName); +} + +/* +** Return a pointer to the Table structure for the table that a trigger +** is set on. +*/ +static Table *tableOfTrigger(Trigger *pTrigger){ + return sqlite3HashFind(&pTrigger->pTabSchema->tblHash, pTrigger->table); +} + + +/* +** Drop a trigger given a pointer to that trigger. +*/ +SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){ + Table *pTable; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema); + assert( iDb>=0 && iDbnDb ); + pTable = tableOfTrigger(pTrigger); + assert( pTable ); + assert( pTable->pSchema==pTrigger->pSchema || iDb==1 ); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code = SQLITE_DROP_TRIGGER; + const char *zDb = db->aDb[iDb].zName; + const char *zTab = SCHEMA_TABLE(iDb); + if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER; + if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) || + sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ + return; + } + } +#endif + + /* Generate code to destroy the database record of the trigger. + */ + assert( pTable!=0 ); + if( (v = sqlite3GetVdbe(pParse))!=0 ){ + int base; + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList dropTrigger[] = { + { OP_Rewind, 0, ADDR(9), 0}, + { OP_String8, 0, 1, 0}, /* 1 */ + { OP_Column, 0, 1, 2}, + { OP_Ne, 2, ADDR(8), 1}, + { OP_String8, 0, 1, 0}, /* 4: "trigger" */ + { OP_Column, 0, 0, 2}, + { OP_Ne, 2, ADDR(8), 1}, + { OP_Delete, 0, 0, 0}, + { OP_Next, 0, ADDR(1), 0}, /* 8 */ + }; + + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3OpenMasterTable(pParse, iDb); + base = sqlite3VdbeAddOpList(v, ArraySize(dropTrigger), dropTrigger, iLn); + sqlite3VdbeChangeP4(v, base+1, pTrigger->zName, P4_TRANSIENT); + sqlite3VdbeChangeP4(v, base+4, "trigger", P4_STATIC); + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddOp2(v, OP_Close, 0, 0); + sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0); + if( pParse->nMem<3 ){ + pParse->nMem = 3; + } + } +} + +/* +** Remove a trigger from the hash tables of the sqlite* pointer. +*/ +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){ + Trigger *pTrigger; + Hash *pHash; + + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pHash = &(db->aDb[iDb].pSchema->trigHash); + pTrigger = sqlite3HashInsert(pHash, zName, 0); + if( ALWAYS(pTrigger) ){ + if( pTrigger->pSchema==pTrigger->pTabSchema ){ + Table *pTab = tableOfTrigger(pTrigger); + Trigger **pp; + for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext)); + *pp = (*pp)->pNext; + } + sqlite3DeleteTrigger(db, pTrigger); + db->flags |= SQLITE_InternChanges; + } +} + +/* +** pEList is the SET clause of an UPDATE statement. Each entry +** in pEList is of the format =. If any of the entries +** in pEList have an which matches an identifier in pIdList, +** then return TRUE. If pIdList==NULL, then it is considered a +** wildcard that matches anything. Likewise if pEList==NULL then +** it matches anything so always return true. Return false only +** if there is no match. +*/ +static int checkColumnOverlap(IdList *pIdList, ExprList *pEList){ + int e; + if( pIdList==0 || NEVER(pEList==0) ) return 1; + for(e=0; enExpr; e++){ + if( sqlite3IdListIndex(pIdList, pEList->a[e].zName)>=0 ) return 1; + } + return 0; +} + +/* +** Return a list of all triggers on table pTab if there exists at least +** one trigger that must be fired when an operation of type 'op' is +** performed on the table, and, if that operation is an UPDATE, if at +** least one of the columns in pChanges is being modified. +*/ +SQLITE_PRIVATE Trigger *sqlite3TriggersExist( + Parse *pParse, /* Parse context */ + Table *pTab, /* The table the contains the triggers */ + int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */ + ExprList *pChanges, /* Columns that change in an UPDATE statement */ + int *pMask /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ +){ + int mask = 0; + Trigger *pList = 0; + Trigger *p; + + if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){ + pList = sqlite3TriggerList(pParse, pTab); + } + assert( pList==0 || IsVirtual(pTab)==0 ); + for(p=pList; p; p=p->pNext){ + if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){ + mask |= p->tr_tm; + } + } + if( pMask ){ + *pMask = mask; + } + return (mask ? pList : 0); +} + +/* +** Convert the pStep->zTarget string into a SrcList and return a pointer +** to that SrcList. +** +** This routine adds a specific database name, if needed, to the target when +** forming the SrcList. This prevents a trigger in one database from +** referring to a target in another database. An exception is when the +** trigger is in TEMP in which case it can refer to any other database it +** wants. +*/ +static SrcList *targetSrcList( + Parse *pParse, /* The parsing context */ + TriggerStep *pStep /* The trigger containing the target token */ +){ + sqlite3 *db = pParse->db; + int iDb; /* Index of the database to use */ + SrcList *pSrc; /* SrcList to be returned */ + + pSrc = sqlite3SrcListAppend(db, 0, 0, 0); + if( pSrc ){ + assert( pSrc->nSrc>0 ); + pSrc->a[pSrc->nSrc-1].zName = sqlite3DbStrDup(db, pStep->zTarget); + iDb = sqlite3SchemaToIndex(db, pStep->pTrig->pSchema); + if( iDb==0 || iDb>=2 ){ + assert( iDbnDb ); + pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName); + } + } + return pSrc; +} + +/* +** Generate VDBE code for the statements inside the body of a single +** trigger. +*/ +static int codeTriggerProgram( + Parse *pParse, /* The parser context */ + TriggerStep *pStepList, /* List of statements inside the trigger body */ + int orconf /* Conflict algorithm. (OE_Abort, etc) */ +){ + TriggerStep *pStep; + Vdbe *v = pParse->pVdbe; + sqlite3 *db = pParse->db; + + assert( pParse->pTriggerTab && pParse->pToplevel ); + assert( pStepList ); + assert( v!=0 ); + for(pStep=pStepList; pStep; pStep=pStep->pNext){ + /* Figure out the ON CONFLICT policy that will be used for this step + ** of the trigger program. If the statement that caused this trigger + ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use + ** the ON CONFLICT policy that was specified as part of the trigger + ** step statement. Example: + ** + ** CREATE TRIGGER AFTER INSERT ON t1 BEGIN; + ** INSERT OR REPLACE INTO t2 VALUES(new.a, new.b); + ** END; + ** + ** INSERT INTO t1 ... ; -- insert into t2 uses REPLACE policy + ** INSERT OR IGNORE INTO t1 ... ; -- insert into t2 uses IGNORE policy + */ + pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf; + assert( pParse->okConstFactor==0 ); + + switch( pStep->op ){ + case TK_UPDATE: { + sqlite3Update(pParse, + targetSrcList(pParse, pStep), + sqlite3ExprListDup(db, pStep->pExprList, 0), + sqlite3ExprDup(db, pStep->pWhere, 0), + pParse->eOrconf + ); + break; + } + case TK_INSERT: { + sqlite3Insert(pParse, + targetSrcList(pParse, pStep), + sqlite3SelectDup(db, pStep->pSelect, 0), + sqlite3IdListDup(db, pStep->pIdList), + pParse->eOrconf + ); + break; + } + case TK_DELETE: { + sqlite3DeleteFrom(pParse, + targetSrcList(pParse, pStep), + sqlite3ExprDup(db, pStep->pWhere, 0) + ); + break; + } + default: assert( pStep->op==TK_SELECT ); { + SelectDest sDest; + Select *pSelect = sqlite3SelectDup(db, pStep->pSelect, 0); + sqlite3SelectDestInit(&sDest, SRT_Discard, 0); + sqlite3Select(pParse, pSelect, &sDest); + sqlite3SelectDelete(db, pSelect); + break; + } + } + if( pStep->op!=TK_SELECT ){ + sqlite3VdbeAddOp0(v, OP_ResetCount); + } + } + + return 0; +} + +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +/* +** This function is used to add VdbeComment() annotations to a VDBE +** program. It is not used in production code, only for debugging. +*/ +static const char *onErrorText(int onError){ + switch( onError ){ + case OE_Abort: return "abort"; + case OE_Rollback: return "rollback"; + case OE_Fail: return "fail"; + case OE_Replace: return "replace"; + case OE_Ignore: return "ignore"; + case OE_Default: return "default"; + } + return "n/a"; +} +#endif + +/* +** Parse context structure pFrom has just been used to create a sub-vdbe +** (trigger program). If an error has occurred, transfer error information +** from pFrom to pTo. +*/ +static void transferParseError(Parse *pTo, Parse *pFrom){ + assert( pFrom->zErrMsg==0 || pFrom->nErr ); + assert( pTo->zErrMsg==0 || pTo->nErr ); + if( pTo->nErr==0 ){ + pTo->zErrMsg = pFrom->zErrMsg; + pTo->nErr = pFrom->nErr; + pTo->rc = pFrom->rc; + }else{ + sqlite3DbFree(pFrom->db, pFrom->zErrMsg); + } +} + +/* +** Create and populate a new TriggerPrg object with a sub-program +** implementing trigger pTrigger with ON CONFLICT policy orconf. +*/ +static TriggerPrg *codeRowTrigger( + Parse *pParse, /* Current parse context */ + Trigger *pTrigger, /* Trigger to code */ + Table *pTab, /* The table pTrigger is attached to */ + int orconf /* ON CONFLICT policy to code trigger program with */ +){ + Parse *pTop = sqlite3ParseToplevel(pParse); + sqlite3 *db = pParse->db; /* Database handle */ + TriggerPrg *pPrg; /* Value to return */ + Expr *pWhen = 0; /* Duplicate of trigger WHEN expression */ + Vdbe *v; /* Temporary VM */ + NameContext sNC; /* Name context for sub-vdbe */ + SubProgram *pProgram = 0; /* Sub-vdbe for trigger program */ + Parse *pSubParse; /* Parse context for sub-vdbe */ + int iEndTrigger = 0; /* Label to jump to if WHEN is false */ + + assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) ); + assert( pTop->pVdbe ); + + /* Allocate the TriggerPrg and SubProgram objects. To ensure that they + ** are freed if an error occurs, link them into the Parse.pTriggerPrg + ** list of the top-level Parse object sooner rather than later. */ + pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg)); + if( !pPrg ) return 0; + pPrg->pNext = pTop->pTriggerPrg; + pTop->pTriggerPrg = pPrg; + pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram)); + if( !pProgram ) return 0; + sqlite3VdbeLinkSubProgram(pTop->pVdbe, pProgram); + pPrg->pTrigger = pTrigger; + pPrg->orconf = orconf; + pPrg->aColmask[0] = 0xffffffff; + pPrg->aColmask[1] = 0xffffffff; + + /* Allocate and populate a new Parse context to use for coding the + ** trigger sub-program. */ + pSubParse = sqlite3StackAllocZero(db, sizeof(Parse)); + if( !pSubParse ) return 0; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pSubParse; + pSubParse->db = db; + pSubParse->pTriggerTab = pTab; + pSubParse->pToplevel = pTop; + pSubParse->zAuthContext = pTrigger->zName; + pSubParse->eTriggerOp = pTrigger->op; + pSubParse->nQueryLoop = pParse->nQueryLoop; + + v = sqlite3GetVdbe(pSubParse); + if( v ){ + VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)", + pTrigger->zName, onErrorText(orconf), + (pTrigger->tr_tm==TRIGGER_BEFORE ? "BEFORE" : "AFTER"), + (pTrigger->op==TK_UPDATE ? "UPDATE" : ""), + (pTrigger->op==TK_INSERT ? "INSERT" : ""), + (pTrigger->op==TK_DELETE ? "DELETE" : ""), + pTab->zName + )); +#ifndef SQLITE_OMIT_TRACE + sqlite3VdbeChangeP4(v, -1, + sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC + ); +#endif + + /* If one was specified, code the WHEN clause. If it evaluates to false + ** (or NULL) the sub-vdbe is immediately halted by jumping to the + ** OP_Halt inserted at the end of the program. */ + if( pTrigger->pWhen ){ + pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0); + if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen) + && db->mallocFailed==0 + ){ + iEndTrigger = sqlite3VdbeMakeLabel(v); + sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL); + } + sqlite3ExprDelete(db, pWhen); + } + + /* Code the trigger program into the sub-vdbe. */ + codeTriggerProgram(pSubParse, pTrigger->step_list, orconf); + + /* Insert an OP_Halt at the end of the sub-program. */ + if( iEndTrigger ){ + sqlite3VdbeResolveLabel(v, iEndTrigger); + } + sqlite3VdbeAddOp0(v, OP_Halt); + VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf))); + + transferParseError(pParse, pSubParse); + if( db->mallocFailed==0 ){ + pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg); + } + pProgram->nMem = pSubParse->nMem; + pProgram->nCsr = pSubParse->nTab; + pProgram->nOnce = pSubParse->nOnce; + pProgram->token = (void *)pTrigger; + pPrg->aColmask[0] = pSubParse->oldmask; + pPrg->aColmask[1] = pSubParse->newmask; + sqlite3VdbeDelete(v); + } + + assert( !pSubParse->pAinc && !pSubParse->pZombieTab ); + assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg ); + sqlite3ParserReset(pSubParse); + sqlite3StackFree(db, pSubParse); + + return pPrg; +} + +/* +** Return a pointer to a TriggerPrg object containing the sub-program for +** trigger pTrigger with default ON CONFLICT algorithm orconf. If no such +** TriggerPrg object exists, a new object is allocated and populated before +** being returned. +*/ +static TriggerPrg *getRowTrigger( + Parse *pParse, /* Current parse context */ + Trigger *pTrigger, /* Trigger to code */ + Table *pTab, /* The table trigger pTrigger is attached to */ + int orconf /* ON CONFLICT algorithm. */ +){ + Parse *pRoot = sqlite3ParseToplevel(pParse); + TriggerPrg *pPrg; + + assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) ); + + /* It may be that this trigger has already been coded (or is in the + ** process of being coded). If this is the case, then an entry with + ** a matching TriggerPrg.pTrigger field will be present somewhere + ** in the Parse.pTriggerPrg list. Search for such an entry. */ + for(pPrg=pRoot->pTriggerPrg; + pPrg && (pPrg->pTrigger!=pTrigger || pPrg->orconf!=orconf); + pPrg=pPrg->pNext + ); + + /* If an existing TriggerPrg could not be located, create a new one. */ + if( !pPrg ){ + pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf); + } + + return pPrg; +} + +/* +** Generate code for the trigger program associated with trigger p on +** table pTab. The reg, orconf and ignoreJump parameters passed to this +** function are the same as those described in the header function for +** sqlite3CodeRowTrigger() +*/ +SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect( + Parse *pParse, /* Parse context */ + Trigger *p, /* Trigger to code */ + Table *pTab, /* The table to code triggers from */ + int reg, /* Reg array containing OLD.* and NEW.* values */ + int orconf, /* ON CONFLICT policy */ + int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */ +){ + Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */ + TriggerPrg *pPrg; + pPrg = getRowTrigger(pParse, p, pTab, orconf); + assert( pPrg || pParse->nErr || pParse->db->mallocFailed ); + + /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program + ** is a pointer to the sub-vdbe containing the trigger program. */ + if( pPrg ){ + int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers)); + + sqlite3VdbeAddOp3(v, OP_Program, reg, ignoreJump, ++pParse->nMem); + sqlite3VdbeChangeP4(v, -1, (const char *)pPrg->pProgram, P4_SUBPROGRAM); + VdbeComment( + (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf))); + + /* Set the P5 operand of the OP_Program instruction to non-zero if + ** recursive invocation of this trigger program is disallowed. Recursive + ** invocation is disallowed if (a) the sub-program is really a trigger, + ** not a foreign key action, and (b) the flag to enable recursive triggers + ** is clear. */ + sqlite3VdbeChangeP5(v, (u8)bRecursive); + } +} + +/* +** This is called to code the required FOR EACH ROW triggers for an operation +** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE) +** is given by the op parameter. The tr_tm parameter determines whether the +** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then +** parameter pChanges is passed the list of columns being modified. +** +** If there are no triggers that fire at the specified time for the specified +** operation on pTab, this function is a no-op. +** +** The reg argument is the address of the first in an array of registers +** that contain the values substituted for the new.* and old.* references +** in the trigger program. If N is the number of columns in table pTab +** (a copy of pTab->nCol), then registers are populated as follows: +** +** Register Contains +** ------------------------------------------------------ +** reg+0 OLD.rowid +** reg+1 OLD.* value of left-most column of pTab +** ... ... +** reg+N OLD.* value of right-most column of pTab +** reg+N+1 NEW.rowid +** reg+N+2 OLD.* value of left-most column of pTab +** ... ... +** reg+N+N+1 NEW.* value of right-most column of pTab +** +** For ON DELETE triggers, the registers containing the NEW.* values will +** never be accessed by the trigger program, so they are not allocated or +** populated by the caller (there is no data to populate them with anyway). +** Similarly, for ON INSERT triggers the values stored in the OLD.* registers +** are never accessed, and so are not allocated by the caller. So, for an +** ON INSERT trigger, the value passed to this function as parameter reg +** is not a readable register, although registers (reg+N) through +** (reg+N+N+1) are. +** +** Parameter orconf is the default conflict resolution algorithm for the +** trigger program to use (REPLACE, IGNORE etc.). Parameter ignoreJump +** is the instruction that control should jump to if a trigger program +** raises an IGNORE exception. +*/ +SQLITE_PRIVATE void sqlite3CodeRowTrigger( + Parse *pParse, /* Parse context */ + Trigger *pTrigger, /* List of triggers on table pTab */ + int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */ + ExprList *pChanges, /* Changes list for any UPDATE OF triggers */ + int tr_tm, /* One of TRIGGER_BEFORE, TRIGGER_AFTER */ + Table *pTab, /* The table to code triggers from */ + int reg, /* The first in an array of registers (see above) */ + int orconf, /* ON CONFLICT policy */ + int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */ +){ + Trigger *p; /* Used to iterate through pTrigger list */ + + assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE ); + assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER ); + assert( (op==TK_UPDATE)==(pChanges!=0) ); + + for(p=pTrigger; p; p=p->pNext){ + + /* Sanity checking: The schema for the trigger and for the table are + ** always defined. The trigger must be in the same schema as the table + ** or else it must be a TEMP trigger. */ + assert( p->pSchema!=0 ); + assert( p->pTabSchema!=0 ); + assert( p->pSchema==p->pTabSchema + || p->pSchema==pParse->db->aDb[1].pSchema ); + + /* Determine whether we should code this trigger */ + if( p->op==op + && p->tr_tm==tr_tm + && checkColumnOverlap(p->pColumns, pChanges) + ){ + sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump); + } + } +} + +/* +** Triggers may access values stored in the old.* or new.* pseudo-table. +** This function returns a 32-bit bitmask indicating which columns of the +** old.* or new.* tables actually are used by triggers. This information +** may be used by the caller, for example, to avoid having to load the entire +** old.* record into memory when executing an UPDATE or DELETE command. +** +** Bit 0 of the returned mask is set if the left-most column of the +** table may be accessed using an [old|new].reference. Bit 1 is set if +** the second leftmost column value is required, and so on. If there +** are more than 32 columns in the table, and at least one of the columns +** with an index greater than 32 may be accessed, 0xffffffff is returned. +** +** It is not possible to determine if the old.rowid or new.rowid column is +** accessed by triggers. The caller must always assume that it is. +** +** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned +** applies to the old.* table. If 1, the new.* table. +** +** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE +** and TRIGGER_AFTER bits set. Values accessed by BEFORE triggers are only +** included in the returned mask if the TRIGGER_BEFORE bit is set in the +** tr_tm parameter. Similarly, values accessed by AFTER triggers are only +** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm. +*/ +SQLITE_PRIVATE u32 sqlite3TriggerColmask( + Parse *pParse, /* Parse context */ + Trigger *pTrigger, /* List of triggers on table pTab */ + ExprList *pChanges, /* Changes list for any UPDATE OF triggers */ + int isNew, /* 1 for new.* ref mask, 0 for old.* ref mask */ + int tr_tm, /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ + Table *pTab, /* The table to code triggers from */ + int orconf /* Default ON CONFLICT policy for trigger steps */ +){ + const int op = pChanges ? TK_UPDATE : TK_DELETE; + u32 mask = 0; + Trigger *p; + + assert( isNew==1 || isNew==0 ); + for(p=pTrigger; p; p=p->pNext){ + if( p->op==op && (tr_tm&p->tr_tm) + && checkColumnOverlap(p->pColumns,pChanges) + ){ + TriggerPrg *pPrg; + pPrg = getRowTrigger(pParse, p, pTab, orconf); + if( pPrg ){ + mask |= pPrg->aColmask[isNew]; + } + } + } + + return mask; +} + +#endif /* !defined(SQLITE_OMIT_TRIGGER) */ + +/************** End of trigger.c *********************************************/ +/************** Begin file update.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle UPDATE statements. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Forward declaration */ +static void updateVirtualTable( + Parse *pParse, /* The parsing context */ + SrcList *pSrc, /* The virtual table to be modified */ + Table *pTab, /* The virtual table */ + ExprList *pChanges, /* The columns to change in the UPDATE statement */ + Expr *pRowidExpr, /* Expression used to recompute the rowid */ + int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ + Expr *pWhere, /* WHERE clause of the UPDATE statement */ + int onError /* ON CONFLICT strategy */ +); +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/* +** The most recently coded instruction was an OP_Column to retrieve the +** i-th column of table pTab. This routine sets the P4 parameter of the +** OP_Column to the default value, if any. +** +** The default value of a column is specified by a DEFAULT clause in the +** column definition. This was either supplied by the user when the table +** was created, or added later to the table definition by an ALTER TABLE +** command. If the latter, then the row-records in the table btree on disk +** may not contain a value for the column and the default value, taken +** from the P4 parameter of the OP_Column instruction, is returned instead. +** If the former, then all row-records are guaranteed to include a value +** for the column and the P4 value is not required. +** +** Column definitions created by an ALTER TABLE command may only have +** literal default values specified: a number, null or a string. (If a more +** complicated default expression value was provided, it is evaluated +** when the ALTER TABLE is executed and one of the literal values written +** into the sqlite_master table.) +** +** Therefore, the P4 parameter is only required if the default value for +** the column is a literal number, string or null. The sqlite3ValueFromExpr() +** function is capable of transforming these types of expressions into +** sqlite3_value objects. +** +** If parameter iReg is not negative, code an OP_RealAffinity instruction +** on register iReg. This is used when an equivalent integer value is +** stored in place of an 8-byte floating point value in order to save +** space. +*/ +SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){ + assert( pTab!=0 ); + if( !pTab->pSelect ){ + sqlite3_value *pValue = 0; + u8 enc = ENC(sqlite3VdbeDb(v)); + Column *pCol = &pTab->aCol[i]; + VdbeComment((v, "%s.%s", pTab->zName, pCol->zName)); + assert( inCol ); + sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc, + pCol->affinity, &pValue); + if( pValue ){ + sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM); + } +#ifndef SQLITE_OMIT_FLOATING_POINT + if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg); + } +#endif + } +} + +/* +** Process an UPDATE statement. +** +** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL; +** \_______/ \________/ \______/ \________________/ +* onError pTabList pChanges pWhere +*/ +SQLITE_PRIVATE void sqlite3Update( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* The table in which we should change things */ + ExprList *pChanges, /* Things to be changed */ + Expr *pWhere, /* The WHERE clause. May be null */ + int onError /* How to handle constraint errors */ +){ + int i, j; /* Loop counters */ + Table *pTab; /* The table to be updated */ + int addrTop = 0; /* VDBE instruction address of the start of the loop */ + WhereInfo *pWInfo; /* Information about the WHERE clause */ + Vdbe *v; /* The virtual database engine */ + Index *pIdx; /* For looping over indices */ + Index *pPk; /* The PRIMARY KEY index for WITHOUT ROWID tables */ + int nIdx; /* Number of indices that need updating */ + int iBaseCur; /* Base cursor number */ + int iDataCur; /* Cursor for the canonical data btree */ + int iIdxCur; /* Cursor for the first index */ + sqlite3 *db; /* The database structure */ + int *aRegIdx = 0; /* One register assigned to each index to be updated */ + int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the + ** an expression for the i-th column of the table. + ** aXRef[i]==-1 if the i-th column is not changed. */ + u8 *aToOpen; /* 1 for tables and indices to be opened */ + u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */ + u8 chngRowid; /* Rowid changed in a normal table */ + u8 chngKey; /* Either chngPk or chngRowid */ + Expr *pRowidExpr = 0; /* Expression defining the new record number */ + AuthContext sContext; /* The authorization context */ + NameContext sNC; /* The name-context to resolve expressions in */ + int iDb; /* Database containing the table being updated */ + int okOnePass; /* True for one-pass algorithm without the FIFO */ + int hasFK; /* True if foreign key processing is required */ + int labelBreak; /* Jump here to break out of UPDATE loop */ + int labelContinue; /* Jump here to continue next step of UPDATE loop */ + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True when updating a view (INSTEAD OF trigger) */ + Trigger *pTrigger; /* List of triggers on pTab, if required */ + int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ +#endif + int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */ + int iEph = 0; /* Ephemeral table holding all primary key values */ + int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */ + int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ + + /* Register Allocations */ + int regRowCount = 0; /* A count of rows changed */ + int regOldRowid = 0; /* The old rowid */ + int regNewRowid = 0; /* The new rowid */ + int regNew = 0; /* Content of the NEW.* table in triggers */ + int regOld = 0; /* Content of OLD.* table in triggers */ + int regRowSet = 0; /* Rowset of rows to be updated */ + int regKey = 0; /* composite PRIMARY KEY value */ + + memset(&sContext, 0, sizeof(sContext)); + db = pParse->db; + if( pParse->nErr || db->mallocFailed ){ + goto update_cleanup; + } + assert( pTabList->nSrc==1 ); + + /* Locate the table which we want to update. + */ + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ) goto update_cleanup; + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + + /* Figure out if we have any triggers and if the table being + ** updated is a view. + */ +#ifndef SQLITE_OMIT_TRIGGER + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask); + isView = pTab->pSelect!=0; + assert( pTrigger || tmask==0 ); +#else +# define pTrigger 0 +# define isView 0 +# define tmask 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto update_cleanup; + } + if( sqlite3IsReadOnly(pParse, pTab, tmask) ){ + goto update_cleanup; + } + + /* Allocate a cursors for the main database table and for all indices. + ** The index cursors might not be used, but if they are used they + ** need to occur right after the database cursor. So go ahead and + ** allocate enough space, just in case. + */ + pTabList->a[0].iCursor = iBaseCur = iDataCur = pParse->nTab++; + iIdxCur = iDataCur+1; + pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ + if( IsPrimaryKeyIndex(pIdx) && pPk!=0 ){ + iDataCur = pParse->nTab; + pTabList->a[0].iCursor = iDataCur; + } + pParse->nTab++; + } + + /* Allocate space for aXRef[], aRegIdx[], and aToOpen[]. + ** Initialize aXRef[] and aToOpen[] to their default values. + */ + aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 ); + if( aXRef==0 ) goto update_cleanup; + aRegIdx = aXRef+pTab->nCol; + aToOpen = (u8*)(aRegIdx+nIdx); + memset(aToOpen, 1, nIdx+1); + aToOpen[nIdx+1] = 0; + for(i=0; inCol; i++) aXRef[i] = -1; + + /* Initialize the name-context */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + + /* Resolve the column names in all the expressions of the + ** of the UPDATE statement. Also find the column index + ** for each column to be updated in the pChanges array. For each + ** column to be updated, make sure we have authorization to change + ** that column. + */ + chngRowid = chngPk = 0; + for(i=0; inExpr; i++){ + if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){ + goto update_cleanup; + } + for(j=0; jnCol; j++){ + if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){ + if( j==pTab->iPKey ){ + chngRowid = 1; + pRowidExpr = pChanges->a[i].pExpr; + }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){ + chngPk = 1; + } + aXRef[j] = i; + break; + } + } + if( j>=pTab->nCol ){ + if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zName) ){ + j = -1; + chngRowid = 1; + pRowidExpr = pChanges->a[i].pExpr; + }else{ + sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName); + pParse->checkSchema = 1; + goto update_cleanup; + } + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int rc; + rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName, + j<0 ? "ROWID" : pTab->aCol[j].zName, + db->aDb[iDb].zName); + if( rc==SQLITE_DENY ){ + goto update_cleanup; + }else if( rc==SQLITE_IGNORE ){ + aXRef[j] = -1; + } + } +#endif + } + assert( (chngRowid & chngPk)==0 ); + assert( chngRowid==0 || chngRowid==1 ); + assert( chngPk==0 || chngPk==1 ); + chngKey = chngRowid + chngPk; + + /* The SET expressions are not actually used inside the WHERE loop. + ** So reset the colUsed mask + */ + pTabList->a[0].colUsed = 0; + + hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey); + + /* There is one entry in the aRegIdx[] array for each index on the table + ** being updated. Fill in aRegIdx[] with a register number that will hold + ** the key for accessing each index. + ** + ** FIXME: Be smarter about omitting indexes that use expressions. + */ + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + int reg; + if( chngKey || hasFK || pIdx->pPartIdxWhere || pIdx==pPk ){ + reg = ++pParse->nMem; + }else{ + reg = 0; + for(i=0; inKeyCol; i++){ + i16 iIdxCol = pIdx->aiColumn[i]; + if( iIdxCol<0 || aXRef[iIdxCol]>=0 ){ + reg = ++pParse->nMem; + break; + } + } + } + if( reg==0 ) aToOpen[j+1] = 0; + aRegIdx[j] = reg; + } + + /* Begin generating code. */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto update_cleanup; + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, 1, iDb); + + /* Allocate required registers. */ + if( !IsVirtual(pTab) ){ + regRowSet = ++pParse->nMem; + regOldRowid = regNewRowid = ++pParse->nMem; + if( chngPk || pTrigger || hasFK ){ + regOld = pParse->nMem + 1; + pParse->nMem += pTab->nCol; + } + if( chngKey || pTrigger || hasFK ){ + regNewRowid = ++pParse->nMem; + } + regNew = pParse->nMem + 1; + pParse->nMem += pTab->nCol; + } + + /* Start the view context. */ + if( isView ){ + sqlite3AuthContextPush(pParse, &sContext, pTab->zName); + } + + /* If we are trying to update a view, realize that view into + ** an ephemeral table. + */ +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) + if( isView ){ + sqlite3MaterializeView(pParse, pTab, pWhere, iDataCur); + } +#endif + + /* Resolve the column names in all the expressions in the + ** WHERE clause. + */ + if( sqlite3ResolveExprNames(&sNC, pWhere) ){ + goto update_cleanup; + } + +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Virtual tables must be handled separately */ + if( IsVirtual(pTab) ){ + updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef, + pWhere, onError); + goto update_cleanup; + } +#endif + + /* Begin the database scan + */ + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid); + pWInfo = sqlite3WhereBegin( + pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED, iIdxCur + ); + if( pWInfo==0 ) goto update_cleanup; + okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); + + /* Remember the rowid of every item to be updated. + */ + sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid); + if( !okOnePass ){ + sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid); + } + + /* End the database scan loop. + */ + sqlite3WhereEnd(pWInfo); + }else{ + int iPk; /* First of nPk memory cells holding PRIMARY KEY value */ + i16 nPk; /* Number of components of the PRIMARY KEY */ + int addrOpen; /* Address of the OpenEphemeral instruction */ + + assert( pPk!=0 ); + nPk = pPk->nKeyCol; + iPk = pParse->nMem+1; + pParse->nMem += nPk; + regKey = ++pParse->nMem; + iEph = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_Null, 0, iPk); + addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nPk); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, + WHERE_ONEPASS_DESIRED, iIdxCur); + if( pWInfo==0 ) goto update_cleanup; + okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); + for(i=0; iaiColumn[i]>=0 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pPk->aiColumn[i], + iPk+i); + } + if( okOnePass ){ + sqlite3VdbeChangeToNoop(v, addrOpen); + nKey = nPk; + regKey = iPk; + }else{ + sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey, + sqlite3IndexAffinityStr(db, pPk), nPk); + sqlite3VdbeAddOp2(v, OP_IdxInsert, iEph, regKey); + } + sqlite3WhereEnd(pWInfo); + } + + /* Initialize the count of updated rows + */ + if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){ + regRowCount = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); + } + + labelBreak = sqlite3VdbeMakeLabel(v); + if( !isView ){ + /* + ** Open every index that needs updating. Note that if any + ** index could potentially invoke a REPLACE conflict resolution + ** action, then we need to open all indices because we might need + ** to be deleting some records. + */ + if( onError==OE_Replace ){ + memset(aToOpen, 1, nIdx+1); + }else{ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->onError==OE_Replace ){ + memset(aToOpen, 1, nIdx+1); + break; + } + } + } + if( okOnePass ){ + if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0; + if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0; + } + sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iBaseCur, aToOpen, + 0, 0); + } + + /* Top of the update loop */ + if( okOnePass ){ + if( aToOpen[iDataCur-iBaseCur] && !isView ){ + assert( pPk ); + sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey, nKey); + VdbeCoverageNeverTaken(v); + } + labelContinue = labelBreak; + sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak); + VdbeCoverageIf(v, pPk==0); + VdbeCoverageIf(v, pPk!=0); + }else if( pPk ){ + labelContinue = sqlite3VdbeMakeLabel(v); + sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v); + addrTop = sqlite3VdbeAddOp2(v, OP_RowKey, iEph, regKey); + sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey, 0); + VdbeCoverage(v); + }else{ + labelContinue = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, labelBreak, + regOldRowid); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid); + VdbeCoverage(v); + } + + /* If the record number will change, set register regNewRowid to + ** contain the new value. If the record number is not being modified, + ** then regNewRowid is the same register as regOldRowid, which is + ** already populated. */ + assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid ); + if( chngRowid ){ + sqlite3ExprCode(pParse, pRowidExpr, regNewRowid); + sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v); + } + + /* Compute the old pre-UPDATE content of the row being changed, if that + ** information is needed */ + if( chngPk || hasFK || pTrigger ){ + u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0); + oldmask |= sqlite3TriggerColmask(pParse, + pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError + ); + for(i=0; inCol; i++){ + if( oldmask==0xffffffff + || (i<32 && (oldmask & MASKBIT32(i))!=0) + || (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 + ){ + testcase( oldmask!=0xffffffff && i==31 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regOld+i); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i); + } + } + if( chngRowid==0 && pPk==0 ){ + sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid); + } + } + + /* Populate the array of registers beginning at regNew with the new + ** row data. This array is used to check constants, create the new + ** table and index records, and as the values for any new.* references + ** made by triggers. + ** + ** If there are one or more BEFORE triggers, then do not populate the + ** registers associated with columns that are (a) not modified by + ** this UPDATE statement and (b) not accessed by new.* references. The + ** values for registers not modified by the UPDATE must be reloaded from + ** the database after the BEFORE triggers are fired anyway (as the trigger + ** may have modified them). So not loading those that are not going to + ** be used eliminates some redundant opcodes. + */ + newmask = sqlite3TriggerColmask( + pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError + ); + for(i=0; inCol; i++){ + if( i==pTab->iPKey ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i); + }else{ + j = aXRef[i]; + if( j>=0 ){ + sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i); + }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){ + /* This branch loads the value of a column that will not be changed + ** into a register. This is done if there are no BEFORE triggers, or + ** if there are one or more BEFORE triggers that use this value via + ** a new.* reference in a trigger program. + */ + testcase( i==31 ); + testcase( i==32 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i); + } + } + } + + /* Fire any BEFORE UPDATE triggers. This happens before constraints are + ** verified. One could argue that this is wrong. + */ + if( tmask&TRIGGER_BEFORE ){ + sqlite3TableAffinity(v, pTab, regNew); + sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, + TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue); + + /* The row-trigger may have deleted the row being updated. In this + ** case, jump to the next row. No updates or AFTER triggers are + ** required. This behavior - what happens when the row being updated + ** is deleted or renamed by a BEFORE trigger - is left undefined in the + ** documentation. + */ + if( pPk ){ + sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue,regKey,nKey); + VdbeCoverage(v); + }else{ + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid); + VdbeCoverage(v); + } + + /* If it did not delete it, the row-trigger may still have modified + ** some of the columns of the row being updated. Load the values for + ** all columns not modified by the update statement into their + ** registers in case this has happened. + */ + for(i=0; inCol; i++){ + if( aXRef[i]<0 && i!=pTab->iPKey ){ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i); + } + } + } + + if( !isView ){ + int addr1 = 0; /* Address of jump instruction */ + int bReplace = 0; /* True if REPLACE conflict resolution might happen */ + + /* Do constraint checks. */ + assert( regOldRowid>0 ); + sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, + regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace); + + /* Do FK constraint checks. */ + if( hasFK ){ + sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey); + } + + /* Delete the index entries associated with the current record. */ + if( bReplace || chngKey ){ + if( pPk ){ + addr1 = sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, 0, regKey, nKey); + }else{ + addr1 = sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, 0, regOldRowid); + } + VdbeCoverageNeverTaken(v); + } + sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1); + + /* If changing the record number, delete the old record. */ + if( hasFK || chngKey || pPk!=0 ){ + sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0); + } + if( bReplace || chngKey ){ + sqlite3VdbeJumpHere(v, addr1); + } + + if( hasFK ){ + sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey); + } + + /* Insert the new index entries and the new record. */ + sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur, + regNewRowid, aRegIdx, 1, 0, 0); + + /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to + ** handle rows (possibly in other tables) that refer via a foreign key + ** to the row just updated. */ + if( hasFK ){ + sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey); + } + } + + /* Increment the row counter + */ + if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){ + sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1); + } + + sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, + TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue); + + /* Repeat the above with the next record to be updated, until + ** all record selected by the WHERE clause have been updated. + */ + if( okOnePass ){ + /* Nothing to do at end-of-loop for a single-pass */ + }else if( pPk ){ + sqlite3VdbeResolveLabel(v, labelContinue); + sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v); + }else{ + sqlite3VdbeGoto(v, labelContinue); + } + sqlite3VdbeResolveLabel(v, labelBreak); + + /* Close all tables */ + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + assert( aRegIdx ); + if( aToOpen[i+1] ){ + sqlite3VdbeAddOp2(v, OP_Close, iIdxCur+i, 0); + } + } + if( iDataCurnested==0 && pParse->pTriggerTab==0 ){ + sqlite3AutoincrementEnd(pParse); + } + + /* + ** Return the number of rows that were changed. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. + */ + if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){ + sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC); + } + +update_cleanup: + sqlite3AuthContextPop(&sContext); + sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */ + sqlite3SrcListDelete(db, pTabList); + sqlite3ExprListDelete(db, pChanges); + sqlite3ExprDelete(db, pWhere); + return; +} +/* Make sure "isView" and other macros defined above are undefined. Otherwise +** they may interfere with compilation of other functions in this file +** (or in another file, if this file becomes part of the amalgamation). */ +#ifdef isView + #undef isView +#endif +#ifdef pTrigger + #undef pTrigger +#endif + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Generate code for an UPDATE of a virtual table. +** +** There are two possible strategies - the default and the special +** "onepass" strategy. Onepass is only used if the virtual table +** implementation indicates that pWhere may match at most one row. +** +** The default strategy is to create an ephemeral table that contains +** for each row to be changed: +** +** (A) The original rowid of that row. +** (B) The revised rowid for the row. +** (C) The content of every column in the row. +** +** Then loop through the contents of this ephemeral table executing a +** VUpdate for each row. When finished, drop the ephemeral table. +** +** The "onepass" strategy does not use an ephemeral table. Instead, it +** stores the same values (A, B and C above) in a register array and +** makes a single invocation of VUpdate. +*/ +static void updateVirtualTable( + Parse *pParse, /* The parsing context */ + SrcList *pSrc, /* The virtual table to be modified */ + Table *pTab, /* The virtual table */ + ExprList *pChanges, /* The columns to change in the UPDATE statement */ + Expr *pRowid, /* Expression used to recompute the rowid */ + int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ + Expr *pWhere, /* WHERE clause of the UPDATE statement */ + int onError /* ON CONFLICT strategy */ +){ + Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */ + int ephemTab; /* Table holding the result of the SELECT */ + int i; /* Loop counter */ + sqlite3 *db = pParse->db; /* Database connection */ + const char *pVTab = (const char*)sqlite3GetVTable(db, pTab); + WhereInfo *pWInfo; + int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */ + int regArg; /* First register in VUpdate arg array */ + int regRec; /* Register in which to assemble record */ + int regRowid; /* Register for ephem table rowid */ + int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */ + int aDummy[2]; /* Unused arg for sqlite3WhereOkOnePass() */ + int bOnePass; /* True to use onepass strategy */ + int addr; /* Address of OP_OpenEphemeral */ + + /* Allocate nArg registers to martial the arguments to VUpdate. Then + ** create and open the ephemeral table in which the records created from + ** these arguments will be temporarily stored. */ + assert( v ); + ephemTab = pParse->nTab++; + addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg); + regArg = pParse->nMem + 1; + pParse->nMem += nArg; + regRec = ++pParse->nMem; + regRowid = ++pParse->nMem; + + /* Start scanning the virtual table */ + pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0,0,WHERE_ONEPASS_DESIRED,0); + if( pWInfo==0 ) return; + + /* Populate the argument registers. */ + sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg); + if( pRowid ){ + sqlite3ExprCode(pParse, pRowid, regArg+1); + }else{ + sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1); + } + for(i=0; inCol; i++){ + if( aXRef[i]>=0 ){ + sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i); + }else{ + sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i); + } + } + + bOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy); + + if( bOnePass ){ + /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded + ** above. Also, if this is a top-level parse (not a trigger), clear the + ** multi-write flag so that the VM does not open a statement journal */ + sqlite3VdbeChangeToNoop(v, addr); + if( sqlite3IsToplevel(pParse) ){ + pParse->isMultiWrite = 0; + } + }else{ + /* Create a record from the argument register contents and insert it into + ** the ephemeral table. */ + sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec); + sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid); + } + + + if( bOnePass==0 ){ + /* End the virtual table scan */ + sqlite3WhereEnd(pWInfo); + + /* Begin scannning through the ephemeral table. */ + addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v); + + /* Extract arguments from the current row of the ephemeral table and + ** invoke the VUpdate method. */ + for(i=0; iflags&SQLITE_CountRows) ); + return vacuumFinalize(db, pStmt, pzErrMsg); +} + +/* +** Execute zSql on database db. The statement returns exactly +** one column. Execute this as SQL on the same database. +*/ +static int execExecSql(sqlite3 *db, char **pzErrMsg, const char *zSql){ + sqlite3_stmt *pStmt; + int rc; + + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + + while( SQLITE_ROW==sqlite3_step(pStmt) ){ + rc = execSql(db, pzErrMsg, (char*)sqlite3_column_text(pStmt, 0)); + if( rc!=SQLITE_OK ){ + vacuumFinalize(db, pStmt, pzErrMsg); + return rc; + } + } + + return vacuumFinalize(db, pStmt, pzErrMsg); +} + +/* +** The VACUUM command is used to clean up the database, +** collapse free space, etc. It is modelled after the VACUUM command +** in PostgreSQL. The VACUUM command works as follows: +** +** (1) Create a new transient database file +** (2) Copy all content from the database being vacuumed into +** the new transient database file +** (3) Copy content from the transient database back into the +** original database. +** +** The transient database requires temporary disk space approximately +** equal to the size of the original database. The copy operation of +** step (3) requires additional temporary disk space approximately equal +** to the size of the original database for the rollback journal. +** Hence, temporary disk space that is approximately 2x the size of the +** original database is required. Every page of the database is written +** approximately 3 times: Once for step (2) and twice for step (3). +** Two writes per page are required in step (3) because the original +** database content must be written into the rollback journal prior to +** overwriting the database with the vacuumed content. +** +** Only 1x temporary space and only 1x writes would be required if +** the copy of step (3) were replaced by deleting the original database +** and renaming the transient database as the original. But that will +** not work if other processes are attached to the original database. +** And a power loss in between deleting the original and renaming the +** transient would cause the database file to appear to be deleted +** following reboot. +*/ +SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse){ + Vdbe *v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp2(v, OP_Vacuum, 0, 0); + sqlite3VdbeUsesBtree(v, 0); + } + return; +} + +/* +** This routine implements the OP_Vacuum opcode of the VDBE. +*/ +SQLITE_PRIVATE int sqlite3RunVacuum(char **pzErrMsg, sqlite3 *db){ + int rc = SQLITE_OK; /* Return code from service routines */ + Btree *pMain; /* The database being vacuumed */ + Btree *pTemp; /* The temporary database we vacuum into */ + char *zSql = 0; /* SQL statements */ + int saved_flags; /* Saved value of the db->flags */ + int saved_nChange; /* Saved value of db->nChange */ + int saved_nTotalChange; /* Saved value of db->nTotalChange */ + void (*saved_xTrace)(void*,const char*); /* Saved db->xTrace */ + Db *pDb = 0; /* Database to detach at end of vacuum */ + int isMemDb; /* True if vacuuming a :memory: database */ + int nRes; /* Bytes of reserved space at the end of each page */ + int nDb; /* Number of attached databases */ + + if( !db->autoCommit ){ + sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction"); + return SQLITE_ERROR; + } + if( db->nVdbeActive>1 ){ + sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress"); + return SQLITE_ERROR; + } + + /* Save the current value of the database flags so that it can be + ** restored before returning. Then set the writable-schema flag, and + ** disable CHECK and foreign key constraints. */ + saved_flags = db->flags; + saved_nChange = db->nChange; + saved_nTotalChange = db->nTotalChange; + saved_xTrace = db->xTrace; + db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks | SQLITE_PreferBuiltin; + db->flags &= ~(SQLITE_ForeignKeys | SQLITE_ReverseOrder); + db->xTrace = 0; + + pMain = db->aDb[0].pBt; + isMemDb = sqlite3PagerIsMemdb(sqlite3BtreePager(pMain)); + + /* Attach the temporary database as 'vacuum_db'. The synchronous pragma + ** can be set to 'off' for this file, as it is not recovered if a crash + ** occurs anyway. The integrity of the database is maintained by a + ** (possibly synchronous) transaction opened on the main database before + ** sqlite3BtreeCopyFile() is called. + ** + ** An optimisation would be to use a non-journaled pager. + ** (Later:) I tried setting "PRAGMA vacuum_db.journal_mode=OFF" but + ** that actually made the VACUUM run slower. Very little journalling + ** actually occurs when doing a vacuum since the vacuum_db is initially + ** empty. Only the journal header is written. Apparently it takes more + ** time to parse and run the PRAGMA to turn journalling off than it does + ** to write the journal header file. + */ + nDb = db->nDb; + if( sqlite3TempInMemory(db) ){ + zSql = "ATTACH ':memory:' AS vacuum_db;"; + }else{ + zSql = "ATTACH '' AS vacuum_db;"; + } + rc = execSql(db, pzErrMsg, zSql); + if( db->nDb>nDb ){ + pDb = &db->aDb[db->nDb-1]; + assert( strcmp(pDb->zName,"vacuum_db")==0 ); + } + if( rc!=SQLITE_OK ) goto end_of_vacuum; + pTemp = db->aDb[db->nDb-1].pBt; + + /* The call to execSql() to attach the temp database has left the file + ** locked (as there was more than one active statement when the transaction + ** to read the schema was concluded. Unlock it here so that this doesn't + ** cause problems for the call to BtreeSetPageSize() below. */ + sqlite3BtreeCommit(pTemp); + + nRes = sqlite3BtreeGetOptimalReserve(pMain); + + /* A VACUUM cannot change the pagesize of an encrypted database. */ +#ifdef SQLITE_HAS_CODEC + if( db->nextPagesize ){ + extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*); + int nKey; + char *zKey; + sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey); + if( nKey ) db->nextPagesize = 0; + } +#endif + + rc = execSql(db, pzErrMsg, "PRAGMA vacuum_db.synchronous=OFF"); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + + /* Begin a transaction and take an exclusive lock on the main database + ** file. This is done before the sqlite3BtreeGetPageSize(pMain) call below, + ** to ensure that we do not try to change the page-size on a WAL database. + */ + rc = execSql(db, pzErrMsg, "BEGIN;"); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + rc = sqlite3BtreeBeginTrans(pMain, 2); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + + /* Do not attempt to change the page size for a WAL database */ + if( sqlite3PagerGetJournalMode(sqlite3BtreePager(pMain)) + ==PAGER_JOURNALMODE_WAL ){ + db->nextPagesize = 0; + } + + if( sqlite3BtreeSetPageSize(pTemp, sqlite3BtreeGetPageSize(pMain), nRes, 0) + || (!isMemDb && sqlite3BtreeSetPageSize(pTemp, db->nextPagesize, nRes, 0)) + || NEVER(db->mallocFailed) + ){ + rc = SQLITE_NOMEM; + goto end_of_vacuum; + } + +#ifndef SQLITE_OMIT_AUTOVACUUM + sqlite3BtreeSetAutoVacuum(pTemp, db->nextAutovac>=0 ? db->nextAutovac : + sqlite3BtreeGetAutoVacuum(pMain)); +#endif + + /* Query the schema of the main database. Create a mirror schema + ** in the temporary database. + */ + rc = execExecSql(db, pzErrMsg, + "SELECT 'CREATE TABLE vacuum_db.' || substr(sql,14) " + " FROM sqlite_master WHERE type='table' AND name!='sqlite_sequence'" + " AND coalesce(rootpage,1)>0" + ); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + rc = execExecSql(db, pzErrMsg, + "SELECT 'CREATE INDEX vacuum_db.' || substr(sql,14)" + " FROM sqlite_master WHERE sql LIKE 'CREATE INDEX %' "); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + rc = execExecSql(db, pzErrMsg, + "SELECT 'CREATE UNIQUE INDEX vacuum_db.' || substr(sql,21) " + " FROM sqlite_master WHERE sql LIKE 'CREATE UNIQUE INDEX %'"); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + + /* Loop through the tables in the main database. For each, do + ** an "INSERT INTO vacuum_db.xxx SELECT * FROM main.xxx;" to copy + ** the contents to the temporary database. + */ + assert( (db->flags & SQLITE_Vacuum)==0 ); + db->flags |= SQLITE_Vacuum; + rc = execExecSql(db, pzErrMsg, + "SELECT 'INSERT INTO vacuum_db.' || quote(name) " + "|| ' SELECT * FROM main.' || quote(name) || ';'" + "FROM main.sqlite_master " + "WHERE type = 'table' AND name!='sqlite_sequence' " + " AND coalesce(rootpage,1)>0" + ); + assert( (db->flags & SQLITE_Vacuum)!=0 ); + db->flags &= ~SQLITE_Vacuum; + if( rc!=SQLITE_OK ) goto end_of_vacuum; + + /* Copy over the sequence table + */ + rc = execExecSql(db, pzErrMsg, + "SELECT 'DELETE FROM vacuum_db.' || quote(name) || ';' " + "FROM vacuum_db.sqlite_master WHERE name='sqlite_sequence' " + ); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + rc = execExecSql(db, pzErrMsg, + "SELECT 'INSERT INTO vacuum_db.' || quote(name) " + "|| ' SELECT * FROM main.' || quote(name) || ';' " + "FROM vacuum_db.sqlite_master WHERE name=='sqlite_sequence';" + ); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + + + /* Copy the triggers, views, and virtual tables from the main database + ** over to the temporary database. None of these objects has any + ** associated storage, so all we have to do is copy their entries + ** from the SQLITE_MASTER table. + */ + rc = execSql(db, pzErrMsg, + "INSERT INTO vacuum_db.sqlite_master " + " SELECT type, name, tbl_name, rootpage, sql" + " FROM main.sqlite_master" + " WHERE type='view' OR type='trigger'" + " OR (type='table' AND rootpage=0)" + ); + if( rc ) goto end_of_vacuum; + + /* At this point, there is a write transaction open on both the + ** vacuum database and the main database. Assuming no error occurs, + ** both transactions are closed by this block - the main database + ** transaction by sqlite3BtreeCopyFile() and the other by an explicit + ** call to sqlite3BtreeCommit(). + */ + { + u32 meta; + int i; + + /* This array determines which meta meta values are preserved in the + ** vacuum. Even entries are the meta value number and odd entries + ** are an increment to apply to the meta value after the vacuum. + ** The increment is used to increase the schema cookie so that other + ** connections to the same database will know to reread the schema. + */ + static const unsigned char aCopy[] = { + BTREE_SCHEMA_VERSION, 1, /* Add one to the old schema cookie */ + BTREE_DEFAULT_CACHE_SIZE, 0, /* Preserve the default page cache size */ + BTREE_TEXT_ENCODING, 0, /* Preserve the text encoding */ + BTREE_USER_VERSION, 0, /* Preserve the user version */ + BTREE_APPLICATION_ID, 0, /* Preserve the application id */ + }; + + assert( 1==sqlite3BtreeIsInTrans(pTemp) ); + assert( 1==sqlite3BtreeIsInTrans(pMain) ); + + /* Copy Btree meta values */ + for(i=0; iflags */ + db->flags = saved_flags; + db->nChange = saved_nChange; + db->nTotalChange = saved_nTotalChange; + db->xTrace = saved_xTrace; + sqlite3BtreeSetPageSize(pMain, -1, -1, 1); + + /* Currently there is an SQL level transaction open on the vacuum + ** database. No locks are held on any other files (since the main file + ** was committed at the btree level). So it safe to end the transaction + ** by manually setting the autoCommit flag to true and detaching the + ** vacuum database. The vacuum_db journal file is deleted when the pager + ** is closed by the DETACH. + */ + db->autoCommit = 1; + + if( pDb ){ + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + pDb->pSchema = 0; + } + + /* This both clears the schemas and reduces the size of the db->aDb[] + ** array. */ + sqlite3ResetAllSchemasOfConnection(db); + + return rc; +} + +#endif /* SQLITE_OMIT_VACUUM && SQLITE_OMIT_ATTACH */ + +/************** End of vacuum.c **********************************************/ +/************** Begin file vtab.c ********************************************/ +/* +** 2006 June 10 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to help implement virtual tables. +*/ +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* #include "sqliteInt.h" */ + +/* +** Before a virtual table xCreate() or xConnect() method is invoked, the +** sqlite3.pVtabCtx member variable is set to point to an instance of +** this struct allocated on the stack. It is used by the implementation of +** the sqlite3_declare_vtab() and sqlite3_vtab_config() APIs, both of which +** are invoked only from within xCreate and xConnect methods. +*/ +struct VtabCtx { + VTable *pVTable; /* The virtual table being constructed */ + Table *pTab; /* The Table object to which the virtual table belongs */ + VtabCtx *pPrior; /* Parent context (if any) */ + int bDeclared; /* True after sqlite3_declare_vtab() is called */ +}; + +/* +** The actual function that does the work of creating a new module. +** This function implements the sqlite3_create_module() and +** sqlite3_create_module_v2() interfaces. +*/ +static int createModule( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux, /* Context pointer for xCreate/xConnect */ + void (*xDestroy)(void *) /* Module destructor function */ +){ + int rc = SQLITE_OK; + int nName; + + sqlite3_mutex_enter(db->mutex); + nName = sqlite3Strlen30(zName); + if( sqlite3HashFind(&db->aModule, zName) ){ + rc = SQLITE_MISUSE_BKPT; + }else{ + Module *pMod; + pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1); + if( pMod ){ + Module *pDel; + char *zCopy = (char *)(&pMod[1]); + memcpy(zCopy, zName, nName+1); + pMod->zName = zCopy; + pMod->pModule = pModule; + pMod->pAux = pAux; + pMod->xDestroy = xDestroy; + pMod->pEpoTab = 0; + pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod); + assert( pDel==0 || pDel==pMod ); + if( pDel ){ + db->mallocFailed = 1; + sqlite3DbFree(db, pDel); + } + } + } + rc = sqlite3ApiExit(db, rc); + if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux); + + sqlite3_mutex_leave(db->mutex); + return rc; +} + + +/* +** External API function used to create a new virtual-table module. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_create_module( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux /* Context pointer for xCreate/xConnect */ +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + return createModule(db, zName, pModule, pAux, 0); +} + +/* +** External API function used to create a new virtual-table module. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_create_module_v2( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux, /* Context pointer for xCreate/xConnect */ + void (*xDestroy)(void *) /* Module destructor function */ +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + return createModule(db, zName, pModule, pAux, xDestroy); +} + +/* +** Lock the virtual table so that it cannot be disconnected. +** Locks nest. Every lock should have a corresponding unlock. +** If an unlock is omitted, resources leaks will occur. +** +** If a disconnect is attempted while a virtual table is locked, +** the disconnect is deferred until all locks have been removed. +*/ +SQLITE_PRIVATE void sqlite3VtabLock(VTable *pVTab){ + pVTab->nRef++; +} + + +/* +** pTab is a pointer to a Table structure representing a virtual-table. +** Return a pointer to the VTable object used by connection db to access +** this virtual-table, if one has been created, or NULL otherwise. +*/ +SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){ + VTable *pVtab; + assert( IsVirtual(pTab) ); + for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext); + return pVtab; +} + +/* +** Decrement the ref-count on a virtual table object. When the ref-count +** reaches zero, call the xDisconnect() method to delete the object. +*/ +SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){ + sqlite3 *db = pVTab->db; + + assert( db ); + assert( pVTab->nRef>0 ); + assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE ); + + pVTab->nRef--; + if( pVTab->nRef==0 ){ + sqlite3_vtab *p = pVTab->pVtab; + if( p ){ + p->pModule->xDisconnect(p); + } + sqlite3DbFree(db, pVTab); + } +} + +/* +** Table p is a virtual table. This function moves all elements in the +** p->pVTable list to the sqlite3.pDisconnect lists of their associated +** database connections to be disconnected at the next opportunity. +** Except, if argument db is not NULL, then the entry associated with +** connection db is left in the p->pVTable list. +*/ +static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){ + VTable *pRet = 0; + VTable *pVTable = p->pVTable; + p->pVTable = 0; + + /* Assert that the mutex (if any) associated with the BtShared database + ** that contains table p is held by the caller. See header comments + ** above function sqlite3VtabUnlockList() for an explanation of why + ** this makes it safe to access the sqlite3.pDisconnect list of any + ** database connection that may have an entry in the p->pVTable list. + */ + assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) ); + + while( pVTable ){ + sqlite3 *db2 = pVTable->db; + VTable *pNext = pVTable->pNext; + assert( db2 ); + if( db2==db ){ + pRet = pVTable; + p->pVTable = pRet; + pRet->pNext = 0; + }else{ + pVTable->pNext = db2->pDisconnect; + db2->pDisconnect = pVTable; + } + pVTable = pNext; + } + + assert( !db || pRet ); + return pRet; +} + +/* +** Table *p is a virtual table. This function removes the VTable object +** for table *p associated with database connection db from the linked +** list in p->pVTab. It also decrements the VTable ref count. This is +** used when closing database connection db to free all of its VTable +** objects without disturbing the rest of the Schema object (which may +** be being used by other shared-cache connections). +*/ +SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p){ + VTable **ppVTab; + + assert( IsVirtual(p) ); + assert( sqlite3BtreeHoldsAllMutexes(db) ); + assert( sqlite3_mutex_held(db->mutex) ); + + for(ppVTab=&p->pVTable; *ppVTab; ppVTab=&(*ppVTab)->pNext){ + if( (*ppVTab)->db==db ){ + VTable *pVTab = *ppVTab; + *ppVTab = pVTab->pNext; + sqlite3VtabUnlock(pVTab); + break; + } + } +} + + +/* +** Disconnect all the virtual table objects in the sqlite3.pDisconnect list. +** +** This function may only be called when the mutexes associated with all +** shared b-tree databases opened using connection db are held by the +** caller. This is done to protect the sqlite3.pDisconnect list. The +** sqlite3.pDisconnect list is accessed only as follows: +** +** 1) By this function. In this case, all BtShared mutexes and the mutex +** associated with the database handle itself must be held. +** +** 2) By function vtabDisconnectAll(), when it adds a VTable entry to +** the sqlite3.pDisconnect list. In this case either the BtShared mutex +** associated with the database the virtual table is stored in is held +** or, if the virtual table is stored in a non-sharable database, then +** the database handle mutex is held. +** +** As a result, a sqlite3.pDisconnect cannot be accessed simultaneously +** by multiple threads. It is thread-safe. +*/ +SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){ + VTable *p = db->pDisconnect; + db->pDisconnect = 0; + + assert( sqlite3BtreeHoldsAllMutexes(db) ); + assert( sqlite3_mutex_held(db->mutex) ); + + if( p ){ + sqlite3ExpirePreparedStatements(db); + do { + VTable *pNext = p->pNext; + sqlite3VtabUnlock(p); + p = pNext; + }while( p ); + } +} + +/* +** Clear any and all virtual-table information from the Table record. +** This routine is called, for example, just before deleting the Table +** record. +** +** Since it is a virtual-table, the Table structure contains a pointer +** to the head of a linked list of VTable structures. Each VTable +** structure is associated with a single sqlite3* user of the schema. +** The reference count of the VTable structure associated with database +** connection db is decremented immediately (which may lead to the +** structure being xDisconnected and free). Any other VTable structures +** in the list are moved to the sqlite3.pDisconnect list of the associated +** database connection. +*/ +SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table *p){ + if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p); + if( p->azModuleArg ){ + int i; + for(i=0; inModuleArg; i++){ + if( i!=1 ) sqlite3DbFree(db, p->azModuleArg[i]); + } + sqlite3DbFree(db, p->azModuleArg); + } +} + +/* +** Add a new module argument to pTable->azModuleArg[]. +** The string is not copied - the pointer is stored. The +** string will be freed automatically when the table is +** deleted. +*/ +static void addModuleArgument(sqlite3 *db, Table *pTable, char *zArg){ + int nBytes = sizeof(char *)*(2+pTable->nModuleArg); + char **azModuleArg; + azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes); + if( azModuleArg==0 ){ + sqlite3DbFree(db, zArg); + }else{ + int i = pTable->nModuleArg++; + azModuleArg[i] = zArg; + azModuleArg[i+1] = 0; + pTable->azModuleArg = azModuleArg; + } +} + +/* +** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE +** statement. The module name has been parsed, but the optional list +** of parameters that follow the module name are still pending. +*/ +SQLITE_PRIVATE void sqlite3VtabBeginParse( + Parse *pParse, /* Parsing context */ + Token *pName1, /* Name of new table, or database name */ + Token *pName2, /* Name of new table or NULL */ + Token *pModuleName, /* Name of the module for the virtual table */ + int ifNotExists /* No error if the table already exists */ +){ + int iDb; /* The database the table is being created in */ + Table *pTable; /* The new virtual table */ + sqlite3 *db; /* Database connection */ + + sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists); + pTable = pParse->pNewTable; + if( pTable==0 ) return; + assert( 0==pTable->pIndex ); + + db = pParse->db; + iDb = sqlite3SchemaToIndex(db, pTable->pSchema); + assert( iDb>=0 ); + + pTable->tabFlags |= TF_Virtual; + pTable->nModuleArg = 0; + addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName)); + addModuleArgument(db, pTable, 0); + addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName)); + assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0) + || (pParse->sNameToken.z==pName1->z && pName2->z==0) + ); + pParse->sNameToken.n = (int)( + &pModuleName->z[pModuleName->n] - pParse->sNameToken.z + ); + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Creating a virtual table invokes the authorization callback twice. + ** The first invocation, to obtain permission to INSERT a row into the + ** sqlite_master table, has already been made by sqlite3StartTable(). + ** The second call, to obtain permission to create the table, is made now. + */ + if( pTable->azModuleArg ){ + sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName, + pTable->azModuleArg[0], pParse->db->aDb[iDb].zName); + } +#endif +} + +/* +** This routine takes the module argument that has been accumulating +** in pParse->zArg[] and appends it to the list of arguments on the +** virtual table currently under construction in pParse->pTable. +*/ +static void addArgumentToVtab(Parse *pParse){ + if( pParse->sArg.z && pParse->pNewTable ){ + const char *z = (const char*)pParse->sArg.z; + int n = pParse->sArg.n; + sqlite3 *db = pParse->db; + addModuleArgument(db, pParse->pNewTable, sqlite3DbStrNDup(db, z, n)); + } +} + +/* +** The parser calls this routine after the CREATE VIRTUAL TABLE statement +** has been completely parsed. +*/ +SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){ + Table *pTab = pParse->pNewTable; /* The table being constructed */ + sqlite3 *db = pParse->db; /* The database connection */ + + if( pTab==0 ) return; + addArgumentToVtab(pParse); + pParse->sArg.z = 0; + if( pTab->nModuleArg<1 ) return; + + /* If the CREATE VIRTUAL TABLE statement is being entered for the + ** first time (in other words if the virtual table is actually being + ** created now instead of just being read out of sqlite_master) then + ** do additional initialization work and store the statement text + ** in the sqlite_master table. + */ + if( !db->init.busy ){ + char *zStmt; + char *zWhere; + int iDb; + int iReg; + Vdbe *v; + + /* Compute the complete text of the CREATE VIRTUAL TABLE statement */ + if( pEnd ){ + pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n; + } + zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken); + + /* A slot for the record has already been allocated in the + ** SQLITE_MASTER table. We just need to update that slot with all + ** the information we've collected. + ** + ** The VM register number pParse->regRowid holds the rowid of an + ** entry in the sqlite_master table tht was created for this vtab + ** by sqlite3StartTable(). + */ + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + sqlite3NestedParse(pParse, + "UPDATE %Q.%s " + "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q " + "WHERE rowid=#%d", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), + pTab->zName, + pTab->zName, + zStmt, + pParse->regRowid + ); + sqlite3DbFree(db, zStmt); + v = sqlite3GetVdbe(pParse); + sqlite3ChangeCookie(pParse, iDb); + + sqlite3VdbeAddOp2(v, OP_Expire, 0, 0); + zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName); + sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere); + + iReg = ++pParse->nMem; + sqlite3VdbeLoadString(v, iReg, pTab->zName); + sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg); + } + + /* If we are rereading the sqlite_master table create the in-memory + ** record of the table. The xConnect() method is not called until + ** the first time the virtual table is used in an SQL statement. This + ** allows a schema that contains virtual tables to be loaded before + ** the required virtual table implementations are registered. */ + else { + Table *pOld; + Schema *pSchema = pTab->pSchema; + const char *zName = pTab->zName; + assert( sqlite3SchemaMutexHeld(db, 0, pSchema) ); + pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab); + if( pOld ){ + db->mallocFailed = 1; + assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */ + return; + } + pParse->pNewTable = 0; + } +} + +/* +** The parser calls this routine when it sees the first token +** of an argument to the module name in a CREATE VIRTUAL TABLE statement. +*/ +SQLITE_PRIVATE void sqlite3VtabArgInit(Parse *pParse){ + addArgumentToVtab(pParse); + pParse->sArg.z = 0; + pParse->sArg.n = 0; +} + +/* +** The parser calls this routine for each token after the first token +** in an argument to the module name in a CREATE VIRTUAL TABLE statement. +*/ +SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse *pParse, Token *p){ + Token *pArg = &pParse->sArg; + if( pArg->z==0 ){ + pArg->z = p->z; + pArg->n = p->n; + }else{ + assert(pArg->z <= p->z); + pArg->n = (int)(&p->z[p->n] - pArg->z); + } +} + +/* +** Invoke a virtual table constructor (either xCreate or xConnect). The +** pointer to the function to invoke is passed as the fourth parameter +** to this procedure. +*/ +static int vtabCallConstructor( + sqlite3 *db, + Table *pTab, + Module *pMod, + int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**), + char **pzErr +){ + VtabCtx sCtx; + VTable *pVTable; + int rc; + const char *const*azArg = (const char *const*)pTab->azModuleArg; + int nArg = pTab->nModuleArg; + char *zErr = 0; + char *zModuleName; + int iDb; + VtabCtx *pCtx; + + /* Check that the virtual-table is not already being initialized */ + for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){ + if( pCtx->pTab==pTab ){ + *pzErr = sqlite3MPrintf(db, + "vtable constructor called recursively: %s", pTab->zName + ); + return SQLITE_LOCKED; + } + } + + zModuleName = sqlite3MPrintf(db, "%s", pTab->zName); + if( !zModuleName ){ + return SQLITE_NOMEM; + } + + pVTable = sqlite3DbMallocZero(db, sizeof(VTable)); + if( !pVTable ){ + sqlite3DbFree(db, zModuleName); + return SQLITE_NOMEM; + } + pVTable->db = db; + pVTable->pMod = pMod; + + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + pTab->azModuleArg[1] = db->aDb[iDb].zName; + + /* Invoke the virtual table constructor */ + assert( &db->pVtabCtx ); + assert( xConstruct ); + sCtx.pTab = pTab; + sCtx.pVTable = pVTable; + sCtx.pPrior = db->pVtabCtx; + sCtx.bDeclared = 0; + db->pVtabCtx = &sCtx; + rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr); + db->pVtabCtx = sCtx.pPrior; + if( rc==SQLITE_NOMEM ) db->mallocFailed = 1; + assert( sCtx.pTab==pTab ); + + if( SQLITE_OK!=rc ){ + if( zErr==0 ){ + *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName); + }else { + *pzErr = sqlite3MPrintf(db, "%s", zErr); + sqlite3_free(zErr); + } + sqlite3DbFree(db, pVTable); + }else if( ALWAYS(pVTable->pVtab) ){ + /* Justification of ALWAYS(): A correct vtab constructor must allocate + ** the sqlite3_vtab object if successful. */ + memset(pVTable->pVtab, 0, sizeof(pVTable->pVtab[0])); + pVTable->pVtab->pModule = pMod->pModule; + pVTable->nRef = 1; + if( sCtx.bDeclared==0 ){ + const char *zFormat = "vtable constructor did not declare schema: %s"; + *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName); + sqlite3VtabUnlock(pVTable); + rc = SQLITE_ERROR; + }else{ + int iCol; + u8 oooHidden = 0; + /* If everything went according to plan, link the new VTable structure + ** into the linked list headed by pTab->pVTable. Then loop through the + ** columns of the table to see if any of them contain the token "hidden". + ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from + ** the type string. */ + pVTable->pNext = pTab->pVTable; + pTab->pVTable = pVTable; + + for(iCol=0; iColnCol; iCol++){ + char *zType = pTab->aCol[iCol].zType; + int nType; + int i = 0; + if( !zType ){ + pTab->tabFlags |= oooHidden; + continue; + } + nType = sqlite3Strlen30(zType); + if( sqlite3StrNICmp("hidden", zType, 6)||(zType[6] && zType[6]!=' ') ){ + for(i=0; i0 ){ + assert(zType[i-1]==' '); + zType[i-1] = '\0'; + } + pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN; + oooHidden = TF_OOOHidden; + }else{ + pTab->tabFlags |= oooHidden; + } + } + } + } + + sqlite3DbFree(db, zModuleName); + return rc; +} + +/* +** This function is invoked by the parser to call the xConnect() method +** of the virtual table pTab. If an error occurs, an error code is returned +** and an error left in pParse. +** +** This call is a no-op if table pTab is not a virtual table. +*/ +SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){ + sqlite3 *db = pParse->db; + const char *zMod; + Module *pMod; + int rc; + + assert( pTab ); + if( (pTab->tabFlags & TF_Virtual)==0 || sqlite3GetVTable(db, pTab) ){ + return SQLITE_OK; + } + + /* Locate the required virtual table module */ + zMod = pTab->azModuleArg[0]; + pMod = (Module*)sqlite3HashFind(&db->aModule, zMod); + + if( !pMod ){ + const char *zModule = pTab->azModuleArg[0]; + sqlite3ErrorMsg(pParse, "no such module: %s", zModule); + rc = SQLITE_ERROR; + }else{ + char *zErr = 0; + rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr); + if( rc!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "%s", zErr); + } + sqlite3DbFree(db, zErr); + } + + return rc; +} +/* +** Grow the db->aVTrans[] array so that there is room for at least one +** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise. +*/ +static int growVTrans(sqlite3 *db){ + const int ARRAY_INCR = 5; + + /* Grow the sqlite3.aVTrans array if required */ + if( (db->nVTrans%ARRAY_INCR)==0 ){ + VTable **aVTrans; + int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR); + aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes); + if( !aVTrans ){ + return SQLITE_NOMEM; + } + memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR); + db->aVTrans = aVTrans; + } + + return SQLITE_OK; +} + +/* +** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should +** have already been reserved using growVTrans(). +*/ +static void addToVTrans(sqlite3 *db, VTable *pVTab){ + /* Add pVtab to the end of sqlite3.aVTrans */ + db->aVTrans[db->nVTrans++] = pVTab; + sqlite3VtabLock(pVTab); +} + +/* +** This function is invoked by the vdbe to call the xCreate method +** of the virtual table named zTab in database iDb. +** +** If an error occurs, *pzErr is set to point an an English language +** description of the error and an SQLITE_XXX error code is returned. +** In this case the caller must call sqlite3DbFree(db, ) on *pzErr. +*/ +SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){ + int rc = SQLITE_OK; + Table *pTab; + Module *pMod; + const char *zMod; + + pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName); + assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable ); + + /* Locate the required virtual table module */ + zMod = pTab->azModuleArg[0]; + pMod = (Module*)sqlite3HashFind(&db->aModule, zMod); + + /* If the module has been registered and includes a Create method, + ** invoke it now. If the module has not been registered, return an + ** error. Otherwise, do nothing. + */ + if( pMod==0 || pMod->pModule->xCreate==0 || pMod->pModule->xDestroy==0 ){ + *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod); + rc = SQLITE_ERROR; + }else{ + rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr); + } + + /* Justification of ALWAYS(): The xConstructor method is required to + ** create a valid sqlite3_vtab if it returns SQLITE_OK. */ + if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){ + rc = growVTrans(db); + if( rc==SQLITE_OK ){ + addToVTrans(db, sqlite3GetVTable(db, pTab)); + } + } + + return rc; +} + +/* +** This function is used to set the schema of a virtual table. It is only +** valid to call this function from within the xCreate() or xConnect() of a +** virtual table module. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){ + VtabCtx *pCtx; + Parse *pParse; + int rc = SQLITE_OK; + Table *pTab; + char *zErr = 0; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + pCtx = db->pVtabCtx; + if( !pCtx || pCtx->bDeclared ){ + sqlite3Error(db, SQLITE_MISUSE); + sqlite3_mutex_leave(db->mutex); + return SQLITE_MISUSE_BKPT; + } + pTab = pCtx->pTab; + assert( (pTab->tabFlags & TF_Virtual)!=0 ); + + pParse = sqlite3StackAllocZero(db, sizeof(*pParse)); + if( pParse==0 ){ + rc = SQLITE_NOMEM; + }else{ + pParse->declareVtab = 1; + pParse->db = db; + pParse->nQueryLoop = 1; + + if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr) + && pParse->pNewTable + && !db->mallocFailed + && !pParse->pNewTable->pSelect + && (pParse->pNewTable->tabFlags & TF_Virtual)==0 + ){ + if( !pTab->aCol ){ + pTab->aCol = pParse->pNewTable->aCol; + pTab->nCol = pParse->pNewTable->nCol; + pParse->pNewTable->nCol = 0; + pParse->pNewTable->aCol = 0; + } + pCtx->bDeclared = 1; + }else{ + sqlite3ErrorWithMsg(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr); + sqlite3DbFree(db, zErr); + rc = SQLITE_ERROR; + } + pParse->declareVtab = 0; + + if( pParse->pVdbe ){ + sqlite3VdbeFinalize(pParse->pVdbe); + } + sqlite3DeleteTable(db, pParse->pNewTable); + sqlite3ParserReset(pParse); + sqlite3StackFree(db, pParse); + } + + assert( (rc&0xff)==rc ); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** This function is invoked by the vdbe to call the xDestroy method +** of the virtual table named zTab in database iDb. This occurs +** when a DROP TABLE is mentioned. +** +** This call is a no-op if zTab is not a virtual table. +*/ +SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){ + int rc = SQLITE_OK; + Table *pTab; + + pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName); + if( ALWAYS(pTab!=0 && pTab->pVTable!=0) ){ + VTable *p; + int (*xDestroy)(sqlite3_vtab *); + for(p=pTab->pVTable; p; p=p->pNext){ + assert( p->pVtab ); + if( p->pVtab->nRef>0 ){ + return SQLITE_LOCKED; + } + } + p = vtabDisconnectAll(db, pTab); + xDestroy = p->pMod->pModule->xDestroy; + assert( xDestroy!=0 ); /* Checked before the virtual table is created */ + rc = xDestroy(p->pVtab); + /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */ + if( rc==SQLITE_OK ){ + assert( pTab->pVTable==p && p->pNext==0 ); + p->pVtab = 0; + pTab->pVTable = 0; + sqlite3VtabUnlock(p); + } + } + + return rc; +} + +/* +** This function invokes either the xRollback or xCommit method +** of each of the virtual tables in the sqlite3.aVTrans array. The method +** called is identified by the second argument, "offset", which is +** the offset of the method to call in the sqlite3_module structure. +** +** The array is cleared after invoking the callbacks. +*/ +static void callFinaliser(sqlite3 *db, int offset){ + int i; + if( db->aVTrans ){ + VTable **aVTrans = db->aVTrans; + db->aVTrans = 0; + for(i=0; inVTrans; i++){ + VTable *pVTab = aVTrans[i]; + sqlite3_vtab *p = pVTab->pVtab; + if( p ){ + int (*x)(sqlite3_vtab *); + x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset); + if( x ) x(p); + } + pVTab->iSavepoint = 0; + sqlite3VtabUnlock(pVTab); + } + sqlite3DbFree(db, aVTrans); + db->nVTrans = 0; + } +} + +/* +** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans +** array. Return the error code for the first error that occurs, or +** SQLITE_OK if all xSync operations are successful. +** +** If an error message is available, leave it in p->zErrMsg. +*/ +SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, Vdbe *p){ + int i; + int rc = SQLITE_OK; + VTable **aVTrans = db->aVTrans; + + db->aVTrans = 0; + for(i=0; rc==SQLITE_OK && inVTrans; i++){ + int (*x)(sqlite3_vtab *); + sqlite3_vtab *pVtab = aVTrans[i]->pVtab; + if( pVtab && (x = pVtab->pModule->xSync)!=0 ){ + rc = x(pVtab); + sqlite3VtabImportErrmsg(p, pVtab); + } + } + db->aVTrans = aVTrans; + return rc; +} + +/* +** Invoke the xRollback method of all virtual tables in the +** sqlite3.aVTrans array. Then clear the array itself. +*/ +SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db){ + callFinaliser(db, offsetof(sqlite3_module,xRollback)); + return SQLITE_OK; +} + +/* +** Invoke the xCommit method of all virtual tables in the +** sqlite3.aVTrans array. Then clear the array itself. +*/ +SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db){ + callFinaliser(db, offsetof(sqlite3_module,xCommit)); + return SQLITE_OK; +} + +/* +** If the virtual table pVtab supports the transaction interface +** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is +** not currently open, invoke the xBegin method now. +** +** If the xBegin call is successful, place the sqlite3_vtab pointer +** in the sqlite3.aVTrans array. +*/ +SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){ + int rc = SQLITE_OK; + const sqlite3_module *pModule; + + /* Special case: If db->aVTrans is NULL and db->nVTrans is greater + ** than zero, then this function is being called from within a + ** virtual module xSync() callback. It is illegal to write to + ** virtual module tables in this case, so return SQLITE_LOCKED. + */ + if( sqlite3VtabInSync(db) ){ + return SQLITE_LOCKED; + } + if( !pVTab ){ + return SQLITE_OK; + } + pModule = pVTab->pVtab->pModule; + + if( pModule->xBegin ){ + int i; + + /* If pVtab is already in the aVTrans array, return early */ + for(i=0; inVTrans; i++){ + if( db->aVTrans[i]==pVTab ){ + return SQLITE_OK; + } + } + + /* Invoke the xBegin method. If successful, add the vtab to the + ** sqlite3.aVTrans[] array. */ + rc = growVTrans(db); + if( rc==SQLITE_OK ){ + rc = pModule->xBegin(pVTab->pVtab); + if( rc==SQLITE_OK ){ + int iSvpt = db->nStatement + db->nSavepoint; + addToVTrans(db, pVTab); + if( iSvpt ) rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, iSvpt-1); + } + } + } + return rc; +} + +/* +** Invoke either the xSavepoint, xRollbackTo or xRelease method of all +** virtual tables that currently have an open transaction. Pass iSavepoint +** as the second argument to the virtual table method invoked. +** +** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is +** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is +** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with +** an open transaction is invoked. +** +** If any virtual table method returns an error code other than SQLITE_OK, +** processing is abandoned and the error returned to the caller of this +** function immediately. If all calls to virtual table methods are successful, +** SQLITE_OK is returned. +*/ +SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){ + int rc = SQLITE_OK; + + assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN ); + assert( iSavepoint>=-1 ); + if( db->aVTrans ){ + int i; + for(i=0; rc==SQLITE_OK && inVTrans; i++){ + VTable *pVTab = db->aVTrans[i]; + const sqlite3_module *pMod = pVTab->pMod->pModule; + if( pVTab->pVtab && pMod->iVersion>=2 ){ + int (*xMethod)(sqlite3_vtab *, int); + switch( op ){ + case SAVEPOINT_BEGIN: + xMethod = pMod->xSavepoint; + pVTab->iSavepoint = iSavepoint+1; + break; + case SAVEPOINT_ROLLBACK: + xMethod = pMod->xRollbackTo; + break; + default: + xMethod = pMod->xRelease; + break; + } + if( xMethod && pVTab->iSavepoint>iSavepoint ){ + rc = xMethod(pVTab->pVtab, iSavepoint); + } + } + } + } + return rc; +} + +/* +** The first parameter (pDef) is a function implementation. The +** second parameter (pExpr) is the first argument to this function. +** If pExpr is a column in a virtual table, then let the virtual +** table implementation have an opportunity to overload the function. +** +** This routine is used to allow virtual table implementations to +** overload MATCH, LIKE, GLOB, and REGEXP operators. +** +** Return either the pDef argument (indicating no change) or a +** new FuncDef structure that is marked as ephemeral using the +** SQLITE_FUNC_EPHEM flag. +*/ +SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction( + sqlite3 *db, /* Database connection for reporting malloc problems */ + FuncDef *pDef, /* Function to possibly overload */ + int nArg, /* Number of arguments to the function */ + Expr *pExpr /* First argument to the function */ +){ + Table *pTab; + sqlite3_vtab *pVtab; + sqlite3_module *pMod; + void (*xFunc)(sqlite3_context*,int,sqlite3_value**) = 0; + void *pArg = 0; + FuncDef *pNew; + int rc = 0; + char *zLowerName; + unsigned char *z; + + + /* Check to see the left operand is a column in a virtual table */ + if( NEVER(pExpr==0) ) return pDef; + if( pExpr->op!=TK_COLUMN ) return pDef; + pTab = pExpr->pTab; + if( NEVER(pTab==0) ) return pDef; + if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef; + pVtab = sqlite3GetVTable(db, pTab)->pVtab; + assert( pVtab!=0 ); + assert( pVtab->pModule!=0 ); + pMod = (sqlite3_module *)pVtab->pModule; + if( pMod->xFindFunction==0 ) return pDef; + + /* Call the xFindFunction method on the virtual table implementation + ** to see if the implementation wants to overload this function + */ + zLowerName = sqlite3DbStrDup(db, pDef->zName); + if( zLowerName ){ + for(z=(unsigned char*)zLowerName; *z; z++){ + *z = sqlite3UpperToLower[*z]; + } + rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xFunc, &pArg); + sqlite3DbFree(db, zLowerName); + } + if( rc==0 ){ + return pDef; + } + + /* Create a new ephemeral function definition for the overloaded + ** function */ + pNew = sqlite3DbMallocZero(db, sizeof(*pNew) + + sqlite3Strlen30(pDef->zName) + 1); + if( pNew==0 ){ + return pDef; + } + *pNew = *pDef; + pNew->zName = (char *)&pNew[1]; + memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1); + pNew->xFunc = xFunc; + pNew->pUserData = pArg; + pNew->funcFlags |= SQLITE_FUNC_EPHEM; + return pNew; +} + +/* +** Make sure virtual table pTab is contained in the pParse->apVirtualLock[] +** array so that an OP_VBegin will get generated for it. Add pTab to the +** array if it is missing. If pTab is already in the array, this routine +** is a no-op. +*/ +SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + int i, n; + Table **apVtabLock; + + assert( IsVirtual(pTab) ); + for(i=0; inVtabLock; i++){ + if( pTab==pToplevel->apVtabLock[i] ) return; + } + n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]); + apVtabLock = sqlite3_realloc64(pToplevel->apVtabLock, n); + if( apVtabLock ){ + pToplevel->apVtabLock = apVtabLock; + pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab; + }else{ + pToplevel->db->mallocFailed = 1; + } +} + +/* +** Check to see if virtual tale module pMod can be have an eponymous +** virtual table instance. If it can, create one if one does not already +** exist. Return non-zero if the eponymous virtual table instance exists +** when this routine returns, and return zero if it does not exist. +** +** An eponymous virtual table instance is one that is named after its +** module, and more importantly, does not require a CREATE VIRTUAL TABLE +** statement in order to come into existance. Eponymous virtual table +** instances always exist. They cannot be DROP-ed. +** +** Any virtual table module for which xConnect and xCreate are the same +** method can have an eponymous virtual table instance. +*/ +SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){ + const sqlite3_module *pModule = pMod->pModule; + Table *pTab; + char *zErr = 0; + int nName; + int rc; + sqlite3 *db = pParse->db; + if( pMod->pEpoTab ) return 1; + if( pModule->xCreate!=0 && pModule->xCreate!=pModule->xConnect ) return 0; + nName = sqlite3Strlen30(pMod->zName) + 1; + pTab = sqlite3DbMallocZero(db, sizeof(Table) + nName); + if( pTab==0 ) return 0; + pMod->pEpoTab = pTab; + pTab->zName = (char*)&pTab[1]; + memcpy(pTab->zName, pMod->zName, nName); + pTab->nRef = 1; + pTab->pSchema = db->aDb[0].pSchema; + pTab->tabFlags |= TF_Virtual; + pTab->nModuleArg = 0; + pTab->iPKey = -1; + addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName)); + addModuleArgument(db, pTab, 0); + addModuleArgument(db, pTab, sqlite3DbStrDup(db, pTab->zName)); + rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr); + if( rc ){ + sqlite3ErrorMsg(pParse, "%s", zErr); + sqlite3DbFree(db, zErr); + sqlite3VtabEponymousTableClear(db, pMod); + return 0; + } + return 1; +} + +/* +** Erase the eponymous virtual table instance associated with +** virtual table module pMod, if it exists. +*/ +SQLITE_PRIVATE void sqlite3VtabEponymousTableClear(sqlite3 *db, Module *pMod){ + Table *pTab = pMod->pEpoTab; + if( pTab!=0 ){ + sqlite3DeleteColumnNames(db, pTab); + sqlite3VtabClear(db, pTab); + sqlite3DbFree(db, pTab); + pMod->pEpoTab = 0; + } +} + +/* +** Return the ON CONFLICT resolution mode in effect for the virtual +** table update operation currently in progress. +** +** The results of this routine are undefined unless it is called from +** within an xUpdate method. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_vtab_on_conflict(sqlite3 *db){ + static const unsigned char aMap[] = { + SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE + }; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 ); + assert( OE_Ignore==4 && OE_Replace==5 ); + assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 ); + return (int)aMap[db->vtabOnConflict-1]; +} + +/* +** Call from within the xCreate() or xConnect() methods to provide +** the SQLite core with additional information about the behavior +** of the virtual table being implemented. +*/ +SQLITE_API int SQLITE_CDECL sqlite3_vtab_config(sqlite3 *db, int op, ...){ + va_list ap; + int rc = SQLITE_OK; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + va_start(ap, op); + switch( op ){ + case SQLITE_VTAB_CONSTRAINT_SUPPORT: { + VtabCtx *p = db->pVtabCtx; + if( !p ){ + rc = SQLITE_MISUSE_BKPT; + }else{ + assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 ); + p->pVTable->bConstraint = (u8)va_arg(ap, int); + } + break; + } + default: + rc = SQLITE_MISUSE_BKPT; + break; + } + va_end(ap); + + if( rc!=SQLITE_OK ) sqlite3Error(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/************** End of vtab.c ************************************************/ +/************** Begin file wherecode.c ***************************************/ +/* +** 2015-06-06 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This module contains C code that generates VDBE code used to process +** the WHERE clause of SQL statements. +** +** This file was split off from where.c on 2015-06-06 in order to reduce the +** size of where.c and make it easier to edit. This file contains the routines +** that actually generate the bulk of the WHERE loop code. The original where.c +** file retains the code that does query planning and analysis. +*/ +/* #include "sqliteInt.h" */ +/************** Include whereInt.h in the middle of wherecode.c **************/ +/************** Begin file whereInt.h ****************************************/ +/* +** 2013-11-12 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains structure and macro definitions for the query +** planner logic in "where.c". These definitions are broken out into +** a separate source file for easier editing. +*/ + +/* +** Trace output macros +*/ +#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) +/***/ int sqlite3WhereTrace; +#endif +#if defined(SQLITE_DEBUG) \ + && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE)) +# define WHERETRACE(K,X) if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X +# define WHERETRACE_ENABLED 1 +#else +# define WHERETRACE(K,X) +#endif + +/* Forward references +*/ +typedef struct WhereClause WhereClause; +typedef struct WhereMaskSet WhereMaskSet; +typedef struct WhereOrInfo WhereOrInfo; +typedef struct WhereAndInfo WhereAndInfo; +typedef struct WhereLevel WhereLevel; +typedef struct WhereLoop WhereLoop; +typedef struct WherePath WherePath; +typedef struct WhereTerm WhereTerm; +typedef struct WhereLoopBuilder WhereLoopBuilder; +typedef struct WhereScan WhereScan; +typedef struct WhereOrCost WhereOrCost; +typedef struct WhereOrSet WhereOrSet; + +/* +** This object contains information needed to implement a single nested +** loop in WHERE clause. +** +** Contrast this object with WhereLoop. This object describes the +** implementation of the loop. WhereLoop describes the algorithm. +** This object contains a pointer to the WhereLoop algorithm as one of +** its elements. +** +** The WhereInfo object contains a single instance of this object for +** each term in the FROM clause (which is to say, for each of the +** nested loops as implemented). The order of WhereLevel objects determines +** the loop nested order, with WhereInfo.a[0] being the outer loop and +** WhereInfo.a[WhereInfo.nLevel-1] being the inner loop. +*/ +struct WhereLevel { + int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */ + int iTabCur; /* The VDBE cursor used to access the table */ + int iIdxCur; /* The VDBE cursor used to access pIdx */ + int addrBrk; /* Jump here to break out of the loop */ + int addrNxt; /* Jump here to start the next IN combination */ + int addrSkip; /* Jump here for next iteration of skip-scan */ + int addrCont; /* Jump here to continue with the next loop cycle */ + int addrFirst; /* First instruction of interior of the loop */ + int addrBody; /* Beginning of the body of this loop */ + int iLikeRepCntr; /* LIKE range processing counter register */ + int addrLikeRep; /* LIKE range processing address */ + u8 iFrom; /* Which entry in the FROM clause */ + u8 op, p3, p5; /* Opcode, P3 & P5 of the opcode that ends the loop */ + int p1, p2; /* Operands of the opcode used to ends the loop */ + union { /* Information that depends on pWLoop->wsFlags */ + struct { + int nIn; /* Number of entries in aInLoop[] */ + struct InLoop { + int iCur; /* The VDBE cursor used by this IN operator */ + int addrInTop; /* Top of the IN loop */ + u8 eEndLoopOp; /* IN Loop terminator. OP_Next or OP_Prev */ + } *aInLoop; /* Information about each nested IN operator */ + } in; /* Used when pWLoop->wsFlags&WHERE_IN_ABLE */ + Index *pCovidx; /* Possible covering index for WHERE_MULTI_OR */ + } u; + struct WhereLoop *pWLoop; /* The selected WhereLoop object */ + Bitmask notReady; /* FROM entries not usable at this level */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + int addrVisit; /* Address at which row is visited */ +#endif +}; + +/* +** Each instance of this object represents an algorithm for evaluating one +** term of a join. Every term of the FROM clause will have at least +** one corresponding WhereLoop object (unless INDEXED BY constraints +** prevent a query solution - which is an error) and many terms of the +** FROM clause will have multiple WhereLoop objects, each describing a +** potential way of implementing that FROM-clause term, together with +** dependencies and cost estimates for using the chosen algorithm. +** +** Query planning consists of building up a collection of these WhereLoop +** objects, then computing a particular sequence of WhereLoop objects, with +** one WhereLoop object per FROM clause term, that satisfy all dependencies +** and that minimize the overall cost. +*/ +struct WhereLoop { + Bitmask prereq; /* Bitmask of other loops that must run first */ + Bitmask maskSelf; /* Bitmask identifying table iTab */ +#ifdef SQLITE_DEBUG + char cId; /* Symbolic ID of this loop for debugging use */ +#endif + u8 iTab; /* Position in FROM clause of table for this loop */ + u8 iSortIdx; /* Sorting index number. 0==None */ + LogEst rSetup; /* One-time setup cost (ex: create transient index) */ + LogEst rRun; /* Cost of running each loop */ + LogEst nOut; /* Estimated number of output rows */ + union { + struct { /* Information for internal btree tables */ + u16 nEq; /* Number of equality constraints */ + Index *pIndex; /* Index used, or NULL */ + } btree; + struct { /* Information for virtual tables */ + int idxNum; /* Index number */ + u8 needFree; /* True if sqlite3_free(idxStr) is needed */ + i8 isOrdered; /* True if satisfies ORDER BY */ + u16 omitMask; /* Terms that may be omitted */ + char *idxStr; /* Index identifier string */ + } vtab; + } u; + u32 wsFlags; /* WHERE_* flags describing the plan */ + u16 nLTerm; /* Number of entries in aLTerm[] */ + u16 nSkip; /* Number of NULL aLTerm[] entries */ + /**** whereLoopXfer() copies fields above ***********************/ +# define WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot) + u16 nLSlot; /* Number of slots allocated for aLTerm[] */ + WhereTerm **aLTerm; /* WhereTerms used */ + WhereLoop *pNextLoop; /* Next WhereLoop object in the WhereClause */ + WhereTerm *aLTermSpace[3]; /* Initial aLTerm[] space */ +}; + +/* This object holds the prerequisites and the cost of running a +** subquery on one operand of an OR operator in the WHERE clause. +** See WhereOrSet for additional information +*/ +struct WhereOrCost { + Bitmask prereq; /* Prerequisites */ + LogEst rRun; /* Cost of running this subquery */ + LogEst nOut; /* Number of outputs for this subquery */ +}; + +/* The WhereOrSet object holds a set of possible WhereOrCosts that +** correspond to the subquery(s) of OR-clause processing. Only the +** best N_OR_COST elements are retained. +*/ +#define N_OR_COST 3 +struct WhereOrSet { + u16 n; /* Number of valid a[] entries */ + WhereOrCost a[N_OR_COST]; /* Set of best costs */ +}; + +/* +** Each instance of this object holds a sequence of WhereLoop objects +** that implement some or all of a query plan. +** +** Think of each WhereLoop object as a node in a graph with arcs +** showing dependencies and costs for travelling between nodes. (That is +** not a completely accurate description because WhereLoop costs are a +** vector, not a scalar, and because dependencies are many-to-one, not +** one-to-one as are graph nodes. But it is a useful visualization aid.) +** Then a WherePath object is a path through the graph that visits some +** or all of the WhereLoop objects once. +** +** The "solver" works by creating the N best WherePath objects of length +** 1. Then using those as a basis to compute the N best WherePath objects +** of length 2. And so forth until the length of WherePaths equals the +** number of nodes in the FROM clause. The best (lowest cost) WherePath +** at the end is the chosen query plan. +*/ +struct WherePath { + Bitmask maskLoop; /* Bitmask of all WhereLoop objects in this path */ + Bitmask revLoop; /* aLoop[]s that should be reversed for ORDER BY */ + LogEst nRow; /* Estimated number of rows generated by this path */ + LogEst rCost; /* Total cost of this path */ + LogEst rUnsorted; /* Total cost of this path ignoring sorting costs */ + i8 isOrdered; /* No. of ORDER BY terms satisfied. -1 for unknown */ + WhereLoop **aLoop; /* Array of WhereLoop objects implementing this path */ +}; + +/* +** The query generator uses an array of instances of this structure to +** help it analyze the subexpressions of the WHERE clause. Each WHERE +** clause subexpression is separated from the others by AND operators, +** usually, or sometimes subexpressions separated by OR. +** +** All WhereTerms are collected into a single WhereClause structure. +** The following identity holds: +** +** WhereTerm.pWC->a[WhereTerm.idx] == WhereTerm +** +** When a term is of the form: +** +** X +** +** where X is a column name and is one of certain operators, +** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the +** cursor number and column number for X. WhereTerm.eOperator records +** the using a bitmask encoding defined by WO_xxx below. The +** use of a bitmask encoding for the operator allows us to search +** quickly for terms that match any of several different operators. +** +** A WhereTerm might also be two or more subterms connected by OR: +** +** (t1.X ) OR (t1.Y ) OR .... +** +** In this second case, wtFlag has the TERM_ORINFO bit set and eOperator==WO_OR +** and the WhereTerm.u.pOrInfo field points to auxiliary information that +** is collected about the OR clause. +** +** If a term in the WHERE clause does not match either of the two previous +** categories, then eOperator==0. The WhereTerm.pExpr field is still set +** to the original subexpression content and wtFlags is set up appropriately +** but no other fields in the WhereTerm object are meaningful. +** +** When eOperator!=0, prereqRight and prereqAll record sets of cursor numbers, +** but they do so indirectly. A single WhereMaskSet structure translates +** cursor number into bits and the translated bit is stored in the prereq +** fields. The translation is used in order to maximize the number of +** bits that will fit in a Bitmask. The VDBE cursor numbers might be +** spread out over the non-negative integers. For example, the cursor +** numbers might be 3, 8, 9, 10, 20, 23, 41, and 45. The WhereMaskSet +** translates these sparse cursor numbers into consecutive integers +** beginning with 0 in order to make the best possible use of the available +** bits in the Bitmask. So, in the example above, the cursor numbers +** would be mapped into integers 0 through 7. +** +** The number of terms in a join is limited by the number of bits +** in prereqRight and prereqAll. The default is 64 bits, hence SQLite +** is only able to process joins with 64 or fewer tables. +*/ +struct WhereTerm { + Expr *pExpr; /* Pointer to the subexpression that is this term */ + int iParent; /* Disable pWC->a[iParent] when this term disabled */ + int leftCursor; /* Cursor number of X in "X " */ + union { + int leftColumn; /* Column number of X in "X " */ + WhereOrInfo *pOrInfo; /* Extra information if (eOperator & WO_OR)!=0 */ + WhereAndInfo *pAndInfo; /* Extra information if (eOperator& WO_AND)!=0 */ + } u; + LogEst truthProb; /* Probability of truth for this expression */ + u16 eOperator; /* A WO_xx value describing */ + u16 wtFlags; /* TERM_xxx bit flags. See below */ + u8 nChild; /* Number of children that must disable us */ + WhereClause *pWC; /* The clause this term is part of */ + Bitmask prereqRight; /* Bitmask of tables used by pExpr->pRight */ + Bitmask prereqAll; /* Bitmask of tables referenced by pExpr */ +}; + +/* +** Allowed values of WhereTerm.wtFlags +*/ +#define TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, pExpr) */ +#define TERM_VIRTUAL 0x02 /* Added by the optimizer. Do not code */ +#define TERM_CODED 0x04 /* This term is already coded */ +#define TERM_COPIED 0x08 /* Has a child */ +#define TERM_ORINFO 0x10 /* Need to free the WhereTerm.u.pOrInfo object */ +#define TERM_ANDINFO 0x20 /* Need to free the WhereTerm.u.pAndInfo obj */ +#define TERM_OR_OK 0x40 /* Used during OR-clause processing */ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +# define TERM_VNULL 0x80 /* Manufactured x>NULL or x<=NULL term */ +#else +# define TERM_VNULL 0x00 /* Disabled if not using stat3 */ +#endif +#define TERM_LIKEOPT 0x100 /* Virtual terms from the LIKE optimization */ +#define TERM_LIKECOND 0x200 /* Conditionally this LIKE operator term */ +#define TERM_LIKE 0x400 /* The original LIKE operator */ +#define TERM_IS 0x800 /* Term.pExpr is an IS operator */ + +/* +** An instance of the WhereScan object is used as an iterator for locating +** terms in the WHERE clause that are useful to the query planner. +*/ +struct WhereScan { + WhereClause *pOrigWC; /* Original, innermost WhereClause */ + WhereClause *pWC; /* WhereClause currently being scanned */ + char *zCollName; /* Required collating sequence, if not NULL */ + Expr *pIdxExpr; /* Search for this index expression */ + char idxaff; /* Must match this affinity, if zCollName!=NULL */ + unsigned char nEquiv; /* Number of entries in aEquiv[] */ + unsigned char iEquiv; /* Next unused slot in aEquiv[] */ + u32 opMask; /* Acceptable operators */ + int k; /* Resume scanning at this->pWC->a[this->k] */ + int aiCur[11]; /* Cursors in the equivalence class */ + i16 aiColumn[11]; /* Corresponding column number in the eq-class */ +}; + +/* +** An instance of the following structure holds all information about a +** WHERE clause. Mostly this is a container for one or more WhereTerms. +** +** Explanation of pOuter: For a WHERE clause of the form +** +** a AND ((b AND c) OR (d AND e)) AND f +** +** There are separate WhereClause objects for the whole clause and for +** the subclauses "(b AND c)" and "(d AND e)". The pOuter field of the +** subclauses points to the WhereClause object for the whole clause. +*/ +struct WhereClause { + WhereInfo *pWInfo; /* WHERE clause processing context */ + WhereClause *pOuter; /* Outer conjunction */ + u8 op; /* Split operator. TK_AND or TK_OR */ + int nTerm; /* Number of terms */ + int nSlot; /* Number of entries in a[] */ + WhereTerm *a; /* Each a[] describes a term of the WHERE cluase */ +#if defined(SQLITE_SMALL_STACK) + WhereTerm aStatic[1]; /* Initial static space for a[] */ +#else + WhereTerm aStatic[8]; /* Initial static space for a[] */ +#endif +}; + +/* +** A WhereTerm with eOperator==WO_OR has its u.pOrInfo pointer set to +** a dynamically allocated instance of the following structure. +*/ +struct WhereOrInfo { + WhereClause wc; /* Decomposition into subterms */ + Bitmask indexable; /* Bitmask of all indexable tables in the clause */ +}; + +/* +** A WhereTerm with eOperator==WO_AND has its u.pAndInfo pointer set to +** a dynamically allocated instance of the following structure. +*/ +struct WhereAndInfo { + WhereClause wc; /* The subexpression broken out */ +}; + +/* +** An instance of the following structure keeps track of a mapping +** between VDBE cursor numbers and bits of the bitmasks in WhereTerm. +** +** The VDBE cursor numbers are small integers contained in +** SrcList_item.iCursor and Expr.iTable fields. For any given WHERE +** clause, the cursor numbers might not begin with 0 and they might +** contain gaps in the numbering sequence. But we want to make maximum +** use of the bits in our bitmasks. This structure provides a mapping +** from the sparse cursor numbers into consecutive integers beginning +** with 0. +** +** If WhereMaskSet.ix[A]==B it means that The A-th bit of a Bitmask +** corresponds VDBE cursor number B. The A-th bit of a bitmask is 1<3, 5->1, 8->2, 29->0, +** 57->5, 73->4. Or one of 719 other combinations might be used. It +** does not really matter. What is important is that sparse cursor +** numbers all get mapped into bit numbers that begin with 0 and contain +** no gaps. +*/ +struct WhereMaskSet { + int n; /* Number of assigned cursor values */ + int ix[BMS]; /* Cursor assigned to each bit */ +}; + +/* +** Initialize a WhereMaskSet object +*/ +#define initMaskSet(P) (P)->n=0 + +/* +** This object is a convenience wrapper holding all information needed +** to construct WhereLoop objects for a particular query. +*/ +struct WhereLoopBuilder { + WhereInfo *pWInfo; /* Information about this WHERE */ + WhereClause *pWC; /* WHERE clause terms */ + ExprList *pOrderBy; /* ORDER BY clause */ + WhereLoop *pNew; /* Template WhereLoop */ + WhereOrSet *pOrSet; /* Record best loops here, if not NULL */ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + UnpackedRecord *pRec; /* Probe for stat4 (if required) */ + int nRecValid; /* Number of valid fields currently in pRec */ +#endif +}; + +/* +** The WHERE clause processing routine has two halves. The +** first part does the start of the WHERE loop and the second +** half does the tail of the WHERE loop. An instance of +** this structure is returned by the first half and passed +** into the second half to give some continuity. +** +** An instance of this object holds the complete state of the query +** planner. +*/ +struct WhereInfo { + Parse *pParse; /* Parsing and code generating context */ + SrcList *pTabList; /* List of tables in the join */ + ExprList *pOrderBy; /* The ORDER BY clause or NULL */ + ExprList *pResultSet; /* Result set. DISTINCT operates on these */ + WhereLoop *pLoops; /* List of all WhereLoop objects */ + Bitmask revMask; /* Mask of ORDER BY terms that need reversing */ + LogEst nRowOut; /* Estimated number of output rows */ + u16 wctrlFlags; /* Flags originally passed to sqlite3WhereBegin() */ + i8 nOBSat; /* Number of ORDER BY terms satisfied by indices */ + u8 sorted; /* True if really sorted (not just grouped) */ + u8 eOnePass; /* ONEPASS_OFF, or _SINGLE, or _MULTI */ + u8 untestedTerms; /* Not all WHERE terms resolved by outer loop */ + u8 eDistinct; /* One of the WHERE_DISTINCT_* values below */ + u8 nLevel; /* Number of nested loop */ + int iTop; /* The very beginning of the WHERE loop */ + int iContinue; /* Jump here to continue with next record */ + int iBreak; /* Jump here to break out of the loop */ + int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */ + int aiCurOnePass[2]; /* OP_OpenWrite cursors for the ONEPASS opt */ + WhereMaskSet sMaskSet; /* Map cursor numbers to bitmasks */ + WhereClause sWC; /* Decomposition of the WHERE clause */ + WhereLevel a[1]; /* Information about each nest loop in WHERE */ +}; + +/* +** Private interfaces - callable only by other where.c routines. +** +** where.c: +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereGetMask(WhereMaskSet*,int); +SQLITE_PRIVATE WhereTerm *sqlite3WhereFindTerm( + WhereClause *pWC, /* The WHERE clause to be searched */ + int iCur, /* Cursor number of LHS */ + int iColumn, /* Column number of LHS */ + Bitmask notReady, /* RHS must not overlap with this mask */ + u32 op, /* Mask of WO_xx values describing operator */ + Index *pIdx /* Must be compatible with this index, if not NULL */ +); + +/* wherecode.c: */ +#ifndef SQLITE_OMIT_EXPLAIN +SQLITE_PRIVATE int sqlite3WhereExplainOneScan( + Parse *pParse, /* Parse context */ + SrcList *pTabList, /* Table list this loop refers to */ + WhereLevel *pLevel, /* Scan to write OP_Explain opcode for */ + int iLevel, /* Value for "level" column of output */ + int iFrom, /* Value for "from" column of output */ + u16 wctrlFlags /* Flags passed to sqlite3WhereBegin() */ +); +#else +# define sqlite3WhereExplainOneScan(u,v,w,x,y,z) 0 +#endif /* SQLITE_OMIT_EXPLAIN */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +SQLITE_PRIVATE void sqlite3WhereAddScanStatus( + Vdbe *v, /* Vdbe to add scanstatus entry to */ + SrcList *pSrclist, /* FROM clause pLvl reads data from */ + WhereLevel *pLvl, /* Level to add scanstatus() entry for */ + int addrExplain /* Address of OP_Explain (or 0) */ +); +#else +# define sqlite3WhereAddScanStatus(a, b, c, d) ((void)d) +#endif +SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( + WhereInfo *pWInfo, /* Complete information about the WHERE clause */ + int iLevel, /* Which level of pWInfo->a[] should be coded */ + Bitmask notReady /* Which tables are currently available */ +); + +/* whereexpr.c: */ +SQLITE_PRIVATE void sqlite3WhereClauseInit(WhereClause*,WhereInfo*); +SQLITE_PRIVATE void sqlite3WhereClauseClear(WhereClause*); +SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause*,Expr*,u8); +SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet*, Expr*); +SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet*, ExprList*); +SQLITE_PRIVATE void sqlite3WhereExprAnalyze(SrcList*, WhereClause*); +SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, struct SrcList_item*, WhereClause*); + + + + + +/* +** Bitmasks for the operators on WhereTerm objects. These are all +** operators that are of interest to the query planner. An +** OR-ed combination of these values can be used when searching for +** particular WhereTerms within a WhereClause. +*/ +#define WO_IN 0x0001 +#define WO_EQ 0x0002 +#define WO_LT (WO_EQ<<(TK_LT-TK_EQ)) +#define WO_LE (WO_EQ<<(TK_LE-TK_EQ)) +#define WO_GT (WO_EQ<<(TK_GT-TK_EQ)) +#define WO_GE (WO_EQ<<(TK_GE-TK_EQ)) +#define WO_MATCH 0x0040 +#define WO_IS 0x0080 +#define WO_ISNULL 0x0100 +#define WO_OR 0x0200 /* Two or more OR-connected terms */ +#define WO_AND 0x0400 /* Two or more AND-connected terms */ +#define WO_EQUIV 0x0800 /* Of the form A==B, both columns */ +#define WO_NOOP 0x1000 /* This term does not restrict search space */ + +#define WO_ALL 0x1fff /* Mask of all possible WO_* values */ +#define WO_SINGLE 0x01ff /* Mask of all non-compound WO_* values */ + +/* +** These are definitions of bits in the WhereLoop.wsFlags field. +** The particular combination of bits in each WhereLoop help to +** determine the algorithm that WhereLoop represents. +*/ +#define WHERE_COLUMN_EQ 0x00000001 /* x=EXPR */ +#define WHERE_COLUMN_RANGE 0x00000002 /* xEXPR */ +#define WHERE_COLUMN_IN 0x00000004 /* x IN (...) */ +#define WHERE_COLUMN_NULL 0x00000008 /* x IS NULL */ +#define WHERE_CONSTRAINT 0x0000000f /* Any of the WHERE_COLUMN_xxx values */ +#define WHERE_TOP_LIMIT 0x00000010 /* xEXPR or x>=EXPR constraint */ +#define WHERE_BOTH_LIMIT 0x00000030 /* Both x>EXPR and xaiColumn[i]; + if( i==XN_EXPR ) return ""; + if( i==XN_ROWID ) return "rowid"; + return pIdx->pTable->aCol[i].zName; +} + +/* +** Argument pLevel describes a strategy for scanning table pTab. This +** function appends text to pStr that describes the subset of table +** rows scanned by the strategy in the form of an SQL expression. +** +** For example, if the query: +** +** SELECT * FROM t1 WHERE a=1 AND b>2; +** +** is run and there is an index on (a, b), then this function returns a +** string similar to: +** +** "a=? AND b>?" +*/ +static void explainIndexRange(StrAccum *pStr, WhereLoop *pLoop){ + Index *pIndex = pLoop->u.btree.pIndex; + u16 nEq = pLoop->u.btree.nEq; + u16 nSkip = pLoop->nSkip; + int i, j; + + if( nEq==0 && (pLoop->wsFlags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ) return; + sqlite3StrAccumAppend(pStr, " (", 2); + for(i=0; i=nSkip ? "%s=?" : "ANY(%s)", z); + } + + j = i; + if( pLoop->wsFlags&WHERE_BTM_LIMIT ){ + const char *z = explainIndexColumnName(pIndex, i); + explainAppendTerm(pStr, i++, z, ">"); + } + if( pLoop->wsFlags&WHERE_TOP_LIMIT ){ + const char *z = explainIndexColumnName(pIndex, j); + explainAppendTerm(pStr, i, z, "<"); + } + sqlite3StrAccumAppend(pStr, ")", 1); +} + +/* +** This function is a no-op unless currently processing an EXPLAIN QUERY PLAN +** command, or if either SQLITE_DEBUG or SQLITE_ENABLE_STMT_SCANSTATUS was +** defined at compile-time. If it is not a no-op, a single OP_Explain opcode +** is added to the output to describe the table scan strategy in pLevel. +** +** If an OP_Explain opcode is added to the VM, its address is returned. +** Otherwise, if no OP_Explain is coded, zero is returned. +*/ +SQLITE_PRIVATE int sqlite3WhereExplainOneScan( + Parse *pParse, /* Parse context */ + SrcList *pTabList, /* Table list this loop refers to */ + WhereLevel *pLevel, /* Scan to write OP_Explain opcode for */ + int iLevel, /* Value for "level" column of output */ + int iFrom, /* Value for "from" column of output */ + u16 wctrlFlags /* Flags passed to sqlite3WhereBegin() */ +){ + int ret = 0; +#if !defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_STMT_SCANSTATUS) + if( pParse->explain==2 ) +#endif + { + struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom]; + Vdbe *v = pParse->pVdbe; /* VM being constructed */ + sqlite3 *db = pParse->db; /* Database handle */ + int iId = pParse->iSelectId; /* Select id (left-most output column) */ + int isSearch; /* True for a SEARCH. False for SCAN. */ + WhereLoop *pLoop; /* The controlling WhereLoop object */ + u32 flags; /* Flags that describe this loop */ + char *zMsg; /* Text to add to EQP output */ + StrAccum str; /* EQP output string */ + char zBuf[100]; /* Initial space for EQP output string */ + + pLoop = pLevel->pWLoop; + flags = pLoop->wsFlags; + if( (flags&WHERE_MULTI_OR) || (wctrlFlags&WHERE_ONETABLE_ONLY) ) return 0; + + isSearch = (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 + || ((flags&WHERE_VIRTUALTABLE)==0 && (pLoop->u.btree.nEq>0)) + || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX)); + + sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH); + sqlite3StrAccumAppendAll(&str, isSearch ? "SEARCH" : "SCAN"); + if( pItem->pSelect ){ + sqlite3XPrintf(&str, 0, " SUBQUERY %d", pItem->iSelectId); + }else{ + sqlite3XPrintf(&str, 0, " TABLE %s", pItem->zName); + } + + if( pItem->zAlias ){ + sqlite3XPrintf(&str, 0, " AS %s", pItem->zAlias); + } + if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 ){ + const char *zFmt = 0; + Index *pIdx; + + assert( pLoop->u.btree.pIndex!=0 ); + pIdx = pLoop->u.btree.pIndex; + assert( !(flags&WHERE_AUTO_INDEX) || (flags&WHERE_IDX_ONLY) ); + if( !HasRowid(pItem->pTab) && IsPrimaryKeyIndex(pIdx) ){ + if( isSearch ){ + zFmt = "PRIMARY KEY"; + } + }else if( flags & WHERE_PARTIALIDX ){ + zFmt = "AUTOMATIC PARTIAL COVERING INDEX"; + }else if( flags & WHERE_AUTO_INDEX ){ + zFmt = "AUTOMATIC COVERING INDEX"; + }else if( flags & WHERE_IDX_ONLY ){ + zFmt = "COVERING INDEX %s"; + }else{ + zFmt = "INDEX %s"; + } + if( zFmt ){ + sqlite3StrAccumAppend(&str, " USING ", 7); + sqlite3XPrintf(&str, 0, zFmt, pIdx->zName); + explainIndexRange(&str, pLoop); + } + }else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){ + const char *zRangeOp; + if( flags&(WHERE_COLUMN_EQ|WHERE_COLUMN_IN) ){ + zRangeOp = "="; + }else if( (flags&WHERE_BOTH_LIMIT)==WHERE_BOTH_LIMIT ){ + zRangeOp = ">? AND rowid<"; + }else if( flags&WHERE_BTM_LIMIT ){ + zRangeOp = ">"; + }else{ + assert( flags&WHERE_TOP_LIMIT); + zRangeOp = "<"; + } + sqlite3XPrintf(&str, 0, " USING INTEGER PRIMARY KEY (rowid%s?)",zRangeOp); + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + else if( (flags & WHERE_VIRTUALTABLE)!=0 ){ + sqlite3XPrintf(&str, 0, " VIRTUAL TABLE INDEX %d:%s", + pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr); + } +#endif +#ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS + if( pLoop->nOut>=10 ){ + sqlite3XPrintf(&str, 0, " (~%llu rows)", sqlite3LogEstToInt(pLoop->nOut)); + }else{ + sqlite3StrAccumAppend(&str, " (~1 row)", 9); + } +#endif + zMsg = sqlite3StrAccumFinish(&str); + ret = sqlite3VdbeAddOp4(v, OP_Explain, iId, iLevel, iFrom, zMsg,P4_DYNAMIC); + } + return ret; +} +#endif /* SQLITE_OMIT_EXPLAIN */ + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +/* +** Configure the VM passed as the first argument with an +** sqlite3_stmt_scanstatus() entry corresponding to the scan used to +** implement level pLvl. Argument pSrclist is a pointer to the FROM +** clause that the scan reads data from. +** +** If argument addrExplain is not 0, it must be the address of an +** OP_Explain instruction that describes the same loop. +*/ +SQLITE_PRIVATE void sqlite3WhereAddScanStatus( + Vdbe *v, /* Vdbe to add scanstatus entry to */ + SrcList *pSrclist, /* FROM clause pLvl reads data from */ + WhereLevel *pLvl, /* Level to add scanstatus() entry for */ + int addrExplain /* Address of OP_Explain (or 0) */ +){ + const char *zObj = 0; + WhereLoop *pLoop = pLvl->pWLoop; + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 && pLoop->u.btree.pIndex!=0 ){ + zObj = pLoop->u.btree.pIndex->zName; + }else{ + zObj = pSrclist->a[pLvl->iFrom].zName; + } + sqlite3VdbeScanStatus( + v, addrExplain, pLvl->addrBody, pLvl->addrVisit, pLoop->nOut, zObj + ); +} +#endif + + +/* +** Disable a term in the WHERE clause. Except, do not disable the term +** if it controls a LEFT OUTER JOIN and it did not originate in the ON +** or USING clause of that join. +** +** Consider the term t2.z='ok' in the following queries: +** +** (1) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x WHERE t2.z='ok' +** (2) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x AND t2.z='ok' +** (3) SELECT * FROM t1, t2 WHERE t1.a=t2.x AND t2.z='ok' +** +** The t2.z='ok' is disabled in the in (2) because it originates +** in the ON clause. The term is disabled in (3) because it is not part +** of a LEFT OUTER JOIN. In (1), the term is not disabled. +** +** Disabling a term causes that term to not be tested in the inner loop +** of the join. Disabling is an optimization. When terms are satisfied +** by indices, we disable them to prevent redundant tests in the inner +** loop. We would get the correct results if nothing were ever disabled, +** but joins might run a little slower. The trick is to disable as much +** as we can without disabling too much. If we disabled in (1), we'd get +** the wrong answer. See ticket #813. +** +** If all the children of a term are disabled, then that term is also +** automatically disabled. In this way, terms get disabled if derived +** virtual terms are tested first. For example: +** +** x GLOB 'abc*' AND x>='abc' AND x<'acd' +** \___________/ \______/ \_____/ +** parent child1 child2 +** +** Only the parent term was in the original WHERE clause. The child1 +** and child2 terms were added by the LIKE optimization. If both of +** the virtual child terms are valid, then testing of the parent can be +** skipped. +** +** Usually the parent term is marked as TERM_CODED. But if the parent +** term was originally TERM_LIKE, then the parent gets TERM_LIKECOND instead. +** The TERM_LIKECOND marking indicates that the term should be coded inside +** a conditional such that is only evaluated on the second pass of a +** LIKE-optimization loop, when scanning BLOBs instead of strings. +*/ +static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){ + int nLoop = 0; + while( pTerm + && (pTerm->wtFlags & TERM_CODED)==0 + && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin)) + && (pLevel->notReady & pTerm->prereqAll)==0 + ){ + if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){ + pTerm->wtFlags |= TERM_LIKECOND; + }else{ + pTerm->wtFlags |= TERM_CODED; + } + if( pTerm->iParent<0 ) break; + pTerm = &pTerm->pWC->a[pTerm->iParent]; + pTerm->nChild--; + if( pTerm->nChild!=0 ) break; + nLoop++; + } +} + +/* +** Code an OP_Affinity opcode to apply the column affinity string zAff +** to the n registers starting at base. +** +** As an optimization, SQLITE_AFF_BLOB entries (which are no-ops) at the +** beginning and end of zAff are ignored. If all entries in zAff are +** SQLITE_AFF_BLOB, then no code gets generated. +** +** This routine makes its own copy of zAff so that the caller is free +** to modify zAff after this routine returns. +*/ +static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){ + Vdbe *v = pParse->pVdbe; + if( zAff==0 ){ + assert( pParse->db->mallocFailed ); + return; + } + assert( v!=0 ); + + /* Adjust base and n to skip over SQLITE_AFF_BLOB entries at the beginning + ** and end of the affinity string. + */ + while( n>0 && zAff[0]==SQLITE_AFF_BLOB ){ + n--; + base++; + zAff++; + } + while( n>1 && zAff[n-1]==SQLITE_AFF_BLOB ){ + n--; + } + + /* Code the OP_Affinity opcode if there is anything left to do. */ + if( n>0 ){ + sqlite3VdbeAddOp2(v, OP_Affinity, base, n); + sqlite3VdbeChangeP4(v, -1, zAff, n); + sqlite3ExprCacheAffinityChange(pParse, base, n); + } +} + + +/* +** Generate code for a single equality term of the WHERE clause. An equality +** term can be either X=expr or X IN (...). pTerm is the term to be +** coded. +** +** The current value for the constraint is left in register iReg. +** +** For a constraint of the form X=expr, the expression is evaluated and its +** result is left on the stack. For constraints of the form X IN (...) +** this routine sets up a loop that will iterate over all values of X. +*/ +static int codeEqualityTerm( + Parse *pParse, /* The parsing context */ + WhereTerm *pTerm, /* The term of the WHERE clause to be coded */ + WhereLevel *pLevel, /* The level of the FROM clause we are working on */ + int iEq, /* Index of the equality term within this level */ + int bRev, /* True for reverse-order IN operations */ + int iTarget /* Attempt to leave results in this register */ +){ + Expr *pX = pTerm->pExpr; + Vdbe *v = pParse->pVdbe; + int iReg; /* Register holding results */ + + assert( iTarget>0 ); + if( pX->op==TK_EQ || pX->op==TK_IS ){ + iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget); + }else if( pX->op==TK_ISNULL ){ + iReg = iTarget; + sqlite3VdbeAddOp2(v, OP_Null, 0, iReg); +#ifndef SQLITE_OMIT_SUBQUERY + }else{ + int eType; + int iTab; + struct InLoop *pIn; + WhereLoop *pLoop = pLevel->pWLoop; + + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 + && pLoop->u.btree.pIndex!=0 + && pLoop->u.btree.pIndex->aSortOrder[iEq] + ){ + testcase( iEq==0 ); + testcase( bRev ); + bRev = !bRev; + } + assert( pX->op==TK_IN ); + iReg = iTarget; + eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0); + if( eType==IN_INDEX_INDEX_DESC ){ + testcase( bRev ); + bRev = !bRev; + } + iTab = pX->iTable; + sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0); + VdbeCoverageIf(v, bRev); + VdbeCoverageIf(v, !bRev); + assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 ); + pLoop->wsFlags |= WHERE_IN_ABLE; + if( pLevel->u.in.nIn==0 ){ + pLevel->addrNxt = sqlite3VdbeMakeLabel(v); + } + pLevel->u.in.nIn++; + pLevel->u.in.aInLoop = + sqlite3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop, + sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn); + pIn = pLevel->u.in.aInLoop; + if( pIn ){ + pIn += pLevel->u.in.nIn - 1; + pIn->iCur = iTab; + if( eType==IN_INDEX_ROWID ){ + pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iReg); + }else{ + pIn->addrInTop = sqlite3VdbeAddOp3(v, OP_Column, iTab, 0, iReg); + } + pIn->eEndLoopOp = bRev ? OP_PrevIfOpen : OP_NextIfOpen; + sqlite3VdbeAddOp1(v, OP_IsNull, iReg); VdbeCoverage(v); + }else{ + pLevel->u.in.nIn = 0; + } +#endif + } + disableTerm(pLevel, pTerm); + return iReg; +} + +/* +** Generate code that will evaluate all == and IN constraints for an +** index scan. +** +** For example, consider table t1(a,b,c,d,e,f) with index i1(a,b,c). +** Suppose the WHERE clause is this: a==5 AND b IN (1,2,3) AND c>5 AND c<10 +** The index has as many as three equality constraints, but in this +** example, the third "c" value is an inequality. So only two +** constraints are coded. This routine will generate code to evaluate +** a==5 and b IN (1,2,3). The current values for a and b will be stored +** in consecutive registers and the index of the first register is returned. +** +** In the example above nEq==2. But this subroutine works for any value +** of nEq including 0. If nEq==0, this routine is nearly a no-op. +** The only thing it does is allocate the pLevel->iMem memory cell and +** compute the affinity string. +** +** The nExtraReg parameter is 0 or 1. It is 0 if all WHERE clause constraints +** are == or IN and are covered by the nEq. nExtraReg is 1 if there is +** an inequality constraint (such as the "c>=5 AND c<10" in the example) that +** occurs after the nEq quality constraints. +** +** This routine allocates a range of nEq+nExtraReg memory cells and returns +** the index of the first memory cell in that range. The code that +** calls this routine will use that memory range to store keys for +** start and termination conditions of the loop. +** key value of the loop. If one or more IN operators appear, then +** this routine allocates an additional nEq memory cells for internal +** use. +** +** Before returning, *pzAff is set to point to a buffer containing a +** copy of the column affinity string of the index allocated using +** sqlite3DbMalloc(). Except, entries in the copy of the string associated +** with equality constraints that use BLOB or NONE affinity are set to +** SQLITE_AFF_BLOB. This is to deal with SQL such as the following: +** +** CREATE TABLE t1(a TEXT PRIMARY KEY, b); +** SELECT ... FROM t1 AS t2, t1 WHERE t1.a = t2.b; +** +** In the example above, the index on t1(a) has TEXT affinity. But since +** the right hand side of the equality constraint (t2.b) has BLOB/NONE affinity, +** no conversion should be attempted before using a t2.b value as part of +** a key to search the index. Hence the first byte in the returned affinity +** string in this example would be set to SQLITE_AFF_BLOB. +*/ +static int codeAllEqualityTerms( + Parse *pParse, /* Parsing context */ + WhereLevel *pLevel, /* Which nested loop of the FROM we are coding */ + int bRev, /* Reverse the order of IN operators */ + int nExtraReg, /* Number of extra registers to allocate */ + char **pzAff /* OUT: Set to point to affinity string */ +){ + u16 nEq; /* The number of == or IN constraints to code */ + u16 nSkip; /* Number of left-most columns to skip */ + Vdbe *v = pParse->pVdbe; /* The vm under construction */ + Index *pIdx; /* The index being used for this loop */ + WhereTerm *pTerm; /* A single constraint term */ + WhereLoop *pLoop; /* The WhereLoop object */ + int j; /* Loop counter */ + int regBase; /* Base register */ + int nReg; /* Number of registers to allocate */ + char *zAff; /* Affinity string to return */ + + /* This module is only called on query plans that use an index. */ + pLoop = pLevel->pWLoop; + assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 ); + nEq = pLoop->u.btree.nEq; + nSkip = pLoop->nSkip; + pIdx = pLoop->u.btree.pIndex; + assert( pIdx!=0 ); + + /* Figure out how many memory cells we will need then allocate them. + */ + regBase = pParse->nMem + 1; + nReg = pLoop->u.btree.nEq + nExtraReg; + pParse->nMem += nReg; + + zAff = sqlite3DbStrDup(pParse->db,sqlite3IndexAffinityStr(pParse->db,pIdx)); + if( !zAff ){ + pParse->db->mallocFailed = 1; + } + + if( nSkip ){ + int iIdxCur = pLevel->iIdxCur; + sqlite3VdbeAddOp1(v, (bRev?OP_Last:OP_Rewind), iIdxCur); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + VdbeComment((v, "begin skip-scan on %s", pIdx->zName)); + j = sqlite3VdbeAddOp0(v, OP_Goto); + pLevel->addrSkip = sqlite3VdbeAddOp4Int(v, (bRev?OP_SeekLT:OP_SeekGT), + iIdxCur, 0, regBase, nSkip); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + sqlite3VdbeJumpHere(v, j); + for(j=0; jaiColumn[j]==XN_EXPR ); + VdbeComment((v, "%s", explainIndexColumnName(pIdx, j))); + } + } + + /* Evaluate the equality constraints + */ + assert( zAff==0 || (int)strlen(zAff)>=nEq ); + for(j=nSkip; jaLTerm[j]; + assert( pTerm!=0 ); + /* The following testcase is true for indices with redundant columns. + ** Ex: CREATE INDEX i1 ON t1(a,b,a); SELECT * FROM t1 WHERE a=0 AND b=0; */ + testcase( (pTerm->wtFlags & TERM_CODED)!=0 ); + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, regBase+j); + if( r1!=regBase+j ){ + if( nReg==1 ){ + sqlite3ReleaseTempReg(pParse, regBase); + regBase = r1; + }else{ + sqlite3VdbeAddOp2(v, OP_SCopy, r1, regBase+j); + } + } + testcase( pTerm->eOperator & WO_ISNULL ); + testcase( pTerm->eOperator & WO_IN ); + if( (pTerm->eOperator & (WO_ISNULL|WO_IN))==0 ){ + Expr *pRight = pTerm->pExpr->pRight; + if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk); + VdbeCoverage(v); + } + if( zAff ){ + if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){ + zAff[j] = SQLITE_AFF_BLOB; + } + if( sqlite3ExprNeedsNoAffinityChange(pRight, zAff[j]) ){ + zAff[j] = SQLITE_AFF_BLOB; + } + } + } + } + *pzAff = zAff; + return regBase; +} + +/* +** If the most recently coded instruction is a constant range contraint +** that originated from the LIKE optimization, then change the P3 to be +** pLoop->iLikeRepCntr and set P5. +** +** The LIKE optimization trys to evaluate "x LIKE 'abc%'" as a range +** expression: "x>='ABC' AND x<'abd'". But this requires that the range +** scan loop run twice, once for strings and a second time for BLOBs. +** The OP_String opcodes on the second pass convert the upper and lower +** bound string contants to blobs. This routine makes the necessary changes +** to the OP_String opcodes for that to happen. +*/ +static void whereLikeOptimizationStringFixup( + Vdbe *v, /* prepared statement under construction */ + WhereLevel *pLevel, /* The loop that contains the LIKE operator */ + WhereTerm *pTerm /* The upper or lower bound just coded */ +){ + if( pTerm->wtFlags & TERM_LIKEOPT ){ + VdbeOp *pOp; + assert( pLevel->iLikeRepCntr>0 ); + pOp = sqlite3VdbeGetOp(v, -1); + assert( pOp!=0 ); + assert( pOp->opcode==OP_String8 + || pTerm->pWC->pWInfo->pParse->db->mallocFailed ); + pOp->p3 = pLevel->iLikeRepCntr; + pOp->p5 = 1; + } +} + + +/* +** Generate code for the start of the iLevel-th loop in the WHERE clause +** implementation described by pWInfo. +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( + WhereInfo *pWInfo, /* Complete information about the WHERE clause */ + int iLevel, /* Which level of pWInfo->a[] should be coded */ + Bitmask notReady /* Which tables are currently available */ +){ + int j, k; /* Loop counters */ + int iCur; /* The VDBE cursor for the table */ + int addrNxt; /* Where to jump to continue with the next IN case */ + int omitTable; /* True if we use the index only */ + int bRev; /* True if we need to scan in reverse order */ + WhereLevel *pLevel; /* The where level to be coded */ + WhereLoop *pLoop; /* The WhereLoop object being coded */ + WhereClause *pWC; /* Decomposition of the entire WHERE clause */ + WhereTerm *pTerm; /* A WHERE clause term */ + Parse *pParse; /* Parsing context */ + sqlite3 *db; /* Database connection */ + Vdbe *v; /* The prepared stmt under constructions */ + struct SrcList_item *pTabItem; /* FROM clause term being coded */ + int addrBrk; /* Jump here to break out of the loop */ + int addrCont; /* Jump here to continue with next cycle */ + int iRowidReg = 0; /* Rowid is stored in this register, if not zero */ + int iReleaseReg = 0; /* Temp register to free before returning */ + + pParse = pWInfo->pParse; + v = pParse->pVdbe; + pWC = &pWInfo->sWC; + db = pParse->db; + pLevel = &pWInfo->a[iLevel]; + pLoop = pLevel->pWLoop; + pTabItem = &pWInfo->pTabList->a[pLevel->iFrom]; + iCur = pTabItem->iCursor; + pLevel->notReady = notReady & ~sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur); + bRev = (pWInfo->revMask>>iLevel)&1; + omitTable = (pLoop->wsFlags & WHERE_IDX_ONLY)!=0 + && (pWInfo->wctrlFlags & WHERE_FORCE_TABLE)==0; + VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName)); + + /* Create labels for the "break" and "continue" instructions + ** for the current loop. Jump to addrBrk to break out of a loop. + ** Jump to cont to go immediately to the next iteration of the + ** loop. + ** + ** When there is an IN operator, we also have a "addrNxt" label that + ** means to continue with the next IN value combination. When + ** there are no IN operators in the constraints, the "addrNxt" label + ** is the same as "addrBrk". + */ + addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(v); + addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(v); + + /* If this is the right table of a LEFT OUTER JOIN, allocate and + ** initialize a memory cell that records if this table matches any + ** row of the left table of the join. + */ + if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){ + pLevel->iLeftJoin = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin); + VdbeComment((v, "init LEFT JOIN no-match flag")); + } + + /* Special case of a FROM clause subquery implemented as a co-routine */ + if( pTabItem->fg.viaCoroutine ){ + int regYield = pTabItem->regReturn; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub); + pLevel->p2 = sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk); + VdbeCoverage(v); + VdbeComment((v, "next row of \"%s\"", pTabItem->pTab->zName)); + pLevel->op = OP_Goto; + }else + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){ + /* Case 1: The table is a virtual-table. Use the VFilter and VNext + ** to access the data. + */ + int iReg; /* P3 Value for OP_VFilter */ + int addrNotFound; + int nConstraint = pLoop->nLTerm; + + sqlite3ExprCachePush(pParse); + iReg = sqlite3GetTempRange(pParse, nConstraint+2); + addrNotFound = pLevel->addrBrk; + for(j=0; jaLTerm[j]; + if( pTerm==0 ) continue; + if( pTerm->eOperator & WO_IN ){ + codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget); + addrNotFound = pLevel->addrNxt; + }else{ + sqlite3ExprCode(pParse, pTerm->pExpr->pRight, iTarget); + } + } + sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg); + sqlite3VdbeAddOp2(v, OP_Integer, nConstraint, iReg+1); + sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg, + pLoop->u.vtab.idxStr, + pLoop->u.vtab.needFree ? P4_MPRINTF : P4_STATIC); + VdbeCoverage(v); + pLoop->u.vtab.needFree = 0; + for(j=0; ju.vtab.omitMask>>j)&1 ){ + disableTerm(pLevel, pLoop->aLTerm[j]); + } + } + pLevel->p1 = iCur; + pLevel->op = pWInfo->eOnePass ? OP_Noop : OP_VNext; + pLevel->p2 = sqlite3VdbeCurrentAddr(v); + sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2); + sqlite3ExprCachePop(pParse); + }else +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + + if( (pLoop->wsFlags & WHERE_IPK)!=0 + && (pLoop->wsFlags & (WHERE_COLUMN_IN|WHERE_COLUMN_EQ))!=0 + ){ + /* Case 2: We can directly reference a single row using an + ** equality comparison against the ROWID field. Or + ** we reference multiple rows using a "rowid IN (...)" + ** construct. + */ + assert( pLoop->u.btree.nEq==1 ); + pTerm = pLoop->aLTerm[0]; + assert( pTerm!=0 ); + assert( pTerm->pExpr!=0 ); + assert( omitTable==0 ); + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + iReleaseReg = ++pParse->nMem; + iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg); + if( iRowidReg!=iReleaseReg ) sqlite3ReleaseTempReg(pParse, iReleaseReg); + addrNxt = pLevel->addrNxt; + sqlite3VdbeAddOp2(v, OP_MustBeInt, iRowidReg, addrNxt); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addrNxt, iRowidReg); + VdbeCoverage(v); + sqlite3ExprCacheAffinityChange(pParse, iRowidReg, 1); + sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg); + VdbeComment((v, "pk")); + pLevel->op = OP_Noop; + }else if( (pLoop->wsFlags & WHERE_IPK)!=0 + && (pLoop->wsFlags & WHERE_COLUMN_RANGE)!=0 + ){ + /* Case 3: We have an inequality comparison against the ROWID field. + */ + int testOp = OP_Noop; + int start; + int memEndValue = 0; + WhereTerm *pStart, *pEnd; + + assert( omitTable==0 ); + j = 0; + pStart = pEnd = 0; + if( pLoop->wsFlags & WHERE_BTM_LIMIT ) pStart = pLoop->aLTerm[j++]; + if( pLoop->wsFlags & WHERE_TOP_LIMIT ) pEnd = pLoop->aLTerm[j++]; + assert( pStart!=0 || pEnd!=0 ); + if( bRev ){ + pTerm = pStart; + pStart = pEnd; + pEnd = pTerm; + } + if( pStart ){ + Expr *pX; /* The expression that defines the start bound */ + int r1, rTemp; /* Registers for holding the start boundary */ + + /* The following constant maps TK_xx codes into corresponding + ** seek opcodes. It depends on a particular ordering of TK_xx + */ + const u8 aMoveOp[] = { + /* TK_GT */ OP_SeekGT, + /* TK_LE */ OP_SeekLE, + /* TK_LT */ OP_SeekLT, + /* TK_GE */ OP_SeekGE + }; + assert( TK_LE==TK_GT+1 ); /* Make sure the ordering.. */ + assert( TK_LT==TK_GT+2 ); /* ... of the TK_xx values... */ + assert( TK_GE==TK_GT+3 ); /* ... is correcct. */ + + assert( (pStart->wtFlags & TERM_VNULL)==0 ); + testcase( pStart->wtFlags & TERM_VIRTUAL ); + pX = pStart->pExpr; + assert( pX!=0 ); + testcase( pStart->leftCursor!=iCur ); /* transitive constraints */ + r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp); + sqlite3VdbeAddOp3(v, aMoveOp[pX->op-TK_GT], iCur, addrBrk, r1); + VdbeComment((v, "pk")); + VdbeCoverageIf(v, pX->op==TK_GT); + VdbeCoverageIf(v, pX->op==TK_LE); + VdbeCoverageIf(v, pX->op==TK_LT); + VdbeCoverageIf(v, pX->op==TK_GE); + sqlite3ExprCacheAffinityChange(pParse, r1, 1); + sqlite3ReleaseTempReg(pParse, rTemp); + disableTerm(pLevel, pStart); + }else{ + sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrBrk); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + } + if( pEnd ){ + Expr *pX; + pX = pEnd->pExpr; + assert( pX!=0 ); + assert( (pEnd->wtFlags & TERM_VNULL)==0 ); + testcase( pEnd->leftCursor!=iCur ); /* Transitive constraints */ + testcase( pEnd->wtFlags & TERM_VIRTUAL ); + memEndValue = ++pParse->nMem; + sqlite3ExprCode(pParse, pX->pRight, memEndValue); + if( pX->op==TK_LT || pX->op==TK_GT ){ + testOp = bRev ? OP_Le : OP_Ge; + }else{ + testOp = bRev ? OP_Lt : OP_Gt; + } + disableTerm(pLevel, pEnd); + } + start = sqlite3VdbeCurrentAddr(v); + pLevel->op = bRev ? OP_Prev : OP_Next; + pLevel->p1 = iCur; + pLevel->p2 = start; + assert( pLevel->p5==0 ); + if( testOp!=OP_Noop ){ + iRowidReg = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg); + sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg); + sqlite3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg); + VdbeCoverageIf(v, testOp==OP_Le); + VdbeCoverageIf(v, testOp==OP_Lt); + VdbeCoverageIf(v, testOp==OP_Ge); + VdbeCoverageIf(v, testOp==OP_Gt); + sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL); + } + }else if( pLoop->wsFlags & WHERE_INDEXED ){ + /* Case 4: A scan using an index. + ** + ** The WHERE clause may contain zero or more equality + ** terms ("==" or "IN" operators) that refer to the N + ** left-most columns of the index. It may also contain + ** inequality constraints (>, <, >= or <=) on the indexed + ** column that immediately follows the N equalities. Only + ** the right-most column can be an inequality - the rest must + ** use the "==" and "IN" operators. For example, if the + ** index is on (x,y,z), then the following clauses are all + ** optimized: + ** + ** x=5 + ** x=5 AND y=10 + ** x=5 AND y<10 + ** x=5 AND y>5 AND y<10 + ** x=5 AND y=5 AND z<=10 + ** + ** The z<10 term of the following cannot be used, only + ** the x=5 term: + ** + ** x=5 AND z<10 + ** + ** N may be zero if there are inequality constraints. + ** If there are no inequality constraints, then N is at + ** least one. + ** + ** This case is also used when there are no WHERE clause + ** constraints but an index is selected anyway, in order + ** to force the output order to conform to an ORDER BY. + */ + static const u8 aStartOp[] = { + 0, + 0, + OP_Rewind, /* 2: (!start_constraints && startEq && !bRev) */ + OP_Last, /* 3: (!start_constraints && startEq && bRev) */ + OP_SeekGT, /* 4: (start_constraints && !startEq && !bRev) */ + OP_SeekLT, /* 5: (start_constraints && !startEq && bRev) */ + OP_SeekGE, /* 6: (start_constraints && startEq && !bRev) */ + OP_SeekLE /* 7: (start_constraints && startEq && bRev) */ + }; + static const u8 aEndOp[] = { + OP_IdxGE, /* 0: (end_constraints && !bRev && !endEq) */ + OP_IdxGT, /* 1: (end_constraints && !bRev && endEq) */ + OP_IdxLE, /* 2: (end_constraints && bRev && !endEq) */ + OP_IdxLT, /* 3: (end_constraints && bRev && endEq) */ + }; + u16 nEq = pLoop->u.btree.nEq; /* Number of == or IN terms */ + int regBase; /* Base register holding constraint values */ + WhereTerm *pRangeStart = 0; /* Inequality constraint at range start */ + WhereTerm *pRangeEnd = 0; /* Inequality constraint at range end */ + int startEq; /* True if range start uses ==, >= or <= */ + int endEq; /* True if range end uses ==, >= or <= */ + int start_constraints; /* Start of range is constrained */ + int nConstraint; /* Number of constraint terms */ + Index *pIdx; /* The index we will be using */ + int iIdxCur; /* The VDBE cursor for the index */ + int nExtraReg = 0; /* Number of extra registers needed */ + int op; /* Instruction opcode */ + char *zStartAff; /* Affinity for start of range constraint */ + char cEndAff = 0; /* Affinity for end of range constraint */ + u8 bSeekPastNull = 0; /* True to seek past initial nulls */ + u8 bStopAtNull = 0; /* Add condition to terminate at NULLs */ + + pIdx = pLoop->u.btree.pIndex; + iIdxCur = pLevel->iIdxCur; + assert( nEq>=pLoop->nSkip ); + + /* If this loop satisfies a sort order (pOrderBy) request that + ** was passed to this function to implement a "SELECT min(x) ..." + ** query, then the caller will only allow the loop to run for + ** a single iteration. This means that the first row returned + ** should not have a NULL value stored in 'x'. If column 'x' is + ** the first one after the nEq equality constraints in the index, + ** this requires some special handling. + */ + assert( pWInfo->pOrderBy==0 + || pWInfo->pOrderBy->nExpr==1 + || (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)==0 ); + if( (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)!=0 + && pWInfo->nOBSat>0 + && (pIdx->nKeyCol>nEq) + ){ + assert( pLoop->nSkip==0 ); + bSeekPastNull = 1; + nExtraReg = 1; + } + + /* Find any inequality constraint terms for the start and end + ** of the range. + */ + j = nEq; + if( pLoop->wsFlags & WHERE_BTM_LIMIT ){ + pRangeStart = pLoop->aLTerm[j++]; + nExtraReg = 1; + /* Like optimization range constraints always occur in pairs */ + assert( (pRangeStart->wtFlags & TERM_LIKEOPT)==0 || + (pLoop->wsFlags & WHERE_TOP_LIMIT)!=0 ); + } + if( pLoop->wsFlags & WHERE_TOP_LIMIT ){ + pRangeEnd = pLoop->aLTerm[j++]; + nExtraReg = 1; + if( (pRangeEnd->wtFlags & TERM_LIKEOPT)!=0 ){ + assert( pRangeStart!=0 ); /* LIKE opt constraints */ + assert( pRangeStart->wtFlags & TERM_LIKEOPT ); /* occur in pairs */ + pLevel->iLikeRepCntr = ++pParse->nMem; + testcase( bRev ); + testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC ); + sqlite3VdbeAddOp2(v, OP_Integer, + bRev ^ (pIdx->aSortOrder[nEq]==SQLITE_SO_DESC), + pLevel->iLikeRepCntr); + VdbeComment((v, "LIKE loop counter")); + pLevel->addrLikeRep = sqlite3VdbeCurrentAddr(v); + } + if( pRangeStart==0 + && (j = pIdx->aiColumn[nEq])>=0 + && pIdx->pTable->aCol[j].notNull==0 + ){ + bSeekPastNull = 1; + } + } + assert( pRangeEnd==0 || (pRangeEnd->wtFlags & TERM_VNULL)==0 ); + + /* Generate code to evaluate all constraint terms using == or IN + ** and store the values of those terms in an array of registers + ** starting at regBase. + */ + regBase = codeAllEqualityTerms(pParse,pLevel,bRev,nExtraReg,&zStartAff); + assert( zStartAff==0 || sqlite3Strlen30(zStartAff)>=nEq ); + if( zStartAff ) cEndAff = zStartAff[nEq]; + addrNxt = pLevel->addrNxt; + + /* If we are doing a reverse order scan on an ascending index, or + ** a forward order scan on a descending index, interchange the + ** start and end terms (pRangeStart and pRangeEnd). + */ + if( (nEqnKeyCol && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC)) + || (bRev && pIdx->nKeyCol==nEq) + ){ + SWAP(WhereTerm *, pRangeEnd, pRangeStart); + SWAP(u8, bSeekPastNull, bStopAtNull); + } + + testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 ); + testcase( pRangeStart && (pRangeStart->eOperator & WO_GE)!=0 ); + testcase( pRangeEnd && (pRangeEnd->eOperator & WO_LE)!=0 ); + testcase( pRangeEnd && (pRangeEnd->eOperator & WO_GE)!=0 ); + startEq = !pRangeStart || pRangeStart->eOperator & (WO_LE|WO_GE); + endEq = !pRangeEnd || pRangeEnd->eOperator & (WO_LE|WO_GE); + start_constraints = pRangeStart || nEq>0; + + /* Seek the index cursor to the start of the range. */ + nConstraint = nEq; + if( pRangeStart ){ + Expr *pRight = pRangeStart->pExpr->pRight; + sqlite3ExprCode(pParse, pRight, regBase+nEq); + whereLikeOptimizationStringFixup(v, pLevel, pRangeStart); + if( (pRangeStart->wtFlags & TERM_VNULL)==0 + && sqlite3ExprCanBeNull(pRight) + ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt); + VdbeCoverage(v); + } + if( zStartAff ){ + if( sqlite3CompareAffinity(pRight, zStartAff[nEq])==SQLITE_AFF_BLOB){ + /* Since the comparison is to be performed with no conversions + ** applied to the operands, set the affinity to apply to pRight to + ** SQLITE_AFF_BLOB. */ + zStartAff[nEq] = SQLITE_AFF_BLOB; + } + if( sqlite3ExprNeedsNoAffinityChange(pRight, zStartAff[nEq]) ){ + zStartAff[nEq] = SQLITE_AFF_BLOB; + } + } + nConstraint++; + testcase( pRangeStart->wtFlags & TERM_VIRTUAL ); + }else if( bSeekPastNull ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq); + nConstraint++; + startEq = 0; + start_constraints = 1; + } + codeApplyAffinity(pParse, regBase, nConstraint - bSeekPastNull, zStartAff); + op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev]; + assert( op!=0 ); + sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint); + VdbeCoverage(v); + VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind ); + VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last ); + VdbeCoverageIf(v, op==OP_SeekGT); testcase( op==OP_SeekGT ); + VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE ); + VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE ); + VdbeCoverageIf(v, op==OP_SeekLT); testcase( op==OP_SeekLT ); + + /* Load the value for the inequality constraint at the end of the + ** range (if any). + */ + nConstraint = nEq; + if( pRangeEnd ){ + Expr *pRight = pRangeEnd->pExpr->pRight; + sqlite3ExprCacheRemove(pParse, regBase+nEq, 1); + sqlite3ExprCode(pParse, pRight, regBase+nEq); + whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd); + if( (pRangeEnd->wtFlags & TERM_VNULL)==0 + && sqlite3ExprCanBeNull(pRight) + ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt); + VdbeCoverage(v); + } + if( sqlite3CompareAffinity(pRight, cEndAff)!=SQLITE_AFF_BLOB + && !sqlite3ExprNeedsNoAffinityChange(pRight, cEndAff) + ){ + codeApplyAffinity(pParse, regBase+nEq, 1, &cEndAff); + } + nConstraint++; + testcase( pRangeEnd->wtFlags & TERM_VIRTUAL ); + }else if( bStopAtNull ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq); + endEq = 0; + nConstraint++; + } + sqlite3DbFree(db, zStartAff); + + /* Top of the loop body */ + pLevel->p2 = sqlite3VdbeCurrentAddr(v); + + /* Check if the index cursor is past the end of the range. */ + if( nConstraint ){ + op = aEndOp[bRev*2 + endEq]; + sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint); + testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT ); + testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE ); + testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT ); + testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE ); + } + + /* Seek the table cursor, if required */ + disableTerm(pLevel, pRangeStart); + disableTerm(pLevel, pRangeEnd); + if( omitTable ){ + /* pIdx is a covering index. No need to access the main table. */ + }else if( HasRowid(pIdx->pTable) ){ + iRowidReg = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, iRowidReg); + sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg); + if( pWInfo->eOnePass!=ONEPASS_OFF ){ + sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, iRowidReg); + VdbeCoverage(v); + }else{ + sqlite3VdbeAddOp2(v, OP_Seek, iCur, iRowidReg); /* Deferred seek */ + } + }else if( iCur!=iIdxCur ){ + Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable); + iRowidReg = sqlite3GetTempRange(pParse, pPk->nKeyCol); + for(j=0; jnKeyCol; j++){ + k = sqlite3ColumnOfIndex(pIdx, pPk->aiColumn[j]); + sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, iRowidReg+j); + } + sqlite3VdbeAddOp4Int(v, OP_NotFound, iCur, addrCont, + iRowidReg, pPk->nKeyCol); VdbeCoverage(v); + } + + /* Record the instruction used to terminate the loop. Disable + ** WHERE clause terms made redundant by the index range scan. + */ + if( pLoop->wsFlags & WHERE_ONEROW ){ + pLevel->op = OP_Noop; + }else if( bRev ){ + pLevel->op = OP_Prev; + }else{ + pLevel->op = OP_Next; + } + pLevel->p1 = iIdxCur; + pLevel->p3 = (pLoop->wsFlags&WHERE_UNQ_WANTED)!=0 ? 1:0; + if( (pLoop->wsFlags & WHERE_CONSTRAINT)==0 ){ + pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; + }else{ + assert( pLevel->p5==0 ); + } + }else + +#ifndef SQLITE_OMIT_OR_OPTIMIZATION + if( pLoop->wsFlags & WHERE_MULTI_OR ){ + /* Case 5: Two or more separately indexed terms connected by OR + ** + ** Example: + ** + ** CREATE TABLE t1(a,b,c,d); + ** CREATE INDEX i1 ON t1(a); + ** CREATE INDEX i2 ON t1(b); + ** CREATE INDEX i3 ON t1(c); + ** + ** SELECT * FROM t1 WHERE a=5 OR b=7 OR (c=11 AND d=13) + ** + ** In the example, there are three indexed terms connected by OR. + ** The top of the loop looks like this: + ** + ** Null 1 # Zero the rowset in reg 1 + ** + ** Then, for each indexed term, the following. The arguments to + ** RowSetTest are such that the rowid of the current row is inserted + ** into the RowSet. If it is already present, control skips the + ** Gosub opcode and jumps straight to the code generated by WhereEnd(). + ** + ** sqlite3WhereBegin() + ** RowSetTest # Insert rowid into rowset + ** Gosub 2 A + ** sqlite3WhereEnd() + ** + ** Following the above, code to terminate the loop. Label A, the target + ** of the Gosub above, jumps to the instruction right after the Goto. + ** + ** Null 1 # Zero the rowset in reg 1 + ** Goto B # The loop is finished. + ** + ** A: # Return data, whatever. + ** + ** Return 2 # Jump back to the Gosub + ** + ** B: + ** + ** Added 2014-05-26: If the table is a WITHOUT ROWID table, then + ** use an ephemeral index instead of a RowSet to record the primary + ** keys of the rows we have already seen. + ** + */ + WhereClause *pOrWc; /* The OR-clause broken out into subterms */ + SrcList *pOrTab; /* Shortened table list or OR-clause generation */ + Index *pCov = 0; /* Potential covering index (or NULL) */ + int iCovCur = pParse->nTab++; /* Cursor used for index scans (if any) */ + + int regReturn = ++pParse->nMem; /* Register used with OP_Gosub */ + int regRowset = 0; /* Register for RowSet object */ + int regRowid = 0; /* Register holding rowid */ + int iLoopBody = sqlite3VdbeMakeLabel(v); /* Start of loop body */ + int iRetInit; /* Address of regReturn init */ + int untestedTerms = 0; /* Some terms not completely tested */ + int ii; /* Loop counter */ + u16 wctrlFlags; /* Flags for sub-WHERE clause */ + Expr *pAndExpr = 0; /* An ".. AND (...)" expression */ + Table *pTab = pTabItem->pTab; + + pTerm = pLoop->aLTerm[0]; + assert( pTerm!=0 ); + assert( pTerm->eOperator & WO_OR ); + assert( (pTerm->wtFlags & TERM_ORINFO)!=0 ); + pOrWc = &pTerm->u.pOrInfo->wc; + pLevel->op = OP_Return; + pLevel->p1 = regReturn; + + /* Set up a new SrcList in pOrTab containing the table being scanned + ** by this loop in the a[0] slot and all notReady tables in a[1..] slots. + ** This becomes the SrcList in the recursive call to sqlite3WhereBegin(). + */ + if( pWInfo->nLevel>1 ){ + int nNotReady; /* The number of notReady tables */ + struct SrcList_item *origSrc; /* Original list of tables */ + nNotReady = pWInfo->nLevel - iLevel - 1; + pOrTab = sqlite3StackAllocRaw(db, + sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0])); + if( pOrTab==0 ) return notReady; + pOrTab->nAlloc = (u8)(nNotReady + 1); + pOrTab->nSrc = pOrTab->nAlloc; + memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem)); + origSrc = pWInfo->pTabList->a; + for(k=1; k<=nNotReady; k++){ + memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k])); + } + }else{ + pOrTab = pWInfo->pTabList; + } + + /* Initialize the rowset register to contain NULL. An SQL NULL is + ** equivalent to an empty rowset. Or, create an ephemeral index + ** capable of holding primary keys in the case of a WITHOUT ROWID. + ** + ** Also initialize regReturn to contain the address of the instruction + ** immediately following the OP_Return at the bottom of the loop. This + ** is required in a few obscure LEFT JOIN cases where control jumps + ** over the top of the loop into the body of it. In this case the + ** correct response for the end-of-loop code (the OP_Return) is to + ** fall through to the next instruction, just as an OP_Next does if + ** called on an uninitialized cursor. + */ + if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ + if( HasRowid(pTab) ){ + regRowset = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Null, 0, regRowset); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + regRowset = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, regRowset, pPk->nKeyCol); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + } + regRowid = ++pParse->nMem; + } + iRetInit = sqlite3VdbeAddOp2(v, OP_Integer, 0, regReturn); + + /* If the original WHERE clause is z of the form: (x1 OR x2 OR ...) AND y + ** Then for every term xN, evaluate as the subexpression: xN AND z + ** That way, terms in y that are factored into the disjunction will + ** be picked up by the recursive calls to sqlite3WhereBegin() below. + ** + ** Actually, each subexpression is converted to "xN AND w" where w is + ** the "interesting" terms of z - terms that did not originate in the + ** ON or USING clause of a LEFT JOIN, and terms that are usable as + ** indices. + ** + ** This optimization also only applies if the (x1 OR x2 OR ...) term + ** is not contained in the ON clause of a LEFT JOIN. + ** See ticket http://www.sqlite.org/src/info/f2369304e4 + */ + if( pWC->nTerm>1 ){ + int iTerm; + for(iTerm=0; iTermnTerm; iTerm++){ + Expr *pExpr = pWC->a[iTerm].pExpr; + if( &pWC->a[iTerm] == pTerm ) continue; + if( ExprHasProperty(pExpr, EP_FromJoin) ) continue; + if( (pWC->a[iTerm].wtFlags & TERM_VIRTUAL)!=0 ) continue; + if( (pWC->a[iTerm].eOperator & WO_ALL)==0 ) continue; + testcase( pWC->a[iTerm].wtFlags & TERM_ORINFO ); + pExpr = sqlite3ExprDup(db, pExpr, 0); + pAndExpr = sqlite3ExprAnd(db, pAndExpr, pExpr); + } + if( pAndExpr ){ + pAndExpr = sqlite3PExpr(pParse, TK_AND, 0, pAndExpr, 0); + } + } + + /* Run a separate WHERE clause for each term of the OR clause. After + ** eliminating duplicates from other WHERE clauses, the action for each + ** sub-WHERE clause is to to invoke the main loop body as a subroutine. + */ + wctrlFlags = WHERE_OMIT_OPEN_CLOSE + | WHERE_FORCE_TABLE + | WHERE_ONETABLE_ONLY + | WHERE_NO_AUTOINDEX; + for(ii=0; iinTerm; ii++){ + WhereTerm *pOrTerm = &pOrWc->a[ii]; + if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){ + WhereInfo *pSubWInfo; /* Info for single OR-term scan */ + Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */ + int jmp1 = 0; /* Address of jump operation */ + if( pAndExpr && !ExprHasProperty(pOrExpr, EP_FromJoin) ){ + pAndExpr->pLeft = pOrExpr; + pOrExpr = pAndExpr; + } + /* Loop through table entries that match term pOrTerm. */ + WHERETRACE(0xffff, ("Subplan for OR-clause:\n")); + pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0, + wctrlFlags, iCovCur); + assert( pSubWInfo || pParse->nErr || db->mallocFailed ); + if( pSubWInfo ){ + WhereLoop *pSubLoop; + int addrExplain = sqlite3WhereExplainOneScan( + pParse, pOrTab, &pSubWInfo->a[0], iLevel, pLevel->iFrom, 0 + ); + sqlite3WhereAddScanStatus(v, pOrTab, &pSubWInfo->a[0], addrExplain); + + /* This is the sub-WHERE clause body. First skip over + ** duplicate rows from prior sub-WHERE clauses, and record the + ** rowid (or PRIMARY KEY) for the current row so that the same + ** row will be skipped in subsequent sub-WHERE clauses. + */ + if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ + int r; + int iSet = ((ii==pOrWc->nTerm-1)?-1:ii); + if( HasRowid(pTab) ){ + r = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, regRowid, 0); + jmp1 = sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset, 0, + r,iSet); + VdbeCoverage(v); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + int nPk = pPk->nKeyCol; + int iPk; + + /* Read the PK into an array of temp registers. */ + r = sqlite3GetTempRange(pParse, nPk); + for(iPk=0; iPkaiColumn[iPk]; + int rx; + rx = sqlite3ExprCodeGetColumn(pParse, pTab, iCol, iCur,r+iPk,0); + if( rx!=r+iPk ){ + sqlite3VdbeAddOp2(v, OP_SCopy, rx, r+iPk); + } + } + + /* Check if the temp table already contains this key. If so, + ** the row has already been included in the result set and + ** can be ignored (by jumping past the Gosub below). Otherwise, + ** insert the key into the temp table and proceed with processing + ** the row. + ** + ** Use some of the same optimizations as OP_RowSetTest: If iSet + ** is zero, assume that the key cannot already be present in + ** the temp table. And if iSet is -1, assume that there is no + ** need to insert the key into the temp table, as it will never + ** be tested for. */ + if( iSet ){ + jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, regRowset, 0, r, nPk); + VdbeCoverage(v); + } + if( iSet>=0 ){ + sqlite3VdbeAddOp3(v, OP_MakeRecord, r, nPk, regRowid); + sqlite3VdbeAddOp3(v, OP_IdxInsert, regRowset, regRowid, 0); + if( iSet ) sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + } + + /* Release the array of temp registers */ + sqlite3ReleaseTempRange(pParse, r, nPk); + } + } + + /* Invoke the main loop body as a subroutine */ + sqlite3VdbeAddOp2(v, OP_Gosub, regReturn, iLoopBody); + + /* Jump here (skipping the main loop body subroutine) if the + ** current sub-WHERE row is a duplicate from prior sub-WHEREs. */ + if( jmp1 ) sqlite3VdbeJumpHere(v, jmp1); + + /* The pSubWInfo->untestedTerms flag means that this OR term + ** contained one or more AND term from a notReady table. The + ** terms from the notReady table could not be tested and will + ** need to be tested later. + */ + if( pSubWInfo->untestedTerms ) untestedTerms = 1; + + /* If all of the OR-connected terms are optimized using the same + ** index, and the index is opened using the same cursor number + ** by each call to sqlite3WhereBegin() made by this loop, it may + ** be possible to use that index as a covering index. + ** + ** If the call to sqlite3WhereBegin() above resulted in a scan that + ** uses an index, and this is either the first OR-connected term + ** processed or the index is the same as that used by all previous + ** terms, set pCov to the candidate covering index. Otherwise, set + ** pCov to NULL to indicate that no candidate covering index will + ** be available. + */ + pSubLoop = pSubWInfo->a[0].pWLoop; + assert( (pSubLoop->wsFlags & WHERE_AUTO_INDEX)==0 ); + if( (pSubLoop->wsFlags & WHERE_INDEXED)!=0 + && (ii==0 || pSubLoop->u.btree.pIndex==pCov) + && (HasRowid(pTab) || !IsPrimaryKeyIndex(pSubLoop->u.btree.pIndex)) + ){ + assert( pSubWInfo->a[0].iIdxCur==iCovCur ); + pCov = pSubLoop->u.btree.pIndex; + wctrlFlags |= WHERE_REOPEN_IDX; + }else{ + pCov = 0; + } + + /* Finish the loop through table entries that match term pOrTerm. */ + sqlite3WhereEnd(pSubWInfo); + } + } + } + pLevel->u.pCovidx = pCov; + if( pCov ) pLevel->iIdxCur = iCovCur; + if( pAndExpr ){ + pAndExpr->pLeft = 0; + sqlite3ExprDelete(db, pAndExpr); + } + sqlite3VdbeChangeP1(v, iRetInit, sqlite3VdbeCurrentAddr(v)); + sqlite3VdbeGoto(v, pLevel->addrBrk); + sqlite3VdbeResolveLabel(v, iLoopBody); + + if( pWInfo->nLevel>1 ) sqlite3StackFree(db, pOrTab); + if( !untestedTerms ) disableTerm(pLevel, pTerm); + }else +#endif /* SQLITE_OMIT_OR_OPTIMIZATION */ + + { + /* Case 6: There is no usable index. We must do a complete + ** scan of the entire table. + */ + static const u8 aStep[] = { OP_Next, OP_Prev }; + static const u8 aStart[] = { OP_Rewind, OP_Last }; + assert( bRev==0 || bRev==1 ); + if( pTabItem->fg.isRecursive ){ + /* Tables marked isRecursive have only a single row that is stored in + ** a pseudo-cursor. No need to Rewind or Next such cursors. */ + pLevel->op = OP_Noop; + }else{ + pLevel->op = aStep[bRev]; + pLevel->p1 = iCur; + pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; + } + } + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + pLevel->addrVisit = sqlite3VdbeCurrentAddr(v); +#endif + + /* Insert code to test every subexpression that can be completely + ** computed using the current set of tables. + */ + for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){ + Expr *pE; + int skipLikeAddr = 0; + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + testcase( pTerm->wtFlags & TERM_CODED ); + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( (pTerm->prereqAll & pLevel->notReady)!=0 ){ + testcase( pWInfo->untestedTerms==0 + && (pWInfo->wctrlFlags & WHERE_ONETABLE_ONLY)!=0 ); + pWInfo->untestedTerms = 1; + continue; + } + pE = pTerm->pExpr; + assert( pE!=0 ); + if( pLevel->iLeftJoin && !ExprHasProperty(pE, EP_FromJoin) ){ + continue; + } + if( pTerm->wtFlags & TERM_LIKECOND ){ + assert( pLevel->iLikeRepCntr>0 ); + skipLikeAddr = sqlite3VdbeAddOp1(v, OP_IfNot, pLevel->iLikeRepCntr); + VdbeCoverage(v); + } + sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL); + if( skipLikeAddr ) sqlite3VdbeJumpHere(v, skipLikeAddr); + pTerm->wtFlags |= TERM_CODED; + } + + /* Insert code to test for implied constraints based on transitivity + ** of the "==" operator. + ** + ** Example: If the WHERE clause contains "t1.a=t2.b" and "t2.b=123" + ** and we are coding the t1 loop and the t2 loop has not yet coded, + ** then we cannot use the "t1.a=t2.b" constraint, but we can code + ** the implied "t1.a=123" constraint. + */ + for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){ + Expr *pE, *pEAlt; + WhereTerm *pAlt; + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) continue; + if( (pTerm->eOperator & WO_EQUIV)==0 ) continue; + if( pTerm->leftCursor!=iCur ) continue; + if( pLevel->iLeftJoin ) continue; + pE = pTerm->pExpr; + assert( !ExprHasProperty(pE, EP_FromJoin) ); + assert( (pTerm->prereqRight & pLevel->notReady)!=0 ); + pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.leftColumn, notReady, + WO_EQ|WO_IN|WO_IS, 0); + if( pAlt==0 ) continue; + if( pAlt->wtFlags & (TERM_CODED) ) continue; + testcase( pAlt->eOperator & WO_EQ ); + testcase( pAlt->eOperator & WO_IS ); + testcase( pAlt->eOperator & WO_IN ); + VdbeModuleComment((v, "begin transitive constraint")); + pEAlt = sqlite3StackAllocRaw(db, sizeof(*pEAlt)); + if( pEAlt ){ + *pEAlt = *pAlt->pExpr; + pEAlt->pLeft = pE->pLeft; + sqlite3ExprIfFalse(pParse, pEAlt, addrCont, SQLITE_JUMPIFNULL); + sqlite3StackFree(db, pEAlt); + } + } + + /* For a LEFT OUTER JOIN, generate code that will record the fact that + ** at least one row of the right table has matched the left table. + */ + if( pLevel->iLeftJoin ){ + pLevel->addrFirst = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin); + VdbeComment((v, "record LEFT JOIN hit")); + sqlite3ExprCacheClear(pParse); + for(pTerm=pWC->a, j=0; jnTerm; j++, pTerm++){ + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + testcase( pTerm->wtFlags & TERM_CODED ); + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( (pTerm->prereqAll & pLevel->notReady)!=0 ){ + assert( pWInfo->untestedTerms ); + continue; + } + assert( pTerm->pExpr ); + sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL); + pTerm->wtFlags |= TERM_CODED; + } + } + + return pLevel->notReady; +} + +/************** End of wherecode.c *******************************************/ +/************** Begin file whereexpr.c ***************************************/ +/* +** 2015-06-08 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This module contains C code that generates VDBE code used to process +** the WHERE clause of SQL statements. +** +** This file was originally part of where.c but was split out to improve +** readability and editabiliity. This file contains utility routines for +** analyzing Expr objects in the WHERE clause. +*/ +/* #include "sqliteInt.h" */ +/* #include "whereInt.h" */ + +/* Forward declarations */ +static void exprAnalyze(SrcList*, WhereClause*, int); + +/* +** Deallocate all memory associated with a WhereOrInfo object. +*/ +static void whereOrInfoDelete(sqlite3 *db, WhereOrInfo *p){ + sqlite3WhereClauseClear(&p->wc); + sqlite3DbFree(db, p); +} + +/* +** Deallocate all memory associated with a WhereAndInfo object. +*/ +static void whereAndInfoDelete(sqlite3 *db, WhereAndInfo *p){ + sqlite3WhereClauseClear(&p->wc); + sqlite3DbFree(db, p); +} + +/* +** Add a single new WhereTerm entry to the WhereClause object pWC. +** The new WhereTerm object is constructed from Expr p and with wtFlags. +** The index in pWC->a[] of the new WhereTerm is returned on success. +** 0 is returned if the new WhereTerm could not be added due to a memory +** allocation error. The memory allocation failure will be recorded in +** the db->mallocFailed flag so that higher-level functions can detect it. +** +** This routine will increase the size of the pWC->a[] array as necessary. +** +** If the wtFlags argument includes TERM_DYNAMIC, then responsibility +** for freeing the expression p is assumed by the WhereClause object pWC. +** This is true even if this routine fails to allocate a new WhereTerm. +** +** WARNING: This routine might reallocate the space used to store +** WhereTerms. All pointers to WhereTerms should be invalidated after +** calling this routine. Such pointers may be reinitialized by referencing +** the pWC->a[] array. +*/ +static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){ + WhereTerm *pTerm; + int idx; + testcase( wtFlags & TERM_VIRTUAL ); + if( pWC->nTerm>=pWC->nSlot ){ + WhereTerm *pOld = pWC->a; + sqlite3 *db = pWC->pWInfo->pParse->db; + pWC->a = sqlite3DbMallocRaw(db, sizeof(pWC->a[0])*pWC->nSlot*2 ); + if( pWC->a==0 ){ + if( wtFlags & TERM_DYNAMIC ){ + sqlite3ExprDelete(db, p); + } + pWC->a = pOld; + return 0; + } + memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm); + if( pOld!=pWC->aStatic ){ + sqlite3DbFree(db, pOld); + } + pWC->nSlot = sqlite3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]); + memset(&pWC->a[pWC->nTerm], 0, sizeof(pWC->a[0])*(pWC->nSlot-pWC->nTerm)); + } + pTerm = &pWC->a[idx = pWC->nTerm++]; + if( p && ExprHasProperty(p, EP_Unlikely) ){ + pTerm->truthProb = sqlite3LogEst(p->iTable) - 270; + }else{ + pTerm->truthProb = 1; + } + pTerm->pExpr = sqlite3ExprSkipCollate(p); + pTerm->wtFlags = wtFlags; + pTerm->pWC = pWC; + pTerm->iParent = -1; + return idx; +} + +/* +** Return TRUE if the given operator is one of the operators that is +** allowed for an indexable WHERE clause term. The allowed operators are +** "=", "<", ">", "<=", ">=", "IN", and "IS NULL" +*/ +static int allowedOp(int op){ + assert( TK_GT>TK_EQ && TK_GTTK_EQ && TK_LTTK_EQ && TK_LE=TK_EQ && op<=TK_GE) || op==TK_ISNULL || op==TK_IS; +} + +/* +** Commute a comparison operator. Expressions of the form "X op Y" +** are converted into "Y op X". +** +** If left/right precedence rules come into play when determining the +** collating sequence, then COLLATE operators are adjusted to ensure +** that the collating sequence does not change. For example: +** "Y collate NOCASE op X" becomes "X op Y" because any collation sequence on +** the left hand side of a comparison overrides any collation sequence +** attached to the right. For the same reason the EP_Collate flag +** is not commuted. +*/ +static void exprCommute(Parse *pParse, Expr *pExpr){ + u16 expRight = (pExpr->pRight->flags & EP_Collate); + u16 expLeft = (pExpr->pLeft->flags & EP_Collate); + assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN ); + if( expRight==expLeft ){ + /* Either X and Y both have COLLATE operator or neither do */ + if( expRight ){ + /* Both X and Y have COLLATE operators. Make sure X is always + ** used by clearing the EP_Collate flag from Y. */ + pExpr->pRight->flags &= ~EP_Collate; + }else if( sqlite3ExprCollSeq(pParse, pExpr->pLeft)!=0 ){ + /* Neither X nor Y have COLLATE operators, but X has a non-default + ** collating sequence. So add the EP_Collate marker on X to cause + ** it to be searched first. */ + pExpr->pLeft->flags |= EP_Collate; + } + } + SWAP(Expr*,pExpr->pRight,pExpr->pLeft); + if( pExpr->op>=TK_GT ){ + assert( TK_LT==TK_GT+2 ); + assert( TK_GE==TK_LE+2 ); + assert( TK_GT>TK_EQ ); + assert( TK_GTop>=TK_GT && pExpr->op<=TK_GE ); + pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT; + } +} + +/* +** Translate from TK_xx operator to WO_xx bitmask. +*/ +static u16 operatorMask(int op){ + u16 c; + assert( allowedOp(op) ); + if( op==TK_IN ){ + c = WO_IN; + }else if( op==TK_ISNULL ){ + c = WO_ISNULL; + }else if( op==TK_IS ){ + c = WO_IS; + }else{ + assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff ); + c = (u16)(WO_EQ<<(op-TK_EQ)); + } + assert( op!=TK_ISNULL || c==WO_ISNULL ); + assert( op!=TK_IN || c==WO_IN ); + assert( op!=TK_EQ || c==WO_EQ ); + assert( op!=TK_LT || c==WO_LT ); + assert( op!=TK_LE || c==WO_LE ); + assert( op!=TK_GT || c==WO_GT ); + assert( op!=TK_GE || c==WO_GE ); + assert( op!=TK_IS || c==WO_IS ); + return c; +} + + +#ifndef SQLITE_OMIT_LIKE_OPTIMIZATION +/* +** Check to see if the given expression is a LIKE or GLOB operator that +** can be optimized using inequality constraints. Return TRUE if it is +** so and false if not. +** +** In order for the operator to be optimizible, the RHS must be a string +** literal that does not begin with a wildcard. The LHS must be a column +** that may only be NULL, a string, or a BLOB, never a number. (This means +** that virtual tables cannot participate in the LIKE optimization.) The +** collating sequence for the column on the LHS must be appropriate for +** the operator. +*/ +static int isLikeOrGlob( + Parse *pParse, /* Parsing and code generating context */ + Expr *pExpr, /* Test this expression */ + Expr **ppPrefix, /* Pointer to TK_STRING expression with pattern prefix */ + int *pisComplete, /* True if the only wildcard is % in the last character */ + int *pnoCase /* True if uppercase is equivalent to lowercase */ +){ + const char *z = 0; /* String on RHS of LIKE operator */ + Expr *pRight, *pLeft; /* Right and left size of LIKE operator */ + ExprList *pList; /* List of operands to the LIKE operator */ + int c; /* One character in z[] */ + int cnt; /* Number of non-wildcard prefix characters */ + char wc[3]; /* Wildcard characters */ + sqlite3 *db = pParse->db; /* Database connection */ + sqlite3_value *pVal = 0; + int op; /* Opcode of pRight */ + + if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, wc) ){ + return 0; + } +#ifdef SQLITE_EBCDIC + if( *pnoCase ) return 0; +#endif + pList = pExpr->x.pList; + pLeft = pList->a[1].pExpr; + if( pLeft->op!=TK_COLUMN + || sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT + || IsVirtual(pLeft->pTab) /* Value might be numeric */ + ){ + /* IMP: R-02065-49465 The left-hand side of the LIKE or GLOB operator must + ** be the name of an indexed column with TEXT affinity. */ + return 0; + } + assert( pLeft->iColumn!=(-1) ); /* Because IPK never has AFF_TEXT */ + + pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr); + op = pRight->op; + if( op==TK_VARIABLE ){ + Vdbe *pReprepare = pParse->pReprepare; + int iCol = pRight->iColumn; + pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB); + if( pVal && sqlite3_value_type(pVal)==SQLITE_TEXT ){ + z = (char *)sqlite3_value_text(pVal); + } + sqlite3VdbeSetVarmask(pParse->pVdbe, iCol); + assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER ); + }else if( op==TK_STRING ){ + z = pRight->u.zToken; + } + if( z ){ + cnt = 0; + while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){ + cnt++; + } + if( cnt!=0 && 255!=(u8)z[cnt-1] ){ + Expr *pPrefix; + *pisComplete = c==wc[0] && z[cnt+1]==0; + pPrefix = sqlite3Expr(db, TK_STRING, z); + if( pPrefix ) pPrefix->u.zToken[cnt] = 0; + *ppPrefix = pPrefix; + if( op==TK_VARIABLE ){ + Vdbe *v = pParse->pVdbe; + sqlite3VdbeSetVarmask(v, pRight->iColumn); + if( *pisComplete && pRight->u.zToken[1] ){ + /* If the rhs of the LIKE expression is a variable, and the current + ** value of the variable means there is no need to invoke the LIKE + ** function, then no OP_Variable will be added to the program. + ** This causes problems for the sqlite3_bind_parameter_name() + ** API. To work around them, add a dummy OP_Variable here. + */ + int r1 = sqlite3GetTempReg(pParse); + sqlite3ExprCodeTarget(pParse, pRight, r1); + sqlite3VdbeChangeP3(v, sqlite3VdbeCurrentAddr(v)-1, 0); + sqlite3ReleaseTempReg(pParse, r1); + } + } + }else{ + z = 0; + } + } + + sqlite3ValueFree(pVal); + return (z!=0); +} +#endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */ + + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Check to see if the given expression is of the form +** +** column MATCH expr +** +** If it is then return TRUE. If not, return FALSE. +*/ +static int isMatchOfColumn( + Expr *pExpr /* Test this expression */ +){ + ExprList *pList; + + if( pExpr->op!=TK_FUNCTION ){ + return 0; + } + if( sqlite3StrICmp(pExpr->u.zToken,"match")!=0 ){ + return 0; + } + pList = pExpr->x.pList; + if( pList->nExpr!=2 ){ + return 0; + } + if( pList->a[1].pExpr->op != TK_COLUMN ){ + return 0; + } + return 1; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/* +** If the pBase expression originated in the ON or USING clause of +** a join, then transfer the appropriate markings over to derived. +*/ +static void transferJoinMarkings(Expr *pDerived, Expr *pBase){ + if( pDerived ){ + pDerived->flags |= pBase->flags & EP_FromJoin; + pDerived->iRightJoinTable = pBase->iRightJoinTable; + } +} + +/* +** Mark term iChild as being a child of term iParent +*/ +static void markTermAsChild(WhereClause *pWC, int iChild, int iParent){ + pWC->a[iChild].iParent = iParent; + pWC->a[iChild].truthProb = pWC->a[iParent].truthProb; + pWC->a[iParent].nChild++; +} + +/* +** Return the N-th AND-connected subterm of pTerm. Or if pTerm is not +** a conjunction, then return just pTerm when N==0. If N is exceeds +** the number of available subterms, return NULL. +*/ +static WhereTerm *whereNthSubterm(WhereTerm *pTerm, int N){ + if( pTerm->eOperator!=WO_AND ){ + return N==0 ? pTerm : 0; + } + if( Nu.pAndInfo->wc.nTerm ){ + return &pTerm->u.pAndInfo->wc.a[N]; + } + return 0; +} + +/* +** Subterms pOne and pTwo are contained within WHERE clause pWC. The +** two subterms are in disjunction - they are OR-ed together. +** +** If these two terms are both of the form: "A op B" with the same +** A and B values but different operators and if the operators are +** compatible (if one is = and the other is <, for example) then +** add a new virtual AND term to pWC that is the combination of the +** two. +** +** Some examples: +** +** x x<=y +** x=y OR x=y --> x=y +** x<=y OR x x<=y +** +** The following is NOT generated: +** +** xy --> x!=y +*/ +static void whereCombineDisjuncts( + SrcList *pSrc, /* the FROM clause */ + WhereClause *pWC, /* The complete WHERE clause */ + WhereTerm *pOne, /* First disjunct */ + WhereTerm *pTwo /* Second disjunct */ +){ + u16 eOp = pOne->eOperator | pTwo->eOperator; + sqlite3 *db; /* Database connection (for malloc) */ + Expr *pNew; /* New virtual expression */ + int op; /* Operator for the combined expression */ + int idxNew; /* Index in pWC of the next virtual term */ + + if( (pOne->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return; + if( (pTwo->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return; + if( (eOp & (WO_EQ|WO_LT|WO_LE))!=eOp + && (eOp & (WO_EQ|WO_GT|WO_GE))!=eOp ) return; + assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 ); + assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 ); + if( sqlite3ExprCompare(pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return; + if( sqlite3ExprCompare(pOne->pExpr->pRight, pTwo->pExpr->pRight, -1) )return; + /* If we reach this point, it means the two subterms can be combined */ + if( (eOp & (eOp-1))!=0 ){ + if( eOp & (WO_LT|WO_LE) ){ + eOp = WO_LE; + }else{ + assert( eOp & (WO_GT|WO_GE) ); + eOp = WO_GE; + } + } + db = pWC->pWInfo->pParse->db; + pNew = sqlite3ExprDup(db, pOne->pExpr, 0); + if( pNew==0 ) return; + for(op=TK_EQ; eOp!=(WO_EQ<<(op-TK_EQ)); op++){ assert( opop = op; + idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC); + exprAnalyze(pSrc, pWC, idxNew); +} + +#if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY) +/* +** Analyze a term that consists of two or more OR-connected +** subterms. So in: +** +** ... WHERE (a=5) AND (b=7 OR c=9 OR d=13) AND (d=13) +** ^^^^^^^^^^^^^^^^^^^^ +** +** This routine analyzes terms such as the middle term in the above example. +** A WhereOrTerm object is computed and attached to the term under +** analysis, regardless of the outcome of the analysis. Hence: +** +** WhereTerm.wtFlags |= TERM_ORINFO +** WhereTerm.u.pOrInfo = a dynamically allocated WhereOrTerm object +** +** The term being analyzed must have two or more of OR-connected subterms. +** A single subterm might be a set of AND-connected sub-subterms. +** Examples of terms under analysis: +** +** (A) t1.x=t2.y OR t1.x=t2.z OR t1.y=15 OR t1.z=t3.a+5 +** (B) x=expr1 OR expr2=x OR x=expr3 +** (C) t1.x=t2.y OR (t1.x=t2.z AND t1.y=15) +** (D) x=expr1 OR (y>11 AND y<22 AND z LIKE '*hello*') +** (E) (p.a=1 AND q.b=2 AND r.c=3) OR (p.x=4 AND q.y=5 AND r.z=6) +** (F) x>A OR (x=A AND y>=B) +** +** CASE 1: +** +** If all subterms are of the form T.C=expr for some single column of C and +** a single table T (as shown in example B above) then create a new virtual +** term that is an equivalent IN expression. In other words, if the term +** being analyzed is: +** +** x = expr1 OR expr2 = x OR x = expr3 +** +** then create a new virtual term like this: +** +** x IN (expr1,expr2,expr3) +** +** CASE 2: +** +** If there are exactly two disjuncts and one side has x>A and the other side +** has x=A (for the same x and A) then add a new virtual conjunct term to the +** WHERE clause of the form "x>=A". Example: +** +** x>A OR (x=A AND y>B) adds: x>=A +** +** The added conjunct can sometimes be helpful in query planning. +** +** CASE 3: +** +** If all subterms are indexable by a single table T, then set +** +** WhereTerm.eOperator = WO_OR +** WhereTerm.u.pOrInfo->indexable |= the cursor number for table T +** +** A subterm is "indexable" if it is of the form +** "T.C " where C is any column of table T and +** is one of "=", "<", "<=", ">", ">=", "IS NULL", or "IN". +** A subterm is also indexable if it is an AND of two or more +** subsubterms at least one of which is indexable. Indexable AND +** subterms have their eOperator set to WO_AND and they have +** u.pAndInfo set to a dynamically allocated WhereAndTerm object. +** +** From another point of view, "indexable" means that the subterm could +** potentially be used with an index if an appropriate index exists. +** This analysis does not consider whether or not the index exists; that +** is decided elsewhere. This analysis only looks at whether subterms +** appropriate for indexing exist. +** +** All examples A through E above satisfy case 3. But if a term +** also satisfies case 1 (such as B) we know that the optimizer will +** always prefer case 1, so in that case we pretend that case 3 is not +** satisfied. +** +** It might be the case that multiple tables are indexable. For example, +** (E) above is indexable on tables P, Q, and R. +** +** Terms that satisfy case 3 are candidates for lookup by using +** separate indices to find rowids for each subterm and composing +** the union of all rowids using a RowSet object. This is similar +** to "bitmap indices" in other database engines. +** +** OTHERWISE: +** +** If none of cases 1, 2, or 3 apply, then leave the eOperator set to +** zero. This term is not useful for search. +*/ +static void exprAnalyzeOrTerm( + SrcList *pSrc, /* the FROM clause */ + WhereClause *pWC, /* the complete WHERE clause */ + int idxTerm /* Index of the OR-term to be analyzed */ +){ + WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */ + Parse *pParse = pWInfo->pParse; /* Parser context */ + sqlite3 *db = pParse->db; /* Database connection */ + WhereTerm *pTerm = &pWC->a[idxTerm]; /* The term to be analyzed */ + Expr *pExpr = pTerm->pExpr; /* The expression of the term */ + int i; /* Loop counters */ + WhereClause *pOrWc; /* Breakup of pTerm into subterms */ + WhereTerm *pOrTerm; /* A Sub-term within the pOrWc */ + WhereOrInfo *pOrInfo; /* Additional information associated with pTerm */ + Bitmask chngToIN; /* Tables that might satisfy case 1 */ + Bitmask indexable; /* Tables that are indexable, satisfying case 2 */ + + /* + ** Break the OR clause into its separate subterms. The subterms are + ** stored in a WhereClause structure containing within the WhereOrInfo + ** object that is attached to the original OR clause term. + */ + assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 ); + assert( pExpr->op==TK_OR ); + pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo)); + if( pOrInfo==0 ) return; + pTerm->wtFlags |= TERM_ORINFO; + pOrWc = &pOrInfo->wc; + sqlite3WhereClauseInit(pOrWc, pWInfo); + sqlite3WhereSplit(pOrWc, pExpr, TK_OR); + sqlite3WhereExprAnalyze(pSrc, pOrWc); + if( db->mallocFailed ) return; + assert( pOrWc->nTerm>=2 ); + + /* + ** Compute the set of tables that might satisfy cases 1 or 3. + */ + indexable = ~(Bitmask)0; + chngToIN = ~(Bitmask)0; + for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0 && indexable; i--, pOrTerm++){ + if( (pOrTerm->eOperator & WO_SINGLE)==0 ){ + WhereAndInfo *pAndInfo; + assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 ); + chngToIN = 0; + pAndInfo = sqlite3DbMallocRaw(db, sizeof(*pAndInfo)); + if( pAndInfo ){ + WhereClause *pAndWC; + WhereTerm *pAndTerm; + int j; + Bitmask b = 0; + pOrTerm->u.pAndInfo = pAndInfo; + pOrTerm->wtFlags |= TERM_ANDINFO; + pOrTerm->eOperator = WO_AND; + pAndWC = &pAndInfo->wc; + sqlite3WhereClauseInit(pAndWC, pWC->pWInfo); + sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND); + sqlite3WhereExprAnalyze(pSrc, pAndWC); + pAndWC->pOuter = pWC; + testcase( db->mallocFailed ); + if( !db->mallocFailed ){ + for(j=0, pAndTerm=pAndWC->a; jnTerm; j++, pAndTerm++){ + assert( pAndTerm->pExpr ); + if( allowedOp(pAndTerm->pExpr->op) ){ + b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pAndTerm->leftCursor); + } + } + } + indexable &= b; + } + }else if( pOrTerm->wtFlags & TERM_COPIED ){ + /* Skip this term for now. We revisit it when we process the + ** corresponding TERM_VIRTUAL term */ + }else{ + Bitmask b; + b = sqlite3WhereGetMask(&pWInfo->sMaskSet, pOrTerm->leftCursor); + if( pOrTerm->wtFlags & TERM_VIRTUAL ){ + WhereTerm *pOther = &pOrWc->a[pOrTerm->iParent]; + b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pOther->leftCursor); + } + indexable &= b; + if( (pOrTerm->eOperator & WO_EQ)==0 ){ + chngToIN = 0; + }else{ + chngToIN &= b; + } + } + } + + /* + ** Record the set of tables that satisfy case 3. The set might be + ** empty. + */ + pOrInfo->indexable = indexable; + pTerm->eOperator = indexable==0 ? 0 : WO_OR; + + /* For a two-way OR, attempt to implementation case 2. + */ + if( indexable && pOrWc->nTerm==2 ){ + int iOne = 0; + WhereTerm *pOne; + while( (pOne = whereNthSubterm(&pOrWc->a[0],iOne++))!=0 ){ + int iTwo = 0; + WhereTerm *pTwo; + while( (pTwo = whereNthSubterm(&pOrWc->a[1],iTwo++))!=0 ){ + whereCombineDisjuncts(pSrc, pWC, pOne, pTwo); + } + } + } + + /* + ** chngToIN holds a set of tables that *might* satisfy case 1. But + ** we have to do some additional checking to see if case 1 really + ** is satisfied. + ** + ** chngToIN will hold either 0, 1, or 2 bits. The 0-bit case means + ** that there is no possibility of transforming the OR clause into an + ** IN operator because one or more terms in the OR clause contain + ** something other than == on a column in the single table. The 1-bit + ** case means that every term of the OR clause is of the form + ** "table.column=expr" for some single table. The one bit that is set + ** will correspond to the common table. We still need to check to make + ** sure the same column is used on all terms. The 2-bit case is when + ** the all terms are of the form "table1.column=table2.column". It + ** might be possible to form an IN operator with either table1.column + ** or table2.column as the LHS if either is common to every term of + ** the OR clause. + ** + ** Note that terms of the form "table.column1=table.column2" (the + ** same table on both sizes of the ==) cannot be optimized. + */ + if( chngToIN ){ + int okToChngToIN = 0; /* True if the conversion to IN is valid */ + int iColumn = -1; /* Column index on lhs of IN operator */ + int iCursor = -1; /* Table cursor common to all terms */ + int j = 0; /* Loop counter */ + + /* Search for a table and column that appears on one side or the + ** other of the == operator in every subterm. That table and column + ** will be recorded in iCursor and iColumn. There might not be any + ** such table and column. Set okToChngToIN if an appropriate table + ** and column is found but leave okToChngToIN false if not found. + */ + for(j=0; j<2 && !okToChngToIN; j++){ + pOrTerm = pOrWc->a; + for(i=pOrWc->nTerm-1; i>=0; i--, pOrTerm++){ + assert( pOrTerm->eOperator & WO_EQ ); + pOrTerm->wtFlags &= ~TERM_OR_OK; + if( pOrTerm->leftCursor==iCursor ){ + /* This is the 2-bit case and we are on the second iteration and + ** current term is from the first iteration. So skip this term. */ + assert( j==1 ); + continue; + } + if( (chngToIN & sqlite3WhereGetMask(&pWInfo->sMaskSet, + pOrTerm->leftCursor))==0 ){ + /* This term must be of the form t1.a==t2.b where t2 is in the + ** chngToIN set but t1 is not. This term will be either preceded + ** or follwed by an inverted copy (t2.b==t1.a). Skip this term + ** and use its inversion. */ + testcase( pOrTerm->wtFlags & TERM_COPIED ); + testcase( pOrTerm->wtFlags & TERM_VIRTUAL ); + assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) ); + continue; + } + iColumn = pOrTerm->u.leftColumn; + iCursor = pOrTerm->leftCursor; + break; + } + if( i<0 ){ + /* No candidate table+column was found. This can only occur + ** on the second iteration */ + assert( j==1 ); + assert( IsPowerOfTwo(chngToIN) ); + assert( chngToIN==sqlite3WhereGetMask(&pWInfo->sMaskSet, iCursor) ); + break; + } + testcase( j==1 ); + + /* We have found a candidate table and column. Check to see if that + ** table and column is common to every term in the OR clause */ + okToChngToIN = 1; + for(; i>=0 && okToChngToIN; i--, pOrTerm++){ + assert( pOrTerm->eOperator & WO_EQ ); + if( pOrTerm->leftCursor!=iCursor ){ + pOrTerm->wtFlags &= ~TERM_OR_OK; + }else if( pOrTerm->u.leftColumn!=iColumn ){ + okToChngToIN = 0; + }else{ + int affLeft, affRight; + /* If the right-hand side is also a column, then the affinities + ** of both right and left sides must be such that no type + ** conversions are required on the right. (Ticket #2249) + */ + affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight); + affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft); + if( affRight!=0 && affRight!=affLeft ){ + okToChngToIN = 0; + }else{ + pOrTerm->wtFlags |= TERM_OR_OK; + } + } + } + } + + /* At this point, okToChngToIN is true if original pTerm satisfies + ** case 1. In that case, construct a new virtual term that is + ** pTerm converted into an IN operator. + */ + if( okToChngToIN ){ + Expr *pDup; /* A transient duplicate expression */ + ExprList *pList = 0; /* The RHS of the IN operator */ + Expr *pLeft = 0; /* The LHS of the IN operator */ + Expr *pNew; /* The complete IN operator */ + + for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){ + if( (pOrTerm->wtFlags & TERM_OR_OK)==0 ) continue; + assert( pOrTerm->eOperator & WO_EQ ); + assert( pOrTerm->leftCursor==iCursor ); + assert( pOrTerm->u.leftColumn==iColumn ); + pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0); + pList = sqlite3ExprListAppend(pWInfo->pParse, pList, pDup); + pLeft = pOrTerm->pExpr->pLeft; + } + assert( pLeft!=0 ); + pDup = sqlite3ExprDup(db, pLeft, 0); + pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0, 0); + if( pNew ){ + int idxNew; + transferJoinMarkings(pNew, pExpr); + assert( !ExprHasProperty(pNew, EP_xIsSelect) ); + pNew->x.pList = pList; + idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC); + testcase( idxNew==0 ); + exprAnalyze(pSrc, pWC, idxNew); + pTerm = &pWC->a[idxTerm]; + markTermAsChild(pWC, idxNew, idxTerm); + }else{ + sqlite3ExprListDelete(db, pList); + } + pTerm->eOperator = WO_NOOP; /* case 1 trumps case 3 */ + } + } +} +#endif /* !SQLITE_OMIT_OR_OPTIMIZATION && !SQLITE_OMIT_SUBQUERY */ + +/* +** We already know that pExpr is a binary operator where both operands are +** column references. This routine checks to see if pExpr is an equivalence +** relation: +** 1. The SQLITE_Transitive optimization must be enabled +** 2. Must be either an == or an IS operator +** 3. Not originating in the ON clause of an OUTER JOIN +** 4. The affinities of A and B must be compatible +** 5a. Both operands use the same collating sequence OR +** 5b. The overall collating sequence is BINARY +** If this routine returns TRUE, that means that the RHS can be substituted +** for the LHS anyplace else in the WHERE clause where the LHS column occurs. +** This is an optimization. No harm comes from returning 0. But if 1 is +** returned when it should not be, then incorrect answers might result. +*/ +static int termIsEquivalence(Parse *pParse, Expr *pExpr){ + char aff1, aff2; + CollSeq *pColl; + const char *zColl1, *zColl2; + if( !OptimizationEnabled(pParse->db, SQLITE_Transitive) ) return 0; + if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0; + if( ExprHasProperty(pExpr, EP_FromJoin) ) return 0; + aff1 = sqlite3ExprAffinity(pExpr->pLeft); + aff2 = sqlite3ExprAffinity(pExpr->pRight); + if( aff1!=aff2 + && (!sqlite3IsNumericAffinity(aff1) || !sqlite3IsNumericAffinity(aff2)) + ){ + return 0; + } + pColl = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight); + if( pColl==0 || sqlite3StrICmp(pColl->zName, "BINARY")==0 ) return 1; + pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft); + /* Since pLeft and pRight are both a column references, their collating + ** sequence should always be defined. */ + zColl1 = ALWAYS(pColl) ? pColl->zName : 0; + pColl = sqlite3ExprCollSeq(pParse, pExpr->pRight); + zColl2 = ALWAYS(pColl) ? pColl->zName : 0; + return sqlite3StrICmp(zColl1, zColl2)==0; +} + +/* +** Recursively walk the expressions of a SELECT statement and generate +** a bitmask indicating which tables are used in that expression +** tree. +*/ +static Bitmask exprSelectUsage(WhereMaskSet *pMaskSet, Select *pS){ + Bitmask mask = 0; + while( pS ){ + SrcList *pSrc = pS->pSrc; + mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pEList); + mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pGroupBy); + mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pOrderBy); + mask |= sqlite3WhereExprUsage(pMaskSet, pS->pWhere); + mask |= sqlite3WhereExprUsage(pMaskSet, pS->pHaving); + if( ALWAYS(pSrc!=0) ){ + int i; + for(i=0; inSrc; i++){ + mask |= exprSelectUsage(pMaskSet, pSrc->a[i].pSelect); + mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].pOn); + } + } + pS = pS->pPrior; + } + return mask; +} + +/* +** Expression pExpr is one operand of a comparison operator that might +** be useful for indexing. This routine checks to see if pExpr appears +** in any index. Return TRUE (1) if pExpr is an indexed term and return +** FALSE (0) if not. If TRUE is returned, also set *piCur to the cursor +** number of the table that is indexed and *piColumn to the column number +** of the column that is indexed, or -2 if an expression is being indexed. +** +** If pExpr is a TK_COLUMN column reference, then this routine always returns +** true even if that particular column is not indexed, because the column +** might be added to an automatic index later. +*/ +static int exprMightBeIndexed( + SrcList *pFrom, /* The FROM clause */ + Bitmask mPrereq, /* Bitmask of FROM clause terms referenced by pExpr */ + Expr *pExpr, /* An operand of a comparison operator */ + int *piCur, /* Write the referenced table cursor number here */ + int *piColumn /* Write the referenced table column number here */ +){ + Index *pIdx; + int i; + int iCur; + if( pExpr->op==TK_COLUMN ){ + *piCur = pExpr->iTable; + *piColumn = pExpr->iColumn; + return 1; + } + if( mPrereq==0 ) return 0; /* No table references */ + if( (mPrereq&(mPrereq-1))!=0 ) return 0; /* Refs more than one table */ + for(i=0; mPrereq>1; i++, mPrereq>>=1){} + iCur = pFrom->a[i].iCursor; + for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->aColExpr==0 ) continue; + for(i=0; inKeyCol; i++){ + if( pIdx->aiColumn[i]!=(-2) ) continue; + if( sqlite3ExprCompare(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){ + *piCur = iCur; + *piColumn = -2; + return 1; + } + } + } + return 0; +} + +/* +** The input to this routine is an WhereTerm structure with only the +** "pExpr" field filled in. The job of this routine is to analyze the +** subexpression and populate all the other fields of the WhereTerm +** structure. +** +** If the expression is of the form " X" it gets commuted +** to the standard form of "X ". +** +** If the expression is of the form "X Y" where both X and Y are +** columns, then the original expression is unchanged and a new virtual +** term of the form "Y X" is added to the WHERE clause and +** analyzed separately. The original term is marked with TERM_COPIED +** and the new term is marked with TERM_DYNAMIC (because it's pExpr +** needs to be freed with the WhereClause) and TERM_VIRTUAL (because it +** is a commuted copy of a prior term.) The original term has nChild=1 +** and the copy has idxParent set to the index of the original term. +*/ +static void exprAnalyze( + SrcList *pSrc, /* the FROM clause */ + WhereClause *pWC, /* the WHERE clause */ + int idxTerm /* Index of the term to be analyzed */ +){ + WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */ + WhereTerm *pTerm; /* The term to be analyzed */ + WhereMaskSet *pMaskSet; /* Set of table index masks */ + Expr *pExpr; /* The expression to be analyzed */ + Bitmask prereqLeft; /* Prerequesites of the pExpr->pLeft */ + Bitmask prereqAll; /* Prerequesites of pExpr */ + Bitmask extraRight = 0; /* Extra dependencies on LEFT JOIN */ + Expr *pStr1 = 0; /* RHS of LIKE/GLOB operator */ + int isComplete = 0; /* RHS of LIKE/GLOB ends with wildcard */ + int noCase = 0; /* uppercase equivalent to lowercase */ + int op; /* Top-level operator. pExpr->op */ + Parse *pParse = pWInfo->pParse; /* Parsing context */ + sqlite3 *db = pParse->db; /* Database connection */ + + if( db->mallocFailed ){ + return; + } + pTerm = &pWC->a[idxTerm]; + pMaskSet = &pWInfo->sMaskSet; + pExpr = pTerm->pExpr; + assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE ); + prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft); + op = pExpr->op; + if( op==TK_IN ){ + assert( pExpr->pRight==0 ); + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect); + }else{ + pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList); + } + }else if( op==TK_ISNULL ){ + pTerm->prereqRight = 0; + }else{ + pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight); + } + prereqAll = sqlite3WhereExprUsage(pMaskSet, pExpr); + if( ExprHasProperty(pExpr, EP_FromJoin) ){ + Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->iRightJoinTable); + prereqAll |= x; + extraRight = x-1; /* ON clause terms may not be used with an index + ** on left table of a LEFT JOIN. Ticket #3015 */ + } + pTerm->prereqAll = prereqAll; + pTerm->leftCursor = -1; + pTerm->iParent = -1; + pTerm->eOperator = 0; + if( allowedOp(op) ){ + int iCur, iColumn; + Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft); + Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight); + u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV; + if( exprMightBeIndexed(pSrc, prereqLeft, pLeft, &iCur, &iColumn) ){ + pTerm->leftCursor = iCur; + pTerm->u.leftColumn = iColumn; + pTerm->eOperator = operatorMask(op) & opMask; + } + if( op==TK_IS ) pTerm->wtFlags |= TERM_IS; + if( pRight + && exprMightBeIndexed(pSrc, pTerm->prereqRight, pRight, &iCur, &iColumn) + ){ + WhereTerm *pNew; + Expr *pDup; + u16 eExtraOp = 0; /* Extra bits for pNew->eOperator */ + if( pTerm->leftCursor>=0 ){ + int idxNew; + pDup = sqlite3ExprDup(db, pExpr, 0); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDup); + return; + } + idxNew = whereClauseInsert(pWC, pDup, TERM_VIRTUAL|TERM_DYNAMIC); + if( idxNew==0 ) return; + pNew = &pWC->a[idxNew]; + markTermAsChild(pWC, idxNew, idxTerm); + if( op==TK_IS ) pNew->wtFlags |= TERM_IS; + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + + if( termIsEquivalence(pParse, pDup) ){ + pTerm->eOperator |= WO_EQUIV; + eExtraOp = WO_EQUIV; + } + }else{ + pDup = pExpr; + pNew = pTerm; + } + exprCommute(pParse, pDup); + pNew->leftCursor = iCur; + pNew->u.leftColumn = iColumn; + testcase( (prereqLeft | extraRight) != prereqLeft ); + pNew->prereqRight = prereqLeft | extraRight; + pNew->prereqAll = prereqAll; + pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask; + } + } + +#ifndef SQLITE_OMIT_BETWEEN_OPTIMIZATION + /* If a term is the BETWEEN operator, create two new virtual terms + ** that define the range that the BETWEEN implements. For example: + ** + ** a BETWEEN b AND c + ** + ** is converted into: + ** + ** (a BETWEEN b AND c) AND (a>=b) AND (a<=c) + ** + ** The two new terms are added onto the end of the WhereClause object. + ** The new terms are "dynamic" and are children of the original BETWEEN + ** term. That means that if the BETWEEN term is coded, the children are + ** skipped. Or, if the children are satisfied by an index, the original + ** BETWEEN term is skipped. + */ + else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){ + ExprList *pList = pExpr->x.pList; + int i; + static const u8 ops[] = {TK_GE, TK_LE}; + assert( pList!=0 ); + assert( pList->nExpr==2 ); + for(i=0; i<2; i++){ + Expr *pNewExpr; + int idxNew; + pNewExpr = sqlite3PExpr(pParse, ops[i], + sqlite3ExprDup(db, pExpr->pLeft, 0), + sqlite3ExprDup(db, pList->a[i].pExpr, 0), 0); + transferJoinMarkings(pNewExpr, pExpr); + idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC); + testcase( idxNew==0 ); + exprAnalyze(pSrc, pWC, idxNew); + pTerm = &pWC->a[idxTerm]; + markTermAsChild(pWC, idxNew, idxTerm); + } + } +#endif /* SQLITE_OMIT_BETWEEN_OPTIMIZATION */ + +#if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY) + /* Analyze a term that is composed of two or more subterms connected by + ** an OR operator. + */ + else if( pExpr->op==TK_OR ){ + assert( pWC->op==TK_AND ); + exprAnalyzeOrTerm(pSrc, pWC, idxTerm); + pTerm = &pWC->a[idxTerm]; + } +#endif /* SQLITE_OMIT_OR_OPTIMIZATION */ + +#ifndef SQLITE_OMIT_LIKE_OPTIMIZATION + /* Add constraints to reduce the search space on a LIKE or GLOB + ** operator. + ** + ** A like pattern of the form "x LIKE 'aBc%'" is changed into constraints + ** + ** x>='ABC' AND x<'abd' AND x LIKE 'aBc%' + ** + ** The last character of the prefix "abc" is incremented to form the + ** termination condition "abd". If case is not significant (the default + ** for LIKE) then the lower-bound is made all uppercase and the upper- + ** bound is made all lowercase so that the bounds also work when comparing + ** BLOBs. + */ + if( pWC->op==TK_AND + && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase) + ){ + Expr *pLeft; /* LHS of LIKE/GLOB operator */ + Expr *pStr2; /* Copy of pStr1 - RHS of LIKE/GLOB operator */ + Expr *pNewExpr1; + Expr *pNewExpr2; + int idxNew1; + int idxNew2; + const char *zCollSeqName; /* Name of collating sequence */ + const u16 wtFlags = TERM_LIKEOPT | TERM_VIRTUAL | TERM_DYNAMIC; + + pLeft = pExpr->x.pList->a[1].pExpr; + pStr2 = sqlite3ExprDup(db, pStr1, 0); + + /* Convert the lower bound to upper-case and the upper bound to + ** lower-case (upper-case is less than lower-case in ASCII) so that + ** the range constraints also work for BLOBs + */ + if( noCase && !pParse->db->mallocFailed ){ + int i; + char c; + pTerm->wtFlags |= TERM_LIKE; + for(i=0; (c = pStr1->u.zToken[i])!=0; i++){ + pStr1->u.zToken[i] = sqlite3Toupper(c); + pStr2->u.zToken[i] = sqlite3Tolower(c); + } + } + + if( !db->mallocFailed ){ + u8 c, *pC; /* Last character before the first wildcard */ + pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1]; + c = *pC; + if( noCase ){ + /* The point is to increment the last character before the first + ** wildcard. But if we increment '@', that will push it into the + ** alphabetic range where case conversions will mess up the + ** inequality. To avoid this, make sure to also run the full + ** LIKE on all candidate expressions by clearing the isComplete flag + */ + if( c=='A'-1 ) isComplete = 0; + c = sqlite3UpperToLower[c]; + } + *pC = c + 1; + } + zCollSeqName = noCase ? "NOCASE" : "BINARY"; + pNewExpr1 = sqlite3ExprDup(db, pLeft, 0); + pNewExpr1 = sqlite3PExpr(pParse, TK_GE, + sqlite3ExprAddCollateString(pParse,pNewExpr1,zCollSeqName), + pStr1, 0); + transferJoinMarkings(pNewExpr1, pExpr); + idxNew1 = whereClauseInsert(pWC, pNewExpr1, wtFlags); + testcase( idxNew1==0 ); + exprAnalyze(pSrc, pWC, idxNew1); + pNewExpr2 = sqlite3ExprDup(db, pLeft, 0); + pNewExpr2 = sqlite3PExpr(pParse, TK_LT, + sqlite3ExprAddCollateString(pParse,pNewExpr2,zCollSeqName), + pStr2, 0); + transferJoinMarkings(pNewExpr2, pExpr); + idxNew2 = whereClauseInsert(pWC, pNewExpr2, wtFlags); + testcase( idxNew2==0 ); + exprAnalyze(pSrc, pWC, idxNew2); + pTerm = &pWC->a[idxTerm]; + if( isComplete ){ + markTermAsChild(pWC, idxNew1, idxTerm); + markTermAsChild(pWC, idxNew2, idxTerm); + } + } +#endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Add a WO_MATCH auxiliary term to the constraint set if the + ** current expression is of the form: column MATCH expr. + ** This information is used by the xBestIndex methods of + ** virtual tables. The native query optimizer does not attempt + ** to do anything with MATCH functions. + */ + if( isMatchOfColumn(pExpr) ){ + int idxNew; + Expr *pRight, *pLeft; + WhereTerm *pNewTerm; + Bitmask prereqColumn, prereqExpr; + + pRight = pExpr->x.pList->a[0].pExpr; + pLeft = pExpr->x.pList->a[1].pExpr; + prereqExpr = sqlite3WhereExprUsage(pMaskSet, pRight); + prereqColumn = sqlite3WhereExprUsage(pMaskSet, pLeft); + if( (prereqExpr & prereqColumn)==0 ){ + Expr *pNewExpr; + pNewExpr = sqlite3PExpr(pParse, TK_MATCH, + 0, sqlite3ExprDup(db, pRight, 0), 0); + idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC); + testcase( idxNew==0 ); + pNewTerm = &pWC->a[idxNew]; + pNewTerm->prereqRight = prereqExpr; + pNewTerm->leftCursor = pLeft->iTable; + pNewTerm->u.leftColumn = pLeft->iColumn; + pNewTerm->eOperator = WO_MATCH; + markTermAsChild(pWC, idxNew, idxTerm); + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + pNewTerm->prereqAll = pTerm->prereqAll; + } + } +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + /* When sqlite_stat3 histogram data is available an operator of the + ** form "x IS NOT NULL" can sometimes be evaluated more efficiently + ** as "x>NULL" if x is not an INTEGER PRIMARY KEY. So construct a + ** virtual term of that form. + ** + ** Note that the virtual term must be tagged with TERM_VNULL. + */ + if( pExpr->op==TK_NOTNULL + && pExpr->pLeft->op==TK_COLUMN + && pExpr->pLeft->iColumn>=0 + && OptimizationEnabled(db, SQLITE_Stat34) + ){ + Expr *pNewExpr; + Expr *pLeft = pExpr->pLeft; + int idxNew; + WhereTerm *pNewTerm; + + pNewExpr = sqlite3PExpr(pParse, TK_GT, + sqlite3ExprDup(db, pLeft, 0), + sqlite3PExpr(pParse, TK_NULL, 0, 0, 0), 0); + + idxNew = whereClauseInsert(pWC, pNewExpr, + TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL); + if( idxNew ){ + pNewTerm = &pWC->a[idxNew]; + pNewTerm->prereqRight = 0; + pNewTerm->leftCursor = pLeft->iTable; + pNewTerm->u.leftColumn = pLeft->iColumn; + pNewTerm->eOperator = WO_GT; + markTermAsChild(pWC, idxNew, idxTerm); + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + pNewTerm->prereqAll = pTerm->prereqAll; + } + } +#endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */ + + /* Prevent ON clause terms of a LEFT JOIN from being used to drive + ** an index for tables to the left of the join. + */ + pTerm->prereqRight |= extraRight; +} + +/*************************************************************************** +** Routines with file scope above. Interface to the rest of the where.c +** subsystem follows. +***************************************************************************/ + +/* +** This routine identifies subexpressions in the WHERE clause where +** each subexpression is separated by the AND operator or some other +** operator specified in the op parameter. The WhereClause structure +** is filled with pointers to subexpressions. For example: +** +** WHERE a=='hello' AND coalesce(b,11)<10 AND (c+12!=d OR c==22) +** \________/ \_______________/ \________________/ +** slot[0] slot[1] slot[2] +** +** The original WHERE clause in pExpr is unaltered. All this routine +** does is make slot[] entries point to substructure within pExpr. +** +** In the previous sentence and in the diagram, "slot[]" refers to +** the WhereClause.a[] array. The slot[] array grows as needed to contain +** all terms of the WHERE clause. +*/ +SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){ + Expr *pE2 = sqlite3ExprSkipCollate(pExpr); + pWC->op = op; + if( pE2==0 ) return; + if( pE2->op!=op ){ + whereClauseInsert(pWC, pExpr, 0); + }else{ + sqlite3WhereSplit(pWC, pE2->pLeft, op); + sqlite3WhereSplit(pWC, pE2->pRight, op); + } +} + +/* +** Initialize a preallocated WhereClause structure. +*/ +SQLITE_PRIVATE void sqlite3WhereClauseInit( + WhereClause *pWC, /* The WhereClause to be initialized */ + WhereInfo *pWInfo /* The WHERE processing context */ +){ + pWC->pWInfo = pWInfo; + pWC->pOuter = 0; + pWC->nTerm = 0; + pWC->nSlot = ArraySize(pWC->aStatic); + pWC->a = pWC->aStatic; +} + +/* +** Deallocate a WhereClause structure. The WhereClause structure +** itself is not freed. This routine is the inverse of sqlite3WhereClauseInit(). +*/ +SQLITE_PRIVATE void sqlite3WhereClauseClear(WhereClause *pWC){ + int i; + WhereTerm *a; + sqlite3 *db = pWC->pWInfo->pParse->db; + for(i=pWC->nTerm-1, a=pWC->a; i>=0; i--, a++){ + if( a->wtFlags & TERM_DYNAMIC ){ + sqlite3ExprDelete(db, a->pExpr); + } + if( a->wtFlags & TERM_ORINFO ){ + whereOrInfoDelete(db, a->u.pOrInfo); + }else if( a->wtFlags & TERM_ANDINFO ){ + whereAndInfoDelete(db, a->u.pAndInfo); + } + } + if( pWC->a!=pWC->aStatic ){ + sqlite3DbFree(db, pWC->a); + } +} + + +/* +** These routines walk (recursively) an expression tree and generate +** a bitmask indicating which tables are used in that expression +** tree. +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet *pMaskSet, Expr *p){ + Bitmask mask = 0; + if( p==0 ) return 0; + if( p->op==TK_COLUMN ){ + mask = sqlite3WhereGetMask(pMaskSet, p->iTable); + return mask; + } + mask = sqlite3WhereExprUsage(pMaskSet, p->pRight); + mask |= sqlite3WhereExprUsage(pMaskSet, p->pLeft); + if( ExprHasProperty(p, EP_xIsSelect) ){ + mask |= exprSelectUsage(pMaskSet, p->x.pSelect); + }else{ + mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList); + } + return mask; +} +SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet *pMaskSet, ExprList *pList){ + int i; + Bitmask mask = 0; + if( pList ){ + for(i=0; inExpr; i++){ + mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr); + } + } + return mask; +} + + +/* +** Call exprAnalyze on all terms in a WHERE clause. +** +** Note that exprAnalyze() might add new virtual terms onto the +** end of the WHERE clause. We do not want to analyze these new +** virtual terms, so start analyzing at the end and work forward +** so that the added virtual terms are never processed. +*/ +SQLITE_PRIVATE void sqlite3WhereExprAnalyze( + SrcList *pTabList, /* the FROM clause */ + WhereClause *pWC /* the WHERE clause to be analyzed */ +){ + int i; + for(i=pWC->nTerm-1; i>=0; i--){ + exprAnalyze(pTabList, pWC, i); + } +} + +/* +** For table-valued-functions, transform the function arguments into +** new WHERE clause terms. +** +** Each function argument translates into an equality constraint against +** a HIDDEN column in the table. +*/ +SQLITE_PRIVATE void sqlite3WhereTabFuncArgs( + Parse *pParse, /* Parsing context */ + struct SrcList_item *pItem, /* The FROM clause term to process */ + WhereClause *pWC /* Xfer function arguments to here */ +){ + Table *pTab; + int j, k; + ExprList *pArgs; + Expr *pColRef; + Expr *pTerm; + if( pItem->fg.isTabFunc==0 ) return; + pTab = pItem->pTab; + assert( pTab!=0 ); + pArgs = pItem->u1.pFuncArg; + assert( pArgs!=0 ); + for(j=k=0; jnExpr; j++){ + while( knCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){ k++; } + if( k>=pTab->nCol ){ + sqlite3ErrorMsg(pParse, "too many arguments on %s() - max %d", + pTab->zName, j); + return; + } + pColRef = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0); + if( pColRef==0 ) return; + pColRef->iTable = pItem->iCursor; + pColRef->iColumn = k++; + pColRef->pTab = pTab; + pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, + sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0); + whereClauseInsert(pWC, pTerm, TERM_DYNAMIC); + } +} + +/************** End of whereexpr.c *******************************************/ +/************** Begin file where.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This module contains C code that generates VDBE code used to process +** the WHERE clause of SQL statements. This module is responsible for +** generating the code that loops through a table looking for applicable +** rows. Indices are selected and used to speed the search when doing +** so is applicable. Because this module is responsible for selecting +** indices, you might also think of this module as the "query optimizer". +*/ +/* #include "sqliteInt.h" */ +/* #include "whereInt.h" */ + +/* Forward declaration of methods */ +static int whereLoopResize(sqlite3*, WhereLoop*, int); + +/* Test variable that can be set to enable WHERE tracing */ +#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) +/***/ int sqlite3WhereTrace = 0; +#endif + + +/* +** Return the estimated number of output rows from a WHERE clause +*/ +SQLITE_PRIVATE u64 sqlite3WhereOutputRowCount(WhereInfo *pWInfo){ + return sqlite3LogEstToInt(pWInfo->nRowOut); +} + +/* +** Return one of the WHERE_DISTINCT_xxxxx values to indicate how this +** WHERE clause returns outputs for DISTINCT processing. +*/ +SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo *pWInfo){ + return pWInfo->eDistinct; +} + +/* +** Return TRUE if the WHERE clause returns rows in ORDER BY order. +** Return FALSE if the output needs to be sorted. +*/ +SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo *pWInfo){ + return pWInfo->nOBSat; +} + +/* +** Return the VDBE address or label to jump to in order to continue +** immediately with the next row of a WHERE clause. +*/ +SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo *pWInfo){ + assert( pWInfo->iContinue!=0 ); + return pWInfo->iContinue; +} + +/* +** Return the VDBE address or label to jump to in order to break +** out of a WHERE loop. +*/ +SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo *pWInfo){ + return pWInfo->iBreak; +} + +/* +** Return ONEPASS_OFF (0) if an UPDATE or DELETE statement is unable to +** operate directly on the rowis returned by a WHERE clause. Return +** ONEPASS_SINGLE (1) if the statement can operation directly because only +** a single row is to be changed. Return ONEPASS_MULTI (2) if the one-pass +** optimization can be used on multiple +** +** If the ONEPASS optimization is used (if this routine returns true) +** then also write the indices of open cursors used by ONEPASS +** into aiCur[0] and aiCur[1]. iaCur[0] gets the cursor of the data +** table and iaCur[1] gets the cursor used by an auxiliary index. +** Either value may be -1, indicating that cursor is not used. +** Any cursors returned will have been opened for writing. +** +** aiCur[0] and aiCur[1] both get -1 if the where-clause logic is +** unable to use the ONEPASS optimization. +*/ +SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo *pWInfo, int *aiCur){ + memcpy(aiCur, pWInfo->aiCurOnePass, sizeof(int)*2); +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace && pWInfo->eOnePass!=ONEPASS_OFF ){ + sqlite3DebugPrintf("%s cursors: %d %d\n", + pWInfo->eOnePass==ONEPASS_SINGLE ? "ONEPASS_SINGLE" : "ONEPASS_MULTI", + aiCur[0], aiCur[1]); + } +#endif + return pWInfo->eOnePass; +} + +/* +** Move the content of pSrc into pDest +*/ +static void whereOrMove(WhereOrSet *pDest, WhereOrSet *pSrc){ + pDest->n = pSrc->n; + memcpy(pDest->a, pSrc->a, pDest->n*sizeof(pDest->a[0])); +} + +/* +** Try to insert a new prerequisite/cost entry into the WhereOrSet pSet. +** +** The new entry might overwrite an existing entry, or it might be +** appended, or it might be discarded. Do whatever is the right thing +** so that pSet keeps the N_OR_COST best entries seen so far. +*/ +static int whereOrInsert( + WhereOrSet *pSet, /* The WhereOrSet to be updated */ + Bitmask prereq, /* Prerequisites of the new entry */ + LogEst rRun, /* Run-cost of the new entry */ + LogEst nOut /* Number of outputs for the new entry */ +){ + u16 i; + WhereOrCost *p; + for(i=pSet->n, p=pSet->a; i>0; i--, p++){ + if( rRun<=p->rRun && (prereq & p->prereq)==prereq ){ + goto whereOrInsert_done; + } + if( p->rRun<=rRun && (p->prereq & prereq)==p->prereq ){ + return 0; + } + } + if( pSet->na[pSet->n++]; + p->nOut = nOut; + }else{ + p = pSet->a; + for(i=1; in; i++){ + if( p->rRun>pSet->a[i].rRun ) p = pSet->a + i; + } + if( p->rRun<=rRun ) return 0; + } +whereOrInsert_done: + p->prereq = prereq; + p->rRun = rRun; + if( p->nOut>nOut ) p->nOut = nOut; + return 1; +} + +/* +** Return the bitmask for the given cursor number. Return 0 if +** iCursor is not in the set. +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereGetMask(WhereMaskSet *pMaskSet, int iCursor){ + int i; + assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 ); + for(i=0; in; i++){ + if( pMaskSet->ix[i]==iCursor ){ + return MASKBIT(i); + } + } + return 0; +} + +/* +** Create a new mask for cursor iCursor. +** +** There is one cursor per table in the FROM clause. The number of +** tables in the FROM clause is limited by a test early in the +** sqlite3WhereBegin() routine. So we know that the pMaskSet->ix[] +** array will never overflow. +*/ +static void createMask(WhereMaskSet *pMaskSet, int iCursor){ + assert( pMaskSet->n < ArraySize(pMaskSet->ix) ); + pMaskSet->ix[pMaskSet->n++] = iCursor; +} + +/* +** Advance to the next WhereTerm that matches according to the criteria +** established when the pScan object was initialized by whereScanInit(). +** Return NULL if there are no more matching WhereTerms. +*/ +static WhereTerm *whereScanNext(WhereScan *pScan){ + int iCur; /* The cursor on the LHS of the term */ + i16 iColumn; /* The column on the LHS of the term. -1 for IPK */ + Expr *pX; /* An expression being tested */ + WhereClause *pWC; /* Shorthand for pScan->pWC */ + WhereTerm *pTerm; /* The term being tested */ + int k = pScan->k; /* Where to start scanning */ + + while( pScan->iEquiv<=pScan->nEquiv ){ + iCur = pScan->aiCur[pScan->iEquiv-1]; + iColumn = pScan->aiColumn[pScan->iEquiv-1]; + if( iColumn==XN_EXPR && pScan->pIdxExpr==0 ) return 0; + while( (pWC = pScan->pWC)!=0 ){ + for(pTerm=pWC->a+k; knTerm; k++, pTerm++){ + if( pTerm->leftCursor==iCur + && pTerm->u.leftColumn==iColumn + && (iColumn!=XN_EXPR + || sqlite3ExprCompare(pTerm->pExpr->pLeft,pScan->pIdxExpr,iCur)==0) + && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_FromJoin)) + ){ + if( (pTerm->eOperator & WO_EQUIV)!=0 + && pScan->nEquivaiCur) + && (pX = sqlite3ExprSkipCollate(pTerm->pExpr->pRight))->op==TK_COLUMN + ){ + int j; + for(j=0; jnEquiv; j++){ + if( pScan->aiCur[j]==pX->iTable + && pScan->aiColumn[j]==pX->iColumn ){ + break; + } + } + if( j==pScan->nEquiv ){ + pScan->aiCur[j] = pX->iTable; + pScan->aiColumn[j] = pX->iColumn; + pScan->nEquiv++; + } + } + if( (pTerm->eOperator & pScan->opMask)!=0 ){ + /* Verify the affinity and collating sequence match */ + if( pScan->zCollName && (pTerm->eOperator & WO_ISNULL)==0 ){ + CollSeq *pColl; + Parse *pParse = pWC->pWInfo->pParse; + pX = pTerm->pExpr; + if( !sqlite3IndexAffinityOk(pX, pScan->idxaff) ){ + continue; + } + assert(pX->pLeft); + pColl = sqlite3BinaryCompareCollSeq(pParse, + pX->pLeft, pX->pRight); + if( pColl==0 ) pColl = pParse->db->pDfltColl; + if( sqlite3StrICmp(pColl->zName, pScan->zCollName) ){ + continue; + } + } + if( (pTerm->eOperator & (WO_EQ|WO_IS))!=0 + && (pX = pTerm->pExpr->pRight)->op==TK_COLUMN + && pX->iTable==pScan->aiCur[0] + && pX->iColumn==pScan->aiColumn[0] + ){ + testcase( pTerm->eOperator & WO_IS ); + continue; + } + pScan->k = k+1; + return pTerm; + } + } + } + pScan->pWC = pScan->pWC->pOuter; + k = 0; + } + pScan->pWC = pScan->pOrigWC; + k = 0; + pScan->iEquiv++; + } + return 0; +} + +/* +** Initialize a WHERE clause scanner object. Return a pointer to the +** first match. Return NULL if there are no matches. +** +** The scanner will be searching the WHERE clause pWC. It will look +** for terms of the form "X " where X is column iColumn of table +** iCur. The must be one of the operators described by opMask. +** +** If the search is for X and the WHERE clause contains terms of the +** form X=Y then this routine might also return terms of the form +** "Y ". The number of levels of transitivity is limited, +** but is enough to handle most commonly occurring SQL statements. +** +** If X is not the INTEGER PRIMARY KEY then X must be compatible with +** index pIdx. +*/ +static WhereTerm *whereScanInit( + WhereScan *pScan, /* The WhereScan object being initialized */ + WhereClause *pWC, /* The WHERE clause to be scanned */ + int iCur, /* Cursor to scan for */ + int iColumn, /* Column to scan for */ + u32 opMask, /* Operator(s) to scan for */ + Index *pIdx /* Must be compatible with this index */ +){ + int j = 0; + + /* memset(pScan, 0, sizeof(*pScan)); */ + pScan->pOrigWC = pWC; + pScan->pWC = pWC; + pScan->pIdxExpr = 0; + if( pIdx ){ + j = iColumn; + iColumn = pIdx->aiColumn[j]; + if( iColumn==XN_EXPR ) pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr; + } + if( pIdx && iColumn>=0 ){ + pScan->idxaff = pIdx->pTable->aCol[iColumn].affinity; + pScan->zCollName = pIdx->azColl[j]; + }else{ + pScan->idxaff = 0; + pScan->zCollName = 0; + } + pScan->opMask = opMask; + pScan->k = 0; + pScan->aiCur[0] = iCur; + pScan->aiColumn[0] = iColumn; + pScan->nEquiv = 1; + pScan->iEquiv = 1; + return whereScanNext(pScan); +} + +/* +** Search for a term in the WHERE clause that is of the form "X " +** where X is a reference to the iColumn of table iCur and is one of +** the WO_xx operator codes specified by the op parameter. +** Return a pointer to the term. Return 0 if not found. +** +** If pIdx!=0 then search for terms matching the iColumn-th column of pIdx +** rather than the iColumn-th column of table iCur. +** +** The term returned might by Y= if there is another constraint in +** the WHERE clause that specifies that X=Y. Any such constraints will be +** identified by the WO_EQUIV bit in the pTerm->eOperator field. The +** aiCur[]/iaColumn[] arrays hold X and all its equivalents. There are 11 +** slots in aiCur[]/aiColumn[] so that means we can look for X plus up to 10 +** other equivalent values. Hence a search for X will return if X=A1 +** and A1=A2 and A2=A3 and ... and A9=A10 and A10=. +** +** If there are multiple terms in the WHERE clause of the form "X " +** then try for the one with no dependencies on - in other words where +** is a constant expression of some kind. Only return entries of +** the form "X Y" where Y is a column in another table if no terms of +** the form "X " exist. If no terms with a constant RHS +** exist, try to return a term that does not use WO_EQUIV. +*/ +SQLITE_PRIVATE WhereTerm *sqlite3WhereFindTerm( + WhereClause *pWC, /* The WHERE clause to be searched */ + int iCur, /* Cursor number of LHS */ + int iColumn, /* Column number of LHS */ + Bitmask notReady, /* RHS must not overlap with this mask */ + u32 op, /* Mask of WO_xx values describing operator */ + Index *pIdx /* Must be compatible with this index, if not NULL */ +){ + WhereTerm *pResult = 0; + WhereTerm *p; + WhereScan scan; + + p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx); + op &= WO_EQ|WO_IS; + while( p ){ + if( (p->prereqRight & notReady)==0 ){ + if( p->prereqRight==0 && (p->eOperator&op)!=0 ){ + testcase( p->eOperator & WO_IS ); + return p; + } + if( pResult==0 ) pResult = p; + } + p = whereScanNext(&scan); + } + return pResult; +} + +/* +** This function searches pList for an entry that matches the iCol-th column +** of index pIdx. +** +** If such an expression is found, its index in pList->a[] is returned. If +** no expression is found, -1 is returned. +*/ +static int findIndexCol( + Parse *pParse, /* Parse context */ + ExprList *pList, /* Expression list to search */ + int iBase, /* Cursor for table associated with pIdx */ + Index *pIdx, /* Index to match column of */ + int iCol /* Column of index to match */ +){ + int i; + const char *zColl = pIdx->azColl[iCol]; + + for(i=0; inExpr; i++){ + Expr *p = sqlite3ExprSkipCollate(pList->a[i].pExpr); + if( p->op==TK_COLUMN + && p->iColumn==pIdx->aiColumn[iCol] + && p->iTable==iBase + ){ + CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr); + if( pColl && 0==sqlite3StrICmp(pColl->zName, zColl) ){ + return i; + } + } + } + + return -1; +} + +/* +** Return TRUE if the iCol-th column of index pIdx is NOT NULL +*/ +static int indexColumnNotNull(Index *pIdx, int iCol){ + int j; + assert( pIdx!=0 ); + assert( iCol>=0 && iColnColumn ); + j = pIdx->aiColumn[iCol]; + if( j>=0 ){ + return pIdx->pTable->aCol[j].notNull; + }else if( j==(-1) ){ + return 1; + }else{ + assert( j==(-2) ); + return 0; /* Assume an indexed expression can always yield a NULL */ + + } +} + +/* +** Return true if the DISTINCT expression-list passed as the third argument +** is redundant. +** +** A DISTINCT list is redundant if any subset of the columns in the +** DISTINCT list are collectively unique and individually non-null. +*/ +static int isDistinctRedundant( + Parse *pParse, /* Parsing context */ + SrcList *pTabList, /* The FROM clause */ + WhereClause *pWC, /* The WHERE clause */ + ExprList *pDistinct /* The result set that needs to be DISTINCT */ +){ + Table *pTab; + Index *pIdx; + int i; + int iBase; + + /* If there is more than one table or sub-select in the FROM clause of + ** this query, then it will not be possible to show that the DISTINCT + ** clause is redundant. */ + if( pTabList->nSrc!=1 ) return 0; + iBase = pTabList->a[0].iCursor; + pTab = pTabList->a[0].pTab; + + /* If any of the expressions is an IPK column on table iBase, then return + ** true. Note: The (p->iTable==iBase) part of this test may be false if the + ** current SELECT is a correlated sub-query. + */ + for(i=0; inExpr; i++){ + Expr *p = sqlite3ExprSkipCollate(pDistinct->a[i].pExpr); + if( p->op==TK_COLUMN && p->iTable==iBase && p->iColumn<0 ) return 1; + } + + /* Loop through all indices on the table, checking each to see if it makes + ** the DISTINCT qualifier redundant. It does so if: + ** + ** 1. The index is itself UNIQUE, and + ** + ** 2. All of the columns in the index are either part of the pDistinct + ** list, or else the WHERE clause contains a term of the form "col=X", + ** where X is a constant value. The collation sequences of the + ** comparison and select-list expressions must match those of the index. + ** + ** 3. All of those index columns for which the WHERE clause does not + ** contain a "col=X" term are subject to a NOT NULL constraint. + */ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( !IsUniqueIndex(pIdx) ) continue; + for(i=0; inKeyCol; i++){ + if( 0==sqlite3WhereFindTerm(pWC, iBase, i, ~(Bitmask)0, WO_EQ, pIdx) ){ + if( findIndexCol(pParse, pDistinct, iBase, pIdx, i)<0 ) break; + if( indexColumnNotNull(pIdx, i)==0 ) break; + } + } + if( i==pIdx->nKeyCol ){ + /* This index implies that the DISTINCT qualifier is redundant. */ + return 1; + } + } + + return 0; +} + + +/* +** Estimate the logarithm of the input value to base 2. +*/ +static LogEst estLog(LogEst N){ + return N<=10 ? 0 : sqlite3LogEst(N) - 33; +} + +/* +** Convert OP_Column opcodes to OP_Copy in previously generated code. +** +** This routine runs over generated VDBE code and translates OP_Column +** opcodes into OP_Copy when the table is being accessed via co-routine +** instead of via table lookup. +** +** If the bIncrRowid parameter is 0, then any OP_Rowid instructions on +** cursor iTabCur are transformed into OP_Null. Or, if bIncrRowid is non-zero, +** then each OP_Rowid is transformed into an instruction to increment the +** value stored in its output register. +*/ +static void translateColumnToCopy( + Vdbe *v, /* The VDBE containing code to translate */ + int iStart, /* Translate from this opcode to the end */ + int iTabCur, /* OP_Column/OP_Rowid references to this table */ + int iRegister, /* The first column is in this register */ + int bIncrRowid /* If non-zero, transform OP_rowid to OP_AddImm(1) */ +){ + VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart); + int iEnd = sqlite3VdbeCurrentAddr(v); + for(; iStartp1!=iTabCur ) continue; + if( pOp->opcode==OP_Column ){ + pOp->opcode = OP_Copy; + pOp->p1 = pOp->p2 + iRegister; + pOp->p2 = pOp->p3; + pOp->p3 = 0; + }else if( pOp->opcode==OP_Rowid ){ + if( bIncrRowid ){ + /* Increment the value stored in the P2 operand of the OP_Rowid. */ + pOp->opcode = OP_AddImm; + pOp->p1 = pOp->p2; + pOp->p2 = 1; + }else{ + pOp->opcode = OP_Null; + pOp->p1 = 0; + pOp->p3 = 0; + } + } + } +} + +/* +** Two routines for printing the content of an sqlite3_index_info +** structure. Used for testing and debugging only. If neither +** SQLITE_TEST or SQLITE_DEBUG are defined, then these routines +** are no-ops. +*/ +#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(WHERETRACE_ENABLED) +static void TRACE_IDX_INPUTS(sqlite3_index_info *p){ + int i; + if( !sqlite3WhereTrace ) return; + for(i=0; inConstraint; i++){ + sqlite3DebugPrintf(" constraint[%d]: col=%d termid=%d op=%d usabled=%d\n", + i, + p->aConstraint[i].iColumn, + p->aConstraint[i].iTermOffset, + p->aConstraint[i].op, + p->aConstraint[i].usable); + } + for(i=0; inOrderBy; i++){ + sqlite3DebugPrintf(" orderby[%d]: col=%d desc=%d\n", + i, + p->aOrderBy[i].iColumn, + p->aOrderBy[i].desc); + } +} +static void TRACE_IDX_OUTPUTS(sqlite3_index_info *p){ + int i; + if( !sqlite3WhereTrace ) return; + for(i=0; inConstraint; i++){ + sqlite3DebugPrintf(" usage[%d]: argvIdx=%d omit=%d\n", + i, + p->aConstraintUsage[i].argvIndex, + p->aConstraintUsage[i].omit); + } + sqlite3DebugPrintf(" idxNum=%d\n", p->idxNum); + sqlite3DebugPrintf(" idxStr=%s\n", p->idxStr); + sqlite3DebugPrintf(" orderByConsumed=%d\n", p->orderByConsumed); + sqlite3DebugPrintf(" estimatedCost=%g\n", p->estimatedCost); + sqlite3DebugPrintf(" estimatedRows=%lld\n", p->estimatedRows); +} +#else +#define TRACE_IDX_INPUTS(A) +#define TRACE_IDX_OUTPUTS(A) +#endif + +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX +/* +** Return TRUE if the WHERE clause term pTerm is of a form where it +** could be used with an index to access pSrc, assuming an appropriate +** index existed. +*/ +static int termCanDriveIndex( + WhereTerm *pTerm, /* WHERE clause term to check */ + struct SrcList_item *pSrc, /* Table we are trying to access */ + Bitmask notReady /* Tables in outer loops of the join */ +){ + char aff; + if( pTerm->leftCursor!=pSrc->iCursor ) return 0; + if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0; + if( (pTerm->prereqRight & notReady)!=0 ) return 0; + if( pTerm->u.leftColumn<0 ) return 0; + aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity; + if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0; + testcase( pTerm->pExpr->op==TK_IS ); + return 1; +} +#endif + + +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX +/* +** Generate code to construct the Index object for an automatic index +** and to set up the WhereLevel object pLevel so that the code generator +** makes use of the automatic index. +*/ +static void constructAutomaticIndex( + Parse *pParse, /* The parsing context */ + WhereClause *pWC, /* The WHERE clause */ + struct SrcList_item *pSrc, /* The FROM clause term to get the next index */ + Bitmask notReady, /* Mask of cursors that are not available */ + WhereLevel *pLevel /* Write new index here */ +){ + int nKeyCol; /* Number of columns in the constructed index */ + WhereTerm *pTerm; /* A single term of the WHERE clause */ + WhereTerm *pWCEnd; /* End of pWC->a[] */ + Index *pIdx; /* Object describing the transient index */ + Vdbe *v; /* Prepared statement under construction */ + int addrInit; /* Address of the initialization bypass jump */ + Table *pTable; /* The table being indexed */ + int addrTop; /* Top of the index fill loop */ + int regRecord; /* Register holding an index record */ + int n; /* Column counter */ + int i; /* Loop counter */ + int mxBitCol; /* Maximum column in pSrc->colUsed */ + CollSeq *pColl; /* Collating sequence to on a column */ + WhereLoop *pLoop; /* The Loop object */ + char *zNotUsed; /* Extra space on the end of pIdx */ + Bitmask idxCols; /* Bitmap of columns used for indexing */ + Bitmask extraCols; /* Bitmap of additional columns */ + u8 sentWarning = 0; /* True if a warnning has been issued */ + Expr *pPartial = 0; /* Partial Index Expression */ + int iContinue = 0; /* Jump here to skip excluded rows */ + struct SrcList_item *pTabItem; /* FROM clause term being indexed */ + int addrCounter; /* Address where integer counter is initialized */ + int regBase; /* Array of registers where record is assembled */ + + /* Generate code to skip over the creation and initialization of the + ** transient index on 2nd and subsequent iterations of the loop. */ + v = pParse->pVdbe; + assert( v!=0 ); + addrInit = sqlite3CodeOnce(pParse); VdbeCoverage(v); + + /* Count the number of columns that will be added to the index + ** and used to match WHERE clause constraints */ + nKeyCol = 0; + pTable = pSrc->pTab; + pWCEnd = &pWC->a[pWC->nTerm]; + pLoop = pLevel->pWLoop; + idxCols = 0; + for(pTerm=pWC->a; pTermpExpr; + assert( !ExprHasProperty(pExpr, EP_FromJoin) /* prereq always non-zero */ + || pExpr->iRightJoinTable!=pSrc->iCursor /* for the right-hand */ + || pLoop->prereq!=0 ); /* table of a LEFT JOIN */ + if( pLoop->prereq==0 + && (pTerm->wtFlags & TERM_VIRTUAL)==0 + && !ExprHasProperty(pExpr, EP_FromJoin) + && sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor) ){ + pPartial = sqlite3ExprAnd(pParse->db, pPartial, + sqlite3ExprDup(pParse->db, pExpr, 0)); + } + if( termCanDriveIndex(pTerm, pSrc, notReady) ){ + int iCol = pTerm->u.leftColumn; + Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); + testcase( iCol==BMS ); + testcase( iCol==BMS-1 ); + if( !sentWarning ){ + sqlite3_log(SQLITE_WARNING_AUTOINDEX, + "automatic index on %s(%s)", pTable->zName, + pTable->aCol[iCol].zName); + sentWarning = 1; + } + if( (idxCols & cMask)==0 ){ + if( whereLoopResize(pParse->db, pLoop, nKeyCol+1) ){ + goto end_auto_index_create; + } + pLoop->aLTerm[nKeyCol++] = pTerm; + idxCols |= cMask; + } + } + } + assert( nKeyCol>0 ); + pLoop->u.btree.nEq = pLoop->nLTerm = nKeyCol; + pLoop->wsFlags = WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WHERE_INDEXED + | WHERE_AUTO_INDEX; + + /* Count the number of additional columns needed to create a + ** covering index. A "covering index" is an index that contains all + ** columns that are needed by the query. With a covering index, the + ** original table never needs to be accessed. Automatic indices must + ** be a covering index because the index will not be updated if the + ** original table changes and the index and table cannot both be used + ** if they go out of sync. + */ + extraCols = pSrc->colUsed & (~idxCols | MASKBIT(BMS-1)); + mxBitCol = MIN(BMS-1,pTable->nCol); + testcase( pTable->nCol==BMS-1 ); + testcase( pTable->nCol==BMS-2 ); + for(i=0; icolUsed & MASKBIT(BMS-1) ){ + nKeyCol += pTable->nCol - BMS + 1; + } + + /* Construct the Index object to describe this index */ + pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+1, 0, &zNotUsed); + if( pIdx==0 ) goto end_auto_index_create; + pLoop->u.btree.pIndex = pIdx; + pIdx->zName = "auto-index"; + pIdx->pTable = pTable; + n = 0; + idxCols = 0; + for(pTerm=pWC->a; pTermu.leftColumn; + Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); + testcase( iCol==BMS-1 ); + testcase( iCol==BMS ); + if( (idxCols & cMask)==0 ){ + Expr *pX = pTerm->pExpr; + idxCols |= cMask; + pIdx->aiColumn[n] = pTerm->u.leftColumn; + pColl = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight); + pIdx->azColl[n] = pColl ? pColl->zName : "BINARY"; + n++; + } + } + } + assert( (u32)n==pLoop->u.btree.nEq ); + + /* Add additional columns needed to make the automatic index into + ** a covering index */ + for(i=0; iaiColumn[n] = i; + pIdx->azColl[n] = "BINARY"; + n++; + } + } + if( pSrc->colUsed & MASKBIT(BMS-1) ){ + for(i=BMS-1; inCol; i++){ + pIdx->aiColumn[n] = i; + pIdx->azColl[n] = "BINARY"; + n++; + } + } + assert( n==nKeyCol ); + pIdx->aiColumn[n] = XN_ROWID; + pIdx->azColl[n] = "BINARY"; + + /* Create the automatic index */ + assert( pLevel->iIdxCur>=0 ); + pLevel->iIdxCur = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_OpenAutoindex, pLevel->iIdxCur, nKeyCol+1); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + VdbeComment((v, "for %s", pTable->zName)); + + /* Fill the automatic index with content */ + sqlite3ExprCachePush(pParse); + pTabItem = &pWC->pWInfo->pTabList->a[pLevel->iFrom]; + if( pTabItem->fg.viaCoroutine ){ + int regYield = pTabItem->regReturn; + addrCounter = sqlite3VdbeAddOp2(v, OP_Integer, 0, 0); + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub); + addrTop = sqlite3VdbeAddOp1(v, OP_Yield, regYield); + VdbeCoverage(v); + VdbeComment((v, "next row of \"%s\"", pTabItem->pTab->zName)); + }else{ + addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v); + } + if( pPartial ){ + iContinue = sqlite3VdbeMakeLabel(v); + sqlite3ExprIfFalse(pParse, pPartial, iContinue, SQLITE_JUMPIFNULL); + pLoop->wsFlags |= WHERE_PARTIALIDX; + } + regRecord = sqlite3GetTempReg(pParse); + regBase = sqlite3GenerateIndexKey( + pParse, pIdx, pLevel->iTabCur, regRecord, 0, 0, 0, 0 + ); + sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + if( pPartial ) sqlite3VdbeResolveLabel(v, iContinue); + if( pTabItem->fg.viaCoroutine ){ + sqlite3VdbeChangeP2(v, addrCounter, regBase+n); + translateColumnToCopy(v, addrTop, pLevel->iTabCur, pTabItem->regResult, 1); + sqlite3VdbeGoto(v, addrTop); + pTabItem->fg.viaCoroutine = 0; + }else{ + sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); VdbeCoverage(v); + } + sqlite3VdbeChangeP5(v, SQLITE_STMTSTATUS_AUTOINDEX); + sqlite3VdbeJumpHere(v, addrTop); + sqlite3ReleaseTempReg(pParse, regRecord); + sqlite3ExprCachePop(pParse); + + /* Jump here when skipping the initialization */ + sqlite3VdbeJumpHere(v, addrInit); + +end_auto_index_create: + sqlite3ExprDelete(pParse->db, pPartial); +} +#endif /* SQLITE_OMIT_AUTOMATIC_INDEX */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Allocate and populate an sqlite3_index_info structure. It is the +** responsibility of the caller to eventually release the structure +** by passing the pointer returned by this function to sqlite3_free(). +*/ +static sqlite3_index_info *allocateIndexInfo( + Parse *pParse, + WhereClause *pWC, + Bitmask mUnusable, /* Ignore terms with these prereqs */ + struct SrcList_item *pSrc, + ExprList *pOrderBy +){ + int i, j; + int nTerm; + struct sqlite3_index_constraint *pIdxCons; + struct sqlite3_index_orderby *pIdxOrderBy; + struct sqlite3_index_constraint_usage *pUsage; + WhereTerm *pTerm; + int nOrderBy; + sqlite3_index_info *pIdxInfo; + + /* Count the number of possible WHERE clause constraints referring + ** to this virtual table */ + for(i=nTerm=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + if( pTerm->leftCursor != pSrc->iCursor ) continue; + if( pTerm->prereqRight & mUnusable ) continue; + assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) ); + testcase( pTerm->eOperator & WO_IN ); + testcase( pTerm->eOperator & WO_ISNULL ); + testcase( pTerm->eOperator & WO_IS ); + testcase( pTerm->eOperator & WO_ALL ); + if( (pTerm->eOperator & ~(WO_ISNULL|WO_EQUIV|WO_IS))==0 ) continue; + if( pTerm->wtFlags & TERM_VNULL ) continue; + assert( pTerm->u.leftColumn>=(-1) ); + nTerm++; + } + + /* If the ORDER BY clause contains only columns in the current + ** virtual table then allocate space for the aOrderBy part of + ** the sqlite3_index_info structure. + */ + nOrderBy = 0; + if( pOrderBy ){ + int n = pOrderBy->nExpr; + for(i=0; ia[i].pExpr; + if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break; + } + if( i==n){ + nOrderBy = n; + } + } + + /* Allocate the sqlite3_index_info structure + */ + pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo) + + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm + + sizeof(*pIdxOrderBy)*nOrderBy ); + if( pIdxInfo==0 ){ + sqlite3ErrorMsg(pParse, "out of memory"); + return 0; + } + + /* Initialize the structure. The sqlite3_index_info structure contains + ** many fields that are declared "const" to prevent xBestIndex from + ** changing them. We have to do some funky casting in order to + ** initialize those fields. + */ + pIdxCons = (struct sqlite3_index_constraint*)&pIdxInfo[1]; + pIdxOrderBy = (struct sqlite3_index_orderby*)&pIdxCons[nTerm]; + pUsage = (struct sqlite3_index_constraint_usage*)&pIdxOrderBy[nOrderBy]; + *(int*)&pIdxInfo->nConstraint = nTerm; + *(int*)&pIdxInfo->nOrderBy = nOrderBy; + *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint = pIdxCons; + *(struct sqlite3_index_orderby**)&pIdxInfo->aOrderBy = pIdxOrderBy; + *(struct sqlite3_index_constraint_usage**)&pIdxInfo->aConstraintUsage = + pUsage; + + for(i=j=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + u8 op; + if( pTerm->leftCursor != pSrc->iCursor ) continue; + if( pTerm->prereqRight & mUnusable ) continue; + assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) ); + testcase( pTerm->eOperator & WO_IN ); + testcase( pTerm->eOperator & WO_IS ); + testcase( pTerm->eOperator & WO_ISNULL ); + testcase( pTerm->eOperator & WO_ALL ); + if( (pTerm->eOperator & ~(WO_ISNULL|WO_EQUIV|WO_IS))==0 ) continue; + if( pTerm->wtFlags & TERM_VNULL ) continue; + assert( pTerm->u.leftColumn>=(-1) ); + pIdxCons[j].iColumn = pTerm->u.leftColumn; + pIdxCons[j].iTermOffset = i; + op = (u8)pTerm->eOperator & WO_ALL; + if( op==WO_IN ) op = WO_EQ; + pIdxCons[j].op = op; + /* The direct assignment in the previous line is possible only because + ** the WO_ and SQLITE_INDEX_CONSTRAINT_ codes are identical. The + ** following asserts verify this fact. */ + assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ ); + assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT ); + assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE ); + assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT ); + assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE ); + assert( WO_MATCH==SQLITE_INDEX_CONSTRAINT_MATCH ); + assert( pTerm->eOperator & (WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_MATCH) ); + j++; + } + for(i=0; ia[i].pExpr; + pIdxOrderBy[i].iColumn = pExpr->iColumn; + pIdxOrderBy[i].desc = pOrderBy->a[i].sortOrder; + } + + return pIdxInfo; +} + +/* +** The table object reference passed as the second argument to this function +** must represent a virtual table. This function invokes the xBestIndex() +** method of the virtual table with the sqlite3_index_info object that +** comes in as the 3rd argument to this function. +** +** If an error occurs, pParse is populated with an error message and a +** non-zero value is returned. Otherwise, 0 is returned and the output +** part of the sqlite3_index_info structure is left populated. +** +** Whether or not an error is returned, it is the responsibility of the +** caller to eventually free p->idxStr if p->needToFreeIdxStr indicates +** that this is required. +*/ +static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){ + sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab; + int i; + int rc; + + TRACE_IDX_INPUTS(p); + rc = pVtab->pModule->xBestIndex(pVtab, p); + TRACE_IDX_OUTPUTS(p); + + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM ){ + pParse->db->mallocFailed = 1; + }else if( !pVtab->zErrMsg ){ + sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc)); + }else{ + sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg); + } + } + sqlite3_free(pVtab->zErrMsg); + pVtab->zErrMsg = 0; + + for(i=0; inConstraint; i++){ + if( !p->aConstraint[i].usable && p->aConstraintUsage[i].argvIndex>0 ){ + sqlite3ErrorMsg(pParse, + "table %s: xBestIndex returned an invalid plan", pTab->zName); + } + } + + return pParse->nErr; +} +#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */ + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +/* +** Estimate the location of a particular key among all keys in an +** index. Store the results in aStat as follows: +** +** aStat[0] Est. number of rows less than pRec +** aStat[1] Est. number of rows equal to pRec +** +** Return the index of the sample that is the smallest sample that +** is greater than or equal to pRec. Note that this index is not an index +** into the aSample[] array - it is an index into a virtual set of samples +** based on the contents of aSample[] and the number of fields in record +** pRec. +*/ +static int whereKeyStats( + Parse *pParse, /* Database connection */ + Index *pIdx, /* Index to consider domain of */ + UnpackedRecord *pRec, /* Vector of values to consider */ + int roundUp, /* Round up if true. Round down if false */ + tRowcnt *aStat /* OUT: stats written here */ +){ + IndexSample *aSample = pIdx->aSample; + int iCol; /* Index of required stats in anEq[] etc. */ + int i; /* Index of first sample >= pRec */ + int iSample; /* Smallest sample larger than or equal to pRec */ + int iMin = 0; /* Smallest sample not yet tested */ + int iTest; /* Next sample to test */ + int res; /* Result of comparison operation */ + int nField; /* Number of fields in pRec */ + tRowcnt iLower = 0; /* anLt[] + anEq[] of largest sample pRec is > */ + +#ifndef SQLITE_DEBUG + UNUSED_PARAMETER( pParse ); +#endif + assert( pRec!=0 ); + assert( pIdx->nSample>0 ); + assert( pRec->nField>0 && pRec->nField<=pIdx->nSampleCol ); + + /* Do a binary search to find the first sample greater than or equal + ** to pRec. If pRec contains a single field, the set of samples to search + ** is simply the aSample[] array. If the samples in aSample[] contain more + ** than one fields, all fields following the first are ignored. + ** + ** If pRec contains N fields, where N is more than one, then as well as the + ** samples in aSample[] (truncated to N fields), the search also has to + ** consider prefixes of those samples. For example, if the set of samples + ** in aSample is: + ** + ** aSample[0] = (a, 5) + ** aSample[1] = (a, 10) + ** aSample[2] = (b, 5) + ** aSample[3] = (c, 100) + ** aSample[4] = (c, 105) + ** + ** Then the search space should ideally be the samples above and the + ** unique prefixes [a], [b] and [c]. But since that is hard to organize, + ** the code actually searches this set: + ** + ** 0: (a) + ** 1: (a, 5) + ** 2: (a, 10) + ** 3: (a, 10) + ** 4: (b) + ** 5: (b, 5) + ** 6: (c) + ** 7: (c, 100) + ** 8: (c, 105) + ** 9: (c, 105) + ** + ** For each sample in the aSample[] array, N samples are present in the + ** effective sample array. In the above, samples 0 and 1 are based on + ** sample aSample[0]. Samples 2 and 3 on aSample[1] etc. + ** + ** Often, sample i of each block of N effective samples has (i+1) fields. + ** Except, each sample may be extended to ensure that it is greater than or + ** equal to the previous sample in the array. For example, in the above, + ** sample 2 is the first sample of a block of N samples, so at first it + ** appears that it should be 1 field in size. However, that would make it + ** smaller than sample 1, so the binary search would not work. As a result, + ** it is extended to two fields. The duplicates that this creates do not + ** cause any problems. + */ + nField = pRec->nField; + iCol = 0; + iSample = pIdx->nSample * nField; + do{ + int iSamp; /* Index in aSample[] of test sample */ + int n; /* Number of fields in test sample */ + + iTest = (iMin+iSample)/2; + iSamp = iTest / nField; + if( iSamp>0 ){ + /* The proposed effective sample is a prefix of sample aSample[iSamp]. + ** Specifically, the shortest prefix of at least (1 + iTest%nField) + ** fields that is greater than the previous effective sample. */ + for(n=(iTest % nField) + 1; nnField = n; + res = sqlite3VdbeRecordCompare(aSample[iSamp].n, aSample[iSamp].p, pRec); + if( res<0 ){ + iLower = aSample[iSamp].anLt[n-1] + aSample[iSamp].anEq[n-1]; + iMin = iTest+1; + }else if( res==0 && ndb->mallocFailed==0 ){ + if( res==0 ){ + /* If (res==0) is true, then pRec must be equal to sample i. */ + assert( inSample ); + assert( iCol==nField-1 ); + pRec->nField = nField; + assert( 0==sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec) + || pParse->db->mallocFailed + ); + }else{ + /* Unless i==pIdx->nSample, indicating that pRec is larger than + ** all samples in the aSample[] array, pRec must be smaller than the + ** (iCol+1) field prefix of sample i. */ + assert( i<=pIdx->nSample && i>=0 ); + pRec->nField = iCol+1; + assert( i==pIdx->nSample + || sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)>0 + || pParse->db->mallocFailed ); + + /* if i==0 and iCol==0, then record pRec is smaller than all samples + ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must + ** be greater than or equal to the (iCol) field prefix of sample i. + ** If (i>0), then pRec must also be greater than sample (i-1). */ + if( iCol>0 ){ + pRec->nField = iCol; + assert( sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)<=0 + || pParse->db->mallocFailed ); + } + if( i>0 ){ + pRec->nField = nField; + assert( sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0 + || pParse->db->mallocFailed ); + } + } + } +#endif /* ifdef SQLITE_DEBUG */ + + if( res==0 ){ + /* Record pRec is equal to sample i */ + assert( iCol==nField-1 ); + aStat[0] = aSample[i].anLt[iCol]; + aStat[1] = aSample[i].anEq[iCol]; + }else{ + /* At this point, the (iCol+1) field prefix of aSample[i] is the first + ** sample that is greater than pRec. Or, if i==pIdx->nSample then pRec + ** is larger than all samples in the array. */ + tRowcnt iUpper, iGap; + if( i>=pIdx->nSample ){ + iUpper = sqlite3LogEstToInt(pIdx->aiRowLogEst[0]); + }else{ + iUpper = aSample[i].anLt[iCol]; + } + + if( iLower>=iUpper ){ + iGap = 0; + }else{ + iGap = iUpper - iLower; + } + if( roundUp ){ + iGap = (iGap*2)/3; + }else{ + iGap = iGap/3; + } + aStat[0] = iLower + iGap; + aStat[1] = pIdx->aAvgEq[iCol]; + } + + /* Restore the pRec->nField value before returning. */ + pRec->nField = nField; + return i; +} +#endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */ + +/* +** If it is not NULL, pTerm is a term that provides an upper or lower +** bound on a range scan. Without considering pTerm, it is estimated +** that the scan will visit nNew rows. This function returns the number +** estimated to be visited after taking pTerm into account. +** +** If the user explicitly specified a likelihood() value for this term, +** then the return value is the likelihood multiplied by the number of +** input rows. Otherwise, this function assumes that an "IS NOT NULL" term +** has a likelihood of 0.50, and any other term a likelihood of 0.25. +*/ +static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){ + LogEst nRet = nNew; + if( pTerm ){ + if( pTerm->truthProb<=0 ){ + nRet += pTerm->truthProb; + }else if( (pTerm->wtFlags & TERM_VNULL)==0 ){ + nRet -= 20; assert( 20==sqlite3LogEst(4) ); + } + } + return nRet; +} + + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +/* +** Return the affinity for a single column of an index. +*/ +static char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){ + assert( iCol>=0 && iColnColumn ); + if( !pIdx->zColAff ){ + if( sqlite3IndexAffinityStr(db, pIdx)==0 ) return SQLITE_AFF_BLOB; + } + return pIdx->zColAff[iCol]; +} +#endif + + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +/* +** This function is called to estimate the number of rows visited by a +** range-scan on a skip-scan index. For example: +** +** CREATE INDEX i1 ON t1(a, b, c); +** SELECT * FROM t1 WHERE a=? AND c BETWEEN ? AND ?; +** +** Value pLoop->nOut is currently set to the estimated number of rows +** visited for scanning (a=? AND b=?). This function reduces that estimate +** by some factor to account for the (c BETWEEN ? AND ?) expression based +** on the stat4 data for the index. this scan will be peformed multiple +** times (once for each (a,b) combination that matches a=?) is dealt with +** by the caller. +** +** It does this by scanning through all stat4 samples, comparing values +** extracted from pLower and pUpper with the corresponding column in each +** sample. If L and U are the number of samples found to be less than or +** equal to the values extracted from pLower and pUpper respectively, and +** N is the total number of samples, the pLoop->nOut value is adjusted +** as follows: +** +** nOut = nOut * ( min(U - L, 1) / N ) +** +** If pLower is NULL, or a value cannot be extracted from the term, L is +** set to zero. If pUpper is NULL, or a value cannot be extracted from it, +** U is set to N. +** +** Normally, this function sets *pbDone to 1 before returning. However, +** if no value can be extracted from either pLower or pUpper (and so the +** estimate of the number of rows delivered remains unchanged), *pbDone +** is left as is. +** +** If an error occurs, an SQLite error code is returned. Otherwise, +** SQLITE_OK. +*/ +static int whereRangeSkipScanEst( + Parse *pParse, /* Parsing & code generating context */ + WhereTerm *pLower, /* Lower bound on the range. ex: "x>123" Might be NULL */ + WhereTerm *pUpper, /* Upper bound on the range. ex: "x<455" Might be NULL */ + WhereLoop *pLoop, /* Update the .nOut value of this loop */ + int *pbDone /* Set to true if at least one expr. value extracted */ +){ + Index *p = pLoop->u.btree.pIndex; + int nEq = pLoop->u.btree.nEq; + sqlite3 *db = pParse->db; + int nLower = -1; + int nUpper = p->nSample+1; + int rc = SQLITE_OK; + u8 aff = sqlite3IndexColumnAffinity(db, p, nEq); + CollSeq *pColl; + + sqlite3_value *p1 = 0; /* Value extracted from pLower */ + sqlite3_value *p2 = 0; /* Value extracted from pUpper */ + sqlite3_value *pVal = 0; /* Value extracted from record */ + + pColl = sqlite3LocateCollSeq(pParse, p->azColl[nEq]); + if( pLower ){ + rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1); + nLower = 0; + } + if( pUpper && rc==SQLITE_OK ){ + rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2); + nUpper = p2 ? 0 : p->nSample; + } + + if( p1 || p2 ){ + int i; + int nDiff; + for(i=0; rc==SQLITE_OK && inSample; i++){ + rc = sqlite3Stat4Column(db, p->aSample[i].p, p->aSample[i].n, nEq, &pVal); + if( rc==SQLITE_OK && p1 ){ + int res = sqlite3MemCompare(p1, pVal, pColl); + if( res>=0 ) nLower++; + } + if( rc==SQLITE_OK && p2 ){ + int res = sqlite3MemCompare(p2, pVal, pColl); + if( res>=0 ) nUpper++; + } + } + nDiff = (nUpper - nLower); + if( nDiff<=0 ) nDiff = 1; + + /* If there is both an upper and lower bound specified, and the + ** comparisons indicate that they are close together, use the fallback + ** method (assume that the scan visits 1/64 of the rows) for estimating + ** the number of rows visited. Otherwise, estimate the number of rows + ** using the method described in the header comment for this function. */ + if( nDiff!=1 || pUpper==0 || pLower==0 ){ + int nAdjust = (sqlite3LogEst(p->nSample) - sqlite3LogEst(nDiff)); + pLoop->nOut -= nAdjust; + *pbDone = 1; + WHERETRACE(0x10, ("range skip-scan regions: %u..%u adjust=%d est=%d\n", + nLower, nUpper, nAdjust*-1, pLoop->nOut)); + } + + }else{ + assert( *pbDone==0 ); + } + + sqlite3ValueFree(p1); + sqlite3ValueFree(p2); + sqlite3ValueFree(pVal); + + return rc; +} +#endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */ + +/* +** This function is used to estimate the number of rows that will be visited +** by scanning an index for a range of values. The range may have an upper +** bound, a lower bound, or both. The WHERE clause terms that set the upper +** and lower bounds are represented by pLower and pUpper respectively. For +** example, assuming that index p is on t1(a): +** +** ... FROM t1 WHERE a > ? AND a < ? ... +** |_____| |_____| +** | | +** pLower pUpper +** +** If either of the upper or lower bound is not present, then NULL is passed in +** place of the corresponding WhereTerm. +** +** The value in (pBuilder->pNew->u.btree.nEq) is the number of the index +** column subject to the range constraint. Or, equivalently, the number of +** equality constraints optimized by the proposed index scan. For example, +** assuming index p is on t1(a, b), and the SQL query is: +** +** ... FROM t1 WHERE a = ? AND b > ? AND b < ? ... +** +** then nEq is set to 1 (as the range restricted column, b, is the second +** left-most column of the index). Or, if the query is: +** +** ... FROM t1 WHERE a > ? AND a < ? ... +** +** then nEq is set to 0. +** +** When this function is called, *pnOut is set to the sqlite3LogEst() of the +** number of rows that the index scan is expected to visit without +** considering the range constraints. If nEq is 0, then *pnOut is the number of +** rows in the index. Assuming no error occurs, *pnOut is adjusted (reduced) +** to account for the range constraints pLower and pUpper. +** +** In the absence of sqlite_stat4 ANALYZE data, or if such data cannot be +** used, a single range inequality reduces the search space by a factor of 4. +** and a pair of constraints (x>? AND x123" Might be NULL */ + WhereTerm *pUpper, /* Upper bound on the range. ex: "x<455" Might be NULL */ + WhereLoop *pLoop /* Modify the .nOut and maybe .rRun fields */ +){ + int rc = SQLITE_OK; + int nOut = pLoop->nOut; + LogEst nNew; + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + Index *p = pLoop->u.btree.pIndex; + int nEq = pLoop->u.btree.nEq; + + if( p->nSample>0 && nEqnSampleCol ){ + if( nEq==pBuilder->nRecValid ){ + UnpackedRecord *pRec = pBuilder->pRec; + tRowcnt a[2]; + u8 aff; + + /* Variable iLower will be set to the estimate of the number of rows in + ** the index that are less than the lower bound of the range query. The + ** lower bound being the concatenation of $P and $L, where $P is the + ** key-prefix formed by the nEq values matched against the nEq left-most + ** columns of the index, and $L is the value in pLower. + ** + ** Or, if pLower is NULL or $L cannot be extracted from it (because it + ** is not a simple variable or literal value), the lower bound of the + ** range is $P. Due to a quirk in the way whereKeyStats() works, even + ** if $L is available, whereKeyStats() is called for both ($P) and + ** ($P:$L) and the larger of the two returned values is used. + ** + ** Similarly, iUpper is to be set to the estimate of the number of rows + ** less than the upper bound of the range query. Where the upper bound + ** is either ($P) or ($P:$U). Again, even if $U is available, both values + ** of iUpper are requested of whereKeyStats() and the smaller used. + ** + ** The number of rows between the two bounds is then just iUpper-iLower. + */ + tRowcnt iLower; /* Rows less than the lower bound */ + tRowcnt iUpper; /* Rows less than the upper bound */ + int iLwrIdx = -2; /* aSample[] for the lower bound */ + int iUprIdx = -1; /* aSample[] for the upper bound */ + + if( pRec ){ + testcase( pRec->nField!=pBuilder->nRecValid ); + pRec->nField = pBuilder->nRecValid; + } + aff = sqlite3IndexColumnAffinity(pParse->db, p, nEq); + assert( nEq!=p->nKeyCol || aff==SQLITE_AFF_INTEGER ); + /* Determine iLower and iUpper using ($P) only. */ + if( nEq==0 ){ + iLower = 0; + iUpper = p->nRowEst0; + }else{ + /* Note: this call could be optimized away - since the same values must + ** have been requested when testing key $P in whereEqualScanEst(). */ + whereKeyStats(pParse, p, pRec, 0, a); + iLower = a[0]; + iUpper = a[0] + a[1]; + } + + assert( pLower==0 || (pLower->eOperator & (WO_GT|WO_GE))!=0 ); + assert( pUpper==0 || (pUpper->eOperator & (WO_LT|WO_LE))!=0 ); + assert( p->aSortOrder!=0 ); + if( p->aSortOrder[nEq] ){ + /* The roles of pLower and pUpper are swapped for a DESC index */ + SWAP(WhereTerm*, pLower, pUpper); + } + + /* If possible, improve on the iLower estimate using ($P:$L). */ + if( pLower ){ + int bOk; /* True if value is extracted from pExpr */ + Expr *pExpr = pLower->pExpr->pRight; + rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq, &bOk); + if( rc==SQLITE_OK && bOk ){ + tRowcnt iNew; + iLwrIdx = whereKeyStats(pParse, p, pRec, 0, a); + iNew = a[0] + ((pLower->eOperator & (WO_GT|WO_LE)) ? a[1] : 0); + if( iNew>iLower ) iLower = iNew; + nOut--; + pLower = 0; + } + } + + /* If possible, improve on the iUpper estimate using ($P:$U). */ + if( pUpper ){ + int bOk; /* True if value is extracted from pExpr */ + Expr *pExpr = pUpper->pExpr->pRight; + rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq, &bOk); + if( rc==SQLITE_OK && bOk ){ + tRowcnt iNew; + iUprIdx = whereKeyStats(pParse, p, pRec, 1, a); + iNew = a[0] + ((pUpper->eOperator & (WO_GT|WO_LE)) ? a[1] : 0); + if( iNewpRec = pRec; + if( rc==SQLITE_OK ){ + if( iUpper>iLower ){ + nNew = sqlite3LogEst(iUpper - iLower); + /* TUNING: If both iUpper and iLower are derived from the same + ** sample, then assume they are 4x more selective. This brings + ** the estimated selectivity more in line with what it would be + ** if estimated without the use of STAT3/4 tables. */ + if( iLwrIdx==iUprIdx ) nNew -= 20; assert( 20==sqlite3LogEst(4) ); + }else{ + nNew = 10; assert( 10==sqlite3LogEst(2) ); + } + if( nNewwtFlags & TERM_VNULL)==0 ); + nNew = whereRangeAdjust(pLower, nOut); + nNew = whereRangeAdjust(pUpper, nNew); + + /* TUNING: If there is both an upper and lower limit and neither limit + ** has an application-defined likelihood(), assume the range is + ** reduced by an additional 75%. This means that, by default, an open-ended + ** range query (e.g. col > ?) is assumed to match 1/4 of the rows in the + ** index. While a closed range (e.g. col BETWEEN ? AND ?) is estimated to + ** match 1/64 of the index. */ + if( pLower && pLower->truthProb>0 && pUpper && pUpper->truthProb>0 ){ + nNew -= 20; + } + + nOut -= (pLower!=0) + (pUpper!=0); + if( nNew<10 ) nNew = 10; + if( nNewnOut>nOut ){ + WHERETRACE(0x10,("Range scan lowers nOut from %d to %d\n", + pLoop->nOut, nOut)); + } +#endif + pLoop->nOut = (LogEst)nOut; + return rc; +} + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +/* +** Estimate the number of rows that will be returned based on +** an equality constraint x=VALUE and where that VALUE occurs in +** the histogram data. This only works when x is the left-most +** column of an index and sqlite_stat3 histogram data is available +** for that index. When pExpr==NULL that means the constraint is +** "x IS NULL" instead of "x=VALUE". +** +** Write the estimated row count into *pnRow and return SQLITE_OK. +** If unable to make an estimate, leave *pnRow unchanged and return +** non-zero. +** +** This routine can fail if it is unable to load a collating sequence +** required for string comparison, or if unable to allocate memory +** for a UTF conversion required for comparison. The error is stored +** in the pParse structure. +*/ +static int whereEqualScanEst( + Parse *pParse, /* Parsing & code generating context */ + WhereLoopBuilder *pBuilder, + Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */ + tRowcnt *pnRow /* Write the revised row estimate here */ +){ + Index *p = pBuilder->pNew->u.btree.pIndex; + int nEq = pBuilder->pNew->u.btree.nEq; + UnpackedRecord *pRec = pBuilder->pRec; + u8 aff; /* Column affinity */ + int rc; /* Subfunction return code */ + tRowcnt a[2]; /* Statistics */ + int bOk; + + assert( nEq>=1 ); + assert( nEq<=p->nColumn ); + assert( p->aSample!=0 ); + assert( p->nSample>0 ); + assert( pBuilder->nRecValidnRecValid<(nEq-1) ){ + return SQLITE_NOTFOUND; + } + + /* This is an optimization only. The call to sqlite3Stat4ProbeSetValue() + ** below would return the same value. */ + if( nEq>=p->nColumn ){ + *pnRow = 1; + return SQLITE_OK; + } + + aff = sqlite3IndexColumnAffinity(pParse->db, p, nEq-1); + rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq-1, &bOk); + pBuilder->pRec = pRec; + if( rc!=SQLITE_OK ) return rc; + if( bOk==0 ) return SQLITE_NOTFOUND; + pBuilder->nRecValid = nEq; + + whereKeyStats(pParse, p, pRec, 0, a); + WHERETRACE(0x10,("equality scan regions: %d\n", (int)a[1])); + *pnRow = a[1]; + + return rc; +} +#endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */ + +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 +/* +** Estimate the number of rows that will be returned based on +** an IN constraint where the right-hand side of the IN operator +** is a list of values. Example: +** +** WHERE x IN (1,2,3,4) +** +** Write the estimated row count into *pnRow and return SQLITE_OK. +** If unable to make an estimate, leave *pnRow unchanged and return +** non-zero. +** +** This routine can fail if it is unable to load a collating sequence +** required for string comparison, or if unable to allocate memory +** for a UTF conversion required for comparison. The error is stored +** in the pParse structure. +*/ +static int whereInScanEst( + Parse *pParse, /* Parsing & code generating context */ + WhereLoopBuilder *pBuilder, + ExprList *pList, /* The value list on the RHS of "x IN (v1,v2,v3,...)" */ + tRowcnt *pnRow /* Write the revised row estimate here */ +){ + Index *p = pBuilder->pNew->u.btree.pIndex; + i64 nRow0 = sqlite3LogEstToInt(p->aiRowLogEst[0]); + int nRecValid = pBuilder->nRecValid; + int rc = SQLITE_OK; /* Subfunction return code */ + tRowcnt nEst; /* Number of rows for a single term */ + tRowcnt nRowEst = 0; /* New estimate of the number of rows */ + int i; /* Loop counter */ + + assert( p->aSample!=0 ); + for(i=0; rc==SQLITE_OK && inExpr; i++){ + nEst = nRow0; + rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst); + nRowEst += nEst; + pBuilder->nRecValid = nRecValid; + } + + if( rc==SQLITE_OK ){ + if( nRowEst > nRow0 ) nRowEst = nRow0; + *pnRow = nRowEst; + WHERETRACE(0x10,("IN row estimate: est=%d\n", nRowEst)); + } + assert( pBuilder->nRecValid==nRecValid ); + return rc; +} +#endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */ + + +#ifdef WHERETRACE_ENABLED +/* +** Print the content of a WhereTerm object +*/ +static void whereTermPrint(WhereTerm *pTerm, int iTerm){ + if( pTerm==0 ){ + sqlite3DebugPrintf("TERM-%-3d NULL\n", iTerm); + }else{ + char zType[4]; + memcpy(zType, "...", 4); + if( pTerm->wtFlags & TERM_VIRTUAL ) zType[0] = 'V'; + if( pTerm->eOperator & WO_EQUIV ) zType[1] = 'E'; + if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) zType[2] = 'L'; + sqlite3DebugPrintf( + "TERM-%-3d %p %s cursor=%-3d prob=%-3d op=0x%03x wtFlags=0x%04x\n", + iTerm, pTerm, zType, pTerm->leftCursor, pTerm->truthProb, + pTerm->eOperator, pTerm->wtFlags); + sqlite3TreeViewExpr(0, pTerm->pExpr, 0); + } +} +#endif + +#ifdef WHERETRACE_ENABLED +/* +** Print a WhereLoop object for debugging purposes +*/ +static void whereLoopPrint(WhereLoop *p, WhereClause *pWC){ + WhereInfo *pWInfo = pWC->pWInfo; + int nb = 1+(pWInfo->pTabList->nSrc+7)/8; + struct SrcList_item *pItem = pWInfo->pTabList->a + p->iTab; + Table *pTab = pItem->pTab; + sqlite3DebugPrintf("%c%2d.%0*llx.%0*llx", p->cId, + p->iTab, nb, p->maskSelf, nb, p->prereq); + sqlite3DebugPrintf(" %12s", + pItem->zAlias ? pItem->zAlias : pTab->zName); + if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){ + const char *zName; + if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){ + if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){ + int i = sqlite3Strlen30(zName) - 1; + while( zName[i]!='_' ) i--; + zName += i; + } + sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq); + }else{ + sqlite3DebugPrintf("%20s",""); + } + }else{ + char *z; + if( p->u.vtab.idxStr ){ + z = sqlite3_mprintf("(%d,\"%s\",%x)", + p->u.vtab.idxNum, p->u.vtab.idxStr, p->u.vtab.omitMask); + }else{ + z = sqlite3_mprintf("(%d,%x)", p->u.vtab.idxNum, p->u.vtab.omitMask); + } + sqlite3DebugPrintf(" %-19s", z); + sqlite3_free(z); + } + if( p->wsFlags & WHERE_SKIPSCAN ){ + sqlite3DebugPrintf(" f %05x %d-%d", p->wsFlags, p->nLTerm,p->nSkip); + }else{ + sqlite3DebugPrintf(" f %05x N %d", p->wsFlags, p->nLTerm); + } + sqlite3DebugPrintf(" cost %d,%d,%d\n", p->rSetup, p->rRun, p->nOut); + if( p->nLTerm && (sqlite3WhereTrace & 0x100)!=0 ){ + int i; + for(i=0; inLTerm; i++){ + whereTermPrint(p->aLTerm[i], i); + } + } +} +#endif + +/* +** Convert bulk memory into a valid WhereLoop that can be passed +** to whereLoopClear harmlessly. +*/ +static void whereLoopInit(WhereLoop *p){ + p->aLTerm = p->aLTermSpace; + p->nLTerm = 0; + p->nLSlot = ArraySize(p->aLTermSpace); + p->wsFlags = 0; +} + +/* +** Clear the WhereLoop.u union. Leave WhereLoop.pLTerm intact. +*/ +static void whereLoopClearUnion(sqlite3 *db, WhereLoop *p){ + if( p->wsFlags & (WHERE_VIRTUALTABLE|WHERE_AUTO_INDEX) ){ + if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){ + sqlite3_free(p->u.vtab.idxStr); + p->u.vtab.needFree = 0; + p->u.vtab.idxStr = 0; + }else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){ + sqlite3DbFree(db, p->u.btree.pIndex->zColAff); + sqlite3DbFree(db, p->u.btree.pIndex); + p->u.btree.pIndex = 0; + } + } +} + +/* +** Deallocate internal memory used by a WhereLoop object +*/ +static void whereLoopClear(sqlite3 *db, WhereLoop *p){ + if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm); + whereLoopClearUnion(db, p); + whereLoopInit(p); +} + +/* +** Increase the memory allocation for pLoop->aLTerm[] to be at least n. +*/ +static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){ + WhereTerm **paNew; + if( p->nLSlot>=n ) return SQLITE_OK; + n = (n+7)&~7; + paNew = sqlite3DbMallocRaw(db, sizeof(p->aLTerm[0])*n); + if( paNew==0 ) return SQLITE_NOMEM; + memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot); + if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm); + p->aLTerm = paNew; + p->nLSlot = n; + return SQLITE_OK; +} + +/* +** Transfer content from the second pLoop into the first. +*/ +static int whereLoopXfer(sqlite3 *db, WhereLoop *pTo, WhereLoop *pFrom){ + whereLoopClearUnion(db, pTo); + if( whereLoopResize(db, pTo, pFrom->nLTerm) ){ + memset(&pTo->u, 0, sizeof(pTo->u)); + return SQLITE_NOMEM; + } + memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ); + memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0])); + if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){ + pFrom->u.vtab.needFree = 0; + }else if( (pFrom->wsFlags & WHERE_AUTO_INDEX)!=0 ){ + pFrom->u.btree.pIndex = 0; + } + return SQLITE_OK; +} + +/* +** Delete a WhereLoop object +*/ +static void whereLoopDelete(sqlite3 *db, WhereLoop *p){ + whereLoopClear(db, p); + sqlite3DbFree(db, p); +} + +/* +** Free a WhereInfo structure +*/ +static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){ + if( ALWAYS(pWInfo) ){ + int i; + for(i=0; inLevel; i++){ + WhereLevel *pLevel = &pWInfo->a[i]; + if( pLevel->pWLoop && (pLevel->pWLoop->wsFlags & WHERE_IN_ABLE) ){ + sqlite3DbFree(db, pLevel->u.in.aInLoop); + } + } + sqlite3WhereClauseClear(&pWInfo->sWC); + while( pWInfo->pLoops ){ + WhereLoop *p = pWInfo->pLoops; + pWInfo->pLoops = p->pNextLoop; + whereLoopDelete(db, p); + } + sqlite3DbFree(db, pWInfo); + } +} + +/* +** Return TRUE if all of the following are true: +** +** (1) X has the same or lower cost that Y +** (2) X is a proper subset of Y +** (3) X skips at least as many columns as Y +** +** By "proper subset" we mean that X uses fewer WHERE clause terms +** than Y and that every WHERE clause term used by X is also used +** by Y. +** +** If X is a proper subset of Y then Y is a better choice and ought +** to have a lower cost. This routine returns TRUE when that cost +** relationship is inverted and needs to be adjusted. The third rule +** was added because if X uses skip-scan less than Y it still might +** deserve a lower cost even if it is a proper subset of Y. +*/ +static int whereLoopCheaperProperSubset( + const WhereLoop *pX, /* First WhereLoop to compare */ + const WhereLoop *pY /* Compare against this WhereLoop */ +){ + int i, j; + if( pX->nLTerm-pX->nSkip >= pY->nLTerm-pY->nSkip ){ + return 0; /* X is not a subset of Y */ + } + if( pY->nSkip > pX->nSkip ) return 0; + if( pX->rRun >= pY->rRun ){ + if( pX->rRun > pY->rRun ) return 0; /* X costs more than Y */ + if( pX->nOut > pY->nOut ) return 0; /* X costs more than Y */ + } + for(i=pX->nLTerm-1; i>=0; i--){ + if( pX->aLTerm[i]==0 ) continue; + for(j=pY->nLTerm-1; j>=0; j--){ + if( pY->aLTerm[j]==pX->aLTerm[i] ) break; + } + if( j<0 ) return 0; /* X not a subset of Y since term X[i] not used by Y */ + } + return 1; /* All conditions meet */ +} + +/* +** Try to adjust the cost of WhereLoop pTemplate upwards or downwards so +** that: +** +** (1) pTemplate costs less than any other WhereLoops that are a proper +** subset of pTemplate +** +** (2) pTemplate costs more than any other WhereLoops for which pTemplate +** is a proper subset. +** +** To say "WhereLoop X is a proper subset of Y" means that X uses fewer +** WHERE clause terms than Y and that every WHERE clause term used by X is +** also used by Y. +*/ +static void whereLoopAdjustCost(const WhereLoop *p, WhereLoop *pTemplate){ + if( (pTemplate->wsFlags & WHERE_INDEXED)==0 ) return; + for(; p; p=p->pNextLoop){ + if( p->iTab!=pTemplate->iTab ) continue; + if( (p->wsFlags & WHERE_INDEXED)==0 ) continue; + if( whereLoopCheaperProperSubset(p, pTemplate) ){ + /* Adjust pTemplate cost downward so that it is cheaper than its + ** subset p. */ + WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n", + pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut-1)); + pTemplate->rRun = p->rRun; + pTemplate->nOut = p->nOut - 1; + }else if( whereLoopCheaperProperSubset(pTemplate, p) ){ + /* Adjust pTemplate cost upward so that it is costlier than p since + ** pTemplate is a proper subset of p */ + WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n", + pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut+1)); + pTemplate->rRun = p->rRun; + pTemplate->nOut = p->nOut + 1; + } + } +} + +/* +** Search the list of WhereLoops in *ppPrev looking for one that can be +** supplanted by pTemplate. +** +** Return NULL if the WhereLoop list contains an entry that can supplant +** pTemplate, in other words if pTemplate does not belong on the list. +** +** If pX is a WhereLoop that pTemplate can supplant, then return the +** link that points to pX. +** +** If pTemplate cannot supplant any existing element of the list but needs +** to be added to the list, then return a pointer to the tail of the list. +*/ +static WhereLoop **whereLoopFindLesser( + WhereLoop **ppPrev, + const WhereLoop *pTemplate +){ + WhereLoop *p; + for(p=(*ppPrev); p; ppPrev=&p->pNextLoop, p=*ppPrev){ + if( p->iTab!=pTemplate->iTab || p->iSortIdx!=pTemplate->iSortIdx ){ + /* If either the iTab or iSortIdx values for two WhereLoop are different + ** then those WhereLoops need to be considered separately. Neither is + ** a candidate to replace the other. */ + continue; + } + /* In the current implementation, the rSetup value is either zero + ** or the cost of building an automatic index (NlogN) and the NlogN + ** is the same for compatible WhereLoops. */ + assert( p->rSetup==0 || pTemplate->rSetup==0 + || p->rSetup==pTemplate->rSetup ); + + /* whereLoopAddBtree() always generates and inserts the automatic index + ** case first. Hence compatible candidate WhereLoops never have a larger + ** rSetup. Call this SETUP-INVARIANT */ + assert( p->rSetup>=pTemplate->rSetup ); + + /* Any loop using an appliation-defined index (or PRIMARY KEY or + ** UNIQUE constraint) with one or more == constraints is better + ** than an automatic index. Unless it is a skip-scan. */ + if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 + && (pTemplate->nSkip)==0 + && (pTemplate->wsFlags & WHERE_INDEXED)!=0 + && (pTemplate->wsFlags & WHERE_COLUMN_EQ)!=0 + && (p->prereq & pTemplate->prereq)==pTemplate->prereq + ){ + break; + } + + /* If existing WhereLoop p is better than pTemplate, pTemplate can be + ** discarded. WhereLoop p is better if: + ** (1) p has no more dependencies than pTemplate, and + ** (2) p has an equal or lower cost than pTemplate + */ + if( (p->prereq & pTemplate->prereq)==p->prereq /* (1) */ + && p->rSetup<=pTemplate->rSetup /* (2a) */ + && p->rRun<=pTemplate->rRun /* (2b) */ + && p->nOut<=pTemplate->nOut /* (2c) */ + ){ + return 0; /* Discard pTemplate */ + } + + /* If pTemplate is always better than p, then cause p to be overwritten + ** with pTemplate. pTemplate is better than p if: + ** (1) pTemplate has no more dependences than p, and + ** (2) pTemplate has an equal or lower cost than p. + */ + if( (p->prereq & pTemplate->prereq)==pTemplate->prereq /* (1) */ + && p->rRun>=pTemplate->rRun /* (2a) */ + && p->nOut>=pTemplate->nOut /* (2b) */ + ){ + assert( p->rSetup>=pTemplate->rSetup ); /* SETUP-INVARIANT above */ + break; /* Cause p to be overwritten by pTemplate */ + } + } + return ppPrev; +} + +/* +** Insert or replace a WhereLoop entry using the template supplied. +** +** An existing WhereLoop entry might be overwritten if the new template +** is better and has fewer dependencies. Or the template will be ignored +** and no insert will occur if an existing WhereLoop is faster and has +** fewer dependencies than the template. Otherwise a new WhereLoop is +** added based on the template. +** +** If pBuilder->pOrSet is not NULL then we care about only the +** prerequisites and rRun and nOut costs of the N best loops. That +** information is gathered in the pBuilder->pOrSet object. This special +** processing mode is used only for OR clause processing. +** +** When accumulating multiple loops (when pBuilder->pOrSet is NULL) we +** still might overwrite similar loops with the new template if the +** new template is better. Loops may be overwritten if the following +** conditions are met: +** +** (1) They have the same iTab. +** (2) They have the same iSortIdx. +** (3) The template has same or fewer dependencies than the current loop +** (4) The template has the same or lower cost than the current loop +*/ +static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){ + WhereLoop **ppPrev, *p; + WhereInfo *pWInfo = pBuilder->pWInfo; + sqlite3 *db = pWInfo->pParse->db; + + /* If pBuilder->pOrSet is defined, then only keep track of the costs + ** and prereqs. + */ + if( pBuilder->pOrSet!=0 ){ + if( pTemplate->nLTerm ){ +#if WHERETRACE_ENABLED + u16 n = pBuilder->pOrSet->n; + int x = +#endif + whereOrInsert(pBuilder->pOrSet, pTemplate->prereq, pTemplate->rRun, + pTemplate->nOut); +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + sqlite3DebugPrintf(x?" or-%d: ":" or-X: ", n); + whereLoopPrint(pTemplate, pBuilder->pWC); + } +#endif + } + return SQLITE_OK; + } + + /* Look for an existing WhereLoop to replace with pTemplate + */ + whereLoopAdjustCost(pWInfo->pLoops, pTemplate); + ppPrev = whereLoopFindLesser(&pWInfo->pLoops, pTemplate); + + if( ppPrev==0 ){ + /* There already exists a WhereLoop on the list that is better + ** than pTemplate, so just ignore pTemplate */ +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + sqlite3DebugPrintf(" skip: "); + whereLoopPrint(pTemplate, pBuilder->pWC); + } +#endif + return SQLITE_OK; + }else{ + p = *ppPrev; + } + + /* If we reach this point it means that either p[] should be overwritten + ** with pTemplate[] if p[] exists, or if p==NULL then allocate a new + ** WhereLoop and insert it. + */ +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + if( p!=0 ){ + sqlite3DebugPrintf("replace: "); + whereLoopPrint(p, pBuilder->pWC); + } + sqlite3DebugPrintf(" add: "); + whereLoopPrint(pTemplate, pBuilder->pWC); + } +#endif + if( p==0 ){ + /* Allocate a new WhereLoop to add to the end of the list */ + *ppPrev = p = sqlite3DbMallocRaw(db, sizeof(WhereLoop)); + if( p==0 ) return SQLITE_NOMEM; + whereLoopInit(p); + p->pNextLoop = 0; + }else{ + /* We will be overwriting WhereLoop p[]. But before we do, first + ** go through the rest of the list and delete any other entries besides + ** p[] that are also supplated by pTemplate */ + WhereLoop **ppTail = &p->pNextLoop; + WhereLoop *pToDel; + while( *ppTail ){ + ppTail = whereLoopFindLesser(ppTail, pTemplate); + if( ppTail==0 ) break; + pToDel = *ppTail; + if( pToDel==0 ) break; + *ppTail = pToDel->pNextLoop; +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + sqlite3DebugPrintf(" delete: "); + whereLoopPrint(pToDel, pBuilder->pWC); + } +#endif + whereLoopDelete(db, pToDel); + } + } + whereLoopXfer(db, p, pTemplate); + if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){ + Index *pIndex = p->u.btree.pIndex; + if( pIndex && pIndex->tnum==0 ){ + p->u.btree.pIndex = 0; + } + } + return SQLITE_OK; +} + +/* +** Adjust the WhereLoop.nOut value downward to account for terms of the +** WHERE clause that reference the loop but which are not used by an +** index. +* +** For every WHERE clause term that is not used by the index +** and which has a truth probability assigned by one of the likelihood(), +** likely(), or unlikely() SQL functions, reduce the estimated number +** of output rows by the probability specified. +** +** TUNING: For every WHERE clause term that is not used by the index +** and which does not have an assigned truth probability, heuristics +** described below are used to try to estimate the truth probability. +** TODO --> Perhaps this is something that could be improved by better +** table statistics. +** +** Heuristic 1: Estimate the truth probability as 93.75%. The 93.75% +** value corresponds to -1 in LogEst notation, so this means decrement +** the WhereLoop.nOut field for every such WHERE clause term. +** +** Heuristic 2: If there exists one or more WHERE clause terms of the +** form "x==EXPR" and EXPR is not a constant 0 or 1, then make sure the +** final output row estimate is no greater than 1/4 of the total number +** of rows in the table. In other words, assume that x==EXPR will filter +** out at least 3 out of 4 rows. If EXPR is -1 or 0 or 1, then maybe the +** "x" column is boolean or else -1 or 0 or 1 is a common default value +** on the "x" column and so in that case only cap the output row estimate +** at 1/2 instead of 1/4. +*/ +static void whereLoopOutputAdjust( + WhereClause *pWC, /* The WHERE clause */ + WhereLoop *pLoop, /* The loop to adjust downward */ + LogEst nRow /* Number of rows in the entire table */ +){ + WhereTerm *pTerm, *pX; + Bitmask notAllowed = ~(pLoop->prereq|pLoop->maskSelf); + int i, j, k; + LogEst iReduce = 0; /* pLoop->nOut should not exceed nRow-iReduce */ + + assert( (pLoop->wsFlags & WHERE_AUTO_INDEX)==0 ); + for(i=pWC->nTerm, pTerm=pWC->a; i>0; i--, pTerm++){ + if( (pTerm->wtFlags & TERM_VIRTUAL)!=0 ) break; + if( (pTerm->prereqAll & pLoop->maskSelf)==0 ) continue; + if( (pTerm->prereqAll & notAllowed)!=0 ) continue; + for(j=pLoop->nLTerm-1; j>=0; j--){ + pX = pLoop->aLTerm[j]; + if( pX==0 ) continue; + if( pX==pTerm ) break; + if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break; + } + if( j<0 ){ + if( pTerm->truthProb<=0 ){ + /* If a truth probability is specified using the likelihood() hints, + ** then use the probability provided by the application. */ + pLoop->nOut += pTerm->truthProb; + }else{ + /* In the absence of explicit truth probabilities, use heuristics to + ** guess a reasonable truth probability. */ + pLoop->nOut--; + if( pTerm->eOperator&(WO_EQ|WO_IS) ){ + Expr *pRight = pTerm->pExpr->pRight; + testcase( pTerm->pExpr->op==TK_IS ); + if( sqlite3ExprIsInteger(pRight, &k) && k>=(-1) && k<=1 ){ + k = 10; + }else{ + k = 20; + } + if( iReducenOut > nRow-iReduce ) pLoop->nOut = nRow - iReduce; +} + +/* +** Adjust the cost C by the costMult facter T. This only occurs if +** compiled with -DSQLITE_ENABLE_COSTMULT +*/ +#ifdef SQLITE_ENABLE_COSTMULT +# define ApplyCostMultiplier(C,T) C += T +#else +# define ApplyCostMultiplier(C,T) +#endif + +/* +** We have so far matched pBuilder->pNew->u.btree.nEq terms of the +** index pIndex. Try to match one more. +** +** When this function is called, pBuilder->pNew->nOut contains the +** number of rows expected to be visited by filtering using the nEq +** terms only. If it is modified, this value is restored before this +** function returns. +** +** If pProbe->tnum==0, that means pIndex is a fake index used for the +** INTEGER PRIMARY KEY. +*/ +static int whereLoopAddBtreeIndex( + WhereLoopBuilder *pBuilder, /* The WhereLoop factory */ + struct SrcList_item *pSrc, /* FROM clause term being analyzed */ + Index *pProbe, /* An index on pSrc */ + LogEst nInMul /* log(Number of iterations due to IN) */ +){ + WhereInfo *pWInfo = pBuilder->pWInfo; /* WHERE analyse context */ + Parse *pParse = pWInfo->pParse; /* Parsing context */ + sqlite3 *db = pParse->db; /* Database connection malloc context */ + WhereLoop *pNew; /* Template WhereLoop under construction */ + WhereTerm *pTerm; /* A WhereTerm under consideration */ + int opMask; /* Valid operators for constraints */ + WhereScan scan; /* Iterator for WHERE terms */ + Bitmask saved_prereq; /* Original value of pNew->prereq */ + u16 saved_nLTerm; /* Original value of pNew->nLTerm */ + u16 saved_nEq; /* Original value of pNew->u.btree.nEq */ + u16 saved_nSkip; /* Original value of pNew->nSkip */ + u32 saved_wsFlags; /* Original value of pNew->wsFlags */ + LogEst saved_nOut; /* Original value of pNew->nOut */ + int rc = SQLITE_OK; /* Return code */ + LogEst rSize; /* Number of rows in the table */ + LogEst rLogSize; /* Logarithm of table size */ + WhereTerm *pTop = 0, *pBtm = 0; /* Top and bottom range constraints */ + + pNew = pBuilder->pNew; + if( db->mallocFailed ) return SQLITE_NOMEM; + + assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 ); + assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 ); + if( pNew->wsFlags & WHERE_BTM_LIMIT ){ + opMask = WO_LT|WO_LE; + }else if( /*pProbe->tnum<=0 ||*/ (pSrc->fg.jointype & JT_LEFT)!=0 ){ + opMask = WO_EQ|WO_IN|WO_GT|WO_GE|WO_LT|WO_LE; + }else{ + opMask = WO_EQ|WO_IN|WO_GT|WO_GE|WO_LT|WO_LE|WO_ISNULL|WO_IS; + } + if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE); + + assert( pNew->u.btree.nEqnColumn ); + + saved_nEq = pNew->u.btree.nEq; + saved_nSkip = pNew->nSkip; + saved_nLTerm = pNew->nLTerm; + saved_wsFlags = pNew->wsFlags; + saved_prereq = pNew->prereq; + saved_nOut = pNew->nOut; + pTerm = whereScanInit(&scan, pBuilder->pWC, pSrc->iCursor, saved_nEq, + opMask, pProbe); + pNew->rSetup = 0; + rSize = pProbe->aiRowLogEst[0]; + rLogSize = estLog(rSize); + for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){ + u16 eOp = pTerm->eOperator; /* Shorthand for pTerm->eOperator */ + LogEst rCostIdx; + LogEst nOutUnadjusted; /* nOut before IN() and WHERE adjustments */ + int nIn = 0; +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + int nRecValid = pBuilder->nRecValid; +#endif + if( (eOp==WO_ISNULL || (pTerm->wtFlags&TERM_VNULL)!=0) + && indexColumnNotNull(pProbe, saved_nEq) + ){ + continue; /* ignore IS [NOT] NULL constraints on NOT NULL columns */ + } + if( pTerm->prereqRight & pNew->maskSelf ) continue; + + /* Do not allow the upper bound of a LIKE optimization range constraint + ** to mix with a lower range bound from some other source */ + if( pTerm->wtFlags & TERM_LIKEOPT && pTerm->eOperator==WO_LT ) continue; + + pNew->wsFlags = saved_wsFlags; + pNew->u.btree.nEq = saved_nEq; + pNew->nLTerm = saved_nLTerm; + if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */ + pNew->aLTerm[pNew->nLTerm++] = pTerm; + pNew->prereq = (saved_prereq | pTerm->prereqRight) & ~pNew->maskSelf; + + assert( nInMul==0 + || (pNew->wsFlags & WHERE_COLUMN_NULL)!=0 + || (pNew->wsFlags & WHERE_COLUMN_IN)!=0 + || (pNew->wsFlags & WHERE_SKIPSCAN)!=0 + ); + + if( eOp & WO_IN ){ + Expr *pExpr = pTerm->pExpr; + pNew->wsFlags |= WHERE_COLUMN_IN; + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ + /* "x IN (SELECT ...)": TUNING: the SELECT returns 25 rows */ + nIn = 46; assert( 46==sqlite3LogEst(25) ); + }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){ + /* "x IN (value, value, ...)" */ + nIn = sqlite3LogEst(pExpr->x.pList->nExpr); + } + assert( nIn>0 ); /* RHS always has 2 or more terms... The parser + ** changes "x IN (?)" into "x=?". */ + + }else if( eOp & (WO_EQ|WO_IS) ){ + int iCol = pProbe->aiColumn[saved_nEq]; + pNew->wsFlags |= WHERE_COLUMN_EQ; + assert( saved_nEq==pNew->u.btree.nEq ); + if( iCol==XN_ROWID + || (iCol>0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1) + ){ + if( iCol>=0 && pProbe->uniqNotNull==0 ){ + pNew->wsFlags |= WHERE_UNQ_WANTED; + }else{ + pNew->wsFlags |= WHERE_ONEROW; + } + } + }else if( eOp & WO_ISNULL ){ + pNew->wsFlags |= WHERE_COLUMN_NULL; + }else if( eOp & (WO_GT|WO_GE) ){ + testcase( eOp & WO_GT ); + testcase( eOp & WO_GE ); + pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_BTM_LIMIT; + pBtm = pTerm; + pTop = 0; + if( pTerm->wtFlags & TERM_LIKEOPT ){ + /* Range contraints that come from the LIKE optimization are + ** always used in pairs. */ + pTop = &pTerm[1]; + assert( (pTop-(pTerm->pWC->a))pWC->nTerm ); + assert( pTop->wtFlags & TERM_LIKEOPT ); + assert( pTop->eOperator==WO_LT ); + if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */ + pNew->aLTerm[pNew->nLTerm++] = pTop; + pNew->wsFlags |= WHERE_TOP_LIMIT; + } + }else{ + assert( eOp & (WO_LT|WO_LE) ); + testcase( eOp & WO_LT ); + testcase( eOp & WO_LE ); + pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_TOP_LIMIT; + pTop = pTerm; + pBtm = (pNew->wsFlags & WHERE_BTM_LIMIT)!=0 ? + pNew->aLTerm[pNew->nLTerm-2] : 0; + } + + /* At this point pNew->nOut is set to the number of rows expected to + ** be visited by the index scan before considering term pTerm, or the + ** values of nIn and nInMul. In other words, assuming that all + ** "x IN(...)" terms are replaced with "x = ?". This block updates + ** the value of pNew->nOut to account for pTerm (but not nIn/nInMul). */ + assert( pNew->nOut==saved_nOut ); + if( pNew->wsFlags & WHERE_COLUMN_RANGE ){ + /* Adjust nOut using stat3/stat4 data. Or, if there is no stat3/stat4 + ** data, using some other estimate. */ + whereRangeScanEst(pParse, pBuilder, pBtm, pTop, pNew); + }else{ + int nEq = ++pNew->u.btree.nEq; + assert( eOp & (WO_ISNULL|WO_EQ|WO_IN|WO_IS) ); + + assert( pNew->nOut==saved_nOut ); + if( pTerm->truthProb<=0 && pProbe->aiColumn[saved_nEq]>=0 ){ + assert( (eOp & WO_IN) || nIn==0 ); + testcase( eOp & WO_IN ); + pNew->nOut += pTerm->truthProb; + pNew->nOut -= nIn; + }else{ +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + tRowcnt nOut = 0; + if( nInMul==0 + && pProbe->nSample + && pNew->u.btree.nEq<=pProbe->nSampleCol + && ((eOp & WO_IN)==0 || !ExprHasProperty(pTerm->pExpr, EP_xIsSelect)) + ){ + Expr *pExpr = pTerm->pExpr; + if( (eOp & (WO_EQ|WO_ISNULL|WO_IS))!=0 ){ + testcase( eOp & WO_EQ ); + testcase( eOp & WO_IS ); + testcase( eOp & WO_ISNULL ); + rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut); + }else{ + rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut); + } + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + if( rc!=SQLITE_OK ) break; /* Jump out of the pTerm loop */ + if( nOut ){ + pNew->nOut = sqlite3LogEst(nOut); + if( pNew->nOut>saved_nOut ) pNew->nOut = saved_nOut; + pNew->nOut -= nIn; + } + } + if( nOut==0 ) +#endif + { + pNew->nOut += (pProbe->aiRowLogEst[nEq] - pProbe->aiRowLogEst[nEq-1]); + if( eOp & WO_ISNULL ){ + /* TUNING: If there is no likelihood() value, assume that a + ** "col IS NULL" expression matches twice as many rows + ** as (col=?). */ + pNew->nOut += 10; + } + } + } + } + + /* Set rCostIdx to the cost of visiting selected rows in index. Add + ** it to pNew->rRun, which is currently set to the cost of the index + ** seek only. Then, if this is a non-covering index, add the cost of + ** visiting the rows in the main table. */ + rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow; + pNew->rRun = sqlite3LogEstAdd(rLogSize, rCostIdx); + if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK))==0 ){ + pNew->rRun = sqlite3LogEstAdd(pNew->rRun, pNew->nOut + 16); + } + ApplyCostMultiplier(pNew->rRun, pProbe->pTable->costMult); + + nOutUnadjusted = pNew->nOut; + pNew->rRun += nInMul + nIn; + pNew->nOut += nInMul + nIn; + whereLoopOutputAdjust(pBuilder->pWC, pNew, rSize); + rc = whereLoopInsert(pBuilder, pNew); + + if( pNew->wsFlags & WHERE_COLUMN_RANGE ){ + pNew->nOut = saved_nOut; + }else{ + pNew->nOut = nOutUnadjusted; + } + + if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 + && pNew->u.btree.nEqnColumn + ){ + whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nInMul+nIn); + } + pNew->nOut = saved_nOut; +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + pBuilder->nRecValid = nRecValid; +#endif + } + pNew->prereq = saved_prereq; + pNew->u.btree.nEq = saved_nEq; + pNew->nSkip = saved_nSkip; + pNew->wsFlags = saved_wsFlags; + pNew->nOut = saved_nOut; + pNew->nLTerm = saved_nLTerm; + + /* Consider using a skip-scan if there are no WHERE clause constraints + ** available for the left-most terms of the index, and if the average + ** number of repeats in the left-most terms is at least 18. + ** + ** The magic number 18 is selected on the basis that scanning 17 rows + ** is almost always quicker than an index seek (even though if the index + ** contains fewer than 2^17 rows we assume otherwise in other parts of + ** the code). And, even if it is not, it should not be too much slower. + ** On the other hand, the extra seeks could end up being significantly + ** more expensive. */ + assert( 42==sqlite3LogEst(18) ); + if( saved_nEq==saved_nSkip + && saved_nEq+1nKeyCol + && pProbe->noSkipScan==0 + && pProbe->aiRowLogEst[saved_nEq+1]>=42 /* TUNING: Minimum for skip-scan */ + && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK + ){ + LogEst nIter; + pNew->u.btree.nEq++; + pNew->nSkip++; + pNew->aLTerm[pNew->nLTerm++] = 0; + pNew->wsFlags |= WHERE_SKIPSCAN; + nIter = pProbe->aiRowLogEst[saved_nEq] - pProbe->aiRowLogEst[saved_nEq+1]; + pNew->nOut -= nIter; + /* TUNING: Because uncertainties in the estimates for skip-scan queries, + ** add a 1.375 fudge factor to make skip-scan slightly less likely. */ + nIter += 5; + whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nIter + nInMul); + pNew->nOut = saved_nOut; + pNew->u.btree.nEq = saved_nEq; + pNew->nSkip = saved_nSkip; + pNew->wsFlags = saved_wsFlags; + } + + return rc; +} + +/* +** Return True if it is possible that pIndex might be useful in +** implementing the ORDER BY clause in pBuilder. +** +** Return False if pBuilder does not contain an ORDER BY clause or +** if there is no way for pIndex to be useful in implementing that +** ORDER BY clause. +*/ +static int indexMightHelpWithOrderBy( + WhereLoopBuilder *pBuilder, + Index *pIndex, + int iCursor +){ + ExprList *pOB; + ExprList *aColExpr; + int ii, jj; + + if( pIndex->bUnordered ) return 0; + if( (pOB = pBuilder->pWInfo->pOrderBy)==0 ) return 0; + for(ii=0; iinExpr; ii++){ + Expr *pExpr = sqlite3ExprSkipCollate(pOB->a[ii].pExpr); + if( pExpr->op==TK_COLUMN && pExpr->iTable==iCursor ){ + if( pExpr->iColumn<0 ) return 1; + for(jj=0; jjnKeyCol; jj++){ + if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1; + } + }else if( (aColExpr = pIndex->aColExpr)!=0 ){ + for(jj=0; jjnKeyCol; jj++){ + if( pIndex->aiColumn[jj]!=XN_EXPR ) continue; + if( sqlite3ExprCompare(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){ + return 1; + } + } + } + } + return 0; +} + +/* +** Return a bitmask where 1s indicate that the corresponding column of +** the table is used by an index. Only the first 63 columns are considered. +*/ +static Bitmask columnsInIndex(Index *pIdx){ + Bitmask m = 0; + int j; + for(j=pIdx->nColumn-1; j>=0; j--){ + int x = pIdx->aiColumn[j]; + if( x>=0 ){ + testcase( x==BMS-1 ); + testcase( x==BMS-2 ); + if( xop==TK_AND ){ + if( !whereUsablePartialIndex(iTab,pWC,pWhere->pLeft) ) return 0; + pWhere = pWhere->pRight; + } + for(i=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + Expr *pExpr = pTerm->pExpr; + if( sqlite3ExprImpliesExpr(pExpr, pWhere, iTab) + && (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab) + ){ + return 1; + } + } + return 0; +} + +/* +** Add all WhereLoop objects for a single table of the join where the table +** is idenfied by pBuilder->pNew->iTab. That table is guaranteed to be +** a b-tree table, not a virtual table. +** +** The costs (WhereLoop.rRun) of the b-tree loops added by this function +** are calculated as follows: +** +** For a full scan, assuming the table (or index) contains nRow rows: +** +** cost = nRow * 3.0 // full-table scan +** cost = nRow * K // scan of covering index +** cost = nRow * (K+3.0) // scan of non-covering index +** +** where K is a value between 1.1 and 3.0 set based on the relative +** estimated average size of the index and table records. +** +** For an index scan, where nVisit is the number of index rows visited +** by the scan, and nSeek is the number of seek operations required on +** the index b-tree: +** +** cost = nSeek * (log(nRow) + K * nVisit) // covering index +** cost = nSeek * (log(nRow) + (K+3.0) * nVisit) // non-covering index +** +** Normally, nSeek is 1. nSeek values greater than 1 come about if the +** WHERE clause includes "x IN (....)" terms used in place of "x=?". Or when +** implicit "x IN (SELECT x FROM tbl)" terms are added for skip-scans. +** +** The estimated values (nRow, nVisit, nSeek) often contain a large amount +** of uncertainty. For this reason, scoring is designed to pick plans that +** "do the least harm" if the estimates are inaccurate. For example, a +** log(nRow) factor is omitted from a non-covering index scan in order to +** bias the scoring in favor of using an index, since the worst-case +** performance of using an index is far better than the worst-case performance +** of a full table scan. +*/ +static int whereLoopAddBtree( + WhereLoopBuilder *pBuilder, /* WHERE clause information */ + Bitmask mExtra /* Extra prerequesites for using this table */ +){ + WhereInfo *pWInfo; /* WHERE analysis context */ + Index *pProbe; /* An index we are evaluating */ + Index sPk; /* A fake index object for the primary key */ + LogEst aiRowEstPk[2]; /* The aiRowLogEst[] value for the sPk index */ + i16 aiColumnPk = -1; /* The aColumn[] value for the sPk index */ + SrcList *pTabList; /* The FROM clause */ + struct SrcList_item *pSrc; /* The FROM clause btree term to add */ + WhereLoop *pNew; /* Template WhereLoop object */ + int rc = SQLITE_OK; /* Return code */ + int iSortIdx = 1; /* Index number */ + int b; /* A boolean value */ + LogEst rSize; /* number of rows in the table */ + LogEst rLogSize; /* Logarithm of the number of rows in the table */ + WhereClause *pWC; /* The parsed WHERE clause */ + Table *pTab; /* Table being queried */ + + pNew = pBuilder->pNew; + pWInfo = pBuilder->pWInfo; + pTabList = pWInfo->pTabList; + pSrc = pTabList->a + pNew->iTab; + pTab = pSrc->pTab; + pWC = pBuilder->pWC; + assert( !IsVirtual(pSrc->pTab) ); + + if( pSrc->pIBIndex ){ + /* An INDEXED BY clause specifies a particular index to use */ + pProbe = pSrc->pIBIndex; + }else if( !HasRowid(pTab) ){ + pProbe = pTab->pIndex; + }else{ + /* There is no INDEXED BY clause. Create a fake Index object in local + ** variable sPk to represent the rowid primary key index. Make this + ** fake index the first in a chain of Index objects with all of the real + ** indices to follow */ + Index *pFirst; /* First of real indices on the table */ + memset(&sPk, 0, sizeof(Index)); + sPk.nKeyCol = 1; + sPk.nColumn = 1; + sPk.aiColumn = &aiColumnPk; + sPk.aiRowLogEst = aiRowEstPk; + sPk.onError = OE_Replace; + sPk.pTable = pTab; + sPk.szIdxRow = pTab->szTabRow; + aiRowEstPk[0] = pTab->nRowLogEst; + aiRowEstPk[1] = 0; + pFirst = pSrc->pTab->pIndex; + if( pSrc->fg.notIndexed==0 ){ + /* The real indices of the table are only considered if the + ** NOT INDEXED qualifier is omitted from the FROM clause */ + sPk.pNext = pFirst; + } + pProbe = &sPk; + } + rSize = pTab->nRowLogEst; + rLogSize = estLog(rSize); + +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX + /* Automatic indexes */ + if( !pBuilder->pOrSet /* Not part of an OR optimization */ + && (pWInfo->wctrlFlags & WHERE_NO_AUTOINDEX)==0 + && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0 + && pSrc->pIBIndex==0 /* Has no INDEXED BY clause */ + && !pSrc->fg.notIndexed /* Has no NOT INDEXED clause */ + && HasRowid(pTab) /* Not WITHOUT ROWID table. (FIXME: Why not?) */ + && !pSrc->fg.isCorrelated /* Not a correlated subquery */ + && !pSrc->fg.isRecursive /* Not a recursive common table expression. */ + ){ + /* Generate auto-index WhereLoops */ + WhereTerm *pTerm; + WhereTerm *pWCEnd = pWC->a + pWC->nTerm; + for(pTerm=pWC->a; rc==SQLITE_OK && pTermprereqRight & pNew->maskSelf ) continue; + if( termCanDriveIndex(pTerm, pSrc, 0) ){ + pNew->u.btree.nEq = 1; + pNew->nSkip = 0; + pNew->u.btree.pIndex = 0; + pNew->nLTerm = 1; + pNew->aLTerm[0] = pTerm; + /* TUNING: One-time cost for computing the automatic index is + ** estimated to be X*N*log2(N) where N is the number of rows in + ** the table being indexed and where X is 7 (LogEst=28) for normal + ** tables or 1.375 (LogEst=4) for views and subqueries. The value + ** of X is smaller for views and subqueries so that the query planner + ** will be more aggressive about generating automatic indexes for + ** those objects, since there is no opportunity to add schema + ** indexes on subqueries and views. */ + pNew->rSetup = rLogSize + rSize + 4; + if( pTab->pSelect==0 && (pTab->tabFlags & TF_Ephemeral)==0 ){ + pNew->rSetup += 24; + } + ApplyCostMultiplier(pNew->rSetup, pTab->costMult); + /* TUNING: Each index lookup yields 20 rows in the table. This + ** is more than the usual guess of 10 rows, since we have no way + ** of knowing how selective the index will ultimately be. It would + ** not be unreasonable to make this value much larger. */ + pNew->nOut = 43; assert( 43==sqlite3LogEst(20) ); + pNew->rRun = sqlite3LogEstAdd(rLogSize,pNew->nOut); + pNew->wsFlags = WHERE_AUTO_INDEX; + pNew->prereq = mExtra | pTerm->prereqRight; + rc = whereLoopInsert(pBuilder, pNew); + } + } + } +#endif /* SQLITE_OMIT_AUTOMATIC_INDEX */ + + /* Loop over all indices + */ + for(; rc==SQLITE_OK && pProbe; pProbe=pProbe->pNext, iSortIdx++){ + if( pProbe->pPartIdxWhere!=0 + && !whereUsablePartialIndex(pSrc->iCursor, pWC, pProbe->pPartIdxWhere) ){ + testcase( pNew->iTab!=pSrc->iCursor ); /* See ticket [98d973b8f5] */ + continue; /* Partial index inappropriate for this query */ + } + rSize = pProbe->aiRowLogEst[0]; + pNew->u.btree.nEq = 0; + pNew->nSkip = 0; + pNew->nLTerm = 0; + pNew->iSortIdx = 0; + pNew->rSetup = 0; + pNew->prereq = mExtra; + pNew->nOut = rSize; + pNew->u.btree.pIndex = pProbe; + b = indexMightHelpWithOrderBy(pBuilder, pProbe, pSrc->iCursor); + /* The ONEPASS_DESIRED flags never occurs together with ORDER BY */ + assert( (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || b==0 ); + if( pProbe->tnum<=0 ){ + /* Integer primary key index */ + pNew->wsFlags = WHERE_IPK; + + /* Full table scan */ + pNew->iSortIdx = b ? iSortIdx : 0; + /* TUNING: Cost of full table scan is (N*3.0). */ + pNew->rRun = rSize + 16; + ApplyCostMultiplier(pNew->rRun, pTab->costMult); + whereLoopOutputAdjust(pWC, pNew, rSize); + rc = whereLoopInsert(pBuilder, pNew); + pNew->nOut = rSize; + if( rc ) break; + }else{ + Bitmask m; + if( pProbe->isCovering ){ + pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED; + m = 0; + }else{ + m = pSrc->colUsed & ~columnsInIndex(pProbe); + pNew->wsFlags = (m==0) ? (WHERE_IDX_ONLY|WHERE_INDEXED) : WHERE_INDEXED; + } + + /* Full scan via index */ + if( b + || !HasRowid(pTab) + || ( m==0 + && pProbe->bUnordered==0 + && (pProbe->szIdxRowszTabRow) + && (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 + && sqlite3GlobalConfig.bUseCis + && OptimizationEnabled(pWInfo->pParse->db, SQLITE_CoverIdxScan) + ) + ){ + pNew->iSortIdx = b ? iSortIdx : 0; + + /* The cost of visiting the index rows is N*K, where K is + ** between 1.1 and 3.0, depending on the relative sizes of the + ** index and table rows. If this is a non-covering index scan, + ** also add the cost of visiting table rows (N*3.0). */ + pNew->rRun = rSize + 1 + (15*pProbe->szIdxRow)/pTab->szTabRow; + if( m!=0 ){ + pNew->rRun = sqlite3LogEstAdd(pNew->rRun, rSize+16); + } + ApplyCostMultiplier(pNew->rRun, pTab->costMult); + whereLoopOutputAdjust(pWC, pNew, rSize); + rc = whereLoopInsert(pBuilder, pNew); + pNew->nOut = rSize; + if( rc ) break; + } + } + + rc = whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, 0); +#ifdef SQLITE_ENABLE_STAT3_OR_STAT4 + sqlite3Stat4ProbeFree(pBuilder->pRec); + pBuilder->nRecValid = 0; + pBuilder->pRec = 0; +#endif + + /* If there was an INDEXED BY clause, then only that one index is + ** considered. */ + if( pSrc->pIBIndex ) break; + } + return rc; +} + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Add all WhereLoop objects for a table of the join identified by +** pBuilder->pNew->iTab. That table is guaranteed to be a virtual table. +** +** If there are no LEFT or CROSS JOIN joins in the query, both mExtra and +** mUnusable are set to 0. Otherwise, mExtra is a mask of all FROM clause +** entries that occur before the virtual table in the FROM clause and are +** separated from it by at least one LEFT or CROSS JOIN. Similarly, the +** mUnusable mask contains all FROM clause entries that occur after the +** virtual table and are separated from it by at least one LEFT or +** CROSS JOIN. +** +** For example, if the query were: +** +** ... FROM t1, t2 LEFT JOIN t3, t4, vt CROSS JOIN t5, t6; +** +** then mExtra corresponds to (t1, t2) and mUnusable to (t5, t6). +** +** All the tables in mExtra must be scanned before the current virtual +** table. So any terms for which all prerequisites are satisfied by +** mExtra may be specified as "usable" in all calls to xBestIndex. +** Conversely, all tables in mUnusable must be scanned after the current +** virtual table, so any terms for which the prerequisites overlap with +** mUnusable should always be configured as "not-usable" for xBestIndex. +*/ +static int whereLoopAddVirtual( + WhereLoopBuilder *pBuilder, /* WHERE clause information */ + Bitmask mExtra, /* Tables that must be scanned before this one */ + Bitmask mUnusable /* Tables that must be scanned after this one */ +){ + WhereInfo *pWInfo; /* WHERE analysis context */ + Parse *pParse; /* The parsing context */ + WhereClause *pWC; /* The WHERE clause */ + struct SrcList_item *pSrc; /* The FROM clause term to search */ + Table *pTab; + sqlite3 *db; + sqlite3_index_info *pIdxInfo; + struct sqlite3_index_constraint *pIdxCons; + struct sqlite3_index_constraint_usage *pUsage; + WhereTerm *pTerm; + int i, j; + int iTerm, mxTerm; + int nConstraint; + int seenIn = 0; /* True if an IN operator is seen */ + int seenVar = 0; /* True if a non-constant constraint is seen */ + int iPhase; /* 0: const w/o IN, 1: const, 2: no IN, 2: IN */ + WhereLoop *pNew; + int rc = SQLITE_OK; + + assert( (mExtra & mUnusable)==0 ); + pWInfo = pBuilder->pWInfo; + pParse = pWInfo->pParse; + db = pParse->db; + pWC = pBuilder->pWC; + pNew = pBuilder->pNew; + pSrc = &pWInfo->pTabList->a[pNew->iTab]; + pTab = pSrc->pTab; + assert( IsVirtual(pTab) ); + pIdxInfo = allocateIndexInfo(pParse, pWC, mUnusable, pSrc,pBuilder->pOrderBy); + if( pIdxInfo==0 ) return SQLITE_NOMEM; + pNew->prereq = 0; + pNew->rSetup = 0; + pNew->wsFlags = WHERE_VIRTUALTABLE; + pNew->nLTerm = 0; + pNew->u.vtab.needFree = 0; + pUsage = pIdxInfo->aConstraintUsage; + nConstraint = pIdxInfo->nConstraint; + if( whereLoopResize(db, pNew, nConstraint) ){ + sqlite3DbFree(db, pIdxInfo); + return SQLITE_NOMEM; + } + + for(iPhase=0; iPhase<=3; iPhase++){ + if( !seenIn && (iPhase&1)!=0 ){ + iPhase++; + if( iPhase>3 ) break; + } + if( !seenVar && iPhase>1 ) break; + pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint; + for(i=0; inConstraint; i++, pIdxCons++){ + j = pIdxCons->iTermOffset; + pTerm = &pWC->a[j]; + switch( iPhase ){ + case 0: /* Constants without IN operator */ + pIdxCons->usable = 0; + if( (pTerm->eOperator & WO_IN)!=0 ){ + seenIn = 1; + } + if( (pTerm->prereqRight & ~mExtra)!=0 ){ + seenVar = 1; + }else if( (pTerm->eOperator & WO_IN)==0 ){ + pIdxCons->usable = 1; + } + break; + case 1: /* Constants with IN operators */ + assert( seenIn ); + pIdxCons->usable = (pTerm->prereqRight & ~mExtra)==0; + break; + case 2: /* Variables without IN */ + assert( seenVar ); + pIdxCons->usable = (pTerm->eOperator & WO_IN)==0; + break; + default: /* Variables with IN */ + assert( seenVar && seenIn ); + pIdxCons->usable = 1; + break; + } + } + memset(pUsage, 0, sizeof(pUsage[0])*pIdxInfo->nConstraint); + if( pIdxInfo->needToFreeIdxStr ) sqlite3_free(pIdxInfo->idxStr); + pIdxInfo->idxStr = 0; + pIdxInfo->idxNum = 0; + pIdxInfo->needToFreeIdxStr = 0; + pIdxInfo->orderByConsumed = 0; + pIdxInfo->estimatedCost = SQLITE_BIG_DBL / (double)2; + pIdxInfo->estimatedRows = 25; + pIdxInfo->idxFlags = 0; + rc = vtabBestIndex(pParse, pTab, pIdxInfo); + if( rc ) goto whereLoopAddVtab_exit; + pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint; + pNew->prereq = mExtra; + mxTerm = -1; + assert( pNew->nLSlot>=nConstraint ); + for(i=0; iaLTerm[i] = 0; + pNew->u.vtab.omitMask = 0; + for(i=0; i=0 ){ + j = pIdxCons->iTermOffset; + if( iTerm>=nConstraint + || j<0 + || j>=pWC->nTerm + || pNew->aLTerm[iTerm]!=0 + ){ + rc = SQLITE_ERROR; + sqlite3ErrorMsg(pParse, "%s.xBestIndex() malfunction", pTab->zName); + goto whereLoopAddVtab_exit; + } + testcase( iTerm==nConstraint-1 ); + testcase( j==0 ); + testcase( j==pWC->nTerm-1 ); + pTerm = &pWC->a[j]; + pNew->prereq |= pTerm->prereqRight; + assert( iTermnLSlot ); + pNew->aLTerm[iTerm] = pTerm; + if( iTerm>mxTerm ) mxTerm = iTerm; + testcase( iTerm==15 ); + testcase( iTerm==16 ); + if( iTerm<16 && pUsage[i].omit ) pNew->u.vtab.omitMask |= 1<eOperator & WO_IN)!=0 ){ + if( pUsage[i].omit==0 ){ + /* Do not attempt to use an IN constraint if the virtual table + ** says that the equivalent EQ constraint cannot be safely omitted. + ** If we do attempt to use such a constraint, some rows might be + ** repeated in the output. */ + break; + } + /* A virtual table that is constrained by an IN clause may not + ** consume the ORDER BY clause because (1) the order of IN terms + ** is not necessarily related to the order of output terms and + ** (2) Multiple outputs from a single IN value will not merge + ** together. */ + pIdxInfo->orderByConsumed = 0; + pIdxInfo->idxFlags &= ~SQLITE_INDEX_SCAN_UNIQUE; + } + } + } + if( i>=nConstraint ){ + pNew->nLTerm = mxTerm+1; + assert( pNew->nLTerm<=pNew->nLSlot ); + pNew->u.vtab.idxNum = pIdxInfo->idxNum; + pNew->u.vtab.needFree = pIdxInfo->needToFreeIdxStr; + pIdxInfo->needToFreeIdxStr = 0; + pNew->u.vtab.idxStr = pIdxInfo->idxStr; + pNew->u.vtab.isOrdered = (i8)(pIdxInfo->orderByConsumed ? + pIdxInfo->nOrderBy : 0); + pNew->rSetup = 0; + pNew->rRun = sqlite3LogEstFromDouble(pIdxInfo->estimatedCost); + pNew->nOut = sqlite3LogEst(pIdxInfo->estimatedRows); + + /* Set the WHERE_ONEROW flag if the xBestIndex() method indicated + ** that the scan will visit at most one row. Clear it otherwise. */ + if( pIdxInfo->idxFlags & SQLITE_INDEX_SCAN_UNIQUE ){ + pNew->wsFlags |= WHERE_ONEROW; + }else{ + pNew->wsFlags &= ~WHERE_ONEROW; + } + whereLoopInsert(pBuilder, pNew); + if( pNew->u.vtab.needFree ){ + sqlite3_free(pNew->u.vtab.idxStr); + pNew->u.vtab.needFree = 0; + } + } + } + +whereLoopAddVtab_exit: + if( pIdxInfo->needToFreeIdxStr ) sqlite3_free(pIdxInfo->idxStr); + sqlite3DbFree(db, pIdxInfo); + return rc; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/* +** Add WhereLoop entries to handle OR terms. This works for either +** btrees or virtual tables. +*/ +static int whereLoopAddOr( + WhereLoopBuilder *pBuilder, + Bitmask mExtra, + Bitmask mUnusable +){ + WhereInfo *pWInfo = pBuilder->pWInfo; + WhereClause *pWC; + WhereLoop *pNew; + WhereTerm *pTerm, *pWCEnd; + int rc = SQLITE_OK; + int iCur; + WhereClause tempWC; + WhereLoopBuilder sSubBuild; + WhereOrSet sSum, sCur; + struct SrcList_item *pItem; + + pWC = pBuilder->pWC; + pWCEnd = pWC->a + pWC->nTerm; + pNew = pBuilder->pNew; + memset(&sSum, 0, sizeof(sSum)); + pItem = pWInfo->pTabList->a + pNew->iTab; + iCur = pItem->iCursor; + + for(pTerm=pWC->a; pTermeOperator & WO_OR)!=0 + && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0 + ){ + WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc; + WhereTerm * const pOrWCEnd = &pOrWC->a[pOrWC->nTerm]; + WhereTerm *pOrTerm; + int once = 1; + int i, j; + + sSubBuild = *pBuilder; + sSubBuild.pOrderBy = 0; + sSubBuild.pOrSet = &sCur; + + WHERETRACE(0x200, ("Begin processing OR-clause %p\n", pTerm)); + for(pOrTerm=pOrWC->a; pOrTermeOperator & WO_AND)!=0 ){ + sSubBuild.pWC = &pOrTerm->u.pAndInfo->wc; + }else if( pOrTerm->leftCursor==iCur ){ + tempWC.pWInfo = pWC->pWInfo; + tempWC.pOuter = pWC; + tempWC.op = TK_AND; + tempWC.nTerm = 1; + tempWC.a = pOrTerm; + sSubBuild.pWC = &tempWC; + }else{ + continue; + } + sCur.n = 0; +#ifdef WHERETRACE_ENABLED + WHERETRACE(0x200, ("OR-term %d of %p has %d subterms:\n", + (int)(pOrTerm-pOrWC->a), pTerm, sSubBuild.pWC->nTerm)); + if( sqlite3WhereTrace & 0x400 ){ + for(i=0; inTerm; i++){ + whereTermPrint(&sSubBuild.pWC->a[i], i); + } + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pItem->pTab) ){ + rc = whereLoopAddVirtual(&sSubBuild, mExtra, mUnusable); + }else +#endif + { + rc = whereLoopAddBtree(&sSubBuild, mExtra); + } + if( rc==SQLITE_OK ){ + rc = whereLoopAddOr(&sSubBuild, mExtra, mUnusable); + } + assert( rc==SQLITE_OK || sCur.n==0 ); + if( sCur.n==0 ){ + sSum.n = 0; + break; + }else if( once ){ + whereOrMove(&sSum, &sCur); + once = 0; + }else{ + WhereOrSet sPrev; + whereOrMove(&sPrev, &sSum); + sSum.n = 0; + for(i=0; inLTerm = 1; + pNew->aLTerm[0] = pTerm; + pNew->wsFlags = WHERE_MULTI_OR; + pNew->rSetup = 0; + pNew->iSortIdx = 0; + memset(&pNew->u, 0, sizeof(pNew->u)); + for(i=0; rc==SQLITE_OK && irRun = sSum.a[i].rRun + 1; + pNew->nOut = sSum.a[i].nOut; + pNew->prereq = sSum.a[i].prereq; + rc = whereLoopInsert(pBuilder, pNew); + } + WHERETRACE(0x200, ("End processing OR-clause %p\n", pTerm)); + } + } + return rc; +} + +/* +** Add all WhereLoop objects for all tables +*/ +static int whereLoopAddAll(WhereLoopBuilder *pBuilder){ + WhereInfo *pWInfo = pBuilder->pWInfo; + Bitmask mExtra = 0; + Bitmask mPrior = 0; + int iTab; + SrcList *pTabList = pWInfo->pTabList; + struct SrcList_item *pItem; + struct SrcList_item *pEnd = &pTabList->a[pWInfo->nLevel]; + sqlite3 *db = pWInfo->pParse->db; + int rc = SQLITE_OK; + WhereLoop *pNew; + u8 priorJointype = 0; + + /* Loop over the tables in the join, from left to right */ + pNew = pBuilder->pNew; + whereLoopInit(pNew); + for(iTab=0, pItem=pTabList->a; pItemiTab = iTab; + pNew->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, pItem->iCursor); + if( ((pItem->fg.jointype|priorJointype) & (JT_LEFT|JT_CROSS))!=0 ){ + /* This condition is true when pItem is the FROM clause term on the + ** right-hand-side of a LEFT or CROSS JOIN. */ + mExtra = mPrior; + } + priorJointype = pItem->fg.jointype; + if( IsVirtual(pItem->pTab) ){ + struct SrcList_item *p; + for(p=&pItem[1]; pfg.jointype & (JT_LEFT|JT_CROSS)) ){ + mUnusable |= sqlite3WhereGetMask(&pWInfo->sMaskSet, p->iCursor); + } + } + rc = whereLoopAddVirtual(pBuilder, mExtra, mUnusable); + }else{ + rc = whereLoopAddBtree(pBuilder, mExtra); + } + if( rc==SQLITE_OK ){ + rc = whereLoopAddOr(pBuilder, mExtra, mUnusable); + } + mPrior |= pNew->maskSelf; + if( rc || db->mallocFailed ) break; + } + + whereLoopClear(db, pNew); + return rc; +} + +/* +** Examine a WherePath (with the addition of the extra WhereLoop of the 5th +** parameters) to see if it outputs rows in the requested ORDER BY +** (or GROUP BY) without requiring a separate sort operation. Return N: +** +** N>0: N terms of the ORDER BY clause are satisfied +** N==0: No terms of the ORDER BY clause are satisfied +** N<0: Unknown yet how many terms of ORDER BY might be satisfied. +** +** Note that processing for WHERE_GROUPBY and WHERE_DISTINCTBY is not as +** strict. With GROUP BY and DISTINCT the only requirement is that +** equivalent rows appear immediately adjacent to one another. GROUP BY +** and DISTINCT do not require rows to appear in any particular order as long +** as equivalent rows are grouped together. Thus for GROUP BY and DISTINCT +** the pOrderBy terms can be matched in any order. With ORDER BY, the +** pOrderBy terms must be matched in strict left-to-right order. +*/ +static i8 wherePathSatisfiesOrderBy( + WhereInfo *pWInfo, /* The WHERE clause */ + ExprList *pOrderBy, /* ORDER BY or GROUP BY or DISTINCT clause to check */ + WherePath *pPath, /* The WherePath to check */ + u16 wctrlFlags, /* Might contain WHERE_GROUPBY or WHERE_DISTINCTBY */ + u16 nLoop, /* Number of entries in pPath->aLoop[] */ + WhereLoop *pLast, /* Add this WhereLoop to the end of pPath->aLoop[] */ + Bitmask *pRevMask /* OUT: Mask of WhereLoops to run in reverse order */ +){ + u8 revSet; /* True if rev is known */ + u8 rev; /* Composite sort order */ + u8 revIdx; /* Index sort order */ + u8 isOrderDistinct; /* All prior WhereLoops are order-distinct */ + u8 distinctColumns; /* True if the loop has UNIQUE NOT NULL columns */ + u8 isMatch; /* iColumn matches a term of the ORDER BY clause */ + u16 nKeyCol; /* Number of key columns in pIndex */ + u16 nColumn; /* Total number of ordered columns in the index */ + u16 nOrderBy; /* Number terms in the ORDER BY clause */ + int iLoop; /* Index of WhereLoop in pPath being processed */ + int i, j; /* Loop counters */ + int iCur; /* Cursor number for current WhereLoop */ + int iColumn; /* A column number within table iCur */ + WhereLoop *pLoop = 0; /* Current WhereLoop being processed. */ + WhereTerm *pTerm; /* A single term of the WHERE clause */ + Expr *pOBExpr; /* An expression from the ORDER BY clause */ + CollSeq *pColl; /* COLLATE function from an ORDER BY clause term */ + Index *pIndex; /* The index associated with pLoop */ + sqlite3 *db = pWInfo->pParse->db; /* Database connection */ + Bitmask obSat = 0; /* Mask of ORDER BY terms satisfied so far */ + Bitmask obDone; /* Mask of all ORDER BY terms */ + Bitmask orderDistinctMask; /* Mask of all well-ordered loops */ + Bitmask ready; /* Mask of inner loops */ + + /* + ** We say the WhereLoop is "one-row" if it generates no more than one + ** row of output. A WhereLoop is one-row if all of the following are true: + ** (a) All index columns match with WHERE_COLUMN_EQ. + ** (b) The index is unique + ** Any WhereLoop with an WHERE_COLUMN_EQ constraint on the rowid is one-row. + ** Every one-row WhereLoop will have the WHERE_ONEROW bit set in wsFlags. + ** + ** We say the WhereLoop is "order-distinct" if the set of columns from + ** that WhereLoop that are in the ORDER BY clause are different for every + ** row of the WhereLoop. Every one-row WhereLoop is automatically + ** order-distinct. A WhereLoop that has no columns in the ORDER BY clause + ** is not order-distinct. To be order-distinct is not quite the same as being + ** UNIQUE since a UNIQUE column or index can have multiple rows that + ** are NULL and NULL values are equivalent for the purpose of order-distinct. + ** To be order-distinct, the columns must be UNIQUE and NOT NULL. + ** + ** The rowid for a table is always UNIQUE and NOT NULL so whenever the + ** rowid appears in the ORDER BY clause, the corresponding WhereLoop is + ** automatically order-distinct. + */ + + assert( pOrderBy!=0 ); + if( nLoop && OptimizationDisabled(db, SQLITE_OrderByIdxJoin) ) return 0; + + nOrderBy = pOrderBy->nExpr; + testcase( nOrderBy==BMS-1 ); + if( nOrderBy>BMS-1 ) return 0; /* Cannot optimize overly large ORDER BYs */ + isOrderDistinct = 1; + obDone = MASKBIT(nOrderBy)-1; + orderDistinctMask = 0; + ready = 0; + for(iLoop=0; isOrderDistinct && obSat0 ) ready |= pLoop->maskSelf; + pLoop = iLoopaLoop[iLoop] : pLast; + if( pLoop->wsFlags & WHERE_VIRTUALTABLE ){ + if( pLoop->u.vtab.isOrdered ) obSat = obDone; + break; + } + iCur = pWInfo->pTabList->a[pLoop->iTab].iCursor; + + /* Mark off any ORDER BY term X that is a column in the table of + ** the current loop for which there is term in the WHERE + ** clause of the form X IS NULL or X=? that reference only outer + ** loops. + */ + for(i=0; ia[i].pExpr); + if( pOBExpr->op!=TK_COLUMN ) continue; + if( pOBExpr->iTable!=iCur ) continue; + pTerm = sqlite3WhereFindTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn, + ~ready, WO_EQ|WO_ISNULL|WO_IS, 0); + if( pTerm==0 ) continue; + if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0 && pOBExpr->iColumn>=0 ){ + const char *z1, *z2; + pColl = sqlite3ExprCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr); + if( !pColl ) pColl = db->pDfltColl; + z1 = pColl->zName; + pColl = sqlite3ExprCollSeq(pWInfo->pParse, pTerm->pExpr); + if( !pColl ) pColl = db->pDfltColl; + z2 = pColl->zName; + if( sqlite3StrICmp(z1, z2)!=0 ) continue; + testcase( pTerm->pExpr->op==TK_IS ); + } + obSat |= MASKBIT(i); + } + + if( (pLoop->wsFlags & WHERE_ONEROW)==0 ){ + if( pLoop->wsFlags & WHERE_IPK ){ + pIndex = 0; + nKeyCol = 0; + nColumn = 1; + }else if( (pIndex = pLoop->u.btree.pIndex)==0 || pIndex->bUnordered ){ + return 0; + }else{ + nKeyCol = pIndex->nKeyCol; + nColumn = pIndex->nColumn; + assert( nColumn==nKeyCol+1 || !HasRowid(pIndex->pTable) ); + assert( pIndex->aiColumn[nColumn-1]==XN_ROWID + || !HasRowid(pIndex->pTable)); + isOrderDistinct = IsUniqueIndex(pIndex); + } + + /* Loop through all columns of the index and deal with the ones + ** that are not constrained by == or IN. + */ + rev = revSet = 0; + distinctColumns = 0; + for(j=0; ju.btree.nEq + && pLoop->nSkip==0 + && ((i = pLoop->aLTerm[j]->eOperator) & (WO_EQ|WO_ISNULL|WO_IS))!=0 + ){ + if( i & WO_ISNULL ){ + testcase( isOrderDistinct ); + isOrderDistinct = 0; + } + continue; + } + + /* Get the column number in the table (iColumn) and sort order + ** (revIdx) for the j-th column of the index. + */ + if( pIndex ){ + iColumn = pIndex->aiColumn[j]; + revIdx = pIndex->aSortOrder[j]; + if( iColumn==pIndex->pTable->iPKey ) iColumn = -1; + }else{ + iColumn = XN_ROWID; + revIdx = 0; + } + + /* An unconstrained column that might be NULL means that this + ** WhereLoop is not well-ordered + */ + if( isOrderDistinct + && iColumn>=0 + && j>=pLoop->u.btree.nEq + && pIndex->pTable->aCol[iColumn].notNull==0 + ){ + isOrderDistinct = 0; + } + + /* Find the ORDER BY term that corresponds to the j-th column + ** of the index and mark that ORDER BY term off + */ + bOnce = 1; + isMatch = 0; + for(i=0; bOnce && ia[i].pExpr); + testcase( wctrlFlags & WHERE_GROUPBY ); + testcase( wctrlFlags & WHERE_DISTINCTBY ); + if( (wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY))==0 ) bOnce = 0; + if( iColumn>=(-1) ){ + if( pOBExpr->op!=TK_COLUMN ) continue; + if( pOBExpr->iTable!=iCur ) continue; + if( pOBExpr->iColumn!=iColumn ) continue; + }else{ + if( sqlite3ExprCompare(pOBExpr,pIndex->aColExpr->a[j].pExpr,iCur) ){ + continue; + } + } + if( iColumn>=0 ){ + pColl = sqlite3ExprCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr); + if( !pColl ) pColl = db->pDfltColl; + if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue; + } + isMatch = 1; + break; + } + if( isMatch && (wctrlFlags & WHERE_GROUPBY)==0 ){ + /* Make sure the sort order is compatible in an ORDER BY clause. + ** Sort order is irrelevant for a GROUP BY clause. */ + if( revSet ){ + if( (rev ^ revIdx)!=pOrderBy->a[i].sortOrder ) isMatch = 0; + }else{ + rev = revIdx ^ pOrderBy->a[i].sortOrder; + if( rev ) *pRevMask |= MASKBIT(iLoop); + revSet = 1; + } + } + if( isMatch ){ + if( iColumn<0 ){ + testcase( distinctColumns==0 ); + distinctColumns = 1; + } + obSat |= MASKBIT(i); + }else{ + /* No match found */ + if( j==0 || jmaskSelf; + for(i=0; ia[i].pExpr; + mTerm = sqlite3WhereExprUsage(&pWInfo->sMaskSet,p); + if( mTerm==0 && !sqlite3ExprIsConstant(p) ) continue; + if( (mTerm&~orderDistinctMask)==0 ){ + obSat |= MASKBIT(i); + } + } + } + } /* End the loop over all WhereLoops from outer-most down to inner-most */ + if( obSat==obDone ) return (i8)nOrderBy; + if( !isOrderDistinct ){ + for(i=nOrderBy-1; i>0; i--){ + Bitmask m = MASKBIT(i) - 1; + if( (obSat&m)==m ) return i; + } + return 0; + } + return -1; +} + + +/* +** If the WHERE_GROUPBY flag is set in the mask passed to sqlite3WhereBegin(), +** the planner assumes that the specified pOrderBy list is actually a GROUP +** BY clause - and so any order that groups rows as required satisfies the +** request. +** +** Normally, in this case it is not possible for the caller to determine +** whether or not the rows are really being delivered in sorted order, or +** just in some other order that provides the required grouping. However, +** if the WHERE_SORTBYGROUP flag is also passed to sqlite3WhereBegin(), then +** this function may be called on the returned WhereInfo object. It returns +** true if the rows really will be sorted in the specified order, or false +** otherwise. +** +** For example, assuming: +** +** CREATE INDEX i1 ON t1(x, Y); +** +** then +** +** SELECT * FROM t1 GROUP BY x,y ORDER BY x,y; -- IsSorted()==1 +** SELECT * FROM t1 GROUP BY y,x ORDER BY y,x; -- IsSorted()==0 +*/ +SQLITE_PRIVATE int sqlite3WhereIsSorted(WhereInfo *pWInfo){ + assert( pWInfo->wctrlFlags & WHERE_GROUPBY ); + assert( pWInfo->wctrlFlags & WHERE_SORTBYGROUP ); + return pWInfo->sorted; +} + +#ifdef WHERETRACE_ENABLED +/* For debugging use only: */ +static const char *wherePathName(WherePath *pPath, int nLoop, WhereLoop *pLast){ + static char zName[65]; + int i; + for(i=0; iaLoop[i]->cId; } + if( pLast ) zName[i++] = pLast->cId; + zName[i] = 0; + return zName; +} +#endif + +/* +** Return the cost of sorting nRow rows, assuming that the keys have +** nOrderby columns and that the first nSorted columns are already in +** order. +*/ +static LogEst whereSortingCost( + WhereInfo *pWInfo, + LogEst nRow, + int nOrderBy, + int nSorted +){ + /* TUNING: Estimated cost of a full external sort, where N is + ** the number of rows to sort is: + ** + ** cost = (3.0 * N * log(N)). + ** + ** Or, if the order-by clause has X terms but only the last Y + ** terms are out of order, then block-sorting will reduce the + ** sorting cost to: + ** + ** cost = (3.0 * N * log(N)) * (Y/X) + ** + ** The (Y/X) term is implemented using stack variable rScale + ** below. */ + LogEst rScale, rSortCost; + assert( nOrderBy>0 && 66==sqlite3LogEst(100) ); + rScale = sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66; + rSortCost = nRow + estLog(nRow) + rScale + 16; + + /* TUNING: The cost of implementing DISTINCT using a B-TREE is + ** similar but with a larger constant of proportionality. + ** Multiply by an additional factor of 3.0. */ + if( pWInfo->wctrlFlags & WHERE_WANT_DISTINCT ){ + rSortCost += 16; + } + + return rSortCost; +} + +/* +** Given the list of WhereLoop objects at pWInfo->pLoops, this routine +** attempts to find the lowest cost path that visits each WhereLoop +** once. This path is then loaded into the pWInfo->a[].pWLoop fields. +** +** Assume that the total number of output rows that will need to be sorted +** will be nRowEst (in the 10*log2 representation). Or, ignore sorting +** costs if nRowEst==0. +** +** Return SQLITE_OK on success or SQLITE_NOMEM of a memory allocation +** error occurs. +*/ +static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){ + int mxChoice; /* Maximum number of simultaneous paths tracked */ + int nLoop; /* Number of terms in the join */ + Parse *pParse; /* Parsing context */ + sqlite3 *db; /* The database connection */ + int iLoop; /* Loop counter over the terms of the join */ + int ii, jj; /* Loop counters */ + int mxI = 0; /* Index of next entry to replace */ + int nOrderBy; /* Number of ORDER BY clause terms */ + LogEst mxCost = 0; /* Maximum cost of a set of paths */ + LogEst mxUnsorted = 0; /* Maximum unsorted cost of a set of path */ + int nTo, nFrom; /* Number of valid entries in aTo[] and aFrom[] */ + WherePath *aFrom; /* All nFrom paths at the previous level */ + WherePath *aTo; /* The nTo best paths at the current level */ + WherePath *pFrom; /* An element of aFrom[] that we are working on */ + WherePath *pTo; /* An element of aTo[] that we are working on */ + WhereLoop *pWLoop; /* One of the WhereLoop objects */ + WhereLoop **pX; /* Used to divy up the pSpace memory */ + LogEst *aSortCost = 0; /* Sorting and partial sorting costs */ + char *pSpace; /* Temporary memory used by this routine */ + int nSpace; /* Bytes of space allocated at pSpace */ + + pParse = pWInfo->pParse; + db = pParse->db; + nLoop = pWInfo->nLevel; + /* TUNING: For simple queries, only the best path is tracked. + ** For 2-way joins, the 5 best paths are followed. + ** For joins of 3 or more tables, track the 10 best paths */ + mxChoice = (nLoop<=1) ? 1 : (nLoop==2 ? 5 : 10); + assert( nLoop<=pWInfo->pTabList->nSrc ); + WHERETRACE(0x002, ("---- begin solver. (nRowEst=%d)\n", nRowEst)); + + /* If nRowEst is zero and there is an ORDER BY clause, ignore it. In this + ** case the purpose of this call is to estimate the number of rows returned + ** by the overall query. Once this estimate has been obtained, the caller + ** will invoke this function a second time, passing the estimate as the + ** nRowEst parameter. */ + if( pWInfo->pOrderBy==0 || nRowEst==0 ){ + nOrderBy = 0; + }else{ + nOrderBy = pWInfo->pOrderBy->nExpr; + } + + /* Allocate and initialize space for aTo, aFrom and aSortCost[] */ + nSpace = (sizeof(WherePath)+sizeof(WhereLoop*)*nLoop)*mxChoice*2; + nSpace += sizeof(LogEst) * nOrderBy; + pSpace = sqlite3DbMallocRaw(db, nSpace); + if( pSpace==0 ) return SQLITE_NOMEM; + aTo = (WherePath*)pSpace; + aFrom = aTo+mxChoice; + memset(aFrom, 0, sizeof(aFrom[0])); + pX = (WhereLoop**)(aFrom+mxChoice); + for(ii=mxChoice*2, pFrom=aTo; ii>0; ii--, pFrom++, pX += nLoop){ + pFrom->aLoop = pX; + } + if( nOrderBy ){ + /* If there is an ORDER BY clause and it is not being ignored, set up + ** space for the aSortCost[] array. Each element of the aSortCost array + ** is either zero - meaning it has not yet been initialized - or the + ** cost of sorting nRowEst rows of data where the first X terms of + ** the ORDER BY clause are already in order, where X is the array + ** index. */ + aSortCost = (LogEst*)pX; + memset(aSortCost, 0, sizeof(LogEst) * nOrderBy); + } + assert( aSortCost==0 || &pSpace[nSpace]==(char*)&aSortCost[nOrderBy] ); + assert( aSortCost!=0 || &pSpace[nSpace]==(char*)pX ); + + /* Seed the search with a single WherePath containing zero WhereLoops. + ** + ** TUNING: Do not let the number of iterations go above 28. If the cost + ** of computing an automatic index is not paid back within the first 28 + ** rows, then do not use the automatic index. */ + aFrom[0].nRow = MIN(pParse->nQueryLoop, 48); assert( 48==sqlite3LogEst(28) ); + nFrom = 1; + assert( aFrom[0].isOrdered==0 ); + if( nOrderBy ){ + /* If nLoop is zero, then there are no FROM terms in the query. Since + ** in this case the query may return a maximum of one row, the results + ** are already in the requested order. Set isOrdered to nOrderBy to + ** indicate this. Or, if nLoop is greater than zero, set isOrdered to + ** -1, indicating that the result set may or may not be ordered, + ** depending on the loops added to the current plan. */ + aFrom[0].isOrdered = nLoop>0 ? -1 : nOrderBy; + } + + /* Compute successively longer WherePaths using the previous generation + ** of WherePaths as the basis for the next. Keep track of the mxChoice + ** best paths at each generation */ + for(iLoop=0; iLooppLoops; pWLoop; pWLoop=pWLoop->pNextLoop){ + LogEst nOut; /* Rows visited by (pFrom+pWLoop) */ + LogEst rCost; /* Cost of path (pFrom+pWLoop) */ + LogEst rUnsorted; /* Unsorted cost of (pFrom+pWLoop) */ + i8 isOrdered = pFrom->isOrdered; /* isOrdered for (pFrom+pWLoop) */ + Bitmask maskNew; /* Mask of src visited by (..) */ + Bitmask revMask = 0; /* Mask of rev-order loops for (..) */ + + if( (pWLoop->prereq & ~pFrom->maskLoop)!=0 ) continue; + if( (pWLoop->maskSelf & pFrom->maskLoop)!=0 ) continue; + /* At this point, pWLoop is a candidate to be the next loop. + ** Compute its cost */ + rUnsorted = sqlite3LogEstAdd(pWLoop->rSetup,pWLoop->rRun + pFrom->nRow); + rUnsorted = sqlite3LogEstAdd(rUnsorted, pFrom->rUnsorted); + nOut = pFrom->nRow + pWLoop->nOut; + maskNew = pFrom->maskLoop | pWLoop->maskSelf; + if( isOrdered<0 ){ + isOrdered = wherePathSatisfiesOrderBy(pWInfo, + pWInfo->pOrderBy, pFrom, pWInfo->wctrlFlags, + iLoop, pWLoop, &revMask); + }else{ + revMask = pFrom->revLoop; + } + if( isOrdered>=0 && isOrderedisOrdered^isOrdered)&0x80)==0" is equivalent + ** to (pTo->isOrdered==(-1))==(isOrdered==(-1))" for the range + ** of legal values for isOrdered, -1..64. + */ + for(jj=0, pTo=aTo; jjmaskLoop==maskNew + && ((pTo->isOrdered^isOrdered)&0x80)==0 + ){ + testcase( jj==nTo-1 ); + break; + } + } + if( jj>=nTo ){ + /* None of the existing best-so-far paths match the candidate. */ + if( nTo>=mxChoice + && (rCost>mxCost || (rCost==mxCost && rUnsorted>=mxUnsorted)) + ){ + /* The current candidate is no better than any of the mxChoice + ** paths currently in the best-so-far buffer. So discard + ** this candidate as not viable. */ +#ifdef WHERETRACE_ENABLED /* 0x4 */ + if( sqlite3WhereTrace&0x4 ){ + sqlite3DebugPrintf("Skip %s cost=%-3d,%3d order=%c\n", + wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, + isOrdered>=0 ? isOrdered+'0' : '?'); + } +#endif + continue; + } + /* If we reach this points it means that the new candidate path + ** needs to be added to the set of best-so-far paths. */ + if( nTo=0 ? isOrdered+'0' : '?'); + } +#endif + }else{ + /* Control reaches here if best-so-far path pTo=aTo[jj] covers the + ** same set of loops and has the sam isOrdered setting as the + ** candidate path. Check to see if the candidate should replace + ** pTo or if the candidate should be skipped */ + if( pTo->rCostrCost==rCost && pTo->nRow<=nOut) ){ +#ifdef WHERETRACE_ENABLED /* 0x4 */ + if( sqlite3WhereTrace&0x4 ){ + sqlite3DebugPrintf( + "Skip %s cost=%-3d,%3d order=%c", + wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, + isOrdered>=0 ? isOrdered+'0' : '?'); + sqlite3DebugPrintf(" vs %s cost=%-3d,%d order=%c\n", + wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow, + pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?'); + } +#endif + /* Discard the candidate path from further consideration */ + testcase( pTo->rCost==rCost ); + continue; + } + testcase( pTo->rCost==rCost+1 ); + /* Control reaches here if the candidate path is better than the + ** pTo path. Replace pTo with the candidate. */ +#ifdef WHERETRACE_ENABLED /* 0x4 */ + if( sqlite3WhereTrace&0x4 ){ + sqlite3DebugPrintf( + "Update %s cost=%-3d,%3d order=%c", + wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, + isOrdered>=0 ? isOrdered+'0' : '?'); + sqlite3DebugPrintf(" was %s cost=%-3d,%3d order=%c\n", + wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow, + pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?'); + } +#endif + } + /* pWLoop is a winner. Add it to the set of best so far */ + pTo->maskLoop = pFrom->maskLoop | pWLoop->maskSelf; + pTo->revLoop = revMask; + pTo->nRow = nOut; + pTo->rCost = rCost; + pTo->rUnsorted = rUnsorted; + pTo->isOrdered = isOrdered; + memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop); + pTo->aLoop[iLoop] = pWLoop; + if( nTo>=mxChoice ){ + mxI = 0; + mxCost = aTo[0].rCost; + mxUnsorted = aTo[0].nRow; + for(jj=1, pTo=&aTo[1]; jjrCost>mxCost + || (pTo->rCost==mxCost && pTo->rUnsorted>mxUnsorted) + ){ + mxCost = pTo->rCost; + mxUnsorted = pTo->rUnsorted; + mxI = jj; + } + } + } + } + } + +#ifdef WHERETRACE_ENABLED /* >=2 */ + if( sqlite3WhereTrace & 0x02 ){ + sqlite3DebugPrintf("---- after round %d ----\n", iLoop); + for(ii=0, pTo=aTo; iirCost, pTo->nRow, + pTo->isOrdered>=0 ? (pTo->isOrdered+'0') : '?'); + if( pTo->isOrdered>0 ){ + sqlite3DebugPrintf(" rev=0x%llx\n", pTo->revLoop); + }else{ + sqlite3DebugPrintf("\n"); + } + } + } +#endif + + /* Swap the roles of aFrom and aTo for the next generation */ + pFrom = aTo; + aTo = aFrom; + aFrom = pFrom; + nFrom = nTo; + } + + if( nFrom==0 ){ + sqlite3ErrorMsg(pParse, "no query solution"); + sqlite3DbFree(db, pSpace); + return SQLITE_ERROR; + } + + /* Find the lowest cost path. pFrom will be left pointing to that path */ + pFrom = aFrom; + for(ii=1; iirCost>aFrom[ii].rCost ) pFrom = &aFrom[ii]; + } + assert( pWInfo->nLevel==nLoop ); + /* Load the lowest cost path into pWInfo */ + for(iLoop=0; iLoopa + iLoop; + pLevel->pWLoop = pWLoop = pFrom->aLoop[iLoop]; + pLevel->iFrom = pWLoop->iTab; + pLevel->iTabCur = pWInfo->pTabList->a[pLevel->iFrom].iCursor; + } + if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT)!=0 + && (pWInfo->wctrlFlags & WHERE_DISTINCTBY)==0 + && pWInfo->eDistinct==WHERE_DISTINCT_NOOP + && nRowEst + ){ + Bitmask notUsed; + int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pResultSet, pFrom, + WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], ¬Used); + if( rc==pWInfo->pResultSet->nExpr ){ + pWInfo->eDistinct = WHERE_DISTINCT_ORDERED; + } + } + if( pWInfo->pOrderBy ){ + if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){ + if( pFrom->isOrdered==pWInfo->pOrderBy->nExpr ){ + pWInfo->eDistinct = WHERE_DISTINCT_ORDERED; + } + }else{ + pWInfo->nOBSat = pFrom->isOrdered; + if( pWInfo->nOBSat<0 ) pWInfo->nOBSat = 0; + pWInfo->revMask = pFrom->revLoop; + } + if( (pWInfo->wctrlFlags & WHERE_SORTBYGROUP) + && pWInfo->nOBSat==pWInfo->pOrderBy->nExpr && nLoop>0 + ){ + Bitmask revMask = 0; + int nOrder = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pOrderBy, + pFrom, 0, nLoop-1, pFrom->aLoop[nLoop-1], &revMask + ); + assert( pWInfo->sorted==0 ); + if( nOrder==pWInfo->pOrderBy->nExpr ){ + pWInfo->sorted = 1; + pWInfo->revMask = revMask; + } + } + } + + + pWInfo->nRowOut = pFrom->nRow; + + /* Free temporary memory and return success */ + sqlite3DbFree(db, pSpace); + return SQLITE_OK; +} + +/* +** Most queries use only a single table (they are not joins) and have +** simple == constraints against indexed fields. This routine attempts +** to plan those simple cases using much less ceremony than the +** general-purpose query planner, and thereby yield faster sqlite3_prepare() +** times for the common case. +** +** Return non-zero on success, if this query can be handled by this +** no-frills query planner. Return zero if this query needs the +** general-purpose query planner. +*/ +static int whereShortCut(WhereLoopBuilder *pBuilder){ + WhereInfo *pWInfo; + struct SrcList_item *pItem; + WhereClause *pWC; + WhereTerm *pTerm; + WhereLoop *pLoop; + int iCur; + int j; + Table *pTab; + Index *pIdx; + + pWInfo = pBuilder->pWInfo; + if( pWInfo->wctrlFlags & WHERE_FORCE_TABLE ) return 0; + assert( pWInfo->pTabList->nSrc>=1 ); + pItem = pWInfo->pTabList->a; + pTab = pItem->pTab; + if( IsVirtual(pTab) ) return 0; + if( pItem->fg.isIndexedBy ) return 0; + iCur = pItem->iCursor; + pWC = &pWInfo->sWC; + pLoop = pBuilder->pNew; + pLoop->wsFlags = 0; + pLoop->nSkip = 0; + pTerm = sqlite3WhereFindTerm(pWC, iCur, -1, 0, WO_EQ|WO_IS, 0); + if( pTerm ){ + testcase( pTerm->eOperator & WO_IS ); + pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_IPK|WHERE_ONEROW; + pLoop->aLTerm[0] = pTerm; + pLoop->nLTerm = 1; + pLoop->u.btree.nEq = 1; + /* TUNING: Cost of a rowid lookup is 10 */ + pLoop->rRun = 33; /* 33==sqlite3LogEst(10) */ + }else{ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int opMask; + assert( pLoop->aLTermSpace==pLoop->aLTerm ); + if( !IsUniqueIndex(pIdx) + || pIdx->pPartIdxWhere!=0 + || pIdx->nKeyCol>ArraySize(pLoop->aLTermSpace) + ) continue; + opMask = pIdx->uniqNotNull ? (WO_EQ|WO_IS) : WO_EQ; + for(j=0; jnKeyCol; j++){ + pTerm = sqlite3WhereFindTerm(pWC, iCur, j, 0, opMask, pIdx); + if( pTerm==0 ) break; + testcase( pTerm->eOperator & WO_IS ); + pLoop->aLTerm[j] = pTerm; + } + if( j!=pIdx->nKeyCol ) continue; + pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_ONEROW|WHERE_INDEXED; + if( pIdx->isCovering || (pItem->colUsed & ~columnsInIndex(pIdx))==0 ){ + pLoop->wsFlags |= WHERE_IDX_ONLY; + } + pLoop->nLTerm = j; + pLoop->u.btree.nEq = j; + pLoop->u.btree.pIndex = pIdx; + /* TUNING: Cost of a unique index lookup is 15 */ + pLoop->rRun = 39; /* 39==sqlite3LogEst(15) */ + break; + } + } + if( pLoop->wsFlags ){ + pLoop->nOut = (LogEst)1; + pWInfo->a[0].pWLoop = pLoop; + pLoop->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur); + pWInfo->a[0].iTabCur = iCur; + pWInfo->nRowOut = 1; + if( pWInfo->pOrderBy ) pWInfo->nOBSat = pWInfo->pOrderBy->nExpr; + if( pWInfo->wctrlFlags & WHERE_WANT_DISTINCT ){ + pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; + } +#ifdef SQLITE_DEBUG + pLoop->cId = '0'; +#endif + return 1; + } + return 0; +} + +/* +** Generate the beginning of the loop used for WHERE clause processing. +** The return value is a pointer to an opaque structure that contains +** information needed to terminate the loop. Later, the calling routine +** should invoke sqlite3WhereEnd() with the return value of this function +** in order to complete the WHERE clause processing. +** +** If an error occurs, this routine returns NULL. +** +** The basic idea is to do a nested loop, one loop for each table in +** the FROM clause of a select. (INSERT and UPDATE statements are the +** same as a SELECT with only a single table in the FROM clause.) For +** example, if the SQL is this: +** +** SELECT * FROM t1, t2, t3 WHERE ...; +** +** Then the code generated is conceptually like the following: +** +** foreach row1 in t1 do \ Code generated +** foreach row2 in t2 do |-- by sqlite3WhereBegin() +** foreach row3 in t3 do / +** ... +** end \ Code generated +** end |-- by sqlite3WhereEnd() +** end / +** +** Note that the loops might not be nested in the order in which they +** appear in the FROM clause if a different order is better able to make +** use of indices. Note also that when the IN operator appears in +** the WHERE clause, it might result in additional nested loops for +** scanning through all values on the right-hand side of the IN. +** +** There are Btree cursors associated with each table. t1 uses cursor +** number pTabList->a[0].iCursor. t2 uses the cursor pTabList->a[1].iCursor. +** And so forth. This routine generates code to open those VDBE cursors +** and sqlite3WhereEnd() generates the code to close them. +** +** The code that sqlite3WhereBegin() generates leaves the cursors named +** in pTabList pointing at their appropriate entries. The [...] code +** can use OP_Column and OP_Rowid opcodes on these cursors to extract +** data from the various tables of the loop. +** +** If the WHERE clause is empty, the foreach loops must each scan their +** entire tables. Thus a three-way join is an O(N^3) operation. But if +** the tables have indices and there are terms in the WHERE clause that +** refer to those indices, a complete table scan can be avoided and the +** code will run much faster. Most of the work of this routine is checking +** to see if there are indices that can be used to speed up the loop. +** +** Terms of the WHERE clause are also used to limit which rows actually +** make it to the "..." in the middle of the loop. After each "foreach", +** terms of the WHERE clause that use only terms in that loop and outer +** loops are evaluated and if false a jump is made around all subsequent +** inner loops (or around the "..." if the test occurs within the inner- +** most loop) +** +** OUTER JOINS +** +** An outer join of tables t1 and t2 is conceptally coded as follows: +** +** foreach row1 in t1 do +** flag = 0 +** foreach row2 in t2 do +** start: +** ... +** flag = 1 +** end +** if flag==0 then +** move the row2 cursor to a null row +** goto start +** fi +** end +** +** ORDER BY CLAUSE PROCESSING +** +** pOrderBy is a pointer to the ORDER BY clause (or the GROUP BY clause +** if the WHERE_GROUPBY flag is set in wctrlFlags) of a SELECT statement +** if there is one. If there is no ORDER BY clause or if this routine +** is called from an UPDATE or DELETE statement, then pOrderBy is NULL. +** +** The iIdxCur parameter is the cursor number of an index. If +** WHERE_ONETABLE_ONLY is set, iIdxCur is the cursor number of an index +** to use for OR clause processing. The WHERE clause should use this +** specific cursor. If WHERE_ONEPASS_DESIRED is set, then iIdxCur is +** the first cursor in an array of cursors for all indices. iIdxCur should +** be used to compute the appropriate cursor depending on which index is +** used. +*/ +SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* FROM clause: A list of all tables to be scanned */ + Expr *pWhere, /* The WHERE clause */ + ExprList *pOrderBy, /* An ORDER BY (or GROUP BY) clause, or NULL */ + ExprList *pResultSet, /* Result set of the query */ + u16 wctrlFlags, /* One of the WHERE_* flags defined in sqliteInt.h */ + int iIdxCur /* If WHERE_ONETABLE_ONLY is set, index cursor number */ +){ + int nByteWInfo; /* Num. bytes allocated for WhereInfo struct */ + int nTabList; /* Number of elements in pTabList */ + WhereInfo *pWInfo; /* Will become the return value of this function */ + Vdbe *v = pParse->pVdbe; /* The virtual database engine */ + Bitmask notReady; /* Cursors that are not yet positioned */ + WhereLoopBuilder sWLB; /* The WhereLoop builder */ + WhereMaskSet *pMaskSet; /* The expression mask set */ + WhereLevel *pLevel; /* A single level in pWInfo->a[] */ + WhereLoop *pLoop; /* Pointer to a single WhereLoop object */ + int ii; /* Loop counter */ + sqlite3 *db; /* Database connection */ + int rc; /* Return code */ + + assert( (wctrlFlags & WHERE_ONEPASS_MULTIROW)==0 || ( + (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 + && (wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0 + )); + + /* Variable initialization */ + db = pParse->db; + memset(&sWLB, 0, sizeof(sWLB)); + + /* An ORDER/GROUP BY clause of more than 63 terms cannot be optimized */ + testcase( pOrderBy && pOrderBy->nExpr==BMS-1 ); + if( pOrderBy && pOrderBy->nExpr>=BMS ) pOrderBy = 0; + sWLB.pOrderBy = pOrderBy; + + /* Disable the DISTINCT optimization if SQLITE_DistinctOpt is set via + ** sqlite3_test_ctrl(SQLITE_TESTCTRL_OPTIMIZATIONS,...) */ + if( OptimizationDisabled(db, SQLITE_DistinctOpt) ){ + wctrlFlags &= ~WHERE_WANT_DISTINCT; + } + + /* The number of tables in the FROM clause is limited by the number of + ** bits in a Bitmask + */ + testcase( pTabList->nSrc==BMS ); + if( pTabList->nSrc>BMS ){ + sqlite3ErrorMsg(pParse, "at most %d tables in a join", BMS); + return 0; + } + + /* This function normally generates a nested loop for all tables in + ** pTabList. But if the WHERE_ONETABLE_ONLY flag is set, then we should + ** only generate code for the first table in pTabList and assume that + ** any cursors associated with subsequent tables are uninitialized. + */ + nTabList = (wctrlFlags & WHERE_ONETABLE_ONLY) ? 1 : pTabList->nSrc; + + /* Allocate and initialize the WhereInfo structure that will become the + ** return value. A single allocation is used to store the WhereInfo + ** struct, the contents of WhereInfo.a[], the WhereClause structure + ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte + ** field (type Bitmask) it must be aligned on an 8-byte boundary on + ** some architectures. Hence the ROUND8() below. + */ + nByteWInfo = ROUND8(sizeof(WhereInfo)+(nTabList-1)*sizeof(WhereLevel)); + pWInfo = sqlite3DbMallocZero(db, nByteWInfo + sizeof(WhereLoop)); + if( db->mallocFailed ){ + sqlite3DbFree(db, pWInfo); + pWInfo = 0; + goto whereBeginError; + } + pWInfo->aiCurOnePass[0] = pWInfo->aiCurOnePass[1] = -1; + pWInfo->nLevel = nTabList; + pWInfo->pParse = pParse; + pWInfo->pTabList = pTabList; + pWInfo->pOrderBy = pOrderBy; + pWInfo->pResultSet = pResultSet; + pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(v); + pWInfo->wctrlFlags = wctrlFlags; + pWInfo->savedNQueryLoop = pParse->nQueryLoop; + assert( pWInfo->eOnePass==ONEPASS_OFF ); /* ONEPASS defaults to OFF */ + pMaskSet = &pWInfo->sMaskSet; + sWLB.pWInfo = pWInfo; + sWLB.pWC = &pWInfo->sWC; + sWLB.pNew = (WhereLoop*)(((char*)pWInfo)+nByteWInfo); + assert( EIGHT_BYTE_ALIGNMENT(sWLB.pNew) ); + whereLoopInit(sWLB.pNew); +#ifdef SQLITE_DEBUG + sWLB.pNew->cId = '*'; +#endif + + /* Split the WHERE clause into separate subexpressions where each + ** subexpression is separated by an AND operator. + */ + initMaskSet(pMaskSet); + sqlite3WhereClauseInit(&pWInfo->sWC, pWInfo); + sqlite3WhereSplit(&pWInfo->sWC, pWhere, TK_AND); + + /* Special case: a WHERE clause that is constant. Evaluate the + ** expression and either jump over all of the code or fall thru. + */ + for(ii=0; iinTerm; ii++){ + if( nTabList==0 || sqlite3ExprIsConstantNotJoin(sWLB.pWC->a[ii].pExpr) ){ + sqlite3ExprIfFalse(pParse, sWLB.pWC->a[ii].pExpr, pWInfo->iBreak, + SQLITE_JUMPIFNULL); + sWLB.pWC->a[ii].wtFlags |= TERM_CODED; + } + } + + /* Special case: No FROM clause + */ + if( nTabList==0 ){ + if( pOrderBy ) pWInfo->nOBSat = pOrderBy->nExpr; + if( wctrlFlags & WHERE_WANT_DISTINCT ){ + pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; + } + } + + /* Assign a bit from the bitmask to every term in the FROM clause. + ** + ** The N-th term of the FROM clause is assigned a bitmask of 1<nSrc tables in + ** pTabList, not just the first nTabList tables. nTabList is normally + ** equal to pTabList->nSrc but might be shortened to 1 if the + ** WHERE_ONETABLE_ONLY flag is set. + */ + for(ii=0; iinSrc; ii++){ + createMask(pMaskSet, pTabList->a[ii].iCursor); + sqlite3WhereTabFuncArgs(pParse, &pTabList->a[ii], &pWInfo->sWC); + } +#ifdef SQLITE_DEBUG + for(ii=0; iinSrc; ii++){ + Bitmask m = sqlite3WhereGetMask(pMaskSet, pTabList->a[ii].iCursor); + assert( m==MASKBIT(ii) ); + } +#endif + + /* Analyze all of the subexpressions. */ + sqlite3WhereExprAnalyze(pTabList, &pWInfo->sWC); + if( db->mallocFailed ) goto whereBeginError; + + if( wctrlFlags & WHERE_WANT_DISTINCT ){ + if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pResultSet) ){ + /* The DISTINCT marking is pointless. Ignore it. */ + pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; + }else if( pOrderBy==0 ){ + /* Try to ORDER BY the result set to make distinct processing easier */ + pWInfo->wctrlFlags |= WHERE_DISTINCTBY; + pWInfo->pOrderBy = pResultSet; + } + } + + /* Construct the WhereLoop objects */ + WHERETRACE(0xffff,("*** Optimizer Start *** (wctrlFlags: 0x%x)\n", + wctrlFlags)); +#if defined(WHERETRACE_ENABLED) + if( sqlite3WhereTrace & 0x100 ){ /* Display all terms of the WHERE clause */ + int i; + for(i=0; inTerm; i++){ + whereTermPrint(&sWLB.pWC->a[i], i); + } + } +#endif + + if( nTabList!=1 || whereShortCut(&sWLB)==0 ){ + rc = whereLoopAddAll(&sWLB); + if( rc ) goto whereBeginError; + +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace ){ /* Display all of the WhereLoop objects */ + WhereLoop *p; + int i; + static const char zLabel[] = "0123456789abcdefghijklmnopqrstuvwyxz" + "ABCDEFGHIJKLMNOPQRSTUVWYXZ"; + for(p=pWInfo->pLoops, i=0; p; p=p->pNextLoop, i++){ + p->cId = zLabel[i%sizeof(zLabel)]; + whereLoopPrint(p, sWLB.pWC); + } + } +#endif + + wherePathSolver(pWInfo, 0); + if( db->mallocFailed ) goto whereBeginError; + if( pWInfo->pOrderBy ){ + wherePathSolver(pWInfo, pWInfo->nRowOut+1); + if( db->mallocFailed ) goto whereBeginError; + } + } + if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){ + pWInfo->revMask = (Bitmask)(-1); + } + if( pParse->nErr || NEVER(db->mallocFailed) ){ + goto whereBeginError; + } +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace ){ + sqlite3DebugPrintf("---- Solution nRow=%d", pWInfo->nRowOut); + if( pWInfo->nOBSat>0 ){ + sqlite3DebugPrintf(" ORDERBY=%d,0x%llx", pWInfo->nOBSat, pWInfo->revMask); + } + switch( pWInfo->eDistinct ){ + case WHERE_DISTINCT_UNIQUE: { + sqlite3DebugPrintf(" DISTINCT=unique"); + break; + } + case WHERE_DISTINCT_ORDERED: { + sqlite3DebugPrintf(" DISTINCT=ordered"); + break; + } + case WHERE_DISTINCT_UNORDERED: { + sqlite3DebugPrintf(" DISTINCT=unordered"); + break; + } + } + sqlite3DebugPrintf("\n"); + for(ii=0; iinLevel; ii++){ + whereLoopPrint(pWInfo->a[ii].pWLoop, sWLB.pWC); + } + } +#endif + /* Attempt to omit tables from the join that do not effect the result */ + if( pWInfo->nLevel>=2 + && pResultSet!=0 + && OptimizationEnabled(db, SQLITE_OmitNoopJoin) + ){ + Bitmask tabUsed = sqlite3WhereExprListUsage(pMaskSet, pResultSet); + if( sWLB.pOrderBy ){ + tabUsed |= sqlite3WhereExprListUsage(pMaskSet, sWLB.pOrderBy); + } + while( pWInfo->nLevel>=2 ){ + WhereTerm *pTerm, *pEnd; + pLoop = pWInfo->a[pWInfo->nLevel-1].pWLoop; + if( (pWInfo->pTabList->a[pLoop->iTab].fg.jointype & JT_LEFT)==0 ) break; + if( (wctrlFlags & WHERE_WANT_DISTINCT)==0 + && (pLoop->wsFlags & WHERE_ONEROW)==0 + ){ + break; + } + if( (tabUsed & pLoop->maskSelf)!=0 ) break; + pEnd = sWLB.pWC->a + sWLB.pWC->nTerm; + for(pTerm=sWLB.pWC->a; pTermprereqAll & pLoop->maskSelf)!=0 + && !ExprHasProperty(pTerm->pExpr, EP_FromJoin) + ){ + break; + } + } + if( pTerm drop loop %c not used\n", pLoop->cId)); + pWInfo->nLevel--; + nTabList--; + } + } + WHERETRACE(0xffff,("*** Optimizer Finished ***\n")); + pWInfo->pParse->nQueryLoop += pWInfo->nRowOut; + + /* If the caller is an UPDATE or DELETE statement that is requesting + ** to use a one-pass algorithm, determine if this is appropriate. + ** The one-pass algorithm only works if the WHERE clause constrains + ** the statement to update or delete a single row. + */ + assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 ); + if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 ){ + int wsFlags = pWInfo->a[0].pWLoop->wsFlags; + int bOnerow = (wsFlags & WHERE_ONEROW)!=0; + if( bOnerow || ( (wctrlFlags & WHERE_ONEPASS_MULTIROW) + && 0==(wsFlags & WHERE_VIRTUALTABLE) + )){ + pWInfo->eOnePass = bOnerow ? ONEPASS_SINGLE : ONEPASS_MULTI; + if( HasRowid(pTabList->a[0].pTab) ){ + pWInfo->a[0].pWLoop->wsFlags &= ~WHERE_IDX_ONLY; + } + } + } + + /* Open all tables in the pTabList and any indices selected for + ** searching those tables. + */ + for(ii=0, pLevel=pWInfo->a; iia[pLevel->iFrom]; + pTab = pTabItem->pTab; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + pLoop = pLevel->pWLoop; + if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ){ + /* Do nothing */ + }else +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){ + const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); + int iCur = pTabItem->iCursor; + sqlite3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0, pVTab, P4_VTAB); + }else if( IsVirtual(pTab) ){ + /* noop */ + }else +#endif + if( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 + && (wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0 ){ + int op = OP_OpenRead; + if( pWInfo->eOnePass!=ONEPASS_OFF ){ + op = OP_OpenWrite; + pWInfo->aiCurOnePass[0] = pTabItem->iCursor; + }; + sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op); + assert( pTabItem->iCursor==pLevel->iTabCur ); + testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 ); + testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS ); + if( pWInfo->eOnePass==ONEPASS_OFF && pTab->nColcolUsed; + int n = 0; + for(; b; b=b>>1, n++){} + sqlite3VdbeChangeP4(v, sqlite3VdbeCurrentAddr(v)-1, + SQLITE_INT_TO_PTR(n), P4_INT32); + assert( n<=pTab->nCol ); + } +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, pTabItem->iCursor, 0, 0, + (const u8*)&pTabItem->colUsed, P4_INT64); +#endif + }else{ + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + } + if( pLoop->wsFlags & WHERE_INDEXED ){ + Index *pIx = pLoop->u.btree.pIndex; + int iIndexCur; + int op = OP_OpenRead; + /* iIdxCur is always set if to a positive value if ONEPASS is possible */ + assert( iIdxCur!=0 || (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 ); + if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIx) + && (wctrlFlags & WHERE_ONETABLE_ONLY)!=0 + ){ + /* This is one term of an OR-optimization using the PRIMARY KEY of a + ** WITHOUT ROWID table. No need for a separate index */ + iIndexCur = pLevel->iTabCur; + op = 0; + }else if( pWInfo->eOnePass!=ONEPASS_OFF ){ + Index *pJ = pTabItem->pTab->pIndex; + iIndexCur = iIdxCur; + assert( wctrlFlags & WHERE_ONEPASS_DESIRED ); + while( ALWAYS(pJ) && pJ!=pIx ){ + iIndexCur++; + pJ = pJ->pNext; + } + op = OP_OpenWrite; + pWInfo->aiCurOnePass[1] = iIndexCur; + }else if( iIdxCur && (wctrlFlags & WHERE_ONETABLE_ONLY)!=0 ){ + iIndexCur = iIdxCur; + if( wctrlFlags & WHERE_REOPEN_IDX ) op = OP_ReopenIdx; + }else{ + iIndexCur = pParse->nTab++; + } + pLevel->iIdxCur = iIndexCur; + assert( pIx->pSchema==pTab->pSchema ); + assert( iIndexCur>=0 ); + if( op ){ + sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIx); + if( (pLoop->wsFlags & WHERE_CONSTRAINT)!=0 + && (pLoop->wsFlags & (WHERE_COLUMN_RANGE|WHERE_SKIPSCAN))==0 + && (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)==0 + ){ + sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ); /* Hint to COMDB2 */ + } + VdbeComment((v, "%s", pIx->zName)); +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + { + u64 colUsed = 0; + int ii, jj; + for(ii=0; iinColumn; ii++){ + jj = pIx->aiColumn[ii]; + if( jj<0 ) continue; + if( jj>63 ) jj = 63; + if( (pTabItem->colUsed & MASKBIT(jj))==0 ) continue; + colUsed |= ((u64)1)<<(ii<63 ? ii : 63); + } + sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, iIndexCur, 0, 0, + (u8*)&colUsed, P4_INT64); + } +#endif /* SQLITE_ENABLE_COLUMN_USED_MASK */ + } + } + if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb); + } + pWInfo->iTop = sqlite3VdbeCurrentAddr(v); + if( db->mallocFailed ) goto whereBeginError; + + /* Generate the code to do the search. Each iteration of the for + ** loop below generates code for a single nested loop of the VM + ** program. + */ + notReady = ~(Bitmask)0; + for(ii=0; iia[ii]; + wsFlags = pLevel->pWLoop->wsFlags; +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX + if( (pLevel->pWLoop->wsFlags & WHERE_AUTO_INDEX)!=0 ){ + constructAutomaticIndex(pParse, &pWInfo->sWC, + &pTabList->a[pLevel->iFrom], notReady, pLevel); + if( db->mallocFailed ) goto whereBeginError; + } +#endif + addrExplain = sqlite3WhereExplainOneScan( + pParse, pTabList, pLevel, ii, pLevel->iFrom, wctrlFlags + ); + pLevel->addrBody = sqlite3VdbeCurrentAddr(v); + notReady = sqlite3WhereCodeOneLoopStart(pWInfo, ii, notReady); + pWInfo->iContinue = pLevel->addrCont; + if( (wsFlags&WHERE_MULTI_OR)==0 && (wctrlFlags&WHERE_ONETABLE_ONLY)==0 ){ + sqlite3WhereAddScanStatus(v, pTabList, pLevel, addrExplain); + } + } + + /* Done. */ + VdbeModuleComment((v, "Begin WHERE-core")); + return pWInfo; + + /* Jump here if malloc fails */ +whereBeginError: + if( pWInfo ){ + pParse->nQueryLoop = pWInfo->savedNQueryLoop; + whereInfoFree(db, pWInfo); + } + return 0; +} + +/* +** Generate the end of the WHERE loop. See comments on +** sqlite3WhereBegin() for additional information. +*/ +SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ + Parse *pParse = pWInfo->pParse; + Vdbe *v = pParse->pVdbe; + int i; + WhereLevel *pLevel; + WhereLoop *pLoop; + SrcList *pTabList = pWInfo->pTabList; + sqlite3 *db = pParse->db; + + /* Generate loop termination code. + */ + VdbeModuleComment((v, "End WHERE-core")); + sqlite3ExprCacheClear(pParse); + for(i=pWInfo->nLevel-1; i>=0; i--){ + int addr; + pLevel = &pWInfo->a[i]; + pLoop = pLevel->pWLoop; + sqlite3VdbeResolveLabel(v, pLevel->addrCont); + if( pLevel->op!=OP_Noop ){ + sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3); + sqlite3VdbeChangeP5(v, pLevel->p5); + VdbeCoverage(v); + VdbeCoverageIf(v, pLevel->op==OP_Next); + VdbeCoverageIf(v, pLevel->op==OP_Prev); + VdbeCoverageIf(v, pLevel->op==OP_VNext); + } + if( pLoop->wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){ + struct InLoop *pIn; + int j; + sqlite3VdbeResolveLabel(v, pLevel->addrNxt); + for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){ + sqlite3VdbeJumpHere(v, pIn->addrInTop+1); + sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop); + VdbeCoverage(v); + VdbeCoverageIf(v, pIn->eEndLoopOp==OP_PrevIfOpen); + VdbeCoverageIf(v, pIn->eEndLoopOp==OP_NextIfOpen); + sqlite3VdbeJumpHere(v, pIn->addrInTop-1); + } + } + sqlite3VdbeResolveLabel(v, pLevel->addrBrk); + if( pLevel->addrSkip ){ + sqlite3VdbeGoto(v, pLevel->addrSkip); + VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName)); + sqlite3VdbeJumpHere(v, pLevel->addrSkip); + sqlite3VdbeJumpHere(v, pLevel->addrSkip-2); + } + if( pLevel->addrLikeRep ){ + int op; + if( sqlite3VdbeGetOp(v, pLevel->addrLikeRep-1)->p1 ){ + op = OP_DecrJumpZero; + }else{ + op = OP_JumpZeroIncr; + } + sqlite3VdbeAddOp2(v, op, pLevel->iLikeRepCntr, pLevel->addrLikeRep); + VdbeCoverage(v); + } + if( pLevel->iLeftJoin ){ + addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); VdbeCoverage(v); + assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 + || (pLoop->wsFlags & WHERE_INDEXED)!=0 ); + if( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 ){ + sqlite3VdbeAddOp1(v, OP_NullRow, pTabList->a[i].iCursor); + } + if( pLoop->wsFlags & WHERE_INDEXED ){ + sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur); + } + if( pLevel->op==OP_Return ){ + sqlite3VdbeAddOp2(v, OP_Gosub, pLevel->p1, pLevel->addrFirst); + }else{ + sqlite3VdbeGoto(v, pLevel->addrFirst); + } + sqlite3VdbeJumpHere(v, addr); + } + VdbeModuleComment((v, "End WHERE-loop%d: %s", i, + pWInfo->pTabList->a[pLevel->iFrom].pTab->zName)); + } + + /* The "break" point is here, just past the end of the outer loop. + ** Set it. + */ + sqlite3VdbeResolveLabel(v, pWInfo->iBreak); + + assert( pWInfo->nLevel<=pTabList->nSrc ); + for(i=0, pLevel=pWInfo->a; inLevel; i++, pLevel++){ + int k, last; + VdbeOp *pOp; + Index *pIdx = 0; + struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom]; + Table *pTab = pTabItem->pTab; + assert( pTab!=0 ); + pLoop = pLevel->pWLoop; + + /* For a co-routine, change all OP_Column references to the table of + ** the co-routine into OP_Copy of result contained in a register. + ** OP_Rowid becomes OP_Null. + */ + if( pTabItem->fg.viaCoroutine && !db->mallocFailed ){ + translateColumnToCopy(v, pLevel->addrBody, pLevel->iTabCur, + pTabItem->regResult, 0); + continue; + } + + /* Close all of the cursors that were opened by sqlite3WhereBegin. + ** Except, do not close cursors that will be reused by the OR optimization + ** (WHERE_OMIT_OPEN_CLOSE). And do not close the OP_OpenWrite cursors + ** created for the ONEPASS optimization. + */ + if( (pTab->tabFlags & TF_Ephemeral)==0 + && pTab->pSelect==0 + && (pWInfo->wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0 + ){ + int ws = pLoop->wsFlags; + if( pWInfo->eOnePass==ONEPASS_OFF && (ws & WHERE_IDX_ONLY)==0 ){ + sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor); + } + if( (ws & WHERE_INDEXED)!=0 + && (ws & (WHERE_IPK|WHERE_AUTO_INDEX))==0 + && pLevel->iIdxCur!=pWInfo->aiCurOnePass[1] + ){ + sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur); + } + } + + /* If this scan uses an index, make VDBE code substitutions to read data + ** from the index instead of from the table where possible. In some cases + ** this optimization prevents the table from ever being read, which can + ** yield a significant performance boost. + ** + ** Calls to the code generator in between sqlite3WhereBegin and + ** sqlite3WhereEnd will have created code that references the table + ** directly. This loop scans all that code looking for opcodes + ** that reference the table and converts them into opcodes that + ** reference the index. + */ + if( pLoop->wsFlags & (WHERE_INDEXED|WHERE_IDX_ONLY) ){ + pIdx = pLoop->u.btree.pIndex; + }else if( pLoop->wsFlags & WHERE_MULTI_OR ){ + pIdx = pLevel->u.pCovidx; + } + if( pIdx + && (pWInfo->eOnePass==ONEPASS_OFF || !HasRowid(pIdx->pTable)) + && !db->mallocFailed + ){ + last = sqlite3VdbeCurrentAddr(v); + k = pLevel->addrBody; + pOp = sqlite3VdbeGetOp(v, k); + for(; kp1!=pLevel->iTabCur ) continue; + if( pOp->opcode==OP_Column ){ + int x = pOp->p2; + assert( pIdx->pTable==pTab ); + if( !HasRowid(pTab) ){ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + x = pPk->aiColumn[x]; + assert( x>=0 ); + } + x = sqlite3ColumnOfIndex(pIdx, x); + if( x>=0 ){ + pOp->p2 = x; + pOp->p1 = pLevel->iIdxCur; + } + assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || x>=0 ); + }else if( pOp->opcode==OP_Rowid ){ + pOp->p1 = pLevel->iIdxCur; + pOp->opcode = OP_IdxRowid; + } + } + } + } + + /* Final cleanup + */ + pParse->nQueryLoop = pWInfo->savedNQueryLoop; + whereInfoFree(db, pWInfo); + return; +} + +/************** End of where.c ***********************************************/ +/************** Begin file parse.c *******************************************/ +/* Driver template for the LEMON parser generator. +** The author disclaims copyright to this source code. +** +** This version of "lempar.c" is modified, slightly, for use by SQLite. +** The only modifications are the addition of a couple of NEVER() +** macros to disable tests that are needed in the case of a general +** LALR(1) grammar but which are always false in the +** specific grammar used by SQLite. +*/ +/* First off, code is included that follows the "include" declaration +** in the input grammar file. */ +/* #include */ + +/* #include "sqliteInt.h" */ + +/* +** Disable all error recovery processing in the parser push-down +** automaton. +*/ +#define YYNOERRORRECOVERY 1 + +/* +** Make yytestcase() the same as testcase() +*/ +#define yytestcase(X) testcase(X) + +/* +** An instance of this structure holds information about the +** LIMIT clause of a SELECT statement. +*/ +struct LimitVal { + Expr *pLimit; /* The LIMIT expression. NULL if there is no limit */ + Expr *pOffset; /* The OFFSET expression. NULL if there is none */ +}; + +/* +** An instance of this structure is used to store the LIKE, +** GLOB, NOT LIKE, and NOT GLOB operators. +*/ +struct LikeOp { + Token eOperator; /* "like" or "glob" or "regexp" */ + int bNot; /* True if the NOT keyword is present */ +}; + +/* +** An instance of the following structure describes the event of a +** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT, +** TK_DELETE, or TK_INSTEAD. If the event is of the form +** +** UPDATE ON (a,b,c) +** +** Then the "b" IdList records the list "a,b,c". +*/ +struct TrigEvent { int a; IdList * b; }; + +/* +** An instance of this structure holds the ATTACH key and the key type. +*/ +struct AttachKey { int type; Token key; }; + + + /* + ** For a compound SELECT statement, make sure p->pPrior->pNext==p for + ** all elements in the list. And make sure list length does not exceed + ** SQLITE_LIMIT_COMPOUND_SELECT. + */ + static void parserDoubleLinkSelect(Parse *pParse, Select *p){ + if( p->pPrior ){ + Select *pNext = 0, *pLoop; + int mxSelect, cnt = 0; + for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){ + pLoop->pNext = pNext; + pLoop->selFlags |= SF_Compound; + } + if( (p->selFlags & SF_MultiValue)==0 && + (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 && + cnt>mxSelect + ){ + sqlite3ErrorMsg(pParse, "too many terms in compound SELECT"); + } + } + } + + /* This is a utility routine used to set the ExprSpan.zStart and + ** ExprSpan.zEnd values of pOut so that the span covers the complete + ** range of text beginning with pStart and going to the end of pEnd. + */ + static void spanSet(ExprSpan *pOut, Token *pStart, Token *pEnd){ + pOut->zStart = pStart->z; + pOut->zEnd = &pEnd->z[pEnd->n]; + } + + /* Construct a new Expr object from a single identifier. Use the + ** new Expr to populate pOut. Set the span of pOut to be the identifier + ** that created the expression. + */ + static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){ + pOut->pExpr = sqlite3PExpr(pParse, op, 0, 0, pValue); + pOut->zStart = pValue->z; + pOut->zEnd = &pValue->z[pValue->n]; + } + + /* This routine constructs a binary expression node out of two ExprSpan + ** objects and uses the result to populate a new ExprSpan object. + */ + static void spanBinaryExpr( + ExprSpan *pOut, /* Write the result here */ + Parse *pParse, /* The parsing context. Errors accumulate here */ + int op, /* The binary operation */ + ExprSpan *pLeft, /* The left operand */ + ExprSpan *pRight /* The right operand */ + ){ + pOut->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0); + pOut->zStart = pLeft->zStart; + pOut->zEnd = pRight->zEnd; + } + + /* Construct an expression node for a unary postfix operator + */ + static void spanUnaryPostfix( + ExprSpan *pOut, /* Write the new expression node here */ + Parse *pParse, /* Parsing context to record errors */ + int op, /* The operator */ + ExprSpan *pOperand, /* The operand */ + Token *pPostOp /* The operand token for setting the span */ + ){ + pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0); + pOut->zStart = pOperand->zStart; + pOut->zEnd = &pPostOp->z[pPostOp->n]; + } + + /* A routine to convert a binary TK_IS or TK_ISNOT expression into a + ** unary TK_ISNULL or TK_NOTNULL expression. */ + static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){ + sqlite3 *db = pParse->db; + if( pY && pA && pY->op==TK_NULL ){ + pA->op = (u8)op; + sqlite3ExprDelete(db, pA->pRight); + pA->pRight = 0; + } + } + + /* Construct an expression node for a unary prefix operator + */ + static void spanUnaryPrefix( + ExprSpan *pOut, /* Write the new expression node here */ + Parse *pParse, /* Parsing context to record errors */ + int op, /* The operator */ + ExprSpan *pOperand, /* The operand */ + Token *pPreOp /* The operand token for setting the span */ + ){ + pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0); + pOut->zStart = pPreOp->z; + pOut->zEnd = pOperand->zEnd; + } + + /* Add a single new term to an ExprList that is used to store a + ** list of identifiers. Report an error if the ID list contains + ** a COLLATE clause or an ASC or DESC keyword, except ignore the + ** error while parsing a legacy schema. + */ + static ExprList *parserAddExprIdListTerm( + Parse *pParse, + ExprList *pPrior, + Token *pIdToken, + int hasCollate, + int sortOrder + ){ + ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0); + if( (hasCollate || sortOrder!=SQLITE_SO_UNDEFINED) + && pParse->db->init.busy==0 + ){ + sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"", + pIdToken->n, pIdToken->z); + } + sqlite3ExprListSetName(pParse, p, pIdToken, 1); + return p; + } +/* Next is all token values, in a form suitable for use by makeheaders. +** This section will be null unless lemon is run with the -m switch. +*/ +/* +** These constants (all generated automatically by the parser generator) +** specify the various kinds of tokens (terminals) that the parser +** understands. +** +** Each symbol here is a terminal symbol in the grammar. +*/ +/* Make sure the INTERFACE macro is defined. +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/* The next thing included is series of defines which control +** various aspects of the generated parser. +** YYCODETYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 terminals +** and nonterminals. "int" is used otherwise. +** YYNOCODE is a number of type YYCODETYPE which corresponds +** to no legal terminal or nonterminal number. This +** number is used to fill in empty slots of the hash +** table. +** YYFALLBACK If defined, this indicates that one or more tokens +** have fall-back values which should be used if the +** original value of the token will not parse. +** YYACTIONTYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 rules and +** states combined. "int" is used otherwise. +** sqlite3ParserTOKENTYPE is the data type used for minor tokens given +** directly to the parser from the tokenizer. +** YYMINORTYPE is the data type used for all minor tokens. +** This is typically a union of many types, one of +** which is sqlite3ParserTOKENTYPE. The entry in the union +** for base tokens is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. If +** zero the stack is dynamically sized using realloc() +** sqlite3ParserARG_SDECL A static variable declaration for the %extra_argument +** sqlite3ParserARG_PDECL A parameter declaration for the %extra_argument +** sqlite3ParserARG_STORE Code to store %extra_argument into yypParser +** sqlite3ParserARG_FETCH Code to extract %extra_argument from yypParser +** YYERRORSYMBOL is the code number of the error symbol. If not +** defined, then do no error processing. +** YYNSTATE the combined number of states. +** YYNRULE the number of rules in the grammar +** YY_MAX_SHIFT Maximum value for shift actions +** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions +** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions +** YY_MIN_REDUCE Maximum value for reduce actions +** YY_ERROR_ACTION The yy_action[] code for syntax error +** YY_ACCEPT_ACTION The yy_action[] code for accept +** YY_NO_ACTION The yy_action[] code for no-op +*/ +#define YYCODETYPE unsigned char +#define YYNOCODE 254 +#define YYACTIONTYPE unsigned short int +#define YYWILDCARD 70 +#define sqlite3ParserTOKENTYPE Token +typedef union { + int yyinit; + sqlite3ParserTOKENTYPE yy0; + Select* yy3; + ExprList* yy14; + With* yy59; + SrcList* yy65; + struct LikeOp yy96; + Expr* yy132; + u8 yy186; + int yy328; + ExprSpan yy346; + struct TrigEvent yy378; + u16 yy381; + IdList* yy408; + struct {int value; int mask;} yy429; + TriggerStep* yy473; + struct LimitVal yy476; +} YYMINORTYPE; +#ifndef YYSTACKDEPTH +#define YYSTACKDEPTH 100 +#endif +#define sqlite3ParserARG_SDECL Parse *pParse; +#define sqlite3ParserARG_PDECL ,Parse *pParse +#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse +#define sqlite3ParserARG_STORE yypParser->pParse = pParse +#define YYFALLBACK 1 +#define YYNSTATE 436 +#define YYNRULE 328 +#define YY_MAX_SHIFT 435 +#define YY_MIN_SHIFTREDUCE 649 +#define YY_MAX_SHIFTREDUCE 976 +#define YY_MIN_REDUCE 977 +#define YY_MAX_REDUCE 1304 +#define YY_ERROR_ACTION 1305 +#define YY_ACCEPT_ACTION 1306 +#define YY_NO_ACTION 1307 + +/* The yyzerominor constant is used to initialize instances of +** YYMINORTYPE objects to zero. */ +static const YYMINORTYPE yyzerominor = { 0 }; + +/* Define the yytestcase() macro to be a no-op if is not already defined +** otherwise. +** +** Applications can choose to define yytestcase() in the %include section +** to a macro that can assist in verifying code coverage. For production +** code the yytestcase() macro should be turned off. But it is useful +** for testing. +*/ +#ifndef yytestcase +# define yytestcase(X) +#endif + + +/* Next are the tables used to determine what action to take based on the +** current state and lookahead token. These tables are used to implement +** functions that take a state number and lookahead value and return an +** action integer. +** +** Suppose the action integer is N. Then the action is determined as +** follows +** +** 0 <= N <= YY_MAX_SHIFT Shift N. That is, push the lookahead +** token onto the stack and goto state N. +** +** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then +** and YY_MAX_SHIFTREDUCE reduce by rule N-YY_MIN_SHIFTREDUCE. +** +** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE +** and YY_MAX_REDUCE + +** N == YY_ERROR_ACTION A syntax error has occurred. +** +** N == YY_ACCEPT_ACTION The parser accepts its input. +** +** N == YY_NO_ACTION No such action. Denotes unused +** slots in the yy_action[] table. +** +** The action table is constructed as a single large table named yy_action[]. +** Given state S and lookahead X, the action is computed as +** +** yy_action[ yy_shift_ofst[S] + X ] +** +** If the index value yy_shift_ofst[S]+X is out of range or if the value +** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S] +** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table +** and that yy_default[S] should be used instead. +** +** The formula above is for computing the action when the lookahead is +** a terminal symbol. If the lookahead is a non-terminal (as occurs after +** a reduce action) then the yy_reduce_ofst[] array is used in place of +** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of +** YY_SHIFT_USE_DFLT. +** +** The following are the tables generated in this section: +** +** yy_action[] A single table containing all actions. +** yy_lookahead[] A table containing the lookahead for each entry in +** yy_action. Used to detect hash collisions. +** yy_shift_ofst[] For each state, the offset into yy_action for +** shifting terminals. +** yy_reduce_ofst[] For each state, the offset into yy_action for +** shifting non-terminals after a reduce. +** yy_default[] Default action for each state. +*/ +#define YY_ACTTAB_COUNT (1501) +static const YYACTIONTYPE yy_action[] = { + /* 0 */ 311, 1306, 145, 651, 2, 192, 652, 338, 780, 92, + /* 10 */ 92, 92, 92, 85, 90, 90, 90, 90, 89, 89, + /* 20 */ 88, 88, 88, 87, 335, 88, 88, 88, 87, 335, + /* 30 */ 327, 856, 856, 92, 92, 92, 92, 776, 90, 90, + /* 40 */ 90, 90, 89, 89, 88, 88, 88, 87, 335, 86, + /* 50 */ 83, 166, 93, 94, 84, 868, 871, 860, 860, 91, + /* 60 */ 91, 92, 92, 92, 92, 335, 90, 90, 90, 90, + /* 70 */ 89, 89, 88, 88, 88, 87, 335, 311, 780, 90, + /* 80 */ 90, 90, 90, 89, 89, 88, 88, 88, 87, 335, + /* 90 */ 123, 808, 689, 689, 689, 689, 112, 230, 430, 257, + /* 100 */ 809, 698, 430, 86, 83, 166, 324, 55, 856, 856, + /* 110 */ 201, 158, 276, 387, 271, 386, 188, 689, 689, 828, + /* 120 */ 833, 49, 944, 269, 833, 49, 123, 87, 335, 93, + /* 130 */ 94, 84, 868, 871, 860, 860, 91, 91, 92, 92, + /* 140 */ 92, 92, 342, 90, 90, 90, 90, 89, 89, 88, + /* 150 */ 88, 88, 87, 335, 311, 328, 333, 332, 701, 408, + /* 160 */ 394, 69, 690, 691, 690, 691, 715, 910, 251, 354, + /* 170 */ 250, 698, 704, 430, 908, 430, 909, 89, 89, 88, + /* 180 */ 88, 88, 87, 335, 391, 856, 856, 690, 691, 183, + /* 190 */ 95, 340, 384, 381, 380, 833, 31, 833, 49, 912, + /* 200 */ 912, 333, 332, 379, 123, 311, 93, 94, 84, 868, + /* 210 */ 871, 860, 860, 91, 91, 92, 92, 92, 92, 114, + /* 220 */ 90, 90, 90, 90, 89, 89, 88, 88, 88, 87, + /* 230 */ 335, 430, 408, 399, 435, 657, 856, 856, 346, 57, + /* 240 */ 232, 828, 109, 20, 912, 912, 231, 393, 937, 760, + /* 250 */ 97, 751, 752, 833, 49, 708, 708, 93, 94, 84, + /* 260 */ 868, 871, 860, 860, 91, 91, 92, 92, 92, 92, + /* 270 */ 707, 90, 90, 90, 90, 89, 89, 88, 88, 88, + /* 280 */ 87, 335, 311, 114, 22, 706, 688, 58, 408, 390, + /* 290 */ 251, 349, 240, 749, 752, 689, 689, 847, 685, 115, + /* 300 */ 21, 231, 393, 689, 689, 697, 183, 355, 430, 384, + /* 310 */ 381, 380, 192, 856, 856, 780, 123, 160, 159, 223, + /* 320 */ 379, 738, 25, 315, 362, 841, 143, 689, 689, 835, + /* 330 */ 833, 48, 339, 937, 93, 94, 84, 868, 871, 860, + /* 340 */ 860, 91, 91, 92, 92, 92, 92, 914, 90, 90, + /* 350 */ 90, 90, 89, 89, 88, 88, 88, 87, 335, 311, + /* 360 */ 840, 840, 840, 266, 430, 690, 691, 778, 114, 1300, + /* 370 */ 1300, 430, 1, 690, 691, 697, 688, 689, 689, 689, + /* 380 */ 689, 689, 689, 287, 298, 780, 833, 10, 686, 115, + /* 390 */ 856, 856, 355, 833, 10, 828, 366, 690, 691, 363, + /* 400 */ 321, 76, 123, 74, 23, 737, 807, 323, 356, 353, + /* 410 */ 847, 93, 94, 84, 868, 871, 860, 860, 91, 91, + /* 420 */ 92, 92, 92, 92, 940, 90, 90, 90, 90, 89, + /* 430 */ 89, 88, 88, 88, 87, 335, 311, 806, 841, 429, + /* 440 */ 713, 941, 835, 430, 251, 354, 250, 690, 691, 690, + /* 450 */ 691, 690, 691, 86, 83, 166, 24, 942, 151, 753, + /* 460 */ 285, 907, 403, 907, 164, 833, 10, 856, 856, 965, + /* 470 */ 306, 754, 679, 840, 840, 840, 795, 216, 794, 222, + /* 480 */ 906, 344, 906, 904, 86, 83, 166, 286, 93, 94, + /* 490 */ 84, 868, 871, 860, 860, 91, 91, 92, 92, 92, + /* 500 */ 92, 430, 90, 90, 90, 90, 89, 89, 88, 88, + /* 510 */ 88, 87, 335, 311, 430, 724, 352, 705, 427, 699, + /* 520 */ 700, 376, 210, 833, 49, 793, 397, 857, 857, 940, + /* 530 */ 213, 762, 727, 334, 699, 700, 833, 10, 86, 83, + /* 540 */ 166, 345, 396, 902, 856, 856, 941, 385, 833, 9, + /* 550 */ 406, 869, 872, 187, 890, 728, 347, 398, 404, 977, + /* 560 */ 652, 338, 942, 954, 413, 93, 94, 84, 868, 871, + /* 570 */ 860, 860, 91, 91, 92, 92, 92, 92, 861, 90, + /* 580 */ 90, 90, 90, 89, 89, 88, 88, 88, 87, 335, + /* 590 */ 311, 1219, 114, 430, 834, 430, 5, 165, 192, 688, + /* 600 */ 832, 780, 430, 723, 430, 234, 325, 189, 163, 316, + /* 610 */ 356, 955, 115, 235, 269, 833, 35, 833, 36, 747, + /* 620 */ 720, 856, 856, 793, 833, 12, 833, 27, 745, 174, + /* 630 */ 968, 1290, 968, 1291, 1290, 310, 1291, 693, 317, 245, + /* 640 */ 264, 311, 93, 94, 84, 868, 871, 860, 860, 91, + /* 650 */ 91, 92, 92, 92, 92, 832, 90, 90, 90, 90, + /* 660 */ 89, 89, 88, 88, 88, 87, 335, 430, 320, 213, + /* 670 */ 762, 780, 856, 856, 920, 920, 369, 257, 966, 220, + /* 680 */ 966, 396, 663, 664, 665, 242, 259, 244, 262, 833, + /* 690 */ 37, 650, 2, 93, 94, 84, 868, 871, 860, 860, + /* 700 */ 91, 91, 92, 92, 92, 92, 430, 90, 90, 90, + /* 710 */ 90, 89, 89, 88, 88, 88, 87, 335, 311, 430, + /* 720 */ 239, 430, 917, 368, 430, 238, 916, 793, 833, 38, + /* 730 */ 430, 825, 430, 66, 430, 392, 430, 766, 766, 430, + /* 740 */ 367, 833, 39, 833, 28, 430, 833, 29, 68, 856, + /* 750 */ 856, 900, 833, 40, 833, 41, 833, 42, 833, 11, + /* 760 */ 72, 833, 43, 243, 305, 970, 114, 833, 99, 961, + /* 770 */ 93, 94, 84, 868, 871, 860, 860, 91, 91, 92, + /* 780 */ 92, 92, 92, 430, 90, 90, 90, 90, 89, 89, + /* 790 */ 88, 88, 88, 87, 335, 311, 430, 361, 430, 165, + /* 800 */ 147, 430, 186, 185, 184, 833, 44, 430, 289, 430, + /* 810 */ 246, 430, 971, 430, 212, 163, 430, 357, 833, 45, + /* 820 */ 833, 32, 932, 833, 46, 793, 856, 856, 718, 833, + /* 830 */ 47, 833, 33, 833, 117, 833, 118, 75, 833, 119, + /* 840 */ 288, 305, 967, 214, 935, 322, 311, 93, 94, 84, + /* 850 */ 868, 871, 860, 860, 91, 91, 92, 92, 92, 92, + /* 860 */ 430, 90, 90, 90, 90, 89, 89, 88, 88, 88, + /* 870 */ 87, 335, 430, 832, 426, 317, 288, 856, 856, 114, + /* 880 */ 763, 257, 833, 53, 930, 219, 364, 257, 257, 971, + /* 890 */ 361, 396, 257, 257, 833, 34, 257, 311, 93, 94, + /* 900 */ 84, 868, 871, 860, 860, 91, 91, 92, 92, 92, + /* 910 */ 92, 430, 90, 90, 90, 90, 89, 89, 88, 88, + /* 920 */ 88, 87, 335, 430, 217, 318, 124, 253, 856, 856, + /* 930 */ 218, 943, 257, 833, 100, 898, 759, 774, 361, 755, + /* 940 */ 423, 329, 758, 1017, 289, 833, 50, 682, 311, 93, + /* 950 */ 82, 84, 868, 871, 860, 860, 91, 91, 92, 92, + /* 960 */ 92, 92, 430, 90, 90, 90, 90, 89, 89, 88, + /* 970 */ 88, 88, 87, 335, 430, 256, 419, 114, 249, 856, + /* 980 */ 856, 331, 114, 400, 833, 101, 359, 187, 1064, 726, + /* 990 */ 725, 739, 401, 416, 420, 360, 833, 102, 424, 311, + /* 1000 */ 258, 94, 84, 868, 871, 860, 860, 91, 91, 92, + /* 1010 */ 92, 92, 92, 430, 90, 90, 90, 90, 89, 89, + /* 1020 */ 88, 88, 88, 87, 335, 430, 221, 261, 114, 114, + /* 1030 */ 856, 856, 808, 114, 156, 833, 98, 772, 733, 734, + /* 1040 */ 275, 809, 771, 316, 263, 265, 960, 833, 116, 307, + /* 1050 */ 741, 274, 722, 84, 868, 871, 860, 860, 91, 91, + /* 1060 */ 92, 92, 92, 92, 430, 90, 90, 90, 90, 89, + /* 1070 */ 89, 88, 88, 88, 87, 335, 80, 425, 830, 3, + /* 1080 */ 1214, 191, 430, 721, 336, 336, 833, 113, 252, 80, + /* 1090 */ 425, 68, 3, 913, 913, 428, 270, 336, 336, 430, + /* 1100 */ 377, 784, 430, 197, 833, 106, 430, 716, 428, 430, + /* 1110 */ 267, 430, 897, 68, 414, 430, 769, 409, 430, 71, + /* 1120 */ 430, 833, 105, 123, 833, 103, 847, 414, 833, 49, + /* 1130 */ 843, 833, 104, 833, 52, 800, 123, 833, 54, 847, + /* 1140 */ 833, 51, 833, 26, 831, 802, 77, 78, 191, 389, + /* 1150 */ 430, 372, 114, 79, 432, 431, 911, 911, 835, 77, + /* 1160 */ 78, 779, 893, 408, 410, 197, 79, 432, 431, 791, + /* 1170 */ 226, 835, 833, 30, 772, 80, 425, 716, 3, 771, + /* 1180 */ 411, 412, 897, 336, 336, 290, 291, 839, 703, 840, + /* 1190 */ 840, 840, 842, 19, 428, 695, 684, 672, 111, 671, + /* 1200 */ 843, 673, 840, 840, 840, 842, 19, 207, 661, 278, + /* 1210 */ 148, 304, 280, 414, 282, 6, 822, 348, 248, 241, + /* 1220 */ 358, 934, 720, 80, 425, 847, 3, 161, 382, 273, + /* 1230 */ 284, 336, 336, 415, 296, 958, 895, 894, 157, 674, + /* 1240 */ 107, 194, 428, 948, 135, 77, 78, 777, 953, 951, + /* 1250 */ 56, 319, 79, 432, 431, 121, 66, 835, 59, 128, + /* 1260 */ 146, 414, 350, 130, 351, 819, 131, 132, 133, 375, + /* 1270 */ 173, 149, 138, 847, 936, 365, 178, 70, 425, 827, + /* 1280 */ 3, 889, 62, 371, 915, 336, 336, 792, 840, 840, + /* 1290 */ 840, 842, 19, 77, 78, 208, 428, 144, 179, 373, + /* 1300 */ 79, 432, 431, 255, 180, 835, 260, 675, 181, 308, + /* 1310 */ 388, 744, 326, 743, 742, 414, 731, 718, 712, 402, + /* 1320 */ 309, 711, 788, 65, 277, 272, 789, 847, 730, 710, + /* 1330 */ 709, 279, 193, 787, 281, 876, 840, 840, 840, 842, + /* 1340 */ 19, 786, 283, 73, 418, 330, 422, 77, 78, 227, + /* 1350 */ 96, 407, 67, 405, 79, 432, 431, 292, 228, 835, + /* 1360 */ 215, 202, 229, 293, 767, 303, 302, 301, 204, 299, + /* 1370 */ 294, 295, 676, 7, 681, 433, 669, 206, 110, 224, + /* 1380 */ 203, 205, 434, 667, 666, 658, 120, 168, 656, 237, + /* 1390 */ 840, 840, 840, 842, 19, 337, 155, 233, 236, 341, + /* 1400 */ 167, 905, 108, 313, 903, 826, 314, 125, 126, 127, + /* 1410 */ 129, 170, 247, 756, 172, 928, 134, 136, 171, 60, + /* 1420 */ 61, 123, 169, 137, 175, 933, 176, 927, 8, 13, + /* 1430 */ 177, 254, 191, 918, 139, 370, 924, 140, 678, 150, + /* 1440 */ 374, 274, 182, 378, 141, 122, 63, 14, 383, 729, + /* 1450 */ 268, 15, 64, 225, 846, 845, 874, 16, 765, 770, + /* 1460 */ 4, 162, 209, 395, 211, 142, 878, 796, 801, 312, + /* 1470 */ 190, 71, 68, 875, 873, 939, 199, 938, 17, 195, + /* 1480 */ 18, 196, 417, 975, 152, 653, 976, 198, 153, 421, + /* 1490 */ 877, 154, 200, 844, 696, 81, 343, 297, 1019, 1018, + /* 1500 */ 300, +}; +static const YYCODETYPE yy_lookahead[] = { + /* 0 */ 19, 144, 145, 146, 147, 24, 1, 2, 27, 80, + /* 10 */ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + /* 20 */ 91, 92, 93, 94, 95, 91, 92, 93, 94, 95, + /* 30 */ 19, 50, 51, 80, 81, 82, 83, 212, 85, 86, + /* 40 */ 87, 88, 89, 90, 91, 92, 93, 94, 95, 224, + /* 50 */ 225, 226, 71, 72, 73, 74, 75, 76, 77, 78, + /* 60 */ 79, 80, 81, 82, 83, 95, 85, 86, 87, 88, + /* 70 */ 89, 90, 91, 92, 93, 94, 95, 19, 97, 85, + /* 80 */ 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + /* 90 */ 66, 33, 27, 28, 27, 28, 22, 201, 152, 152, + /* 100 */ 42, 27, 152, 224, 225, 226, 95, 211, 50, 51, + /* 110 */ 99, 100, 101, 102, 103, 104, 105, 27, 28, 59, + /* 120 */ 174, 175, 243, 112, 174, 175, 66, 94, 95, 71, + /* 130 */ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + /* 140 */ 82, 83, 195, 85, 86, 87, 88, 89, 90, 91, + /* 150 */ 92, 93, 94, 95, 19, 209, 89, 90, 173, 209, + /* 160 */ 210, 26, 97, 98, 97, 98, 181, 100, 108, 109, + /* 170 */ 110, 97, 174, 152, 107, 152, 109, 89, 90, 91, + /* 180 */ 92, 93, 94, 95, 163, 50, 51, 97, 98, 99, + /* 190 */ 55, 244, 102, 103, 104, 174, 175, 174, 175, 132, + /* 200 */ 133, 89, 90, 113, 66, 19, 71, 72, 73, 74, + /* 210 */ 75, 76, 77, 78, 79, 80, 81, 82, 83, 198, + /* 220 */ 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + /* 230 */ 95, 152, 209, 210, 148, 149, 50, 51, 100, 53, + /* 240 */ 154, 59, 156, 22, 132, 133, 119, 120, 163, 163, + /* 250 */ 22, 192, 193, 174, 175, 27, 28, 71, 72, 73, + /* 260 */ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + /* 270 */ 174, 85, 86, 87, 88, 89, 90, 91, 92, 93, + /* 280 */ 94, 95, 19, 198, 198, 174, 152, 24, 209, 210, + /* 290 */ 108, 109, 110, 192, 193, 27, 28, 69, 164, 165, + /* 300 */ 79, 119, 120, 27, 28, 27, 99, 222, 152, 102, + /* 310 */ 103, 104, 24, 50, 51, 27, 66, 89, 90, 185, + /* 320 */ 113, 187, 22, 157, 239, 97, 58, 27, 28, 101, + /* 330 */ 174, 175, 246, 163, 71, 72, 73, 74, 75, 76, + /* 340 */ 77, 78, 79, 80, 81, 82, 83, 11, 85, 86, + /* 350 */ 87, 88, 89, 90, 91, 92, 93, 94, 95, 19, + /* 360 */ 132, 133, 134, 23, 152, 97, 98, 91, 198, 119, + /* 370 */ 120, 152, 22, 97, 98, 97, 152, 27, 28, 27, + /* 380 */ 28, 27, 28, 227, 160, 97, 174, 175, 164, 165, + /* 390 */ 50, 51, 222, 174, 175, 59, 230, 97, 98, 233, + /* 400 */ 188, 137, 66, 139, 234, 187, 177, 188, 152, 239, + /* 410 */ 69, 71, 72, 73, 74, 75, 76, 77, 78, 79, + /* 420 */ 80, 81, 82, 83, 12, 85, 86, 87, 88, 89, + /* 430 */ 90, 91, 92, 93, 94, 95, 19, 177, 97, 152, + /* 440 */ 23, 29, 101, 152, 108, 109, 110, 97, 98, 97, + /* 450 */ 98, 97, 98, 224, 225, 226, 22, 45, 24, 47, + /* 460 */ 152, 152, 152, 152, 152, 174, 175, 50, 51, 249, + /* 470 */ 250, 59, 21, 132, 133, 134, 124, 221, 124, 188, + /* 480 */ 171, 172, 171, 172, 224, 225, 226, 152, 71, 72, + /* 490 */ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + /* 500 */ 83, 152, 85, 86, 87, 88, 89, 90, 91, 92, + /* 510 */ 93, 94, 95, 19, 152, 183, 65, 23, 170, 171, + /* 520 */ 172, 19, 23, 174, 175, 26, 152, 50, 51, 12, + /* 530 */ 196, 197, 37, 170, 171, 172, 174, 175, 224, 225, + /* 540 */ 226, 232, 208, 232, 50, 51, 29, 52, 174, 175, + /* 550 */ 188, 74, 75, 51, 103, 60, 222, 163, 209, 0, + /* 560 */ 1, 2, 45, 152, 47, 71, 72, 73, 74, 75, + /* 570 */ 76, 77, 78, 79, 80, 81, 82, 83, 101, 85, + /* 580 */ 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + /* 590 */ 19, 140, 198, 152, 23, 152, 22, 98, 24, 152, + /* 600 */ 152, 27, 152, 183, 152, 152, 111, 213, 214, 107, + /* 610 */ 152, 164, 165, 152, 112, 174, 175, 174, 175, 181, + /* 620 */ 182, 50, 51, 124, 174, 175, 174, 175, 190, 26, + /* 630 */ 22, 23, 22, 23, 26, 166, 26, 168, 169, 16, + /* 640 */ 16, 19, 71, 72, 73, 74, 75, 76, 77, 78, + /* 650 */ 79, 80, 81, 82, 83, 152, 85, 86, 87, 88, + /* 660 */ 89, 90, 91, 92, 93, 94, 95, 152, 220, 196, + /* 670 */ 197, 97, 50, 51, 108, 109, 110, 152, 70, 221, + /* 680 */ 70, 208, 7, 8, 9, 62, 62, 64, 64, 174, + /* 690 */ 175, 146, 147, 71, 72, 73, 74, 75, 76, 77, + /* 700 */ 78, 79, 80, 81, 82, 83, 152, 85, 86, 87, + /* 710 */ 88, 89, 90, 91, 92, 93, 94, 95, 19, 152, + /* 720 */ 195, 152, 31, 220, 152, 152, 35, 26, 174, 175, + /* 730 */ 152, 163, 152, 130, 152, 115, 152, 117, 118, 152, + /* 740 */ 49, 174, 175, 174, 175, 152, 174, 175, 26, 50, + /* 750 */ 51, 152, 174, 175, 174, 175, 174, 175, 174, 175, + /* 760 */ 138, 174, 175, 140, 22, 23, 198, 174, 175, 152, + /* 770 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + /* 780 */ 81, 82, 83, 152, 85, 86, 87, 88, 89, 90, + /* 790 */ 91, 92, 93, 94, 95, 19, 152, 152, 152, 98, + /* 800 */ 24, 152, 108, 109, 110, 174, 175, 152, 152, 152, + /* 810 */ 152, 152, 70, 152, 213, 214, 152, 152, 174, 175, + /* 820 */ 174, 175, 152, 174, 175, 124, 50, 51, 106, 174, + /* 830 */ 175, 174, 175, 174, 175, 174, 175, 138, 174, 175, + /* 840 */ 152, 22, 23, 22, 163, 189, 19, 71, 72, 73, + /* 850 */ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + /* 860 */ 152, 85, 86, 87, 88, 89, 90, 91, 92, 93, + /* 870 */ 94, 95, 152, 152, 168, 169, 152, 50, 51, 198, + /* 880 */ 197, 152, 174, 175, 152, 240, 152, 152, 152, 70, + /* 890 */ 152, 208, 152, 152, 174, 175, 152, 19, 71, 72, + /* 900 */ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + /* 910 */ 83, 152, 85, 86, 87, 88, 89, 90, 91, 92, + /* 920 */ 93, 94, 95, 152, 195, 247, 248, 152, 50, 51, + /* 930 */ 195, 195, 152, 174, 175, 195, 195, 26, 152, 195, + /* 940 */ 252, 220, 163, 122, 152, 174, 175, 163, 19, 71, + /* 950 */ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + /* 960 */ 82, 83, 152, 85, 86, 87, 88, 89, 90, 91, + /* 970 */ 92, 93, 94, 95, 152, 195, 252, 198, 240, 50, + /* 980 */ 51, 189, 198, 19, 174, 175, 19, 51, 23, 100, + /* 990 */ 101, 26, 28, 163, 163, 28, 174, 175, 163, 19, + /* 1000 */ 152, 72, 73, 74, 75, 76, 77, 78, 79, 80, + /* 1010 */ 81, 82, 83, 152, 85, 86, 87, 88, 89, 90, + /* 1020 */ 91, 92, 93, 94, 95, 152, 240, 152, 198, 198, + /* 1030 */ 50, 51, 33, 198, 123, 174, 175, 116, 7, 8, + /* 1040 */ 101, 42, 121, 107, 152, 152, 23, 174, 175, 26, + /* 1050 */ 152, 112, 183, 73, 74, 75, 76, 77, 78, 79, + /* 1060 */ 80, 81, 82, 83, 152, 85, 86, 87, 88, 89, + /* 1070 */ 90, 91, 92, 93, 94, 95, 19, 20, 23, 22, + /* 1080 */ 23, 26, 152, 152, 27, 28, 174, 175, 23, 19, + /* 1090 */ 20, 26, 22, 132, 133, 38, 152, 27, 28, 152, + /* 1100 */ 23, 215, 152, 26, 174, 175, 152, 27, 38, 152, + /* 1110 */ 23, 152, 27, 26, 57, 152, 23, 163, 152, 26, + /* 1120 */ 152, 174, 175, 66, 174, 175, 69, 57, 174, 175, + /* 1130 */ 27, 174, 175, 174, 175, 152, 66, 174, 175, 69, + /* 1140 */ 174, 175, 174, 175, 152, 23, 89, 90, 26, 91, + /* 1150 */ 152, 236, 198, 96, 97, 98, 132, 133, 101, 89, + /* 1160 */ 90, 152, 23, 209, 210, 26, 96, 97, 98, 152, + /* 1170 */ 212, 101, 174, 175, 116, 19, 20, 97, 22, 121, + /* 1180 */ 152, 193, 97, 27, 28, 152, 152, 152, 152, 132, + /* 1190 */ 133, 134, 135, 136, 38, 23, 152, 152, 26, 152, + /* 1200 */ 97, 152, 132, 133, 134, 135, 136, 235, 152, 212, + /* 1210 */ 199, 150, 212, 57, 212, 200, 203, 216, 241, 216, + /* 1220 */ 241, 203, 182, 19, 20, 69, 22, 186, 178, 177, + /* 1230 */ 216, 27, 28, 229, 202, 39, 177, 177, 200, 155, + /* 1240 */ 245, 122, 38, 41, 22, 89, 90, 91, 159, 159, + /* 1250 */ 242, 159, 96, 97, 98, 71, 130, 101, 242, 191, + /* 1260 */ 223, 57, 18, 194, 159, 203, 194, 194, 194, 18, + /* 1270 */ 158, 223, 191, 69, 203, 159, 158, 19, 20, 191, + /* 1280 */ 22, 203, 137, 46, 238, 27, 28, 159, 132, 133, + /* 1290 */ 134, 135, 136, 89, 90, 159, 38, 22, 158, 179, + /* 1300 */ 96, 97, 98, 237, 158, 101, 159, 159, 158, 179, + /* 1310 */ 107, 176, 48, 176, 176, 57, 184, 106, 176, 125, + /* 1320 */ 179, 178, 218, 107, 217, 176, 218, 69, 184, 176, + /* 1330 */ 176, 217, 159, 218, 217, 159, 132, 133, 134, 135, + /* 1340 */ 136, 218, 217, 137, 179, 95, 179, 89, 90, 228, + /* 1350 */ 129, 126, 128, 127, 96, 97, 98, 206, 231, 101, + /* 1360 */ 5, 25, 231, 205, 207, 10, 11, 12, 13, 14, + /* 1370 */ 204, 203, 17, 26, 162, 161, 13, 6, 180, 180, + /* 1380 */ 153, 153, 151, 151, 151, 151, 167, 32, 4, 34, + /* 1390 */ 132, 133, 134, 135, 136, 3, 22, 142, 43, 68, + /* 1400 */ 15, 23, 16, 251, 23, 120, 251, 248, 131, 111, + /* 1410 */ 123, 56, 16, 20, 125, 1, 123, 131, 63, 79, + /* 1420 */ 79, 66, 67, 111, 36, 28, 122, 1, 5, 22, + /* 1430 */ 107, 140, 26, 54, 54, 44, 61, 107, 20, 24, + /* 1440 */ 19, 112, 105, 53, 22, 40, 22, 22, 53, 30, + /* 1450 */ 23, 22, 22, 53, 23, 23, 23, 22, 116, 23, + /* 1460 */ 22, 122, 23, 26, 23, 22, 11, 124, 28, 114, + /* 1470 */ 36, 26, 26, 23, 23, 23, 122, 23, 36, 26, + /* 1480 */ 36, 22, 24, 23, 22, 1, 23, 26, 22, 24, + /* 1490 */ 23, 22, 122, 23, 23, 22, 141, 23, 122, 122, + /* 1500 */ 15, +}; +#define YY_SHIFT_USE_DFLT (-72) +#define YY_SHIFT_COUNT (435) +#define YY_SHIFT_MIN (-71) +#define YY_SHIFT_MAX (1485) +static const short yy_shift_ofst[] = { + /* 0 */ 5, 1057, 1355, 1070, 1204, 1204, 1204, 90, 60, -19, + /* 10 */ 58, 58, 186, 1204, 1204, 1204, 1204, 1204, 1204, 1204, + /* 20 */ 67, 67, 182, 336, 65, 250, 135, 263, 340, 417, + /* 30 */ 494, 571, 622, 699, 776, 827, 827, 827, 827, 827, + /* 40 */ 827, 827, 827, 827, 827, 827, 827, 827, 827, 827, + /* 50 */ 878, 827, 929, 980, 980, 1156, 1204, 1204, 1204, 1204, + /* 60 */ 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, + /* 70 */ 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, + /* 80 */ 1204, 1204, 1204, 1204, 1258, 1204, 1204, 1204, 1204, 1204, + /* 90 */ 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, -71, -47, + /* 100 */ -47, -47, -47, -47, -6, 88, -66, 65, 65, 451, + /* 110 */ 502, 112, 112, 33, 127, 278, -30, -72, -72, -72, + /* 120 */ 11, 412, 412, 268, 608, 610, 65, 65, 65, 65, + /* 130 */ 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, + /* 140 */ 65, 65, 65, 65, 65, 559, 138, 278, 127, 24, + /* 150 */ 24, 24, 24, 24, 24, -72, -72, -72, 228, 341, + /* 160 */ 341, 207, 276, 300, 352, 354, 350, 65, 65, 65, + /* 170 */ 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, + /* 180 */ 65, 65, 65, 65, 495, 495, 495, 65, 65, 499, + /* 190 */ 65, 65, 65, 574, 65, 65, 517, 65, 65, 65, + /* 200 */ 65, 65, 65, 65, 65, 65, 65, 566, 691, 288, + /* 210 */ 288, 288, 701, 620, 1058, 675, 603, 964, 964, 967, + /* 220 */ 603, 967, 722, 965, 936, 999, 964, 264, 999, 999, + /* 230 */ 911, 921, 434, 1196, 1119, 1119, 1202, 1202, 1119, 1222, + /* 240 */ 1184, 1126, 1244, 1244, 1244, 1244, 1119, 1251, 1126, 1222, + /* 250 */ 1184, 1184, 1126, 1119, 1251, 1145, 1237, 1119, 1119, 1251, + /* 260 */ 1275, 1119, 1251, 1119, 1251, 1275, 1203, 1203, 1203, 1264, + /* 270 */ 1275, 1203, 1211, 1203, 1264, 1203, 1203, 1194, 1216, 1194, + /* 280 */ 1216, 1194, 1216, 1194, 1216, 1119, 1119, 1206, 1275, 1250, + /* 290 */ 1250, 1275, 1221, 1225, 1224, 1226, 1126, 1336, 1347, 1363, + /* 300 */ 1363, 1371, 1371, 1371, 1371, -72, -72, -72, -72, -72, + /* 310 */ -72, 477, 623, 742, 819, 624, 694, 74, 1023, 221, + /* 320 */ 1055, 1065, 1077, 1087, 1080, 889, 1031, 939, 1093, 1122, + /* 330 */ 1085, 1139, 961, 1024, 1172, 1103, 821, 1384, 1392, 1374, + /* 340 */ 1255, 1385, 1331, 1386, 1378, 1381, 1285, 1277, 1298, 1287, + /* 350 */ 1393, 1289, 1396, 1414, 1293, 1286, 1340, 1341, 1312, 1397, + /* 360 */ 1388, 1304, 1426, 1423, 1407, 1323, 1291, 1379, 1406, 1380, + /* 370 */ 1375, 1391, 1330, 1415, 1418, 1421, 1329, 1337, 1422, 1390, + /* 380 */ 1424, 1425, 1427, 1429, 1395, 1419, 1430, 1400, 1405, 1431, + /* 390 */ 1432, 1433, 1342, 1435, 1436, 1438, 1437, 1339, 1439, 1441, + /* 400 */ 1440, 1434, 1443, 1343, 1445, 1442, 1446, 1444, 1445, 1450, + /* 410 */ 1451, 1452, 1453, 1454, 1459, 1455, 1460, 1462, 1458, 1461, + /* 420 */ 1463, 1466, 1465, 1461, 1467, 1469, 1470, 1471, 1473, 1354, + /* 430 */ 1370, 1376, 1377, 1474, 1485, 1484, +}; +#define YY_REDUCE_USE_DFLT (-176) +#define YY_REDUCE_COUNT (310) +#define YY_REDUCE_MIN (-175) +#define YY_REDUCE_MAX (1234) +static const short yy_reduce_ofst[] = { + /* 0 */ -143, 954, 86, 21, -50, 23, 79, 134, 170, -175, + /* 10 */ 229, 260, -121, 212, 219, 291, -54, 349, 362, 156, + /* 20 */ 309, 311, 334, 85, 224, 394, 314, 314, 314, 314, + /* 30 */ 314, 314, 314, 314, 314, 314, 314, 314, 314, 314, + /* 40 */ 314, 314, 314, 314, 314, 314, 314, 314, 314, 314, + /* 50 */ 314, 314, 314, 314, 314, 374, 441, 443, 450, 452, + /* 60 */ 515, 554, 567, 569, 572, 578, 580, 582, 584, 587, + /* 70 */ 593, 631, 644, 646, 649, 655, 657, 659, 661, 664, + /* 80 */ 708, 720, 759, 771, 810, 822, 861, 873, 912, 930, + /* 90 */ 947, 950, 957, 959, 963, 966, 968, 998, 314, 314, + /* 100 */ 314, 314, 314, 314, 314, 314, 314, 447, -53, 166, + /* 110 */ 438, 348, 363, 314, 473, 469, 314, 314, 314, 314, + /* 120 */ -15, 59, 101, 688, 220, 220, 525, 256, 729, 735, + /* 130 */ 736, 740, 741, 744, 645, 448, 738, 458, 786, 503, + /* 140 */ 780, 656, 721, 724, 792, 545, 568, 706, 683, 681, + /* 150 */ 779, 784, 830, 831, 835, 678, 601, -104, -2, 96, + /* 160 */ 111, 218, 287, 308, 310, 312, 335, 411, 453, 461, + /* 170 */ 573, 599, 617, 658, 665, 670, 732, 734, 775, 848, + /* 180 */ 875, 892, 893, 898, 332, 420, 869, 931, 944, 886, + /* 190 */ 983, 992, 1009, 958, 1017, 1028, 988, 1033, 1034, 1035, + /* 200 */ 287, 1036, 1044, 1045, 1047, 1049, 1056, 915, 972, 997, + /* 210 */ 1000, 1002, 886, 1011, 1015, 1061, 1013, 1001, 1003, 977, + /* 220 */ 1018, 979, 1050, 1041, 1040, 1052, 1014, 1004, 1059, 1060, + /* 230 */ 1032, 1038, 1084, 995, 1089, 1090, 1008, 1016, 1092, 1037, + /* 240 */ 1068, 1062, 1069, 1072, 1073, 1074, 1105, 1112, 1071, 1048, + /* 250 */ 1081, 1088, 1078, 1116, 1118, 1046, 1066, 1128, 1136, 1140, + /* 260 */ 1120, 1147, 1146, 1148, 1150, 1130, 1135, 1137, 1138, 1132, + /* 270 */ 1141, 1142, 1143, 1149, 1144, 1153, 1154, 1104, 1107, 1108, + /* 280 */ 1114, 1115, 1117, 1123, 1125, 1173, 1176, 1121, 1165, 1127, + /* 290 */ 1131, 1167, 1157, 1151, 1158, 1166, 1168, 1212, 1214, 1227, + /* 300 */ 1228, 1231, 1232, 1233, 1234, 1152, 1155, 1159, 1198, 1199, + /* 310 */ 1219, +}; +static const YYACTIONTYPE yy_default[] = { + /* 0 */ 982, 1300, 1300, 1300, 1214, 1214, 1214, 1305, 1300, 1109, + /* 10 */ 1138, 1138, 1274, 1305, 1305, 1305, 1305, 1305, 1305, 1212, + /* 20 */ 1305, 1305, 1305, 1300, 1305, 1113, 1144, 1305, 1305, 1305, + /* 30 */ 1305, 1305, 1305, 1305, 1305, 1273, 1275, 1152, 1151, 1254, + /* 40 */ 1125, 1149, 1142, 1146, 1215, 1208, 1209, 1207, 1211, 1216, + /* 50 */ 1305, 1145, 1177, 1192, 1176, 1305, 1305, 1305, 1305, 1305, + /* 60 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 70 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 80 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 90 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1186, 1191, + /* 100 */ 1198, 1190, 1187, 1179, 1178, 1180, 1181, 1305, 1305, 1008, + /* 110 */ 1074, 1305, 1305, 1182, 1305, 1020, 1183, 1195, 1194, 1193, + /* 120 */ 1015, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 130 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 140 */ 1305, 1305, 1305, 1305, 1305, 982, 1300, 1305, 1305, 1300, + /* 150 */ 1300, 1300, 1300, 1300, 1300, 1292, 1113, 1103, 1305, 1305, + /* 160 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1280, 1278, + /* 170 */ 1305, 1227, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 180 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 190 */ 1305, 1305, 1305, 1109, 1305, 1305, 1305, 1305, 1305, 1305, + /* 200 */ 1305, 1305, 1305, 1305, 1305, 1305, 988, 1305, 1247, 1109, + /* 210 */ 1109, 1109, 1111, 1089, 1101, 990, 1148, 1127, 1127, 1259, + /* 220 */ 1148, 1259, 1045, 1068, 1042, 1138, 1127, 1210, 1138, 1138, + /* 230 */ 1110, 1101, 1305, 1285, 1118, 1118, 1277, 1277, 1118, 1157, + /* 240 */ 1078, 1148, 1085, 1085, 1085, 1085, 1118, 1005, 1148, 1157, + /* 250 */ 1078, 1078, 1148, 1118, 1005, 1253, 1251, 1118, 1118, 1005, + /* 260 */ 1220, 1118, 1005, 1118, 1005, 1220, 1076, 1076, 1076, 1060, + /* 270 */ 1220, 1076, 1045, 1076, 1060, 1076, 1076, 1131, 1126, 1131, + /* 280 */ 1126, 1131, 1126, 1131, 1126, 1118, 1118, 1305, 1220, 1224, + /* 290 */ 1224, 1220, 1143, 1132, 1141, 1139, 1148, 1011, 1063, 998, + /* 300 */ 998, 987, 987, 987, 987, 1297, 1297, 1292, 1047, 1047, + /* 310 */ 1030, 1305, 1305, 1305, 1305, 1305, 1305, 1022, 1305, 1229, + /* 320 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 330 */ 1305, 1305, 1305, 1305, 1305, 1305, 1164, 1305, 983, 1287, + /* 340 */ 1305, 1305, 1284, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 350 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 360 */ 1305, 1257, 1305, 1305, 1305, 1305, 1305, 1305, 1250, 1249, + /* 370 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 380 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, + /* 390 */ 1305, 1305, 1092, 1305, 1305, 1305, 1096, 1305, 1305, 1305, + /* 400 */ 1305, 1305, 1305, 1305, 1140, 1305, 1133, 1305, 1213, 1305, + /* 410 */ 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1302, + /* 420 */ 1305, 1305, 1305, 1301, 1305, 1305, 1305, 1305, 1305, 1166, + /* 430 */ 1305, 1165, 1169, 1305, 996, 1305, +}; + +/* The next table maps tokens into fallback tokens. If a construct +** like the following: +** +** %fallback ID X Y Z. +** +** appears in the grammar, then ID becomes a fallback token for X, Y, +** and Z. Whenever one of the tokens X, Y, or Z is input to the parser +** but it does not parse, the type of the token is changed to ID and +** the parse is retried before an error is thrown. +*/ +#ifdef YYFALLBACK +static const YYCODETYPE yyFallback[] = { + 0, /* $ => nothing */ + 0, /* SEMI => nothing */ + 27, /* EXPLAIN => ID */ + 27, /* QUERY => ID */ + 27, /* PLAN => ID */ + 27, /* BEGIN => ID */ + 0, /* TRANSACTION => nothing */ + 27, /* DEFERRED => ID */ + 27, /* IMMEDIATE => ID */ + 27, /* EXCLUSIVE => ID */ + 0, /* COMMIT => nothing */ + 27, /* END => ID */ + 27, /* ROLLBACK => ID */ + 27, /* SAVEPOINT => ID */ + 27, /* RELEASE => ID */ + 0, /* TO => nothing */ + 0, /* TABLE => nothing */ + 0, /* CREATE => nothing */ + 27, /* IF => ID */ + 0, /* NOT => nothing */ + 0, /* EXISTS => nothing */ + 27, /* TEMP => ID */ + 0, /* LP => nothing */ + 0, /* RP => nothing */ + 0, /* AS => nothing */ + 27, /* WITHOUT => ID */ + 0, /* COMMA => nothing */ + 0, /* ID => nothing */ + 0, /* INDEXED => nothing */ + 27, /* ABORT => ID */ + 27, /* ACTION => ID */ + 27, /* AFTER => ID */ + 27, /* ANALYZE => ID */ + 27, /* ASC => ID */ + 27, /* ATTACH => ID */ + 27, /* BEFORE => ID */ + 27, /* BY => ID */ + 27, /* CASCADE => ID */ + 27, /* CAST => ID */ + 27, /* COLUMNKW => ID */ + 27, /* CONFLICT => ID */ + 27, /* DATABASE => ID */ + 27, /* DESC => ID */ + 27, /* DETACH => ID */ + 27, /* EACH => ID */ + 27, /* FAIL => ID */ + 27, /* FOR => ID */ + 27, /* IGNORE => ID */ + 27, /* INITIALLY => ID */ + 27, /* INSTEAD => ID */ + 27, /* LIKE_KW => ID */ + 27, /* MATCH => ID */ + 27, /* NO => ID */ + 27, /* KEY => ID */ + 27, /* OF => ID */ + 27, /* OFFSET => ID */ + 27, /* PRAGMA => ID */ + 27, /* RAISE => ID */ + 27, /* RECURSIVE => ID */ + 27, /* REPLACE => ID */ + 27, /* RESTRICT => ID */ + 27, /* ROW => ID */ + 27, /* TRIGGER => ID */ + 27, /* VACUUM => ID */ + 27, /* VIEW => ID */ + 27, /* VIRTUAL => ID */ + 27, /* WITH => ID */ + 27, /* REINDEX => ID */ + 27, /* RENAME => ID */ + 27, /* CTIME_KW => ID */ +}; +#endif /* YYFALLBACK */ + +/* The following structure represents a single element of the +** parser's stack. Information stored includes: +** +** + The state number for the parser at this level of the stack. +** +** + The value of the token stored at this level of the stack. +** (In other words, the "major" token.) +** +** + The semantic value stored at this level of the stack. This is +** the information used by the action routines in the grammar. +** It is sometimes called the "minor" token. +** +** After the "shift" half of a SHIFTREDUCE action, the stateno field +** actually contains the reduce action for the second half of the +** SHIFTREDUCE. +*/ +struct yyStackEntry { + YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */ + YYCODETYPE major; /* The major token value. This is the code + ** number for the token at this stack level */ + YYMINORTYPE minor; /* The user-supplied minor token value. This + ** is the value of the token */ +}; +typedef struct yyStackEntry yyStackEntry; + +/* The state of the parser is completely contained in an instance of +** the following structure */ +struct yyParser { + int yyidx; /* Index of top element in stack */ +#ifdef YYTRACKMAXSTACKDEPTH + int yyidxMax; /* Maximum value of yyidx */ +#endif + int yyerrcnt; /* Shifts left before out of the error */ + sqlite3ParserARG_SDECL /* A place to hold %extra_argument */ +#if YYSTACKDEPTH<=0 + int yystksz; /* Current side of the stack */ + yyStackEntry *yystack; /* The parser's stack */ +#else + yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ +#endif +}; +typedef struct yyParser yyParser; + +#ifndef NDEBUG +/* #include */ +static FILE *yyTraceFILE = 0; +static char *yyTracePrompt = 0; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Turn parser tracing on by giving a stream to which to write the trace +** and a prompt to preface each trace message. Tracing is turned off +** by making either argument NULL +** +** Inputs: +**
      +**
    • A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +**
    • A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +**
    +** +** Outputs: +** None. +*/ +SQLITE_PRIVATE void sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *const yyTokenName[] = { + "$", "SEMI", "EXPLAIN", "QUERY", + "PLAN", "BEGIN", "TRANSACTION", "DEFERRED", + "IMMEDIATE", "EXCLUSIVE", "COMMIT", "END", + "ROLLBACK", "SAVEPOINT", "RELEASE", "TO", + "TABLE", "CREATE", "IF", "NOT", + "EXISTS", "TEMP", "LP", "RP", + "AS", "WITHOUT", "COMMA", "ID", + "INDEXED", "ABORT", "ACTION", "AFTER", + "ANALYZE", "ASC", "ATTACH", "BEFORE", + "BY", "CASCADE", "CAST", "COLUMNKW", + "CONFLICT", "DATABASE", "DESC", "DETACH", + "EACH", "FAIL", "FOR", "IGNORE", + "INITIALLY", "INSTEAD", "LIKE_KW", "MATCH", + "NO", "KEY", "OF", "OFFSET", + "PRAGMA", "RAISE", "RECURSIVE", "REPLACE", + "RESTRICT", "ROW", "TRIGGER", "VACUUM", + "VIEW", "VIRTUAL", "WITH", "REINDEX", + "RENAME", "CTIME_KW", "ANY", "OR", + "AND", "IS", "BETWEEN", "IN", + "ISNULL", "NOTNULL", "NE", "EQ", + "GT", "LE", "LT", "GE", + "ESCAPE", "BITAND", "BITOR", "LSHIFT", + "RSHIFT", "PLUS", "MINUS", "STAR", + "SLASH", "REM", "CONCAT", "COLLATE", + "BITNOT", "STRING", "JOIN_KW", "CONSTRAINT", + "DEFAULT", "NULL", "PRIMARY", "UNIQUE", + "CHECK", "REFERENCES", "AUTOINCR", "ON", + "INSERT", "DELETE", "UPDATE", "SET", + "DEFERRABLE", "FOREIGN", "DROP", "UNION", + "ALL", "EXCEPT", "INTERSECT", "SELECT", + "VALUES", "DISTINCT", "DOT", "FROM", + "JOIN", "USING", "ORDER", "GROUP", + "HAVING", "LIMIT", "WHERE", "INTO", + "INTEGER", "FLOAT", "BLOB", "VARIABLE", + "CASE", "WHEN", "THEN", "ELSE", + "INDEX", "ALTER", "ADD", "error", + "input", "cmdlist", "ecmd", "explain", + "cmdx", "cmd", "transtype", "trans_opt", + "nm", "savepoint_opt", "create_table", "create_table_args", + "createkw", "temp", "ifnotexists", "dbnm", + "columnlist", "conslist_opt", "table_options", "select", + "column", "columnid", "type", "carglist", + "typetoken", "typename", "signed", "plus_num", + "minus_num", "ccons", "term", "expr", + "onconf", "sortorder", "autoinc", "eidlist_opt", + "refargs", "defer_subclause", "refarg", "refact", + "init_deferred_pred_opt", "conslist", "tconscomma", "tcons", + "sortlist", "eidlist", "defer_subclause_opt", "orconf", + "resolvetype", "raisetype", "ifexists", "fullname", + "selectnowith", "oneselect", "with", "multiselect_op", + "distinct", "selcollist", "from", "where_opt", + "groupby_opt", "having_opt", "orderby_opt", "limit_opt", + "values", "nexprlist", "exprlist", "sclp", + "as", "seltablist", "stl_prefix", "joinop", + "indexed_opt", "on_opt", "using_opt", "joinop2", + "idlist", "setlist", "insert_cmd", "idlist_opt", + "likeop", "between_op", "in_op", "case_operand", + "case_exprlist", "case_else", "uniqueflag", "collate", + "nmnum", "trigger_decl", "trigger_cmd_list", "trigger_time", + "trigger_event", "foreach_clause", "when_clause", "trigger_cmd", + "trnm", "tridxby", "database_kw_opt", "key_opt", + "add_column_fullname", "kwcolumn_opt", "create_vtab", "vtabarglist", + "vtabarg", "vtabargtoken", "lp", "anylist", + "wqlist", +}; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *const yyRuleName[] = { + /* 0 */ "input ::= cmdlist", + /* 1 */ "cmdlist ::= cmdlist ecmd", + /* 2 */ "cmdlist ::= ecmd", + /* 3 */ "ecmd ::= SEMI", + /* 4 */ "ecmd ::= explain cmdx SEMI", + /* 5 */ "explain ::=", + /* 6 */ "explain ::= EXPLAIN", + /* 7 */ "explain ::= EXPLAIN QUERY PLAN", + /* 8 */ "cmdx ::= cmd", + /* 9 */ "cmd ::= BEGIN transtype trans_opt", + /* 10 */ "trans_opt ::=", + /* 11 */ "trans_opt ::= TRANSACTION", + /* 12 */ "trans_opt ::= TRANSACTION nm", + /* 13 */ "transtype ::=", + /* 14 */ "transtype ::= DEFERRED", + /* 15 */ "transtype ::= IMMEDIATE", + /* 16 */ "transtype ::= EXCLUSIVE", + /* 17 */ "cmd ::= COMMIT trans_opt", + /* 18 */ "cmd ::= END trans_opt", + /* 19 */ "cmd ::= ROLLBACK trans_opt", + /* 20 */ "savepoint_opt ::= SAVEPOINT", + /* 21 */ "savepoint_opt ::=", + /* 22 */ "cmd ::= SAVEPOINT nm", + /* 23 */ "cmd ::= RELEASE savepoint_opt nm", + /* 24 */ "cmd ::= ROLLBACK trans_opt TO savepoint_opt nm", + /* 25 */ "cmd ::= create_table create_table_args", + /* 26 */ "create_table ::= createkw temp TABLE ifnotexists nm dbnm", + /* 27 */ "createkw ::= CREATE", + /* 28 */ "ifnotexists ::=", + /* 29 */ "ifnotexists ::= IF NOT EXISTS", + /* 30 */ "temp ::= TEMP", + /* 31 */ "temp ::=", + /* 32 */ "create_table_args ::= LP columnlist conslist_opt RP table_options", + /* 33 */ "create_table_args ::= AS select", + /* 34 */ "table_options ::=", + /* 35 */ "table_options ::= WITHOUT nm", + /* 36 */ "columnlist ::= columnlist COMMA column", + /* 37 */ "columnlist ::= column", + /* 38 */ "column ::= columnid type carglist", + /* 39 */ "columnid ::= nm", + /* 40 */ "nm ::= ID|INDEXED", + /* 41 */ "nm ::= STRING", + /* 42 */ "nm ::= JOIN_KW", + /* 43 */ "type ::=", + /* 44 */ "type ::= typetoken", + /* 45 */ "typetoken ::= typename", + /* 46 */ "typetoken ::= typename LP signed RP", + /* 47 */ "typetoken ::= typename LP signed COMMA signed RP", + /* 48 */ "typename ::= ID|STRING", + /* 49 */ "typename ::= typename ID|STRING", + /* 50 */ "signed ::= plus_num", + /* 51 */ "signed ::= minus_num", + /* 52 */ "carglist ::= carglist ccons", + /* 53 */ "carglist ::=", + /* 54 */ "ccons ::= CONSTRAINT nm", + /* 55 */ "ccons ::= DEFAULT term", + /* 56 */ "ccons ::= DEFAULT LP expr RP", + /* 57 */ "ccons ::= DEFAULT PLUS term", + /* 58 */ "ccons ::= DEFAULT MINUS term", + /* 59 */ "ccons ::= DEFAULT ID|INDEXED", + /* 60 */ "ccons ::= NULL onconf", + /* 61 */ "ccons ::= NOT NULL onconf", + /* 62 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc", + /* 63 */ "ccons ::= UNIQUE onconf", + /* 64 */ "ccons ::= CHECK LP expr RP", + /* 65 */ "ccons ::= REFERENCES nm eidlist_opt refargs", + /* 66 */ "ccons ::= defer_subclause", + /* 67 */ "ccons ::= COLLATE ID|STRING", + /* 68 */ "autoinc ::=", + /* 69 */ "autoinc ::= AUTOINCR", + /* 70 */ "refargs ::=", + /* 71 */ "refargs ::= refargs refarg", + /* 72 */ "refarg ::= MATCH nm", + /* 73 */ "refarg ::= ON INSERT refact", + /* 74 */ "refarg ::= ON DELETE refact", + /* 75 */ "refarg ::= ON UPDATE refact", + /* 76 */ "refact ::= SET NULL", + /* 77 */ "refact ::= SET DEFAULT", + /* 78 */ "refact ::= CASCADE", + /* 79 */ "refact ::= RESTRICT", + /* 80 */ "refact ::= NO ACTION", + /* 81 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt", + /* 82 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt", + /* 83 */ "init_deferred_pred_opt ::=", + /* 84 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED", + /* 85 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE", + /* 86 */ "conslist_opt ::=", + /* 87 */ "conslist_opt ::= COMMA conslist", + /* 88 */ "conslist ::= conslist tconscomma tcons", + /* 89 */ "conslist ::= tcons", + /* 90 */ "tconscomma ::= COMMA", + /* 91 */ "tconscomma ::=", + /* 92 */ "tcons ::= CONSTRAINT nm", + /* 93 */ "tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf", + /* 94 */ "tcons ::= UNIQUE LP sortlist RP onconf", + /* 95 */ "tcons ::= CHECK LP expr RP onconf", + /* 96 */ "tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt", + /* 97 */ "defer_subclause_opt ::=", + /* 98 */ "defer_subclause_opt ::= defer_subclause", + /* 99 */ "onconf ::=", + /* 100 */ "onconf ::= ON CONFLICT resolvetype", + /* 101 */ "orconf ::=", + /* 102 */ "orconf ::= OR resolvetype", + /* 103 */ "resolvetype ::= raisetype", + /* 104 */ "resolvetype ::= IGNORE", + /* 105 */ "resolvetype ::= REPLACE", + /* 106 */ "cmd ::= DROP TABLE ifexists fullname", + /* 107 */ "ifexists ::= IF EXISTS", + /* 108 */ "ifexists ::=", + /* 109 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select", + /* 110 */ "cmd ::= DROP VIEW ifexists fullname", + /* 111 */ "cmd ::= select", + /* 112 */ "select ::= with selectnowith", + /* 113 */ "selectnowith ::= oneselect", + /* 114 */ "selectnowith ::= selectnowith multiselect_op oneselect", + /* 115 */ "multiselect_op ::= UNION", + /* 116 */ "multiselect_op ::= UNION ALL", + /* 117 */ "multiselect_op ::= EXCEPT|INTERSECT", + /* 118 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt", + /* 119 */ "oneselect ::= values", + /* 120 */ "values ::= VALUES LP nexprlist RP", + /* 121 */ "values ::= values COMMA LP exprlist RP", + /* 122 */ "distinct ::= DISTINCT", + /* 123 */ "distinct ::= ALL", + /* 124 */ "distinct ::=", + /* 125 */ "sclp ::= selcollist COMMA", + /* 126 */ "sclp ::=", + /* 127 */ "selcollist ::= sclp expr as", + /* 128 */ "selcollist ::= sclp STAR", + /* 129 */ "selcollist ::= sclp nm DOT STAR", + /* 130 */ "as ::= AS nm", + /* 131 */ "as ::= ID|STRING", + /* 132 */ "as ::=", + /* 133 */ "from ::=", + /* 134 */ "from ::= FROM seltablist", + /* 135 */ "stl_prefix ::= seltablist joinop", + /* 136 */ "stl_prefix ::=", + /* 137 */ "seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt", + /* 138 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt", + /* 139 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt", + /* 140 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt", + /* 141 */ "dbnm ::=", + /* 142 */ "dbnm ::= DOT nm", + /* 143 */ "fullname ::= nm dbnm", + /* 144 */ "joinop ::= COMMA|JOIN", + /* 145 */ "joinop ::= JOIN_KW JOIN", + /* 146 */ "joinop ::= JOIN_KW nm JOIN", + /* 147 */ "joinop ::= JOIN_KW nm nm JOIN", + /* 148 */ "on_opt ::= ON expr", + /* 149 */ "on_opt ::=", + /* 150 */ "indexed_opt ::=", + /* 151 */ "indexed_opt ::= INDEXED BY nm", + /* 152 */ "indexed_opt ::= NOT INDEXED", + /* 153 */ "using_opt ::= USING LP idlist RP", + /* 154 */ "using_opt ::=", + /* 155 */ "orderby_opt ::=", + /* 156 */ "orderby_opt ::= ORDER BY sortlist", + /* 157 */ "sortlist ::= sortlist COMMA expr sortorder", + /* 158 */ "sortlist ::= expr sortorder", + /* 159 */ "sortorder ::= ASC", + /* 160 */ "sortorder ::= DESC", + /* 161 */ "sortorder ::=", + /* 162 */ "groupby_opt ::=", + /* 163 */ "groupby_opt ::= GROUP BY nexprlist", + /* 164 */ "having_opt ::=", + /* 165 */ "having_opt ::= HAVING expr", + /* 166 */ "limit_opt ::=", + /* 167 */ "limit_opt ::= LIMIT expr", + /* 168 */ "limit_opt ::= LIMIT expr OFFSET expr", + /* 169 */ "limit_opt ::= LIMIT expr COMMA expr", + /* 170 */ "cmd ::= with DELETE FROM fullname indexed_opt where_opt", + /* 171 */ "where_opt ::=", + /* 172 */ "where_opt ::= WHERE expr", + /* 173 */ "cmd ::= with UPDATE orconf fullname indexed_opt SET setlist where_opt", + /* 174 */ "setlist ::= setlist COMMA nm EQ expr", + /* 175 */ "setlist ::= nm EQ expr", + /* 176 */ "cmd ::= with insert_cmd INTO fullname idlist_opt select", + /* 177 */ "cmd ::= with insert_cmd INTO fullname idlist_opt DEFAULT VALUES", + /* 178 */ "insert_cmd ::= INSERT orconf", + /* 179 */ "insert_cmd ::= REPLACE", + /* 180 */ "idlist_opt ::=", + /* 181 */ "idlist_opt ::= LP idlist RP", + /* 182 */ "idlist ::= idlist COMMA nm", + /* 183 */ "idlist ::= nm", + /* 184 */ "expr ::= term", + /* 185 */ "expr ::= LP expr RP", + /* 186 */ "term ::= NULL", + /* 187 */ "expr ::= ID|INDEXED", + /* 188 */ "expr ::= JOIN_KW", + /* 189 */ "expr ::= nm DOT nm", + /* 190 */ "expr ::= nm DOT nm DOT nm", + /* 191 */ "term ::= INTEGER|FLOAT|BLOB", + /* 192 */ "term ::= STRING", + /* 193 */ "expr ::= VARIABLE", + /* 194 */ "expr ::= expr COLLATE ID|STRING", + /* 195 */ "expr ::= CAST LP expr AS typetoken RP", + /* 196 */ "expr ::= ID|INDEXED LP distinct exprlist RP", + /* 197 */ "expr ::= ID|INDEXED LP STAR RP", + /* 198 */ "term ::= CTIME_KW", + /* 199 */ "expr ::= expr AND expr", + /* 200 */ "expr ::= expr OR expr", + /* 201 */ "expr ::= expr LT|GT|GE|LE expr", + /* 202 */ "expr ::= expr EQ|NE expr", + /* 203 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr", + /* 204 */ "expr ::= expr PLUS|MINUS expr", + /* 205 */ "expr ::= expr STAR|SLASH|REM expr", + /* 206 */ "expr ::= expr CONCAT expr", + /* 207 */ "likeop ::= LIKE_KW|MATCH", + /* 208 */ "likeop ::= NOT LIKE_KW|MATCH", + /* 209 */ "expr ::= expr likeop expr", + /* 210 */ "expr ::= expr likeop expr ESCAPE expr", + /* 211 */ "expr ::= expr ISNULL|NOTNULL", + /* 212 */ "expr ::= expr NOT NULL", + /* 213 */ "expr ::= expr IS expr", + /* 214 */ "expr ::= expr IS NOT expr", + /* 215 */ "expr ::= NOT expr", + /* 216 */ "expr ::= BITNOT expr", + /* 217 */ "expr ::= MINUS expr", + /* 218 */ "expr ::= PLUS expr", + /* 219 */ "between_op ::= BETWEEN", + /* 220 */ "between_op ::= NOT BETWEEN", + /* 221 */ "expr ::= expr between_op expr AND expr", + /* 222 */ "in_op ::= IN", + /* 223 */ "in_op ::= NOT IN", + /* 224 */ "expr ::= expr in_op LP exprlist RP", + /* 225 */ "expr ::= LP select RP", + /* 226 */ "expr ::= expr in_op LP select RP", + /* 227 */ "expr ::= expr in_op nm dbnm", + /* 228 */ "expr ::= EXISTS LP select RP", + /* 229 */ "expr ::= CASE case_operand case_exprlist case_else END", + /* 230 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", + /* 231 */ "case_exprlist ::= WHEN expr THEN expr", + /* 232 */ "case_else ::= ELSE expr", + /* 233 */ "case_else ::=", + /* 234 */ "case_operand ::= expr", + /* 235 */ "case_operand ::=", + /* 236 */ "exprlist ::= nexprlist", + /* 237 */ "exprlist ::=", + /* 238 */ "nexprlist ::= nexprlist COMMA expr", + /* 239 */ "nexprlist ::= expr", + /* 240 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt", + /* 241 */ "uniqueflag ::= UNIQUE", + /* 242 */ "uniqueflag ::=", + /* 243 */ "eidlist_opt ::=", + /* 244 */ "eidlist_opt ::= LP eidlist RP", + /* 245 */ "eidlist ::= eidlist COMMA nm collate sortorder", + /* 246 */ "eidlist ::= nm collate sortorder", + /* 247 */ "collate ::=", + /* 248 */ "collate ::= COLLATE ID|STRING", + /* 249 */ "cmd ::= DROP INDEX ifexists fullname", + /* 250 */ "cmd ::= VACUUM", + /* 251 */ "cmd ::= VACUUM nm", + /* 252 */ "cmd ::= PRAGMA nm dbnm", + /* 253 */ "cmd ::= PRAGMA nm dbnm EQ nmnum", + /* 254 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP", + /* 255 */ "cmd ::= PRAGMA nm dbnm EQ minus_num", + /* 256 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP", + /* 257 */ "nmnum ::= plus_num", + /* 258 */ "nmnum ::= nm", + /* 259 */ "nmnum ::= ON", + /* 260 */ "nmnum ::= DELETE", + /* 261 */ "nmnum ::= DEFAULT", + /* 262 */ "plus_num ::= PLUS INTEGER|FLOAT", + /* 263 */ "plus_num ::= INTEGER|FLOAT", + /* 264 */ "minus_num ::= MINUS INTEGER|FLOAT", + /* 265 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END", + /* 266 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause", + /* 267 */ "trigger_time ::= BEFORE", + /* 268 */ "trigger_time ::= AFTER", + /* 269 */ "trigger_time ::= INSTEAD OF", + /* 270 */ "trigger_time ::=", + /* 271 */ "trigger_event ::= DELETE|INSERT", + /* 272 */ "trigger_event ::= UPDATE", + /* 273 */ "trigger_event ::= UPDATE OF idlist", + /* 274 */ "foreach_clause ::=", + /* 275 */ "foreach_clause ::= FOR EACH ROW", + /* 276 */ "when_clause ::=", + /* 277 */ "when_clause ::= WHEN expr", + /* 278 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", + /* 279 */ "trigger_cmd_list ::= trigger_cmd SEMI", + /* 280 */ "trnm ::= nm", + /* 281 */ "trnm ::= nm DOT nm", + /* 282 */ "tridxby ::=", + /* 283 */ "tridxby ::= INDEXED BY nm", + /* 284 */ "tridxby ::= NOT INDEXED", + /* 285 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt", + /* 286 */ "trigger_cmd ::= insert_cmd INTO trnm idlist_opt select", + /* 287 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt", + /* 288 */ "trigger_cmd ::= select", + /* 289 */ "expr ::= RAISE LP IGNORE RP", + /* 290 */ "expr ::= RAISE LP raisetype COMMA nm RP", + /* 291 */ "raisetype ::= ROLLBACK", + /* 292 */ "raisetype ::= ABORT", + /* 293 */ "raisetype ::= FAIL", + /* 294 */ "cmd ::= DROP TRIGGER ifexists fullname", + /* 295 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", + /* 296 */ "cmd ::= DETACH database_kw_opt expr", + /* 297 */ "key_opt ::=", + /* 298 */ "key_opt ::= KEY expr", + /* 299 */ "database_kw_opt ::= DATABASE", + /* 300 */ "database_kw_opt ::=", + /* 301 */ "cmd ::= REINDEX", + /* 302 */ "cmd ::= REINDEX nm dbnm", + /* 303 */ "cmd ::= ANALYZE", + /* 304 */ "cmd ::= ANALYZE nm dbnm", + /* 305 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", + /* 306 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column", + /* 307 */ "add_column_fullname ::= fullname", + /* 308 */ "kwcolumn_opt ::=", + /* 309 */ "kwcolumn_opt ::= COLUMNKW", + /* 310 */ "cmd ::= create_vtab", + /* 311 */ "cmd ::= create_vtab LP vtabarglist RP", + /* 312 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm", + /* 313 */ "vtabarglist ::= vtabarg", + /* 314 */ "vtabarglist ::= vtabarglist COMMA vtabarg", + /* 315 */ "vtabarg ::=", + /* 316 */ "vtabarg ::= vtabarg vtabargtoken", + /* 317 */ "vtabargtoken ::= ANY", + /* 318 */ "vtabargtoken ::= lp anylist RP", + /* 319 */ "lp ::= LP", + /* 320 */ "anylist ::=", + /* 321 */ "anylist ::= anylist LP anylist RP", + /* 322 */ "anylist ::= anylist ANY", + /* 323 */ "with ::=", + /* 324 */ "with ::= WITH wqlist", + /* 325 */ "with ::= WITH RECURSIVE wqlist", + /* 326 */ "wqlist ::= nm eidlist_opt AS LP select RP", + /* 327 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP", +}; +#endif /* NDEBUG */ + + +#if YYSTACKDEPTH<=0 +/* +** Try to increase the size of the parser stack. +*/ +static void yyGrowStack(yyParser *p){ + int newSize; + yyStackEntry *pNew; + + newSize = p->yystksz*2 + 100; + pNew = realloc(p->yystack, newSize*sizeof(pNew[0])); + if( pNew ){ + p->yystack = pNew; + p->yystksz = newSize; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack grows to %d entries!\n", + yyTracePrompt, p->yystksz); + } +#endif + } +} +#endif + +/* +** This function allocates a new parser. +** The only argument is a pointer to a function which works like +** malloc. +** +** Inputs: +** A pointer to the function used to allocate memory. +** +** Outputs: +** A pointer to a parser. This pointer is used in subsequent calls +** to sqlite3Parser and sqlite3ParserFree. +*/ +SQLITE_PRIVATE void *sqlite3ParserAlloc(void *(*mallocProc)(u64)){ + yyParser *pParser; + pParser = (yyParser*)(*mallocProc)( (u64)sizeof(yyParser) ); + if( pParser ){ + pParser->yyidx = -1; +#ifdef YYTRACKMAXSTACKDEPTH + pParser->yyidxMax = 0; +#endif +#if YYSTACKDEPTH<=0 + pParser->yystack = NULL; + pParser->yystksz = 0; + yyGrowStack(pParser); +#endif + } + return pParser; +} + +/* The following function deletes the value associated with a +** symbol. The symbol can be either a terminal or nonterminal. +** "yymajor" is the symbol code, and "yypminor" is a pointer to +** the value. +*/ +static void yy_destructor( + yyParser *yypParser, /* The parser */ + YYCODETYPE yymajor, /* Type code for object to destroy */ + YYMINORTYPE *yypminor /* The object to be destroyed */ +){ + sqlite3ParserARG_FETCH; + switch( yymajor ){ + /* Here is inserted the actions which take place when a + ** terminal or non-terminal is destroyed. This can happen + ** when the symbol is popped from the stack during a + ** reduce or during error processing or when a parser is + ** being destroyed before it is finished parsing. + ** + ** Note: during a reduce, the only symbols destroyed are those + ** which appear on the RHS of the rule, but which are not used + ** inside the C code. + */ + case 163: /* select */ + case 196: /* selectnowith */ + case 197: /* oneselect */ + case 208: /* values */ +{ +sqlite3SelectDelete(pParse->db, (yypminor->yy3)); +} + break; + case 174: /* term */ + case 175: /* expr */ +{ +sqlite3ExprDelete(pParse->db, (yypminor->yy346).pExpr); +} + break; + case 179: /* eidlist_opt */ + case 188: /* sortlist */ + case 189: /* eidlist */ + case 201: /* selcollist */ + case 204: /* groupby_opt */ + case 206: /* orderby_opt */ + case 209: /* nexprlist */ + case 210: /* exprlist */ + case 211: /* sclp */ + case 221: /* setlist */ + case 228: /* case_exprlist */ +{ +sqlite3ExprListDelete(pParse->db, (yypminor->yy14)); +} + break; + case 195: /* fullname */ + case 202: /* from */ + case 213: /* seltablist */ + case 214: /* stl_prefix */ +{ +sqlite3SrcListDelete(pParse->db, (yypminor->yy65)); +} + break; + case 198: /* with */ + case 252: /* wqlist */ +{ +sqlite3WithDelete(pParse->db, (yypminor->yy59)); +} + break; + case 203: /* where_opt */ + case 205: /* having_opt */ + case 217: /* on_opt */ + case 227: /* case_operand */ + case 229: /* case_else */ + case 238: /* when_clause */ + case 243: /* key_opt */ +{ +sqlite3ExprDelete(pParse->db, (yypminor->yy132)); +} + break; + case 218: /* using_opt */ + case 220: /* idlist */ + case 223: /* idlist_opt */ +{ +sqlite3IdListDelete(pParse->db, (yypminor->yy408)); +} + break; + case 234: /* trigger_cmd_list */ + case 239: /* trigger_cmd */ +{ +sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy473)); +} + break; + case 236: /* trigger_event */ +{ +sqlite3IdListDelete(pParse->db, (yypminor->yy378).b); +} + break; + default: break; /* If no destructor action specified: do nothing */ + } +} + +/* +** Pop the parser's stack once. +** +** If there is a destructor routine associated with the token which +** is popped from the stack, then call it. +** +** Return the major token number for the symbol popped. +*/ +static int yy_pop_parser_stack(yyParser *pParser){ + YYCODETYPE yymajor; + yyStackEntry *yytos = &pParser->yystack[pParser->yyidx]; + + /* There is no mechanism by which the parser stack can be popped below + ** empty in SQLite. */ + assert( pParser->yyidx>=0 ); +#ifndef NDEBUG + if( yyTraceFILE && pParser->yyidx>=0 ){ + fprintf(yyTraceFILE,"%sPopping %s\n", + yyTracePrompt, + yyTokenName[yytos->major]); + } +#endif + yymajor = yytos->major; + yy_destructor(pParser, yymajor, &yytos->minor); + pParser->yyidx--; + return yymajor; +} + +/* +** Deallocate and destroy a parser. Destructors are all called for +** all stack elements before shutting the parser down. +** +** Inputs: +**
      +**
    • A pointer to the parser. This should be a pointer +** obtained from sqlite3ParserAlloc. +**
    • A pointer to a function used to reclaim memory obtained +** from malloc. +**
    +*/ +SQLITE_PRIVATE void sqlite3ParserFree( + void *p, /* The parser to be deleted */ + void (*freeProc)(void*) /* Function used to reclaim memory */ +){ + yyParser *pParser = (yyParser*)p; + /* In SQLite, we never try to destroy a parser that was not successfully + ** created in the first place. */ + if( NEVER(pParser==0) ) return; + while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser); +#if YYSTACKDEPTH<=0 + free(pParser->yystack); +#endif + (*freeProc)((void*)pParser); +} + +/* +** Return the peak depth of the stack for a parser. +*/ +#ifdef YYTRACKMAXSTACKDEPTH +SQLITE_PRIVATE int sqlite3ParserStackPeak(void *p){ + yyParser *pParser = (yyParser*)p; + return pParser->yyidxMax; +} +#endif + +/* +** Find the appropriate action for a parser given the terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_shift_action( + yyParser *pParser, /* The parser */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; + int stateno = pParser->yystack[pParser->yyidx].stateno; + + if( stateno>=YY_MIN_REDUCE ) return stateno; + assert( stateno <= YY_SHIFT_COUNT ); + i = yy_shift_ofst[stateno]; + if( i==YY_SHIFT_USE_DFLT ) return yy_default[stateno]; + assert( iLookAhead!=YYNOCODE ); + i += iLookAhead; + if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ + if( iLookAhead>0 ){ +#ifdef YYFALLBACK + YYCODETYPE iFallback; /* Fallback token */ + if( iLookAhead %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + return yy_find_shift_action(pParser, iFallback); + } +#endif +#ifdef YYWILDCARD + { + int j = i - iLookAhead + YYWILDCARD; + if( +#if YY_SHIFT_MIN+YYWILDCARD<0 + j>=0 && +#endif +#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT + j %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]); + } +#endif /* NDEBUG */ + return yy_action[j]; + } + } +#endif /* YYWILDCARD */ + } + return yy_default[stateno]; + }else{ + return yy_action[i]; + } +} + +/* +** Find the appropriate action for a parser given the non-terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_reduce_action( + int stateno, /* Current state number */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; +#ifdef YYERRORSYMBOL + if( stateno>YY_REDUCE_COUNT ){ + return yy_default[stateno]; + } +#else + assert( stateno<=YY_REDUCE_COUNT ); +#endif + i = yy_reduce_ofst[stateno]; + assert( i!=YY_REDUCE_USE_DFLT ); + assert( iLookAhead!=YYNOCODE ); + i += iLookAhead; +#ifdef YYERRORSYMBOL + if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ + return yy_default[stateno]; + } +#else + assert( i>=0 && iyyidx--; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will execute if the parser + ** stack every overflows */ + + UNUSED_PARAMETER(yypMinor); /* Silence some compiler warnings */ + sqlite3ErrorMsg(pParse, "parser stack overflow"); + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument var */ +} + +/* +** Print tracing information for a SHIFT action +*/ +#ifndef NDEBUG +static void yyTraceShift(yyParser *yypParser, int yyNewState){ + if( yyTraceFILE ){ + int i; + if( yyNewStateyyidx; i++) + fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]); + fprintf(yyTraceFILE,"\n"); + }else{ + fprintf(yyTraceFILE,"%sShift *\n",yyTracePrompt); + } + } +} +#else +# define yyTraceShift(X,Y) +#endif + +/* +** Perform a shift action. Return the number of errors. +*/ +static void yy_shift( + yyParser *yypParser, /* The parser to be shifted */ + int yyNewState, /* The new state to shift in */ + int yyMajor, /* The major token to shift in */ + YYMINORTYPE *yypMinor /* Pointer to the minor token to shift in */ +){ + yyStackEntry *yytos; + yypParser->yyidx++; +#ifdef YYTRACKMAXSTACKDEPTH + if( yypParser->yyidx>yypParser->yyidxMax ){ + yypParser->yyidxMax = yypParser->yyidx; + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yyidx>=YYSTACKDEPTH ){ + yyStackOverflow(yypParser, yypMinor); + return; + } +#else + if( yypParser->yyidx>=yypParser->yystksz ){ + yyGrowStack(yypParser); + if( yypParser->yyidx>=yypParser->yystksz ){ + yyStackOverflow(yypParser, yypMinor); + return; + } + } +#endif + yytos = &yypParser->yystack[yypParser->yyidx]; + yytos->stateno = (YYACTIONTYPE)yyNewState; + yytos->major = (YYCODETYPE)yyMajor; + yytos->minor = *yypMinor; + yyTraceShift(yypParser, yyNewState); +} + +/* The following table contains information about every rule that +** is used during the reduce. +*/ +static const struct { + YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ + unsigned char nrhs; /* Number of right-hand side symbols in the rule */ +} yyRuleInfo[] = { + { 144, 1 }, + { 145, 2 }, + { 145, 1 }, + { 146, 1 }, + { 146, 3 }, + { 147, 0 }, + { 147, 1 }, + { 147, 3 }, + { 148, 1 }, + { 149, 3 }, + { 151, 0 }, + { 151, 1 }, + { 151, 2 }, + { 150, 0 }, + { 150, 1 }, + { 150, 1 }, + { 150, 1 }, + { 149, 2 }, + { 149, 2 }, + { 149, 2 }, + { 153, 1 }, + { 153, 0 }, + { 149, 2 }, + { 149, 3 }, + { 149, 5 }, + { 149, 2 }, + { 154, 6 }, + { 156, 1 }, + { 158, 0 }, + { 158, 3 }, + { 157, 1 }, + { 157, 0 }, + { 155, 5 }, + { 155, 2 }, + { 162, 0 }, + { 162, 2 }, + { 160, 3 }, + { 160, 1 }, + { 164, 3 }, + { 165, 1 }, + { 152, 1 }, + { 152, 1 }, + { 152, 1 }, + { 166, 0 }, + { 166, 1 }, + { 168, 1 }, + { 168, 4 }, + { 168, 6 }, + { 169, 1 }, + { 169, 2 }, + { 170, 1 }, + { 170, 1 }, + { 167, 2 }, + { 167, 0 }, + { 173, 2 }, + { 173, 2 }, + { 173, 4 }, + { 173, 3 }, + { 173, 3 }, + { 173, 2 }, + { 173, 2 }, + { 173, 3 }, + { 173, 5 }, + { 173, 2 }, + { 173, 4 }, + { 173, 4 }, + { 173, 1 }, + { 173, 2 }, + { 178, 0 }, + { 178, 1 }, + { 180, 0 }, + { 180, 2 }, + { 182, 2 }, + { 182, 3 }, + { 182, 3 }, + { 182, 3 }, + { 183, 2 }, + { 183, 2 }, + { 183, 1 }, + { 183, 1 }, + { 183, 2 }, + { 181, 3 }, + { 181, 2 }, + { 184, 0 }, + { 184, 2 }, + { 184, 2 }, + { 161, 0 }, + { 161, 2 }, + { 185, 3 }, + { 185, 1 }, + { 186, 1 }, + { 186, 0 }, + { 187, 2 }, + { 187, 7 }, + { 187, 5 }, + { 187, 5 }, + { 187, 10 }, + { 190, 0 }, + { 190, 1 }, + { 176, 0 }, + { 176, 3 }, + { 191, 0 }, + { 191, 2 }, + { 192, 1 }, + { 192, 1 }, + { 192, 1 }, + { 149, 4 }, + { 194, 2 }, + { 194, 0 }, + { 149, 9 }, + { 149, 4 }, + { 149, 1 }, + { 163, 2 }, + { 196, 1 }, + { 196, 3 }, + { 199, 1 }, + { 199, 2 }, + { 199, 1 }, + { 197, 9 }, + { 197, 1 }, + { 208, 4 }, + { 208, 5 }, + { 200, 1 }, + { 200, 1 }, + { 200, 0 }, + { 211, 2 }, + { 211, 0 }, + { 201, 3 }, + { 201, 2 }, + { 201, 4 }, + { 212, 2 }, + { 212, 1 }, + { 212, 0 }, + { 202, 0 }, + { 202, 2 }, + { 214, 2 }, + { 214, 0 }, + { 213, 7 }, + { 213, 9 }, + { 213, 7 }, + { 213, 7 }, + { 159, 0 }, + { 159, 2 }, + { 195, 2 }, + { 215, 1 }, + { 215, 2 }, + { 215, 3 }, + { 215, 4 }, + { 217, 2 }, + { 217, 0 }, + { 216, 0 }, + { 216, 3 }, + { 216, 2 }, + { 218, 4 }, + { 218, 0 }, + { 206, 0 }, + { 206, 3 }, + { 188, 4 }, + { 188, 2 }, + { 177, 1 }, + { 177, 1 }, + { 177, 0 }, + { 204, 0 }, + { 204, 3 }, + { 205, 0 }, + { 205, 2 }, + { 207, 0 }, + { 207, 2 }, + { 207, 4 }, + { 207, 4 }, + { 149, 6 }, + { 203, 0 }, + { 203, 2 }, + { 149, 8 }, + { 221, 5 }, + { 221, 3 }, + { 149, 6 }, + { 149, 7 }, + { 222, 2 }, + { 222, 1 }, + { 223, 0 }, + { 223, 3 }, + { 220, 3 }, + { 220, 1 }, + { 175, 1 }, + { 175, 3 }, + { 174, 1 }, + { 175, 1 }, + { 175, 1 }, + { 175, 3 }, + { 175, 5 }, + { 174, 1 }, + { 174, 1 }, + { 175, 1 }, + { 175, 3 }, + { 175, 6 }, + { 175, 5 }, + { 175, 4 }, + { 174, 1 }, + { 175, 3 }, + { 175, 3 }, + { 175, 3 }, + { 175, 3 }, + { 175, 3 }, + { 175, 3 }, + { 175, 3 }, + { 175, 3 }, + { 224, 1 }, + { 224, 2 }, + { 175, 3 }, + { 175, 5 }, + { 175, 2 }, + { 175, 3 }, + { 175, 3 }, + { 175, 4 }, + { 175, 2 }, + { 175, 2 }, + { 175, 2 }, + { 175, 2 }, + { 225, 1 }, + { 225, 2 }, + { 175, 5 }, + { 226, 1 }, + { 226, 2 }, + { 175, 5 }, + { 175, 3 }, + { 175, 5 }, + { 175, 4 }, + { 175, 4 }, + { 175, 5 }, + { 228, 5 }, + { 228, 4 }, + { 229, 2 }, + { 229, 0 }, + { 227, 1 }, + { 227, 0 }, + { 210, 1 }, + { 210, 0 }, + { 209, 3 }, + { 209, 1 }, + { 149, 12 }, + { 230, 1 }, + { 230, 0 }, + { 179, 0 }, + { 179, 3 }, + { 189, 5 }, + { 189, 3 }, + { 231, 0 }, + { 231, 2 }, + { 149, 4 }, + { 149, 1 }, + { 149, 2 }, + { 149, 3 }, + { 149, 5 }, + { 149, 6 }, + { 149, 5 }, + { 149, 6 }, + { 232, 1 }, + { 232, 1 }, + { 232, 1 }, + { 232, 1 }, + { 232, 1 }, + { 171, 2 }, + { 171, 1 }, + { 172, 2 }, + { 149, 5 }, + { 233, 11 }, + { 235, 1 }, + { 235, 1 }, + { 235, 2 }, + { 235, 0 }, + { 236, 1 }, + { 236, 1 }, + { 236, 3 }, + { 237, 0 }, + { 237, 3 }, + { 238, 0 }, + { 238, 2 }, + { 234, 3 }, + { 234, 2 }, + { 240, 1 }, + { 240, 3 }, + { 241, 0 }, + { 241, 3 }, + { 241, 2 }, + { 239, 7 }, + { 239, 5 }, + { 239, 5 }, + { 239, 1 }, + { 175, 4 }, + { 175, 6 }, + { 193, 1 }, + { 193, 1 }, + { 193, 1 }, + { 149, 4 }, + { 149, 6 }, + { 149, 3 }, + { 243, 0 }, + { 243, 2 }, + { 242, 1 }, + { 242, 0 }, + { 149, 1 }, + { 149, 3 }, + { 149, 1 }, + { 149, 3 }, + { 149, 6 }, + { 149, 6 }, + { 244, 1 }, + { 245, 0 }, + { 245, 1 }, + { 149, 1 }, + { 149, 4 }, + { 246, 8 }, + { 247, 1 }, + { 247, 3 }, + { 248, 0 }, + { 248, 2 }, + { 249, 1 }, + { 249, 3 }, + { 250, 1 }, + { 251, 0 }, + { 251, 4 }, + { 251, 2 }, + { 198, 0 }, + { 198, 2 }, + { 198, 3 }, + { 252, 6 }, + { 252, 8 }, +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +*/ +static void yy_reduce( + yyParser *yypParser, /* The parser */ + int yyruleno /* Number of the rule by which to reduce */ +){ + int yygoto; /* The next state */ + int yyact; /* The next action */ + YYMINORTYPE yygotominor; /* The LHS of the rule reduced */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + sqlite3ParserARG_FETCH; + yymsp = &yypParser->yystack[yypParser->yyidx]; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno>=0 + && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ + yysize = yyRuleInfo[yyruleno].nrhs; + fprintf(yyTraceFILE, "%sReduce [%s] -> state %d.\n", yyTracePrompt, + yyRuleName[yyruleno], yymsp[-yysize].stateno); + } +#endif /* NDEBUG */ + + /* Silence complaints from purify about yygotominor being uninitialized + ** in some cases when it is copied into the stack after the following + ** switch. yygotominor is uninitialized when a rule reduces that does + ** not set the value of its left-hand side nonterminal. Leaving the + ** value of the nonterminal uninitialized is utterly harmless as long + ** as the value is never used. So really the only thing this code + ** accomplishes is to quieten purify. + ** + ** 2007-01-16: The wireshark project (www.wireshark.org) reports that + ** without this code, their parser segfaults. I'm not sure what there + ** parser is doing to make this happen. This is the second bug report + ** from wireshark this week. Clearly they are stressing Lemon in ways + ** that it has not been previously stressed... (SQLite ticket #2172) + */ + /*memset(&yygotominor, 0, sizeof(yygotominor));*/ + yygotominor = yyzerominor; + + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line + ** { ... } // User supplied code + ** #line + ** break; + */ + case 5: /* explain ::= */ +{ sqlite3BeginParse(pParse, 0); } + break; + case 6: /* explain ::= EXPLAIN */ +{ sqlite3BeginParse(pParse, 1); } + break; + case 7: /* explain ::= EXPLAIN QUERY PLAN */ +{ sqlite3BeginParse(pParse, 2); } + break; + case 8: /* cmdx ::= cmd */ +{ sqlite3FinishCoding(pParse); } + break; + case 9: /* cmd ::= BEGIN transtype trans_opt */ +{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy328);} + break; + case 13: /* transtype ::= */ +{yygotominor.yy328 = TK_DEFERRED;} + break; + case 14: /* transtype ::= DEFERRED */ + case 15: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==15); + case 16: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==16); + case 115: /* multiselect_op ::= UNION */ yytestcase(yyruleno==115); + case 117: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==117); +{yygotominor.yy328 = yymsp[0].major;} + break; + case 17: /* cmd ::= COMMIT trans_opt */ + case 18: /* cmd ::= END trans_opt */ yytestcase(yyruleno==18); +{sqlite3CommitTransaction(pParse);} + break; + case 19: /* cmd ::= ROLLBACK trans_opt */ +{sqlite3RollbackTransaction(pParse);} + break; + case 22: /* cmd ::= SAVEPOINT nm */ +{ + sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0); +} + break; + case 23: /* cmd ::= RELEASE savepoint_opt nm */ +{ + sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0); +} + break; + case 24: /* cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ +{ + sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0); +} + break; + case 26: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */ +{ + sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy328,0,0,yymsp[-2].minor.yy328); +} + break; + case 27: /* createkw ::= CREATE */ +{ + pParse->db->lookaside.bEnabled = 0; + yygotominor.yy0 = yymsp[0].minor.yy0; +} + break; + case 28: /* ifnotexists ::= */ + case 31: /* temp ::= */ yytestcase(yyruleno==31); + case 68: /* autoinc ::= */ yytestcase(yyruleno==68); + case 81: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ yytestcase(yyruleno==81); + case 83: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==83); + case 85: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ yytestcase(yyruleno==85); + case 97: /* defer_subclause_opt ::= */ yytestcase(yyruleno==97); + case 108: /* ifexists ::= */ yytestcase(yyruleno==108); + case 219: /* between_op ::= BETWEEN */ yytestcase(yyruleno==219); + case 222: /* in_op ::= IN */ yytestcase(yyruleno==222); + case 247: /* collate ::= */ yytestcase(yyruleno==247); +{yygotominor.yy328 = 0;} + break; + case 29: /* ifnotexists ::= IF NOT EXISTS */ + case 30: /* temp ::= TEMP */ yytestcase(yyruleno==30); + case 69: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==69); + case 84: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ yytestcase(yyruleno==84); + case 107: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==107); + case 220: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==220); + case 223: /* in_op ::= NOT IN */ yytestcase(yyruleno==223); + case 248: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==248); +{yygotominor.yy328 = 1;} + break; + case 32: /* create_table_args ::= LP columnlist conslist_opt RP table_options */ +{ + sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy186,0); +} + break; + case 33: /* create_table_args ::= AS select */ +{ + sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy3); + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3); +} + break; + case 34: /* table_options ::= */ +{yygotominor.yy186 = 0;} + break; + case 35: /* table_options ::= WITHOUT nm */ +{ + if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){ + yygotominor.yy186 = TF_WithoutRowid | TF_NoVisibleRowid; + }else{ + yygotominor.yy186 = 0; + sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z); + } +} + break; + case 38: /* column ::= columnid type carglist */ +{ + yygotominor.yy0.z = yymsp[-2].minor.yy0.z; + yygotominor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-2].minor.yy0.z) + pParse->sLastToken.n; +} + break; + case 39: /* columnid ::= nm */ +{ + sqlite3AddColumn(pParse,&yymsp[0].minor.yy0); + yygotominor.yy0 = yymsp[0].minor.yy0; + pParse->constraintName.n = 0; +} + break; + case 40: /* nm ::= ID|INDEXED */ + case 41: /* nm ::= STRING */ yytestcase(yyruleno==41); + case 42: /* nm ::= JOIN_KW */ yytestcase(yyruleno==42); + case 45: /* typetoken ::= typename */ yytestcase(yyruleno==45); + case 48: /* typename ::= ID|STRING */ yytestcase(yyruleno==48); + case 130: /* as ::= AS nm */ yytestcase(yyruleno==130); + case 131: /* as ::= ID|STRING */ yytestcase(yyruleno==131); + case 142: /* dbnm ::= DOT nm */ yytestcase(yyruleno==142); + case 151: /* indexed_opt ::= INDEXED BY nm */ yytestcase(yyruleno==151); + case 257: /* nmnum ::= plus_num */ yytestcase(yyruleno==257); + case 258: /* nmnum ::= nm */ yytestcase(yyruleno==258); + case 259: /* nmnum ::= ON */ yytestcase(yyruleno==259); + case 260: /* nmnum ::= DELETE */ yytestcase(yyruleno==260); + case 261: /* nmnum ::= DEFAULT */ yytestcase(yyruleno==261); + case 262: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==262); + case 263: /* plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==263); + case 264: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==264); + case 280: /* trnm ::= nm */ yytestcase(yyruleno==280); +{yygotominor.yy0 = yymsp[0].minor.yy0;} + break; + case 44: /* type ::= typetoken */ +{sqlite3AddColumnType(pParse,&yymsp[0].minor.yy0);} + break; + case 46: /* typetoken ::= typename LP signed RP */ +{ + yygotominor.yy0.z = yymsp[-3].minor.yy0.z; + yygotominor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z); +} + break; + case 47: /* typetoken ::= typename LP signed COMMA signed RP */ +{ + yygotominor.yy0.z = yymsp[-5].minor.yy0.z; + yygotominor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z); +} + break; + case 49: /* typename ::= typename ID|STRING */ +{yygotominor.yy0.z=yymsp[-1].minor.yy0.z; yygotominor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);} + break; + case 54: /* ccons ::= CONSTRAINT nm */ + case 92: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==92); +{pParse->constraintName = yymsp[0].minor.yy0;} + break; + case 55: /* ccons ::= DEFAULT term */ + case 57: /* ccons ::= DEFAULT PLUS term */ yytestcase(yyruleno==57); +{sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy346);} + break; + case 56: /* ccons ::= DEFAULT LP expr RP */ +{sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy346);} + break; + case 58: /* ccons ::= DEFAULT MINUS term */ +{ + ExprSpan v; + v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy346.pExpr, 0, 0); + v.zStart = yymsp[-1].minor.yy0.z; + v.zEnd = yymsp[0].minor.yy346.zEnd; + sqlite3AddDefaultValue(pParse,&v); +} + break; + case 59: /* ccons ::= DEFAULT ID|INDEXED */ +{ + ExprSpan v; + spanExpr(&v, pParse, TK_STRING, &yymsp[0].minor.yy0); + sqlite3AddDefaultValue(pParse,&v); +} + break; + case 61: /* ccons ::= NOT NULL onconf */ +{sqlite3AddNotNull(pParse, yymsp[0].minor.yy328);} + break; + case 62: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */ +{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy328,yymsp[0].minor.yy328,yymsp[-2].minor.yy328);} + break; + case 63: /* ccons ::= UNIQUE onconf */ +{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy328,0,0,0,0);} + break; + case 64: /* ccons ::= CHECK LP expr RP */ +{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy346.pExpr);} + break; + case 65: /* ccons ::= REFERENCES nm eidlist_opt refargs */ +{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy328);} + break; + case 66: /* ccons ::= defer_subclause */ +{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy328);} + break; + case 67: /* ccons ::= COLLATE ID|STRING */ +{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);} + break; + case 70: /* refargs ::= */ +{ yygotominor.yy328 = OE_None*0x0101; /* EV: R-19803-45884 */} + break; + case 71: /* refargs ::= refargs refarg */ +{ yygotominor.yy328 = (yymsp[-1].minor.yy328 & ~yymsp[0].minor.yy429.mask) | yymsp[0].minor.yy429.value; } + break; + case 72: /* refarg ::= MATCH nm */ + case 73: /* refarg ::= ON INSERT refact */ yytestcase(yyruleno==73); +{ yygotominor.yy429.value = 0; yygotominor.yy429.mask = 0x000000; } + break; + case 74: /* refarg ::= ON DELETE refact */ +{ yygotominor.yy429.value = yymsp[0].minor.yy328; yygotominor.yy429.mask = 0x0000ff; } + break; + case 75: /* refarg ::= ON UPDATE refact */ +{ yygotominor.yy429.value = yymsp[0].minor.yy328<<8; yygotominor.yy429.mask = 0x00ff00; } + break; + case 76: /* refact ::= SET NULL */ +{ yygotominor.yy328 = OE_SetNull; /* EV: R-33326-45252 */} + break; + case 77: /* refact ::= SET DEFAULT */ +{ yygotominor.yy328 = OE_SetDflt; /* EV: R-33326-45252 */} + break; + case 78: /* refact ::= CASCADE */ +{ yygotominor.yy328 = OE_Cascade; /* EV: R-33326-45252 */} + break; + case 79: /* refact ::= RESTRICT */ +{ yygotominor.yy328 = OE_Restrict; /* EV: R-33326-45252 */} + break; + case 80: /* refact ::= NO ACTION */ +{ yygotominor.yy328 = OE_None; /* EV: R-33326-45252 */} + break; + case 82: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ + case 98: /* defer_subclause_opt ::= defer_subclause */ yytestcase(yyruleno==98); + case 100: /* onconf ::= ON CONFLICT resolvetype */ yytestcase(yyruleno==100); + case 103: /* resolvetype ::= raisetype */ yytestcase(yyruleno==103); +{yygotominor.yy328 = yymsp[0].minor.yy328;} + break; + case 86: /* conslist_opt ::= */ +{yygotominor.yy0.n = 0; yygotominor.yy0.z = 0;} + break; + case 87: /* conslist_opt ::= COMMA conslist */ +{yygotominor.yy0 = yymsp[-1].minor.yy0;} + break; + case 90: /* tconscomma ::= COMMA */ +{pParse->constraintName.n = 0;} + break; + case 93: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ +{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy328,yymsp[-2].minor.yy328,0);} + break; + case 94: /* tcons ::= UNIQUE LP sortlist RP onconf */ +{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy328,0,0,0,0);} + break; + case 95: /* tcons ::= CHECK LP expr RP onconf */ +{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy346.pExpr);} + break; + case 96: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ +{ + sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy328); + sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy328); +} + break; + case 99: /* onconf ::= */ +{yygotominor.yy328 = OE_Default;} + break; + case 101: /* orconf ::= */ +{yygotominor.yy186 = OE_Default;} + break; + case 102: /* orconf ::= OR resolvetype */ +{yygotominor.yy186 = (u8)yymsp[0].minor.yy328;} + break; + case 104: /* resolvetype ::= IGNORE */ +{yygotominor.yy328 = OE_Ignore;} + break; + case 105: /* resolvetype ::= REPLACE */ +{yygotominor.yy328 = OE_Replace;} + break; + case 106: /* cmd ::= DROP TABLE ifexists fullname */ +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy65, 0, yymsp[-1].minor.yy328); +} + break; + case 109: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ +{ + sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[0].minor.yy3, yymsp[-7].minor.yy328, yymsp[-5].minor.yy328); +} + break; + case 110: /* cmd ::= DROP VIEW ifexists fullname */ +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy65, 1, yymsp[-1].minor.yy328); +} + break; + case 111: /* cmd ::= select */ +{ + SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0}; + sqlite3Select(pParse, yymsp[0].minor.yy3, &dest); + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3); +} + break; + case 112: /* select ::= with selectnowith */ +{ + Select *p = yymsp[0].minor.yy3; + if( p ){ + p->pWith = yymsp[-1].minor.yy59; + parserDoubleLinkSelect(pParse, p); + }else{ + sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy59); + } + yygotominor.yy3 = p; +} + break; + case 113: /* selectnowith ::= oneselect */ + case 119: /* oneselect ::= values */ yytestcase(yyruleno==119); +{yygotominor.yy3 = yymsp[0].minor.yy3;} + break; + case 114: /* selectnowith ::= selectnowith multiselect_op oneselect */ +{ + Select *pRhs = yymsp[0].minor.yy3; + Select *pLhs = yymsp[-2].minor.yy3; + if( pRhs && pRhs->pPrior ){ + SrcList *pFrom; + Token x; + x.n = 0; + parserDoubleLinkSelect(pParse, pRhs); + pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0); + pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0,0); + } + if( pRhs ){ + pRhs->op = (u8)yymsp[-1].minor.yy328; + pRhs->pPrior = pLhs; + if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue; + pRhs->selFlags &= ~SF_MultiValue; + if( yymsp[-1].minor.yy328!=TK_ALL ) pParse->hasCompound = 1; + }else{ + sqlite3SelectDelete(pParse->db, pLhs); + } + yygotominor.yy3 = pRhs; +} + break; + case 116: /* multiselect_op ::= UNION ALL */ +{yygotominor.yy328 = TK_ALL;} + break; + case 118: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ +{ + yygotominor.yy3 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy65,yymsp[-4].minor.yy132,yymsp[-3].minor.yy14,yymsp[-2].minor.yy132,yymsp[-1].minor.yy14,yymsp[-7].minor.yy381,yymsp[0].minor.yy476.pLimit,yymsp[0].minor.yy476.pOffset); +#if SELECTTRACE_ENABLED + /* Populate the Select.zSelName[] string that is used to help with + ** query planner debugging, to differentiate between multiple Select + ** objects in a complex query. + ** + ** If the SELECT keyword is immediately followed by a C-style comment + ** then extract the first few alphanumeric characters from within that + ** comment to be the zSelName value. Otherwise, the label is #N where + ** is an integer that is incremented with each SELECT statement seen. + */ + if( yygotominor.yy3!=0 ){ + const char *z = yymsp[-8].minor.yy0.z+6; + int i; + sqlite3_snprintf(sizeof(yygotominor.yy3->zSelName), yygotominor.yy3->zSelName, "#%d", + ++pParse->nSelect); + while( z[0]==' ' ) z++; + if( z[0]=='/' && z[1]=='*' ){ + z += 2; + while( z[0]==' ' ) z++; + for(i=0; sqlite3Isalnum(z[i]); i++){} + sqlite3_snprintf(sizeof(yygotominor.yy3->zSelName), yygotominor.yy3->zSelName, "%.*s", i, z); + } + } +#endif /* SELECTRACE_ENABLED */ +} + break; + case 120: /* values ::= VALUES LP nexprlist RP */ +{ + yygotominor.yy3 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0,0); +} + break; + case 121: /* values ::= values COMMA LP exprlist RP */ +{ + Select *pRight, *pLeft = yymsp[-4].minor.yy3; + pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values|SF_MultiValue,0,0); + if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue; + if( pRight ){ + pRight->op = TK_ALL; + pLeft = yymsp[-4].minor.yy3; + pRight->pPrior = pLeft; + yygotominor.yy3 = pRight; + }else{ + yygotominor.yy3 = pLeft; + } +} + break; + case 122: /* distinct ::= DISTINCT */ +{yygotominor.yy381 = SF_Distinct;} + break; + case 123: /* distinct ::= ALL */ +{yygotominor.yy381 = SF_All;} + break; + case 124: /* distinct ::= */ +{yygotominor.yy381 = 0;} + break; + case 125: /* sclp ::= selcollist COMMA */ + case 244: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==244); +{yygotominor.yy14 = yymsp[-1].minor.yy14;} + break; + case 126: /* sclp ::= */ + case 155: /* orderby_opt ::= */ yytestcase(yyruleno==155); + case 162: /* groupby_opt ::= */ yytestcase(yyruleno==162); + case 237: /* exprlist ::= */ yytestcase(yyruleno==237); + case 243: /* eidlist_opt ::= */ yytestcase(yyruleno==243); +{yygotominor.yy14 = 0;} + break; + case 127: /* selcollist ::= sclp expr as */ +{ + yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, yymsp[-1].minor.yy346.pExpr); + if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[0].minor.yy0, 1); + sqlite3ExprListSetSpan(pParse,yygotominor.yy14,&yymsp[-1].minor.yy346); +} + break; + case 128: /* selcollist ::= sclp STAR */ +{ + Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0); + yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy14, p); +} + break; + case 129: /* selcollist ::= sclp nm DOT STAR */ +{ + Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &yymsp[0].minor.yy0); + Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0); + Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0); + yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, pDot); +} + break; + case 132: /* as ::= */ +{yygotominor.yy0.n = 0;} + break; + case 133: /* from ::= */ +{yygotominor.yy65 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy65));} + break; + case 134: /* from ::= FROM seltablist */ +{ + yygotominor.yy65 = yymsp[0].minor.yy65; + sqlite3SrcListShiftJoinType(yygotominor.yy65); +} + break; + case 135: /* stl_prefix ::= seltablist joinop */ +{ + yygotominor.yy65 = yymsp[-1].minor.yy65; + if( ALWAYS(yygotominor.yy65 && yygotominor.yy65->nSrc>0) ) yygotominor.yy65->a[yygotominor.yy65->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy328; +} + break; + case 136: /* stl_prefix ::= */ +{yygotominor.yy65 = 0;} + break; + case 137: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */ +{ + yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy132,yymsp[0].minor.yy408); + sqlite3SrcListIndexedBy(pParse, yygotominor.yy65, &yymsp[-2].minor.yy0); +} + break; + case 138: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */ +{ + yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy65,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy132,yymsp[0].minor.yy408); + sqlite3SrcListFuncArgs(pParse, yygotominor.yy65, yymsp[-4].minor.yy14); +} + break; + case 139: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */ +{ + yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy3,yymsp[-1].minor.yy132,yymsp[0].minor.yy408); + } + break; + case 140: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */ +{ + if( yymsp[-6].minor.yy65==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy132==0 && yymsp[0].minor.yy408==0 ){ + yygotominor.yy65 = yymsp[-4].minor.yy65; + }else if( yymsp[-4].minor.yy65->nSrc==1 ){ + yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy132,yymsp[0].minor.yy408); + if( yygotominor.yy65 ){ + struct SrcList_item *pNew = &yygotominor.yy65->a[yygotominor.yy65->nSrc-1]; + struct SrcList_item *pOld = yymsp[-4].minor.yy65->a; + pNew->zName = pOld->zName; + pNew->zDatabase = pOld->zDatabase; + pNew->pSelect = pOld->pSelect; + pOld->zName = pOld->zDatabase = 0; + pOld->pSelect = 0; + } + sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy65); + }else{ + Select *pSubquery; + sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy65); + pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy65,0,0,0,0,SF_NestedFrom,0,0); + yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy132,yymsp[0].minor.yy408); + } + } + break; + case 141: /* dbnm ::= */ + case 150: /* indexed_opt ::= */ yytestcase(yyruleno==150); +{yygotominor.yy0.z=0; yygotominor.yy0.n=0;} + break; + case 143: /* fullname ::= nm dbnm */ +{yygotominor.yy65 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);} + break; + case 144: /* joinop ::= COMMA|JOIN */ +{ yygotominor.yy328 = JT_INNER; } + break; + case 145: /* joinop ::= JOIN_KW JOIN */ +{ yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); } + break; + case 146: /* joinop ::= JOIN_KW nm JOIN */ +{ yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); } + break; + case 147: /* joinop ::= JOIN_KW nm nm JOIN */ +{ yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); } + break; + case 148: /* on_opt ::= ON expr */ + case 165: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==165); + case 172: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==172); + case 232: /* case_else ::= ELSE expr */ yytestcase(yyruleno==232); + case 234: /* case_operand ::= expr */ yytestcase(yyruleno==234); +{yygotominor.yy132 = yymsp[0].minor.yy346.pExpr;} + break; + case 149: /* on_opt ::= */ + case 164: /* having_opt ::= */ yytestcase(yyruleno==164); + case 171: /* where_opt ::= */ yytestcase(yyruleno==171); + case 233: /* case_else ::= */ yytestcase(yyruleno==233); + case 235: /* case_operand ::= */ yytestcase(yyruleno==235); +{yygotominor.yy132 = 0;} + break; + case 152: /* indexed_opt ::= NOT INDEXED */ +{yygotominor.yy0.z=0; yygotominor.yy0.n=1;} + break; + case 153: /* using_opt ::= USING LP idlist RP */ + case 181: /* idlist_opt ::= LP idlist RP */ yytestcase(yyruleno==181); +{yygotominor.yy408 = yymsp[-1].minor.yy408;} + break; + case 154: /* using_opt ::= */ + case 180: /* idlist_opt ::= */ yytestcase(yyruleno==180); +{yygotominor.yy408 = 0;} + break; + case 156: /* orderby_opt ::= ORDER BY sortlist */ + case 163: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==163); + case 236: /* exprlist ::= nexprlist */ yytestcase(yyruleno==236); +{yygotominor.yy14 = yymsp[0].minor.yy14;} + break; + case 157: /* sortlist ::= sortlist COMMA expr sortorder */ +{ + yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14,yymsp[-1].minor.yy346.pExpr); + sqlite3ExprListSetSortOrder(yygotominor.yy14,yymsp[0].minor.yy328); +} + break; + case 158: /* sortlist ::= expr sortorder */ +{ + yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy346.pExpr); + sqlite3ExprListSetSortOrder(yygotominor.yy14,yymsp[0].minor.yy328); +} + break; + case 159: /* sortorder ::= ASC */ +{yygotominor.yy328 = SQLITE_SO_ASC;} + break; + case 160: /* sortorder ::= DESC */ +{yygotominor.yy328 = SQLITE_SO_DESC;} + break; + case 161: /* sortorder ::= */ +{yygotominor.yy328 = SQLITE_SO_UNDEFINED;} + break; + case 166: /* limit_opt ::= */ +{yygotominor.yy476.pLimit = 0; yygotominor.yy476.pOffset = 0;} + break; + case 167: /* limit_opt ::= LIMIT expr */ +{yygotominor.yy476.pLimit = yymsp[0].minor.yy346.pExpr; yygotominor.yy476.pOffset = 0;} + break; + case 168: /* limit_opt ::= LIMIT expr OFFSET expr */ +{yygotominor.yy476.pLimit = yymsp[-2].minor.yy346.pExpr; yygotominor.yy476.pOffset = yymsp[0].minor.yy346.pExpr;} + break; + case 169: /* limit_opt ::= LIMIT expr COMMA expr */ +{yygotominor.yy476.pOffset = yymsp[-2].minor.yy346.pExpr; yygotominor.yy476.pLimit = yymsp[0].minor.yy346.pExpr;} + break; + case 170: /* cmd ::= with DELETE FROM fullname indexed_opt where_opt */ +{ + sqlite3WithPush(pParse, yymsp[-5].minor.yy59, 1); + sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy65, &yymsp[-1].minor.yy0); + sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy65,yymsp[0].minor.yy132); +} + break; + case 173: /* cmd ::= with UPDATE orconf fullname indexed_opt SET setlist where_opt */ +{ + sqlite3WithPush(pParse, yymsp[-7].minor.yy59, 1); + sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy65, &yymsp[-3].minor.yy0); + sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy14,"set list"); + sqlite3Update(pParse,yymsp[-4].minor.yy65,yymsp[-1].minor.yy14,yymsp[0].minor.yy132,yymsp[-5].minor.yy186); +} + break; + case 174: /* setlist ::= setlist COMMA nm EQ expr */ +{ + yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy346.pExpr); + sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1); +} + break; + case 175: /* setlist ::= nm EQ expr */ +{ + yygotominor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy346.pExpr); + sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1); +} + break; + case 176: /* cmd ::= with insert_cmd INTO fullname idlist_opt select */ +{ + sqlite3WithPush(pParse, yymsp[-5].minor.yy59, 1); + sqlite3Insert(pParse, yymsp[-2].minor.yy65, yymsp[0].minor.yy3, yymsp[-1].minor.yy408, yymsp[-4].minor.yy186); +} + break; + case 177: /* cmd ::= with insert_cmd INTO fullname idlist_opt DEFAULT VALUES */ +{ + sqlite3WithPush(pParse, yymsp[-6].minor.yy59, 1); + sqlite3Insert(pParse, yymsp[-3].minor.yy65, 0, yymsp[-2].minor.yy408, yymsp[-5].minor.yy186); +} + break; + case 178: /* insert_cmd ::= INSERT orconf */ +{yygotominor.yy186 = yymsp[0].minor.yy186;} + break; + case 179: /* insert_cmd ::= REPLACE */ +{yygotominor.yy186 = OE_Replace;} + break; + case 182: /* idlist ::= idlist COMMA nm */ +{yygotominor.yy408 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy408,&yymsp[0].minor.yy0);} + break; + case 183: /* idlist ::= nm */ +{yygotominor.yy408 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);} + break; + case 184: /* expr ::= term */ +{yygotominor.yy346 = yymsp[0].minor.yy346;} + break; + case 185: /* expr ::= LP expr RP */ +{yygotominor.yy346.pExpr = yymsp[-1].minor.yy346.pExpr; spanSet(&yygotominor.yy346,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);} + break; + case 186: /* term ::= NULL */ + case 191: /* term ::= INTEGER|FLOAT|BLOB */ yytestcase(yyruleno==191); + case 192: /* term ::= STRING */ yytestcase(yyruleno==192); +{spanExpr(&yygotominor.yy346, pParse, yymsp[0].major, &yymsp[0].minor.yy0);} + break; + case 187: /* expr ::= ID|INDEXED */ + case 188: /* expr ::= JOIN_KW */ yytestcase(yyruleno==188); +{spanExpr(&yygotominor.yy346, pParse, TK_ID, &yymsp[0].minor.yy0);} + break; + case 189: /* expr ::= nm DOT nm */ +{ + Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0); + Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0); + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0); + spanSet(&yygotominor.yy346,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); +} + break; + case 190: /* expr ::= nm DOT nm DOT nm */ +{ + Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-4].minor.yy0); + Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0); + Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0); + Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0); + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0); + spanSet(&yygotominor.yy346,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0); +} + break; + case 193: /* expr ::= VARIABLE */ +{ + if( yymsp[0].minor.yy0.n>=2 && yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1]) ){ + /* When doing a nested parse, one can include terms in an expression + ** that look like this: #1 #2 ... These terms refer to registers + ** in the virtual machine. #N is the N-th register. */ + if( pParse->nested==0 ){ + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &yymsp[0].minor.yy0); + yygotominor.yy346.pExpr = 0; + }else{ + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0); + if( yygotominor.yy346.pExpr ) sqlite3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy346.pExpr->iTable); + } + }else{ + spanExpr(&yygotominor.yy346, pParse, TK_VARIABLE, &yymsp[0].minor.yy0); + sqlite3ExprAssignVarNumber(pParse, yygotominor.yy346.pExpr); + } + spanSet(&yygotominor.yy346, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0); +} + break; + case 194: /* expr ::= expr COLLATE ID|STRING */ +{ + yygotominor.yy346.pExpr = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy346.pExpr, &yymsp[0].minor.yy0, 1); + yygotominor.yy346.zStart = yymsp[-2].minor.yy346.zStart; + yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n]; +} + break; + case 195: /* expr ::= CAST LP expr AS typetoken RP */ +{ + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy346.pExpr, 0, &yymsp[-1].minor.yy0); + spanSet(&yygotominor.yy346,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0); +} + break; + case 196: /* expr ::= ID|INDEXED LP distinct exprlist RP */ +{ + if( yymsp[-1].minor.yy14 && yymsp[-1].minor.yy14->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){ + sqlite3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0); + } + yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0); + spanSet(&yygotominor.yy346,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0); + if( yymsp[-2].minor.yy381==SF_Distinct && yygotominor.yy346.pExpr ){ + yygotominor.yy346.pExpr->flags |= EP_Distinct; + } +} + break; + case 197: /* expr ::= ID|INDEXED LP STAR RP */ +{ + yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0); + spanSet(&yygotominor.yy346,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); +} + break; + case 198: /* term ::= CTIME_KW */ +{ + yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0); + spanSet(&yygotominor.yy346, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0); +} + break; + case 199: /* expr ::= expr AND expr */ + case 200: /* expr ::= expr OR expr */ yytestcase(yyruleno==200); + case 201: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==201); + case 202: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==202); + case 203: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==203); + case 204: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==204); + case 205: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==205); + case 206: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==206); +{spanBinaryExpr(&yygotominor.yy346,pParse,yymsp[-1].major,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy346);} + break; + case 207: /* likeop ::= LIKE_KW|MATCH */ +{yygotominor.yy96.eOperator = yymsp[0].minor.yy0; yygotominor.yy96.bNot = 0;} + break; + case 208: /* likeop ::= NOT LIKE_KW|MATCH */ +{yygotominor.yy96.eOperator = yymsp[0].minor.yy0; yygotominor.yy96.bNot = 1;} + break; + case 209: /* expr ::= expr likeop expr */ +{ + ExprList *pList; + pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy346.pExpr); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy346.pExpr); + yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy96.eOperator); + if( yymsp[-1].minor.yy96.bNot ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0); + yygotominor.yy346.zStart = yymsp[-2].minor.yy346.zStart; + yygotominor.yy346.zEnd = yymsp[0].minor.yy346.zEnd; + if( yygotominor.yy346.pExpr ) yygotominor.yy346.pExpr->flags |= EP_InfixFunc; +} + break; + case 210: /* expr ::= expr likeop expr ESCAPE expr */ +{ + ExprList *pList; + pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy346.pExpr); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr); + yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy96.eOperator); + if( yymsp[-3].minor.yy96.bNot ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0); + yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart; + yygotominor.yy346.zEnd = yymsp[0].minor.yy346.zEnd; + if( yygotominor.yy346.pExpr ) yygotominor.yy346.pExpr->flags |= EP_InfixFunc; +} + break; + case 211: /* expr ::= expr ISNULL|NOTNULL */ +{spanUnaryPostfix(&yygotominor.yy346,pParse,yymsp[0].major,&yymsp[-1].minor.yy346,&yymsp[0].minor.yy0);} + break; + case 212: /* expr ::= expr NOT NULL */ +{spanUnaryPostfix(&yygotominor.yy346,pParse,TK_NOTNULL,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy0);} + break; + case 213: /* expr ::= expr IS expr */ +{ + spanBinaryExpr(&yygotominor.yy346,pParse,TK_IS,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy346); + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_ISNULL); +} + break; + case 214: /* expr ::= expr IS NOT expr */ +{ + spanBinaryExpr(&yygotominor.yy346,pParse,TK_ISNOT,&yymsp[-3].minor.yy346,&yymsp[0].minor.yy346); + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_NOTNULL); +} + break; + case 215: /* expr ::= NOT expr */ + case 216: /* expr ::= BITNOT expr */ yytestcase(yyruleno==216); +{spanUnaryPrefix(&yygotominor.yy346,pParse,yymsp[-1].major,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);} + break; + case 217: /* expr ::= MINUS expr */ +{spanUnaryPrefix(&yygotominor.yy346,pParse,TK_UMINUS,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);} + break; + case 218: /* expr ::= PLUS expr */ +{spanUnaryPrefix(&yygotominor.yy346,pParse,TK_UPLUS,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);} + break; + case 221: /* expr ::= expr between_op expr AND expr */ +{ + ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr); + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy346.pExpr, 0, 0); + if( yygotominor.yy346.pExpr ){ + yygotominor.yy346.pExpr->x.pList = pList; + }else{ + sqlite3ExprListDelete(pParse->db, pList); + } + if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0); + yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart; + yygotominor.yy346.zEnd = yymsp[0].minor.yy346.zEnd; +} + break; + case 224: /* expr ::= expr in_op LP exprlist RP */ +{ + if( yymsp[-1].minor.yy14==0 ){ + /* Expressions of the form + ** + ** expr1 IN () + ** expr1 NOT IN () + ** + ** simplify to constants 0 (false) and 1 (true), respectively, + ** regardless of the value of expr1. + */ + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[yymsp[-3].minor.yy328]); + sqlite3ExprDelete(pParse->db, yymsp[-4].minor.yy346.pExpr); + }else if( yymsp[-1].minor.yy14->nExpr==1 ){ + /* Expressions of the form: + ** + ** expr1 IN (?1) + ** expr1 NOT IN (?2) + ** + ** with exactly one value on the RHS can be simplified to something + ** like this: + ** + ** expr1 == ?1 + ** expr1 <> ?2 + ** + ** But, the RHS of the == or <> is marked with the EP_Generic flag + ** so that it may not contribute to the computation of comparison + ** affinity or the collating sequence to use for comparison. Otherwise, + ** the semantics would be subtly different from IN or NOT IN. + */ + Expr *pRHS = yymsp[-1].minor.yy14->a[0].pExpr; + yymsp[-1].minor.yy14->a[0].pExpr = 0; + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14); + /* pRHS cannot be NULL because a malloc error would have been detected + ** before now and control would have never reached this point */ + if( ALWAYS(pRHS) ){ + pRHS->flags &= ~EP_Collate; + pRHS->flags |= EP_Generic; + } + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, yymsp[-3].minor.yy328 ? TK_NE : TK_EQ, yymsp[-4].minor.yy346.pExpr, pRHS, 0); + }else{ + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0); + if( yygotominor.yy346.pExpr ){ + yygotominor.yy346.pExpr->x.pList = yymsp[-1].minor.yy14; + sqlite3ExprSetHeightAndFlags(pParse, yygotominor.yy346.pExpr); + }else{ + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14); + } + if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0); + } + yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart; + yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n]; + } + break; + case 225: /* expr ::= LP select RP */ +{ + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0); + if( yygotominor.yy346.pExpr ){ + yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3; + ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect|EP_Subquery); + sqlite3ExprSetHeightAndFlags(pParse, yygotominor.yy346.pExpr); + }else{ + sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3); + } + yygotominor.yy346.zStart = yymsp[-2].minor.yy0.z; + yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n]; + } + break; + case 226: /* expr ::= expr in_op LP select RP */ +{ + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0); + if( yygotominor.yy346.pExpr ){ + yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3; + ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect|EP_Subquery); + sqlite3ExprSetHeightAndFlags(pParse, yygotominor.yy346.pExpr); + }else{ + sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3); + } + if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0); + yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart; + yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n]; + } + break; + case 227: /* expr ::= expr in_op nm dbnm */ +{ + SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0); + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy346.pExpr, 0, 0); + if( yygotominor.yy346.pExpr ){ + yygotominor.yy346.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0); + ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect|EP_Subquery); + sqlite3ExprSetHeightAndFlags(pParse, yygotominor.yy346.pExpr); + }else{ + sqlite3SrcListDelete(pParse->db, pSrc); + } + if( yymsp[-2].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0); + yygotominor.yy346.zStart = yymsp[-3].minor.yy346.zStart; + yygotominor.yy346.zEnd = yymsp[0].minor.yy0.z ? &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] : &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]; + } + break; + case 228: /* expr ::= EXISTS LP select RP */ +{ + Expr *p = yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0); + if( p ){ + p->x.pSelect = yymsp[-1].minor.yy3; + ExprSetProperty(p, EP_xIsSelect|EP_Subquery); + sqlite3ExprSetHeightAndFlags(pParse, p); + }else{ + sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3); + } + yygotominor.yy346.zStart = yymsp[-3].minor.yy0.z; + yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n]; + } + break; + case 229: /* expr ::= CASE case_operand case_exprlist case_else END */ +{ + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy132, 0, 0); + if( yygotominor.yy346.pExpr ){ + yygotominor.yy346.pExpr->x.pList = yymsp[-1].minor.yy132 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy132) : yymsp[-2].minor.yy14; + sqlite3ExprSetHeightAndFlags(pParse, yygotominor.yy346.pExpr); + }else{ + sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14); + sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy132); + } + yygotominor.yy346.zStart = yymsp[-4].minor.yy0.z; + yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n]; +} + break; + case 230: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */ +{ + yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy346.pExpr); + yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr); +} + break; + case 231: /* case_exprlist ::= WHEN expr THEN expr */ +{ + yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr); + yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr); +} + break; + case 238: /* nexprlist ::= nexprlist COMMA expr */ +{yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy346.pExpr);} + break; + case 239: /* nexprlist ::= expr */ +{yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy346.pExpr);} + break; + case 240: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ +{ + sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, + sqlite3SrcListAppend(pParse->db,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy14, yymsp[-10].minor.yy328, + &yymsp[-11].minor.yy0, yymsp[0].minor.yy132, SQLITE_SO_ASC, yymsp[-8].minor.yy328); +} + break; + case 241: /* uniqueflag ::= UNIQUE */ + case 292: /* raisetype ::= ABORT */ yytestcase(yyruleno==292); +{yygotominor.yy328 = OE_Abort;} + break; + case 242: /* uniqueflag ::= */ +{yygotominor.yy328 = OE_None;} + break; + case 245: /* eidlist ::= eidlist COMMA nm collate sortorder */ +{ + yygotominor.yy14 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy328, yymsp[0].minor.yy328); +} + break; + case 246: /* eidlist ::= nm collate sortorder */ +{ + yygotominor.yy14 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy328, yymsp[0].minor.yy328); +} + break; + case 249: /* cmd ::= DROP INDEX ifexists fullname */ +{sqlite3DropIndex(pParse, yymsp[0].minor.yy65, yymsp[-1].minor.yy328);} + break; + case 250: /* cmd ::= VACUUM */ + case 251: /* cmd ::= VACUUM nm */ yytestcase(yyruleno==251); +{sqlite3Vacuum(pParse);} + break; + case 252: /* cmd ::= PRAGMA nm dbnm */ +{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);} + break; + case 253: /* cmd ::= PRAGMA nm dbnm EQ nmnum */ +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);} + break; + case 254: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */ +{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);} + break; + case 255: /* cmd ::= PRAGMA nm dbnm EQ minus_num */ +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);} + break; + case 256: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */ +{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);} + break; + case 265: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ +{ + Token all; + all.z = yymsp[-3].minor.yy0.z; + all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n; + sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy473, &all); +} + break; + case 266: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ +{ + sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy328, yymsp[-4].minor.yy378.a, yymsp[-4].minor.yy378.b, yymsp[-2].minor.yy65, yymsp[0].minor.yy132, yymsp[-10].minor.yy328, yymsp[-8].minor.yy328); + yygotominor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); +} + break; + case 267: /* trigger_time ::= BEFORE */ + case 270: /* trigger_time ::= */ yytestcase(yyruleno==270); +{ yygotominor.yy328 = TK_BEFORE; } + break; + case 268: /* trigger_time ::= AFTER */ +{ yygotominor.yy328 = TK_AFTER; } + break; + case 269: /* trigger_time ::= INSTEAD OF */ +{ yygotominor.yy328 = TK_INSTEAD;} + break; + case 271: /* trigger_event ::= DELETE|INSERT */ + case 272: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==272); +{yygotominor.yy378.a = yymsp[0].major; yygotominor.yy378.b = 0;} + break; + case 273: /* trigger_event ::= UPDATE OF idlist */ +{yygotominor.yy378.a = TK_UPDATE; yygotominor.yy378.b = yymsp[0].minor.yy408;} + break; + case 276: /* when_clause ::= */ + case 297: /* key_opt ::= */ yytestcase(yyruleno==297); +{ yygotominor.yy132 = 0; } + break; + case 277: /* when_clause ::= WHEN expr */ + case 298: /* key_opt ::= KEY expr */ yytestcase(yyruleno==298); +{ yygotominor.yy132 = yymsp[0].minor.yy346.pExpr; } + break; + case 278: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ +{ + assert( yymsp[-2].minor.yy473!=0 ); + yymsp[-2].minor.yy473->pLast->pNext = yymsp[-1].minor.yy473; + yymsp[-2].minor.yy473->pLast = yymsp[-1].minor.yy473; + yygotominor.yy473 = yymsp[-2].minor.yy473; +} + break; + case 279: /* trigger_cmd_list ::= trigger_cmd SEMI */ +{ + assert( yymsp[-1].minor.yy473!=0 ); + yymsp[-1].minor.yy473->pLast = yymsp[-1].minor.yy473; + yygotominor.yy473 = yymsp[-1].minor.yy473; +} + break; + case 281: /* trnm ::= nm DOT nm */ +{ + yygotominor.yy0 = yymsp[0].minor.yy0; + sqlite3ErrorMsg(pParse, + "qualified table names are not allowed on INSERT, UPDATE, and DELETE " + "statements within triggers"); +} + break; + case 283: /* tridxby ::= INDEXED BY nm */ +{ + sqlite3ErrorMsg(pParse, + "the INDEXED BY clause is not allowed on UPDATE or DELETE statements " + "within triggers"); +} + break; + case 284: /* tridxby ::= NOT INDEXED */ +{ + sqlite3ErrorMsg(pParse, + "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements " + "within triggers"); +} + break; + case 285: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */ +{ yygotominor.yy473 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy14, yymsp[0].minor.yy132, yymsp[-5].minor.yy186); } + break; + case 286: /* trigger_cmd ::= insert_cmd INTO trnm idlist_opt select */ +{yygotominor.yy473 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy408, yymsp[0].minor.yy3, yymsp[-4].minor.yy186);} + break; + case 287: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */ +{yygotominor.yy473 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy132);} + break; + case 288: /* trigger_cmd ::= select */ +{yygotominor.yy473 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy3); } + break; + case 289: /* expr ::= RAISE LP IGNORE RP */ +{ + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0); + if( yygotominor.yy346.pExpr ){ + yygotominor.yy346.pExpr->affinity = OE_Ignore; + } + yygotominor.yy346.zStart = yymsp[-3].minor.yy0.z; + yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n]; +} + break; + case 290: /* expr ::= RAISE LP raisetype COMMA nm RP */ +{ + yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0); + if( yygotominor.yy346.pExpr ) { + yygotominor.yy346.pExpr->affinity = (char)yymsp[-3].minor.yy328; + } + yygotominor.yy346.zStart = yymsp[-5].minor.yy0.z; + yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n]; +} + break; + case 291: /* raisetype ::= ROLLBACK */ +{yygotominor.yy328 = OE_Rollback;} + break; + case 293: /* raisetype ::= FAIL */ +{yygotominor.yy328 = OE_Fail;} + break; + case 294: /* cmd ::= DROP TRIGGER ifexists fullname */ +{ + sqlite3DropTrigger(pParse,yymsp[0].minor.yy65,yymsp[-1].minor.yy328); +} + break; + case 295: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ +{ + sqlite3Attach(pParse, yymsp[-3].minor.yy346.pExpr, yymsp[-1].minor.yy346.pExpr, yymsp[0].minor.yy132); +} + break; + case 296: /* cmd ::= DETACH database_kw_opt expr */ +{ + sqlite3Detach(pParse, yymsp[0].minor.yy346.pExpr); +} + break; + case 301: /* cmd ::= REINDEX */ +{sqlite3Reindex(pParse, 0, 0);} + break; + case 302: /* cmd ::= REINDEX nm dbnm */ +{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} + break; + case 303: /* cmd ::= ANALYZE */ +{sqlite3Analyze(pParse, 0, 0);} + break; + case 304: /* cmd ::= ANALYZE nm dbnm */ +{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} + break; + case 305: /* cmd ::= ALTER TABLE fullname RENAME TO nm */ +{ + sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy65,&yymsp[0].minor.yy0); +} + break; + case 306: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */ +{ + sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy0); +} + break; + case 307: /* add_column_fullname ::= fullname */ +{ + pParse->db->lookaside.bEnabled = 0; + sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy65); +} + break; + case 310: /* cmd ::= create_vtab */ +{sqlite3VtabFinishParse(pParse,0);} + break; + case 311: /* cmd ::= create_vtab LP vtabarglist RP */ +{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);} + break; + case 312: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ +{ + sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy328); +} + break; + case 315: /* vtabarg ::= */ +{sqlite3VtabArgInit(pParse);} + break; + case 317: /* vtabargtoken ::= ANY */ + case 318: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==318); + case 319: /* lp ::= LP */ yytestcase(yyruleno==319); +{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);} + break; + case 323: /* with ::= */ +{yygotominor.yy59 = 0;} + break; + case 324: /* with ::= WITH wqlist */ + case 325: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==325); +{ yygotominor.yy59 = yymsp[0].minor.yy59; } + break; + case 326: /* wqlist ::= nm eidlist_opt AS LP select RP */ +{ + yygotominor.yy59 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy3); +} + break; + case 327: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */ +{ + yygotominor.yy59 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy59, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy3); +} + break; + default: + /* (0) input ::= cmdlist */ yytestcase(yyruleno==0); + /* (1) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==1); + /* (2) cmdlist ::= ecmd */ yytestcase(yyruleno==2); + /* (3) ecmd ::= SEMI */ yytestcase(yyruleno==3); + /* (4) ecmd ::= explain cmdx SEMI */ yytestcase(yyruleno==4); + /* (10) trans_opt ::= */ yytestcase(yyruleno==10); + /* (11) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==11); + /* (12) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==12); + /* (20) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==20); + /* (21) savepoint_opt ::= */ yytestcase(yyruleno==21); + /* (25) cmd ::= create_table create_table_args */ yytestcase(yyruleno==25); + /* (36) columnlist ::= columnlist COMMA column */ yytestcase(yyruleno==36); + /* (37) columnlist ::= column */ yytestcase(yyruleno==37); + /* (43) type ::= */ yytestcase(yyruleno==43); + /* (50) signed ::= plus_num */ yytestcase(yyruleno==50); + /* (51) signed ::= minus_num */ yytestcase(yyruleno==51); + /* (52) carglist ::= carglist ccons */ yytestcase(yyruleno==52); + /* (53) carglist ::= */ yytestcase(yyruleno==53); + /* (60) ccons ::= NULL onconf */ yytestcase(yyruleno==60); + /* (88) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==88); + /* (89) conslist ::= tcons */ yytestcase(yyruleno==89); + /* (91) tconscomma ::= */ yytestcase(yyruleno==91); + /* (274) foreach_clause ::= */ yytestcase(yyruleno==274); + /* (275) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==275); + /* (282) tridxby ::= */ yytestcase(yyruleno==282); + /* (299) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==299); + /* (300) database_kw_opt ::= */ yytestcase(yyruleno==300); + /* (308) kwcolumn_opt ::= */ yytestcase(yyruleno==308); + /* (309) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==309); + /* (313) vtabarglist ::= vtabarg */ yytestcase(yyruleno==313); + /* (314) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==314); + /* (316) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==316); + /* (320) anylist ::= */ yytestcase(yyruleno==320); + /* (321) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==321); + /* (322) anylist ::= anylist ANY */ yytestcase(yyruleno==322); + break; + }; + assert( yyruleno>=0 && yyrulenoyyidx -= yysize; + yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto); + if( yyact <= YY_MAX_SHIFTREDUCE ){ + if( yyact>YY_MAX_SHIFT ) yyact += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE; + /* If the reduce action popped at least + ** one element off the stack, then we can push the new element back + ** onto the stack here, and skip the stack overflow test in yy_shift(). + ** That gives a significant speed improvement. */ + if( yysize ){ + yypParser->yyidx++; + yymsp -= yysize-1; + yymsp->stateno = (YYACTIONTYPE)yyact; + yymsp->major = (YYCODETYPE)yygoto; + yymsp->minor = yygotominor; + yyTraceShift(yypParser, yyact); + }else{ + yy_shift(yypParser,yyact,yygoto,&yygotominor); + } + }else{ + assert( yyact == YY_ACCEPT_ACTION ); + yy_accept(yypParser); + } +} + +/* +** The following code executes when the parse fails +*/ +#ifndef YYNOERRORRECOVERY +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + sqlite3ParserARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} +#endif /* YYNOERRORRECOVERY */ + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + YYMINORTYPE yyminor /* The minor type of the error token */ +){ + sqlite3ParserARG_FETCH; +#define TOKEN (yyminor.yy0) + + UNUSED_PARAMETER(yymajor); /* Silence some compiler warnings */ + assert( TOKEN.z[0] ); /* The tokenizer always gives us a token */ + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + sqlite3ParserARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "sqlite3ParserAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +**
      +**
    • A pointer to the parser (an opaque structure.) +**
    • The major token number. +**
    • The minor token number. +**
    • An option argument of a grammar-specified type. +**
    +** +** Outputs: +** None. +*/ +SQLITE_PRIVATE void sqlite3Parser( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + sqlite3ParserTOKENTYPE yyminor /* The value for the token */ + sqlite3ParserARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + int yyact; /* The parser action. */ +#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) + int yyendofinput; /* True if we are at the end of input */ +#endif +#ifdef YYERRORSYMBOL + int yyerrorhit = 0; /* True if yymajor has invoked an error */ +#endif + yyParser *yypParser; /* The parser */ + + /* (re)initialize the parser, if necessary */ + yypParser = (yyParser*)yyp; + if( yypParser->yyidx<0 ){ +#if YYSTACKDEPTH<=0 + if( yypParser->yystksz <=0 ){ + /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/ + yyminorunion = yyzerominor; + yyStackOverflow(yypParser, &yyminorunion); + return; + } +#endif + yypParser->yyidx = 0; + yypParser->yyerrcnt = -1; + yypParser->yystack[0].stateno = 0; + yypParser->yystack[0].major = 0; + } + yyminorunion.yy0 = yyminor; +#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) + yyendofinput = (yymajor==0); +#endif + sqlite3ParserARG_STORE; + +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]); + } +#endif + + do{ + yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor); + if( yyact <= YY_MAX_SHIFTREDUCE ){ + if( yyact > YY_MAX_SHIFT ) yyact += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE; + yy_shift(yypParser,yyact,yymajor,&yyminorunion); + yypParser->yyerrcnt--; + yymajor = YYNOCODE; + }else if( yyact <= YY_MAX_REDUCE ){ + yy_reduce(yypParser,yyact-YY_MIN_REDUCE); + }else{ + assert( yyact == YY_ERROR_ACTION ); +#ifdef YYERRORSYMBOL + int yymx; +#endif +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yymx = yypParser->yystack[yypParser->yyidx].major; + if( yymx==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion); + yymajor = YYNOCODE; + }else{ + while( + yypParser->yyidx >= 0 && + yymx != YYERRORSYMBOL && + (yyact = yy_find_reduce_action( + yypParser->yystack[yypParser->yyidx].stateno, + YYERRORSYMBOL)) >= YY_MIN_REDUCE + ){ + yy_pop_parser_stack(yypParser); + } + if( yypParser->yyidx < 0 || yymajor==0 ){ + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + yy_parse_failed(yypParser); + yymajor = YYNOCODE; + }else if( yymx!=YYERRORSYMBOL ){ + YYMINORTYPE u2; + u2.YYERRSYMDT = 0; + yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; +#elif defined(YYNOERRORRECOVERY) + /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to + ** do any kind of error recovery. Instead, simply invoke the syntax + ** error routine and continue going as if nothing had happened. + ** + ** Applications can set this macro (for example inside %include) if + ** they intend to abandon the parse upon the first syntax error seen. + */ + yy_syntax_error(yypParser,yymajor,yyminorunion); + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + yymajor = YYNOCODE; + +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yypParser->yyerrcnt = 3; + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); + } + yymajor = YYNOCODE; +#endif + } + }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 ); +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sReturn\n",yyTracePrompt); + } +#endif + return; +} + +/************** End of parse.c ***********************************************/ +/************** Begin file tokenize.c ****************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** An tokenizer for SQL +** +** This file contains C code that splits an SQL input string up into +** individual tokens and sends those tokens one-by-one over to the +** parser for analysis. +*/ +/* #include "sqliteInt.h" */ +/* #include */ + +/* +** The charMap() macro maps alphabetic characters into their +** lower-case ASCII equivalent. On ASCII machines, this is just +** an upper-to-lower case map. On EBCDIC machines we also need +** to adjust the encoding. Only alphabetic characters and underscores +** need to be translated. +*/ +#ifdef SQLITE_ASCII +# define charMap(X) sqlite3UpperToLower[(unsigned char)X] +#endif +#ifdef SQLITE_EBCDIC +# define charMap(X) ebcdicToAscii[(unsigned char)X] +const unsigned char ebcdicToAscii[] = { +/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 0, /* 6x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */ + 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* 8x */ + 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* 9x */ + 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ax */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */ + 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* Cx */ + 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* Dx */ + 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ex */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Fx */ +}; +#endif + +/* +** The sqlite3KeywordCode function looks up an identifier to determine if +** it is a keyword. If it is a keyword, the token code of that keyword is +** returned. If the input is not a keyword, TK_ID is returned. +** +** The implementation of this routine was generated by a program, +** mkkeywordhash.h, located in the tool subdirectory of the distribution. +** The output of the mkkeywordhash.c program is written into a file +** named keywordhash.h and then included into this source file by +** the #include below. +*/ +/************** Include keywordhash.h in the middle of tokenize.c ************/ +/************** Begin file keywordhash.h *************************************/ +/***** This file contains automatically generated code ****** +** +** The code in this file has been automatically generated by +** +** sqlite/tool/mkkeywordhash.c +** +** The code in this file implements a function that determines whether +** or not a given identifier is really an SQL keyword. The same thing +** might be implemented more directly using a hand-written hash table. +** But by using this automatically generated code, the size of the code +** is substantially reduced. This is important for embedded applications +** on platforms with limited memory. +*/ +/* Hash score: 182 */ +static int keywordCode(const char *z, int n){ + /* zText[] encodes 834 bytes of keywords in 554 bytes */ + /* REINDEXEDESCAPEACHECKEYBEFOREIGNOREGEXPLAINSTEADDATABASELECT */ + /* ABLEFTHENDEFERRABLELSEXCEPTRANSACTIONATURALTERAISEXCLUSIVE */ + /* XISTSAVEPOINTERSECTRIGGEREFERENCESCONSTRAINTOFFSETEMPORARY */ + /* UNIQUERYWITHOUTERELEASEATTACHAVINGROUPDATEBEGINNERECURSIVE */ + /* BETWEENOTNULLIKECASCADELETECASECOLLATECREATECURRENT_DATEDETACH */ + /* IMMEDIATEJOINSERTMATCHPLANALYZEPRAGMABORTVALUESVIRTUALIMITWHEN */ + /* WHERENAMEAFTEREPLACEANDEFAULTAUTOINCREMENTCASTCOLUMNCOMMIT */ + /* CONFLICTCROSSCURRENT_TIMESTAMPRIMARYDEFERREDISTINCTDROPFAIL */ + /* FROMFULLGLOBYIFISNULLORDERESTRICTRIGHTROLLBACKROWUNIONUSING */ + /* VACUUMVIEWINITIALLY */ + static const char zText[553] = { + 'R','E','I','N','D','E','X','E','D','E','S','C','A','P','E','A','C','H', + 'E','C','K','E','Y','B','E','F','O','R','E','I','G','N','O','R','E','G', + 'E','X','P','L','A','I','N','S','T','E','A','D','D','A','T','A','B','A', + 'S','E','L','E','C','T','A','B','L','E','F','T','H','E','N','D','E','F', + 'E','R','R','A','B','L','E','L','S','E','X','C','E','P','T','R','A','N', + 'S','A','C','T','I','O','N','A','T','U','R','A','L','T','E','R','A','I', + 'S','E','X','C','L','U','S','I','V','E','X','I','S','T','S','A','V','E', + 'P','O','I','N','T','E','R','S','E','C','T','R','I','G','G','E','R','E', + 'F','E','R','E','N','C','E','S','C','O','N','S','T','R','A','I','N','T', + 'O','F','F','S','E','T','E','M','P','O','R','A','R','Y','U','N','I','Q', + 'U','E','R','Y','W','I','T','H','O','U','T','E','R','E','L','E','A','S', + 'E','A','T','T','A','C','H','A','V','I','N','G','R','O','U','P','D','A', + 'T','E','B','E','G','I','N','N','E','R','E','C','U','R','S','I','V','E', + 'B','E','T','W','E','E','N','O','T','N','U','L','L','I','K','E','C','A', + 'S','C','A','D','E','L','E','T','E','C','A','S','E','C','O','L','L','A', + 'T','E','C','R','E','A','T','E','C','U','R','R','E','N','T','_','D','A', + 'T','E','D','E','T','A','C','H','I','M','M','E','D','I','A','T','E','J', + 'O','I','N','S','E','R','T','M','A','T','C','H','P','L','A','N','A','L', + 'Y','Z','E','P','R','A','G','M','A','B','O','R','T','V','A','L','U','E', + 'S','V','I','R','T','U','A','L','I','M','I','T','W','H','E','N','W','H', + 'E','R','E','N','A','M','E','A','F','T','E','R','E','P','L','A','C','E', + 'A','N','D','E','F','A','U','L','T','A','U','T','O','I','N','C','R','E', + 'M','E','N','T','C','A','S','T','C','O','L','U','M','N','C','O','M','M', + 'I','T','C','O','N','F','L','I','C','T','C','R','O','S','S','C','U','R', + 'R','E','N','T','_','T','I','M','E','S','T','A','M','P','R','I','M','A', + 'R','Y','D','E','F','E','R','R','E','D','I','S','T','I','N','C','T','D', + 'R','O','P','F','A','I','L','F','R','O','M','F','U','L','L','G','L','O', + 'B','Y','I','F','I','S','N','U','L','L','O','R','D','E','R','E','S','T', + 'R','I','C','T','R','I','G','H','T','R','O','L','L','B','A','C','K','R', + 'O','W','U','N','I','O','N','U','S','I','N','G','V','A','C','U','U','M', + 'V','I','E','W','I','N','I','T','I','A','L','L','Y', + }; + static const unsigned char aHash[127] = { + 76, 105, 117, 74, 0, 45, 0, 0, 82, 0, 77, 0, 0, + 42, 12, 78, 15, 0, 116, 85, 54, 112, 0, 19, 0, 0, + 121, 0, 119, 115, 0, 22, 93, 0, 9, 0, 0, 70, 71, + 0, 69, 6, 0, 48, 90, 102, 0, 118, 101, 0, 0, 44, + 0, 103, 24, 0, 17, 0, 122, 53, 23, 0, 5, 110, 25, + 96, 0, 0, 124, 106, 60, 123, 57, 28, 55, 0, 91, 0, + 100, 26, 0, 99, 0, 0, 0, 95, 92, 97, 88, 109, 14, + 39, 108, 0, 81, 0, 18, 89, 111, 32, 0, 120, 80, 113, + 62, 46, 84, 0, 0, 94, 40, 59, 114, 0, 36, 0, 0, + 29, 0, 86, 63, 64, 0, 20, 61, 0, 56, + }; + static const unsigned char aNext[124] = { + 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, + 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 33, 0, 21, 0, 0, 0, 0, 0, 50, + 0, 43, 3, 47, 0, 0, 0, 0, 30, 0, 58, 0, 38, + 0, 0, 0, 1, 66, 0, 0, 67, 0, 41, 0, 0, 0, + 0, 0, 0, 49, 65, 0, 0, 0, 0, 31, 52, 16, 34, + 10, 0, 0, 0, 0, 0, 0, 0, 11, 72, 79, 0, 8, + 0, 104, 98, 0, 107, 0, 87, 0, 75, 51, 0, 27, 37, + 73, 83, 0, 35, 68, 0, 0, + }; + static const unsigned char aLen[124] = { + 7, 7, 5, 4, 6, 4, 5, 3, 6, 7, 3, 6, 6, + 7, 7, 3, 8, 2, 6, 5, 4, 4, 3, 10, 4, 6, + 11, 6, 2, 7, 5, 5, 9, 6, 9, 9, 7, 10, 10, + 4, 6, 2, 3, 9, 4, 2, 6, 5, 7, 4, 5, 7, + 6, 6, 5, 6, 5, 5, 9, 7, 7, 3, 2, 4, 4, + 7, 3, 6, 4, 7, 6, 12, 6, 9, 4, 6, 5, 4, + 7, 6, 5, 6, 7, 5, 4, 5, 6, 5, 7, 3, 7, + 13, 2, 2, 4, 6, 6, 8, 5, 17, 12, 7, 8, 8, + 2, 4, 4, 4, 4, 4, 2, 2, 6, 5, 8, 5, 8, + 3, 5, 5, 6, 4, 9, 3, + }; + static const unsigned short int aOffset[124] = { + 0, 2, 2, 8, 9, 14, 16, 20, 23, 25, 25, 29, 33, + 36, 41, 46, 48, 53, 54, 59, 62, 65, 67, 69, 78, 81, + 86, 91, 95, 96, 101, 105, 109, 117, 122, 128, 136, 142, 152, + 159, 162, 162, 165, 167, 167, 171, 176, 179, 184, 184, 188, 192, + 199, 204, 209, 212, 218, 221, 225, 234, 240, 240, 240, 243, 246, + 250, 251, 255, 261, 265, 272, 278, 290, 296, 305, 307, 313, 318, + 320, 327, 332, 337, 343, 349, 354, 358, 361, 367, 371, 378, 380, + 387, 389, 391, 400, 404, 410, 416, 424, 429, 429, 445, 452, 459, + 460, 467, 471, 475, 479, 483, 486, 488, 490, 496, 500, 508, 513, + 521, 524, 529, 534, 540, 544, 549, + }; + static const unsigned char aCode[124] = { + TK_REINDEX, TK_INDEXED, TK_INDEX, TK_DESC, TK_ESCAPE, + TK_EACH, TK_CHECK, TK_KEY, TK_BEFORE, TK_FOREIGN, + TK_FOR, TK_IGNORE, TK_LIKE_KW, TK_EXPLAIN, TK_INSTEAD, + TK_ADD, TK_DATABASE, TK_AS, TK_SELECT, TK_TABLE, + TK_JOIN_KW, TK_THEN, TK_END, TK_DEFERRABLE, TK_ELSE, + TK_EXCEPT, TK_TRANSACTION,TK_ACTION, TK_ON, TK_JOIN_KW, + TK_ALTER, TK_RAISE, TK_EXCLUSIVE, TK_EXISTS, TK_SAVEPOINT, + TK_INTERSECT, TK_TRIGGER, TK_REFERENCES, TK_CONSTRAINT, TK_INTO, + TK_OFFSET, TK_OF, TK_SET, TK_TEMP, TK_TEMP, + TK_OR, TK_UNIQUE, TK_QUERY, TK_WITHOUT, TK_WITH, + TK_JOIN_KW, TK_RELEASE, TK_ATTACH, TK_HAVING, TK_GROUP, + TK_UPDATE, TK_BEGIN, TK_JOIN_KW, TK_RECURSIVE, TK_BETWEEN, + TK_NOTNULL, TK_NOT, TK_NO, TK_NULL, TK_LIKE_KW, + TK_CASCADE, TK_ASC, TK_DELETE, TK_CASE, TK_COLLATE, + TK_CREATE, TK_CTIME_KW, TK_DETACH, TK_IMMEDIATE, TK_JOIN, + TK_INSERT, TK_MATCH, TK_PLAN, TK_ANALYZE, TK_PRAGMA, + TK_ABORT, TK_VALUES, TK_VIRTUAL, TK_LIMIT, TK_WHEN, + TK_WHERE, TK_RENAME, TK_AFTER, TK_REPLACE, TK_AND, + TK_DEFAULT, TK_AUTOINCR, TK_TO, TK_IN, TK_CAST, + TK_COLUMNKW, TK_COMMIT, TK_CONFLICT, TK_JOIN_KW, TK_CTIME_KW, + TK_CTIME_KW, TK_PRIMARY, TK_DEFERRED, TK_DISTINCT, TK_IS, + TK_DROP, TK_FAIL, TK_FROM, TK_JOIN_KW, TK_LIKE_KW, + TK_BY, TK_IF, TK_ISNULL, TK_ORDER, TK_RESTRICT, + TK_JOIN_KW, TK_ROLLBACK, TK_ROW, TK_UNION, TK_USING, + TK_VACUUM, TK_VIEW, TK_INITIALLY, TK_ALL, + }; + int h, i; + if( n<2 ) return TK_ID; + h = ((charMap(z[0])*4) ^ + (charMap(z[n-1])*3) ^ + n) % 127; + for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){ + if( aLen[i]==n && sqlite3StrNICmp(&zText[aOffset[i]],z,n)==0 ){ + testcase( i==0 ); /* REINDEX */ + testcase( i==1 ); /* INDEXED */ + testcase( i==2 ); /* INDEX */ + testcase( i==3 ); /* DESC */ + testcase( i==4 ); /* ESCAPE */ + testcase( i==5 ); /* EACH */ + testcase( i==6 ); /* CHECK */ + testcase( i==7 ); /* KEY */ + testcase( i==8 ); /* BEFORE */ + testcase( i==9 ); /* FOREIGN */ + testcase( i==10 ); /* FOR */ + testcase( i==11 ); /* IGNORE */ + testcase( i==12 ); /* REGEXP */ + testcase( i==13 ); /* EXPLAIN */ + testcase( i==14 ); /* INSTEAD */ + testcase( i==15 ); /* ADD */ + testcase( i==16 ); /* DATABASE */ + testcase( i==17 ); /* AS */ + testcase( i==18 ); /* SELECT */ + testcase( i==19 ); /* TABLE */ + testcase( i==20 ); /* LEFT */ + testcase( i==21 ); /* THEN */ + testcase( i==22 ); /* END */ + testcase( i==23 ); /* DEFERRABLE */ + testcase( i==24 ); /* ELSE */ + testcase( i==25 ); /* EXCEPT */ + testcase( i==26 ); /* TRANSACTION */ + testcase( i==27 ); /* ACTION */ + testcase( i==28 ); /* ON */ + testcase( i==29 ); /* NATURAL */ + testcase( i==30 ); /* ALTER */ + testcase( i==31 ); /* RAISE */ + testcase( i==32 ); /* EXCLUSIVE */ + testcase( i==33 ); /* EXISTS */ + testcase( i==34 ); /* SAVEPOINT */ + testcase( i==35 ); /* INTERSECT */ + testcase( i==36 ); /* TRIGGER */ + testcase( i==37 ); /* REFERENCES */ + testcase( i==38 ); /* CONSTRAINT */ + testcase( i==39 ); /* INTO */ + testcase( i==40 ); /* OFFSET */ + testcase( i==41 ); /* OF */ + testcase( i==42 ); /* SET */ + testcase( i==43 ); /* TEMPORARY */ + testcase( i==44 ); /* TEMP */ + testcase( i==45 ); /* OR */ + testcase( i==46 ); /* UNIQUE */ + testcase( i==47 ); /* QUERY */ + testcase( i==48 ); /* WITHOUT */ + testcase( i==49 ); /* WITH */ + testcase( i==50 ); /* OUTER */ + testcase( i==51 ); /* RELEASE */ + testcase( i==52 ); /* ATTACH */ + testcase( i==53 ); /* HAVING */ + testcase( i==54 ); /* GROUP */ + testcase( i==55 ); /* UPDATE */ + testcase( i==56 ); /* BEGIN */ + testcase( i==57 ); /* INNER */ + testcase( i==58 ); /* RECURSIVE */ + testcase( i==59 ); /* BETWEEN */ + testcase( i==60 ); /* NOTNULL */ + testcase( i==61 ); /* NOT */ + testcase( i==62 ); /* NO */ + testcase( i==63 ); /* NULL */ + testcase( i==64 ); /* LIKE */ + testcase( i==65 ); /* CASCADE */ + testcase( i==66 ); /* ASC */ + testcase( i==67 ); /* DELETE */ + testcase( i==68 ); /* CASE */ + testcase( i==69 ); /* COLLATE */ + testcase( i==70 ); /* CREATE */ + testcase( i==71 ); /* CURRENT_DATE */ + testcase( i==72 ); /* DETACH */ + testcase( i==73 ); /* IMMEDIATE */ + testcase( i==74 ); /* JOIN */ + testcase( i==75 ); /* INSERT */ + testcase( i==76 ); /* MATCH */ + testcase( i==77 ); /* PLAN */ + testcase( i==78 ); /* ANALYZE */ + testcase( i==79 ); /* PRAGMA */ + testcase( i==80 ); /* ABORT */ + testcase( i==81 ); /* VALUES */ + testcase( i==82 ); /* VIRTUAL */ + testcase( i==83 ); /* LIMIT */ + testcase( i==84 ); /* WHEN */ + testcase( i==85 ); /* WHERE */ + testcase( i==86 ); /* RENAME */ + testcase( i==87 ); /* AFTER */ + testcase( i==88 ); /* REPLACE */ + testcase( i==89 ); /* AND */ + testcase( i==90 ); /* DEFAULT */ + testcase( i==91 ); /* AUTOINCREMENT */ + testcase( i==92 ); /* TO */ + testcase( i==93 ); /* IN */ + testcase( i==94 ); /* CAST */ + testcase( i==95 ); /* COLUMN */ + testcase( i==96 ); /* COMMIT */ + testcase( i==97 ); /* CONFLICT */ + testcase( i==98 ); /* CROSS */ + testcase( i==99 ); /* CURRENT_TIMESTAMP */ + testcase( i==100 ); /* CURRENT_TIME */ + testcase( i==101 ); /* PRIMARY */ + testcase( i==102 ); /* DEFERRED */ + testcase( i==103 ); /* DISTINCT */ + testcase( i==104 ); /* IS */ + testcase( i==105 ); /* DROP */ + testcase( i==106 ); /* FAIL */ + testcase( i==107 ); /* FROM */ + testcase( i==108 ); /* FULL */ + testcase( i==109 ); /* GLOB */ + testcase( i==110 ); /* BY */ + testcase( i==111 ); /* IF */ + testcase( i==112 ); /* ISNULL */ + testcase( i==113 ); /* ORDER */ + testcase( i==114 ); /* RESTRICT */ + testcase( i==115 ); /* RIGHT */ + testcase( i==116 ); /* ROLLBACK */ + testcase( i==117 ); /* ROW */ + testcase( i==118 ); /* UNION */ + testcase( i==119 ); /* USING */ + testcase( i==120 ); /* VACUUM */ + testcase( i==121 ); /* VIEW */ + testcase( i==122 ); /* INITIALLY */ + testcase( i==123 ); /* ALL */ + return aCode[i]; + } + } + return TK_ID; +} +SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){ + return keywordCode((char*)z, n); +} +#define SQLITE_N_KEYWORD 124 + +/************** End of keywordhash.h *****************************************/ +/************** Continuing where we left off in tokenize.c *******************/ + + +/* +** If X is a character that can be used in an identifier then +** IdChar(X) will be true. Otherwise it is false. +** +** For ASCII, any character with the high-order bit set is +** allowed in an identifier. For 7-bit characters, +** sqlite3IsIdChar[X] must be 1. +** +** For EBCDIC, the rules are more complex but have the same +** end result. +** +** Ticket #1066. the SQL standard does not allow '$' in the +** middle of identifiers. But many SQL implementations do. +** SQLite will allow '$' in identifiers for compatibility. +** But the feature is undocumented. +*/ +#ifdef SQLITE_ASCII +#define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0) +#endif +#ifdef SQLITE_EBCDIC +SQLITE_PRIVATE const char sqlite3IsEbcdicIdChar[] = { +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 4x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, /* 5x */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, /* 6x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, /* 7x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, /* 8x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, /* 9x */ + 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, /* Ax */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Cx */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Dx */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Ex */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, /* Fx */ +}; +#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40])) +#endif + +/* Make the IdChar function accessible from ctime.c */ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +SQLITE_PRIVATE int sqlite3IsIdChar(u8 c){ return IdChar(c); } +#endif + + +/* +** Return the length of the token that begins at z[0]. +** Store the token type in *tokenType before returning. +*/ +SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){ + int i, c; + switch( *z ){ + case ' ': case '\t': case '\n': case '\f': case '\r': { + testcase( z[0]==' ' ); + testcase( z[0]=='\t' ); + testcase( z[0]=='\n' ); + testcase( z[0]=='\f' ); + testcase( z[0]=='\r' ); + for(i=1; sqlite3Isspace(z[i]); i++){} + *tokenType = TK_SPACE; + return i; + } + case '-': { + if( z[1]=='-' ){ + for(i=2; (c=z[i])!=0 && c!='\n'; i++){} + *tokenType = TK_SPACE; /* IMP: R-22934-25134 */ + return i; + } + *tokenType = TK_MINUS; + return 1; + } + case '(': { + *tokenType = TK_LP; + return 1; + } + case ')': { + *tokenType = TK_RP; + return 1; + } + case ';': { + *tokenType = TK_SEMI; + return 1; + } + case '+': { + *tokenType = TK_PLUS; + return 1; + } + case '*': { + *tokenType = TK_STAR; + return 1; + } + case '/': { + if( z[1]!='*' || z[2]==0 ){ + *tokenType = TK_SLASH; + return 1; + } + for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){} + if( c ) i++; + *tokenType = TK_SPACE; /* IMP: R-22934-25134 */ + return i; + } + case '%': { + *tokenType = TK_REM; + return 1; + } + case '=': { + *tokenType = TK_EQ; + return 1 + (z[1]=='='); + } + case '<': { + if( (c=z[1])=='=' ){ + *tokenType = TK_LE; + return 2; + }else if( c=='>' ){ + *tokenType = TK_NE; + return 2; + }else if( c=='<' ){ + *tokenType = TK_LSHIFT; + return 2; + }else{ + *tokenType = TK_LT; + return 1; + } + } + case '>': { + if( (c=z[1])=='=' ){ + *tokenType = TK_GE; + return 2; + }else if( c=='>' ){ + *tokenType = TK_RSHIFT; + return 2; + }else{ + *tokenType = TK_GT; + return 1; + } + } + case '!': { + if( z[1]!='=' ){ + *tokenType = TK_ILLEGAL; + return 2; + }else{ + *tokenType = TK_NE; + return 2; + } + } + case '|': { + if( z[1]!='|' ){ + *tokenType = TK_BITOR; + return 1; + }else{ + *tokenType = TK_CONCAT; + return 2; + } + } + case ',': { + *tokenType = TK_COMMA; + return 1; + } + case '&': { + *tokenType = TK_BITAND; + return 1; + } + case '~': { + *tokenType = TK_BITNOT; + return 1; + } + case '`': + case '\'': + case '"': { + int delim = z[0]; + testcase( delim=='`' ); + testcase( delim=='\'' ); + testcase( delim=='"' ); + for(i=1; (c=z[i])!=0; i++){ + if( c==delim ){ + if( z[i+1]==delim ){ + i++; + }else{ + break; + } + } + } + if( c=='\'' ){ + *tokenType = TK_STRING; + return i+1; + }else if( c!=0 ){ + *tokenType = TK_ID; + return i+1; + }else{ + *tokenType = TK_ILLEGAL; + return i; + } + } + case '.': { +#ifndef SQLITE_OMIT_FLOATING_POINT + if( !sqlite3Isdigit(z[1]) ) +#endif + { + *tokenType = TK_DOT; + return 1; + } + /* If the next character is a digit, this is a floating point + ** number that begins with ".". Fall thru into the next case */ + } + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': { + testcase( z[0]=='0' ); testcase( z[0]=='1' ); testcase( z[0]=='2' ); + testcase( z[0]=='3' ); testcase( z[0]=='4' ); testcase( z[0]=='5' ); + testcase( z[0]=='6' ); testcase( z[0]=='7' ); testcase( z[0]=='8' ); + testcase( z[0]=='9' ); + *tokenType = TK_INTEGER; +#ifndef SQLITE_OMIT_HEX_INTEGER + if( z[0]=='0' && (z[1]=='x' || z[1]=='X') && sqlite3Isxdigit(z[2]) ){ + for(i=3; sqlite3Isxdigit(z[i]); i++){} + return i; + } +#endif + for(i=0; sqlite3Isdigit(z[i]); i++){} +#ifndef SQLITE_OMIT_FLOATING_POINT + if( z[i]=='.' ){ + i++; + while( sqlite3Isdigit(z[i]) ){ i++; } + *tokenType = TK_FLOAT; + } + if( (z[i]=='e' || z[i]=='E') && + ( sqlite3Isdigit(z[i+1]) + || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2])) + ) + ){ + i += 2; + while( sqlite3Isdigit(z[i]) ){ i++; } + *tokenType = TK_FLOAT; + } +#endif + while( IdChar(z[i]) ){ + *tokenType = TK_ILLEGAL; + i++; + } + return i; + } + case '[': { + for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){} + *tokenType = c==']' ? TK_ID : TK_ILLEGAL; + return i; + } + case '?': { + *tokenType = TK_VARIABLE; + for(i=1; sqlite3Isdigit(z[i]); i++){} + return i; + } +#ifndef SQLITE_OMIT_TCL_VARIABLE + case '$': +#endif + case '@': /* For compatibility with MS SQL Server */ + case '#': + case ':': { + int n = 0; + testcase( z[0]=='$' ); testcase( z[0]=='@' ); + testcase( z[0]==':' ); testcase( z[0]=='#' ); + *tokenType = TK_VARIABLE; + for(i=1; (c=z[i])!=0; i++){ + if( IdChar(c) ){ + n++; +#ifndef SQLITE_OMIT_TCL_VARIABLE + }else if( c=='(' && n>0 ){ + do{ + i++; + }while( (c=z[i])!=0 && !sqlite3Isspace(c) && c!=')' ); + if( c==')' ){ + i++; + }else{ + *tokenType = TK_ILLEGAL; + } + break; + }else if( c==':' && z[i+1]==':' ){ + i++; +#endif + }else{ + break; + } + } + if( n==0 ) *tokenType = TK_ILLEGAL; + return i; + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + case 'x': case 'X': { + testcase( z[0]=='x' ); testcase( z[0]=='X' ); + if( z[1]=='\'' ){ + *tokenType = TK_BLOB; + for(i=2; sqlite3Isxdigit(z[i]); i++){} + if( z[i]!='\'' || i%2 ){ + *tokenType = TK_ILLEGAL; + while( z[i] && z[i]!='\'' ){ i++; } + } + if( z[i] ) i++; + return i; + } + /* Otherwise fall through to the next case */ + } +#endif + default: { + if( !IdChar(*z) ){ + break; + } + for(i=1; IdChar(z[i]); i++){} + *tokenType = keywordCode((char*)z, i); + return i; + } + } + *tokenType = TK_ILLEGAL; + return 1; +} + +/* +** Run the parser on the given SQL string. The parser structure is +** passed in. An SQLITE_ status code is returned. If an error occurs +** then an and attempt is made to write an error message into +** memory obtained from sqlite3_malloc() and to make *pzErrMsg point to that +** error message. +*/ +SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){ + int nErr = 0; /* Number of errors encountered */ + int i; /* Loop counter */ + void *pEngine; /* The LEMON-generated LALR(1) parser */ + int tokenType; /* type of the next token */ + int lastTokenParsed = -1; /* type of the previous token */ + u8 enableLookaside; /* Saved value of db->lookaside.bEnabled */ + sqlite3 *db = pParse->db; /* The database connection */ + int mxSqlLen; /* Max length of an SQL string */ + + assert( zSql!=0 ); + mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; + if( db->nVdbeActive==0 ){ + db->u1.isInterrupted = 0; + } + pParse->rc = SQLITE_OK; + pParse->zTail = zSql; + i = 0; + assert( pzErrMsg!=0 ); + /* sqlite3ParserTrace(stdout, "parser: "); */ + pEngine = sqlite3ParserAlloc(sqlite3Malloc); + if( pEngine==0 ){ + db->mallocFailed = 1; + return SQLITE_NOMEM; + } + assert( pParse->pNewTable==0 ); + assert( pParse->pNewTrigger==0 ); + assert( pParse->nVar==0 ); + assert( pParse->nzVar==0 ); + assert( pParse->azVar==0 ); + enableLookaside = db->lookaside.bEnabled; + if( db->lookaside.pStart ) db->lookaside.bEnabled = 1; + while( !db->mallocFailed && zSql[i]!=0 ){ + assert( i>=0 ); + pParse->sLastToken.z = &zSql[i]; + pParse->sLastToken.n = sqlite3GetToken((unsigned char*)&zSql[i],&tokenType); + i += pParse->sLastToken.n; + if( i>mxSqlLen ){ + pParse->rc = SQLITE_TOOBIG; + break; + } + switch( tokenType ){ + case TK_SPACE: { + if( db->u1.isInterrupted ){ + sqlite3ErrorMsg(pParse, "interrupt"); + pParse->rc = SQLITE_INTERRUPT; + goto abort_parse; + } + break; + } + case TK_ILLEGAL: { + sqlite3ErrorMsg(pParse, "unrecognized token: \"%T\"", + &pParse->sLastToken); + goto abort_parse; + } + case TK_SEMI: { + pParse->zTail = &zSql[i]; + /* Fall thru into the default case */ + } + default: { + sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse); + lastTokenParsed = tokenType; + if( pParse->rc!=SQLITE_OK ){ + goto abort_parse; + } + break; + } + } + } +abort_parse: + assert( nErr==0 ); + if( pParse->rc==SQLITE_OK && db->mallocFailed==0 ){ + assert( zSql[i]==0 ); + if( lastTokenParsed!=TK_SEMI ){ + sqlite3Parser(pEngine, TK_SEMI, pParse->sLastToken, pParse); + pParse->zTail = &zSql[i]; + } + if( pParse->rc==SQLITE_OK && db->mallocFailed==0 ){ + sqlite3Parser(pEngine, 0, pParse->sLastToken, pParse); + } + } +#ifdef YYTRACKMAXSTACKDEPTH + sqlite3_mutex_enter(sqlite3MallocMutex()); + sqlite3StatusSet(SQLITE_STATUS_PARSER_STACK, + sqlite3ParserStackPeak(pEngine) + ); + sqlite3_mutex_leave(sqlite3MallocMutex()); +#endif /* YYDEBUG */ + sqlite3ParserFree(pEngine, sqlite3_free); + db->lookaside.bEnabled = enableLookaside; + if( db->mallocFailed ){ + pParse->rc = SQLITE_NOMEM; + } + if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){ + pParse->zErrMsg = sqlite3MPrintf(db, "%s", sqlite3ErrStr(pParse->rc)); + } + assert( pzErrMsg!=0 ); + if( pParse->zErrMsg ){ + *pzErrMsg = pParse->zErrMsg; + sqlite3_log(pParse->rc, "%s", *pzErrMsg); + pParse->zErrMsg = 0; + nErr++; + } + if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){ + sqlite3VdbeDelete(pParse->pVdbe); + pParse->pVdbe = 0; + } +#ifndef SQLITE_OMIT_SHARED_CACHE + if( pParse->nested==0 ){ + sqlite3DbFree(db, pParse->aTableLock); + pParse->aTableLock = 0; + pParse->nTableLock = 0; + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3_free(pParse->apVtabLock); +#endif + + if( !IN_DECLARE_VTAB ){ + /* If the pParse->declareVtab flag is set, do not delete any table + ** structure built up in pParse->pNewTable. The calling code (see vtab.c) + ** will take responsibility for freeing the Table structure. + */ + sqlite3DeleteTable(db, pParse->pNewTable); + } + + if( pParse->bFreeWith ) sqlite3WithDelete(db, pParse->pWith); + sqlite3DeleteTrigger(db, pParse->pNewTrigger); + for(i=pParse->nzVar-1; i>=0; i--) sqlite3DbFree(db, pParse->azVar[i]); + sqlite3DbFree(db, pParse->azVar); + while( pParse->pAinc ){ + AutoincInfo *p = pParse->pAinc; + pParse->pAinc = p->pNext; + sqlite3DbFree(db, p); + } + while( pParse->pZombieTab ){ + Table *p = pParse->pZombieTab; + pParse->pZombieTab = p->pNextZombie; + sqlite3DeleteTable(db, p); + } + assert( nErr==0 || pParse->rc!=SQLITE_OK ); + return nErr; +} + +/************** End of tokenize.c ********************************************/ +/************** Begin file complete.c ****************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** An tokenizer for SQL +** +** This file contains C code that implements the sqlite3_complete() API. +** This code used to be part of the tokenizer.c source file. But by +** separating it out, the code will be automatically omitted from +** static links that do not use it. +*/ +/* #include "sqliteInt.h" */ +#ifndef SQLITE_OMIT_COMPLETE + +/* +** This is defined in tokenize.c. We just have to import the definition. +*/ +#ifndef SQLITE_AMALGAMATION +#ifdef SQLITE_ASCII +#define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0) +#endif +#ifdef SQLITE_EBCDIC +SQLITE_PRIVATE const char sqlite3IsEbcdicIdChar[]; +#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40])) +#endif +#endif /* SQLITE_AMALGAMATION */ + + +/* +** Token types used by the sqlite3_complete() routine. See the header +** comments on that procedure for additional information. +*/ +#define tkSEMI 0 +#define tkWS 1 +#define tkOTHER 2 +#ifndef SQLITE_OMIT_TRIGGER +#define tkEXPLAIN 3 +#define tkCREATE 4 +#define tkTEMP 5 +#define tkTRIGGER 6 +#define tkEND 7 +#endif + +/* +** Return TRUE if the given SQL string ends in a semicolon. +** +** Special handling is require for CREATE TRIGGER statements. +** Whenever the CREATE TRIGGER keywords are seen, the statement +** must end with ";END;". +** +** This implementation uses a state machine with 8 states: +** +** (0) INVALID We have not yet seen a non-whitespace character. +** +** (1) START At the beginning or end of an SQL statement. This routine +** returns 1 if it ends in the START state and 0 if it ends +** in any other state. +** +** (2) NORMAL We are in the middle of statement which ends with a single +** semicolon. +** +** (3) EXPLAIN The keyword EXPLAIN has been seen at the beginning of +** a statement. +** +** (4) CREATE The keyword CREATE has been seen at the beginning of a +** statement, possibly preceded by EXPLAIN and/or followed by +** TEMP or TEMPORARY +** +** (5) TRIGGER We are in the middle of a trigger definition that must be +** ended by a semicolon, the keyword END, and another semicolon. +** +** (6) SEMI We've seen the first semicolon in the ";END;" that occurs at +** the end of a trigger definition. +** +** (7) END We've seen the ";END" of the ";END;" that occurs at the end +** of a trigger definition. +** +** Transitions between states above are determined by tokens extracted +** from the input. The following tokens are significant: +** +** (0) tkSEMI A semicolon. +** (1) tkWS Whitespace. +** (2) tkOTHER Any other SQL token. +** (3) tkEXPLAIN The "explain" keyword. +** (4) tkCREATE The "create" keyword. +** (5) tkTEMP The "temp" or "temporary" keyword. +** (6) tkTRIGGER The "trigger" keyword. +** (7) tkEND The "end" keyword. +** +** Whitespace never causes a state transition and is always ignored. +** This means that a SQL string of all whitespace is invalid. +** +** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed +** to recognize the end of a trigger can be omitted. All we have to do +** is look for a semicolon that is not part of an string or comment. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_complete(const char *zSql){ + u8 state = 0; /* Current state, using numbers defined in header comment */ + u8 token; /* Value of the next token */ + +#ifndef SQLITE_OMIT_TRIGGER + /* A complex statement machine used to detect the end of a CREATE TRIGGER + ** statement. This is the normal case. + */ + static const u8 trans[8][8] = { + /* Token: */ + /* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */ + /* 0 INVALID: */ { 1, 0, 2, 3, 4, 2, 2, 2, }, + /* 1 START: */ { 1, 1, 2, 3, 4, 2, 2, 2, }, + /* 2 NORMAL: */ { 1, 2, 2, 2, 2, 2, 2, 2, }, + /* 3 EXPLAIN: */ { 1, 3, 3, 2, 4, 2, 2, 2, }, + /* 4 CREATE: */ { 1, 4, 2, 2, 2, 4, 5, 2, }, + /* 5 TRIGGER: */ { 6, 5, 5, 5, 5, 5, 5, 5, }, + /* 6 SEMI: */ { 6, 6, 5, 5, 5, 5, 5, 7, }, + /* 7 END: */ { 1, 7, 5, 5, 5, 5, 5, 5, }, + }; +#else + /* If triggers are not supported by this compile then the statement machine + ** used to detect the end of a statement is much simpler + */ + static const u8 trans[3][3] = { + /* Token: */ + /* State: ** SEMI WS OTHER */ + /* 0 INVALID: */ { 1, 0, 2, }, + /* 1 START: */ { 1, 1, 2, }, + /* 2 NORMAL: */ { 1, 2, 2, }, + }; +#endif /* SQLITE_OMIT_TRIGGER */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( zSql==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + + while( *zSql ){ + switch( *zSql ){ + case ';': { /* A semicolon */ + token = tkSEMI; + break; + } + case ' ': + case '\r': + case '\t': + case '\n': + case '\f': { /* White space is ignored */ + token = tkWS; + break; + } + case '/': { /* C-style comments */ + if( zSql[1]!='*' ){ + token = tkOTHER; + break; + } + zSql += 2; + while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; } + if( zSql[0]==0 ) return 0; + zSql++; + token = tkWS; + break; + } + case '-': { /* SQL-style comments from "--" to end of line */ + if( zSql[1]!='-' ){ + token = tkOTHER; + break; + } + while( *zSql && *zSql!='\n' ){ zSql++; } + if( *zSql==0 ) return state==1; + token = tkWS; + break; + } + case '[': { /* Microsoft-style identifiers in [...] */ + zSql++; + while( *zSql && *zSql!=']' ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + case '`': /* Grave-accent quoted symbols used by MySQL */ + case '"': /* single- and double-quoted strings */ + case '\'': { + int c = *zSql; + zSql++; + while( *zSql && *zSql!=c ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + default: { +#ifdef SQLITE_EBCDIC + unsigned char c; +#endif + if( IdChar((u8)*zSql) ){ + /* Keywords and unquoted identifiers */ + int nId; + for(nId=1; IdChar(zSql[nId]); nId++){} +#ifdef SQLITE_OMIT_TRIGGER + token = tkOTHER; +#else + switch( *zSql ){ + case 'c': case 'C': { + if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){ + token = tkCREATE; + }else{ + token = tkOTHER; + } + break; + } + case 't': case 'T': { + if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){ + token = tkTRIGGER; + }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){ + token = tkTEMP; + }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){ + token = tkTEMP; + }else{ + token = tkOTHER; + } + break; + } + case 'e': case 'E': { + if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){ + token = tkEND; + }else +#ifndef SQLITE_OMIT_EXPLAIN + if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){ + token = tkEXPLAIN; + }else +#endif + { + token = tkOTHER; + } + break; + } + default: { + token = tkOTHER; + break; + } + } +#endif /* SQLITE_OMIT_TRIGGER */ + zSql += nId-1; + }else{ + /* Operators and special symbols */ + token = tkOTHER; + } + break; + } + } + state = trans[state][token]; + zSql++; + } + return state==1; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** This routine is the same as the sqlite3_complete() routine described +** above, except that the parameter is required to be UTF-16 encoded, not +** UTF-8. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_complete16(const void *zSql){ + sqlite3_value *pVal; + char const *zSql8; + int rc; + +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + pVal = sqlite3ValueNew(0); + sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC); + zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8); + if( zSql8 ){ + rc = sqlite3_complete(zSql8); + }else{ + rc = SQLITE_NOMEM; + } + sqlite3ValueFree(pVal); + return rc & 0xff; +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_OMIT_COMPLETE */ + +/************** End of complete.c ********************************************/ +/************** Begin file main.c ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Main file for the SQLite library. The routines in this file +** implement the programmer interface to the library. Routines in +** other files are for internal use by SQLite and should not be +** accessed by users of the library. +*/ +/* #include "sqliteInt.h" */ + +#ifdef SQLITE_ENABLE_FTS3 +/************** Include fts3.h in the middle of main.c ***********************/ +/************** Begin file fts3.h ********************************************/ +/* +** 2006 Oct 10 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This header file is used by programs that want to link against the +** FTS3 library. All it does is declare the sqlite3Fts3Init() interface. +*/ +/* #include "sqlite3.h" */ + +#if 0 +extern "C" { +#endif /* __cplusplus */ + +SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db); + +#if 0 +} /* extern "C" */ +#endif /* __cplusplus */ + +/************** End of fts3.h ************************************************/ +/************** Continuing where we left off in main.c ***********************/ +#endif +#ifdef SQLITE_ENABLE_RTREE +/************** Include rtree.h in the middle of main.c **********************/ +/************** Begin file rtree.h *******************************************/ +/* +** 2008 May 26 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This header file is used by programs that want to link against the +** RTREE library. All it does is declare the sqlite3RtreeInit() interface. +*/ +/* #include "sqlite3.h" */ + +#if 0 +extern "C" { +#endif /* __cplusplus */ + +SQLITE_PRIVATE int sqlite3RtreeInit(sqlite3 *db); + +#if 0 +} /* extern "C" */ +#endif /* __cplusplus */ + +/************** End of rtree.h ***********************************************/ +/************** Continuing where we left off in main.c ***********************/ +#endif +#ifdef SQLITE_ENABLE_ICU +/************** Include sqliteicu.h in the middle of main.c ******************/ +/************** Begin file sqliteicu.h ***************************************/ +/* +** 2008 May 26 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This header file is used by programs that want to link against the +** ICU extension. All it does is declare the sqlite3IcuInit() interface. +*/ +/* #include "sqlite3.h" */ + +#if 0 +extern "C" { +#endif /* __cplusplus */ + +SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db); + +#if 0 +} /* extern "C" */ +#endif /* __cplusplus */ + + +/************** End of sqliteicu.h *******************************************/ +/************** Continuing where we left off in main.c ***********************/ +#endif +#ifdef SQLITE_ENABLE_JSON1 +SQLITE_PRIVATE int sqlite3Json1Init(sqlite3*); +#endif +#ifdef SQLITE_ENABLE_FTS5 +SQLITE_PRIVATE int sqlite3Fts5Init(sqlite3*); +#endif + +#ifndef SQLITE_AMALGAMATION +/* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant +** contains the text of SQLITE_VERSION macro. +*/ +SQLITE_API const char sqlite3_version[] = SQLITE_VERSION; +#endif + +/* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns +** a pointer to the to the sqlite3_version[] string constant. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_libversion(void){ return sqlite3_version; } + +/* IMPLEMENTATION-OF: R-63124-39300 The sqlite3_sourceid() function returns a +** pointer to a string constant whose value is the same as the +** SQLITE_SOURCE_ID C preprocessor macro. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; } + +/* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function +** returns an integer equal to SQLITE_VERSION_NUMBER. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; } + +/* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns +** zero if and only if SQLite was compiled with mutexing code omitted due to +** the SQLITE_THREADSAFE compile-time option being set to 0. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; } + +/* +** When compiling the test fixture or with debugging enabled (on Win32), +** this variable being set to non-zero will cause OSTRACE macros to emit +** extra diagnostic information. +*/ +#ifdef SQLITE_HAVE_OS_TRACE +# ifndef SQLITE_DEBUG_OS_TRACE +# define SQLITE_DEBUG_OS_TRACE 0 +# endif + int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE; +#endif + +#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) +/* +** If the following function pointer is not NULL and if +** SQLITE_ENABLE_IOTRACE is enabled, then messages describing +** I/O active are written using this function. These messages +** are intended for debugging activity only. +*/ +SQLITE_API void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...) = 0; +#endif + +/* +** If the following global variable points to a string which is the +** name of a directory, then that directory will be used to store +** temporary files. +** +** See also the "PRAGMA temp_store_directory" SQL command. +*/ +SQLITE_API char *sqlite3_temp_directory = 0; + +/* +** If the following global variable points to a string which is the +** name of a directory, then that directory will be used to store +** all database files specified with a relative pathname. +** +** See also the "PRAGMA data_store_directory" SQL command. +*/ +SQLITE_API char *sqlite3_data_directory = 0; + +/* +** Initialize SQLite. +** +** This routine must be called to initialize the memory allocation, +** VFS, and mutex subsystems prior to doing any serious work with +** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT +** this routine will be called automatically by key routines such as +** sqlite3_open(). +** +** This routine is a no-op except on its very first call for the process, +** or for the first call after a call to sqlite3_shutdown. +** +** The first thread to call this routine runs the initialization to +** completion. If subsequent threads call this routine before the first +** thread has finished the initialization process, then the subsequent +** threads must block until the first thread finishes with the initialization. +** +** The first thread might call this routine recursively. Recursive +** calls to this routine should not block, of course. Otherwise the +** initialization process would never complete. +** +** Let X be the first thread to enter this routine. Let Y be some other +** thread. Then while the initial invocation of this routine by X is +** incomplete, it is required that: +** +** * Calls to this routine from Y must block until the outer-most +** call by X completes. +** +** * Recursive calls to this routine from thread X return immediately +** without blocking. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_initialize(void){ + MUTEX_LOGIC( sqlite3_mutex *pMaster; ) /* The main static mutex */ + int rc; /* Result code */ +#ifdef SQLITE_EXTRA_INIT + int bRunExtraInit = 0; /* Extra initialization needed */ +#endif + +#ifdef SQLITE_OMIT_WSD + rc = sqlite3_wsd_init(4096, 24); + if( rc!=SQLITE_OK ){ + return rc; + } +#endif + + /* If the following assert() fails on some obscure processor/compiler + ** combination, the work-around is to set the correct pointer + ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */ + assert( SQLITE_PTRSIZE==sizeof(char*) ); + + /* If SQLite is already completely initialized, then this call + ** to sqlite3_initialize() should be a no-op. But the initialization + ** must be complete. So isInit must not be set until the very end + ** of this routine. + */ + if( sqlite3GlobalConfig.isInit ) return SQLITE_OK; + + /* Make sure the mutex subsystem is initialized. If unable to + ** initialize the mutex subsystem, return early with the error. + ** If the system is so sick that we are unable to allocate a mutex, + ** there is not much SQLite is going to be able to do. + ** + ** The mutex subsystem must take care of serializing its own + ** initialization. + */ + rc = sqlite3MutexInit(); + if( rc ) return rc; + + /* Initialize the malloc() system and the recursive pInitMutex mutex. + ** This operation is protected by the STATIC_MASTER mutex. Note that + ** MutexAlloc() is called for a static mutex prior to initializing the + ** malloc subsystem - this implies that the allocation of a static + ** mutex must not require support from the malloc subsystem. + */ + MUTEX_LOGIC( pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); ) + sqlite3_mutex_enter(pMaster); + sqlite3GlobalConfig.isMutexInit = 1; + if( !sqlite3GlobalConfig.isMallocInit ){ + rc = sqlite3MallocInit(); + } + if( rc==SQLITE_OK ){ + sqlite3GlobalConfig.isMallocInit = 1; + if( !sqlite3GlobalConfig.pInitMutex ){ + sqlite3GlobalConfig.pInitMutex = + sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE); + if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){ + rc = SQLITE_NOMEM; + } + } + } + if( rc==SQLITE_OK ){ + sqlite3GlobalConfig.nRefInitMutex++; + } + sqlite3_mutex_leave(pMaster); + + /* If rc is not SQLITE_OK at this point, then either the malloc + ** subsystem could not be initialized or the system failed to allocate + ** the pInitMutex mutex. Return an error in either case. */ + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Do the rest of the initialization under the recursive mutex so + ** that we will be able to handle recursive calls into + ** sqlite3_initialize(). The recursive calls normally come through + ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other + ** recursive calls might also be possible. + ** + ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls + ** to the xInit method, so the xInit method need not be threadsafe. + ** + ** The following mutex is what serializes access to the appdef pcache xInit + ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the + ** call to sqlite3PcacheInitialize(). + */ + sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex); + if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){ + FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions); + sqlite3GlobalConfig.inProgress = 1; + memset(pHash, 0, sizeof(sqlite3GlobalFunctions)); + sqlite3RegisterGlobalFunctions(); + if( sqlite3GlobalConfig.isPCacheInit==0 ){ + rc = sqlite3PcacheInitialize(); + } + if( rc==SQLITE_OK ){ + sqlite3GlobalConfig.isPCacheInit = 1; + rc = sqlite3OsInit(); + } + if( rc==SQLITE_OK ){ + sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage, + sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage); + sqlite3GlobalConfig.isInit = 1; +#ifdef SQLITE_EXTRA_INIT + bRunExtraInit = 1; +#endif + } + sqlite3GlobalConfig.inProgress = 0; + } + sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex); + + /* Go back under the static mutex and clean up the recursive + ** mutex to prevent a resource leak. + */ + sqlite3_mutex_enter(pMaster); + sqlite3GlobalConfig.nRefInitMutex--; + if( sqlite3GlobalConfig.nRefInitMutex<=0 ){ + assert( sqlite3GlobalConfig.nRefInitMutex==0 ); + sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex); + sqlite3GlobalConfig.pInitMutex = 0; + } + sqlite3_mutex_leave(pMaster); + + /* The following is just a sanity check to make sure SQLite has + ** been compiled correctly. It is important to run this code, but + ** we don't want to run it too often and soak up CPU cycles for no + ** reason. So we run it once during initialization. + */ +#ifndef NDEBUG +#ifndef SQLITE_OMIT_FLOATING_POINT + /* This section of code's only "output" is via assert() statements. */ + if ( rc==SQLITE_OK ){ + u64 x = (((u64)1)<<63)-1; + double y; + assert(sizeof(x)==8); + assert(sizeof(x)==sizeof(y)); + memcpy(&y, &x, 8); + assert( sqlite3IsNaN(y) ); + } +#endif +#endif + + /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT + ** compile-time option. + */ +#ifdef SQLITE_EXTRA_INIT + if( bRunExtraInit ){ + int SQLITE_EXTRA_INIT(const char*); + rc = SQLITE_EXTRA_INIT(0); + } +#endif + + return rc; +} + +/* +** Undo the effects of sqlite3_initialize(). Must not be called while +** there are outstanding database connections or memory allocations or +** while any part of SQLite is otherwise in use in any thread. This +** routine is not threadsafe. But it is safe to invoke this routine +** on when SQLite is already shut down. If SQLite is already shut down +** when this routine is invoked, then this routine is a harmless no-op. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_shutdown(void){ +#ifdef SQLITE_OMIT_WSD + int rc = sqlite3_wsd_init(4096, 24); + if( rc!=SQLITE_OK ){ + return rc; + } +#endif + + if( sqlite3GlobalConfig.isInit ){ +#ifdef SQLITE_EXTRA_SHUTDOWN + void SQLITE_EXTRA_SHUTDOWN(void); + SQLITE_EXTRA_SHUTDOWN(); +#endif + sqlite3_os_end(); + sqlite3_reset_auto_extension(); + sqlite3GlobalConfig.isInit = 0; + } + if( sqlite3GlobalConfig.isPCacheInit ){ + sqlite3PcacheShutdown(); + sqlite3GlobalConfig.isPCacheInit = 0; + } + if( sqlite3GlobalConfig.isMallocInit ){ + sqlite3MallocEnd(); + sqlite3GlobalConfig.isMallocInit = 0; + +#ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES + /* The heap subsystem has now been shutdown and these values are supposed + ** to be NULL or point to memory that was obtained from sqlite3_malloc(), + ** which would rely on that heap subsystem; therefore, make sure these + ** values cannot refer to heap memory that was just invalidated when the + ** heap subsystem was shutdown. This is only done if the current call to + ** this function resulted in the heap subsystem actually being shutdown. + */ + sqlite3_data_directory = 0; + sqlite3_temp_directory = 0; +#endif + } + if( sqlite3GlobalConfig.isMutexInit ){ + sqlite3MutexEnd(); + sqlite3GlobalConfig.isMutexInit = 0; + } + + return SQLITE_OK; +} + +/* +** This API allows applications to modify the global configuration of +** the SQLite library at run-time. +** +** This routine should only be called when there are no outstanding +** database connections or memory allocations. This routine is not +** threadsafe. Failure to heed these warnings can lead to unpredictable +** behavior. +*/ +SQLITE_API int SQLITE_CDECL sqlite3_config(int op, ...){ + va_list ap; + int rc = SQLITE_OK; + + /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while + ** the SQLite library is in use. */ + if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT; + + va_start(ap, op); + switch( op ){ + + /* Mutex configuration options are only available in a threadsafe + ** compile. + */ +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-54466-46756 */ + case SQLITE_CONFIG_SINGLETHREAD: { + /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to + ** Single-thread. */ + sqlite3GlobalConfig.bCoreMutex = 0; /* Disable mutex on core */ + sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */ + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */ + case SQLITE_CONFIG_MULTITHREAD: { + /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to + ** Multi-thread. */ + sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */ + sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */ + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */ + case SQLITE_CONFIG_SERIALIZED: { + /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to + ** Serialized. */ + sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */ + sqlite3GlobalConfig.bFullMutex = 1; /* Enable mutex on connections */ + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */ + case SQLITE_CONFIG_MUTEX: { + /* Specify an alternative mutex implementation */ + sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*); + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */ + case SQLITE_CONFIG_GETMUTEX: { + /* Retrieve the current mutex implementation */ + *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex; + break; + } +#endif + + case SQLITE_CONFIG_MALLOC: { + /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a + ** single argument which is a pointer to an instance of the + ** sqlite3_mem_methods structure. The argument specifies alternative + ** low-level memory allocation routines to be used in place of the memory + ** allocation routines built into SQLite. */ + sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*); + break; + } + case SQLITE_CONFIG_GETMALLOC: { + /* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a + ** single argument which is a pointer to an instance of the + ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is + ** filled with the currently defined memory allocation routines. */ + if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault(); + *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m; + break; + } + case SQLITE_CONFIG_MEMSTATUS: { + /* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes + ** single argument of type int, interpreted as a boolean, which enables + ** or disables the collection of memory allocation statistics. */ + sqlite3GlobalConfig.bMemstat = va_arg(ap, int); + break; + } + case SQLITE_CONFIG_SCRATCH: { + /* EVIDENCE-OF: R-08404-60887 There are three arguments to + ** SQLITE_CONFIG_SCRATCH: A pointer an 8-byte aligned memory buffer from + ** which the scratch allocations will be drawn, the size of each scratch + ** allocation (sz), and the maximum number of scratch allocations (N). */ + sqlite3GlobalConfig.pScratch = va_arg(ap, void*); + sqlite3GlobalConfig.szScratch = va_arg(ap, int); + sqlite3GlobalConfig.nScratch = va_arg(ap, int); + break; + } + case SQLITE_CONFIG_PAGECACHE: { + /* EVIDENCE-OF: R-31408-40510 There are three arguments to + ** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory, the size + ** of each page buffer (sz), and the number of pages (N). */ + sqlite3GlobalConfig.pPage = va_arg(ap, void*); + sqlite3GlobalConfig.szPage = va_arg(ap, int); + sqlite3GlobalConfig.nPage = va_arg(ap, int); + break; + } + case SQLITE_CONFIG_PCACHE_HDRSZ: { + /* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes + ** a single parameter which is a pointer to an integer and writes into + ** that integer the number of extra bytes per page required for each page + ** in SQLITE_CONFIG_PAGECACHE. */ + *va_arg(ap, int*) = + sqlite3HeaderSizeBtree() + + sqlite3HeaderSizePcache() + + sqlite3HeaderSizePcache1(); + break; + } + + case SQLITE_CONFIG_PCACHE: { + /* no-op */ + break; + } + case SQLITE_CONFIG_GETPCACHE: { + /* now an error */ + rc = SQLITE_ERROR; + break; + } + + case SQLITE_CONFIG_PCACHE2: { + /* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a + ** single argument which is a pointer to an sqlite3_pcache_methods2 + ** object. This object specifies the interface to a custom page cache + ** implementation. */ + sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*); + break; + } + case SQLITE_CONFIG_GETPCACHE2: { + /* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a + ** single argument which is a pointer to an sqlite3_pcache_methods2 + ** object. SQLite copies of the current page cache implementation into + ** that object. */ + if( sqlite3GlobalConfig.pcache2.xInit==0 ){ + sqlite3PCacheSetDefault(); + } + *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2; + break; + } + +/* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only +** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or +** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */ +#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) + case SQLITE_CONFIG_HEAP: { + /* EVIDENCE-OF: R-19854-42126 There are three arguments to + ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the + ** number of bytes in the memory buffer, and the minimum allocation size. + */ + sqlite3GlobalConfig.pHeap = va_arg(ap, void*); + sqlite3GlobalConfig.nHeap = va_arg(ap, int); + sqlite3GlobalConfig.mnReq = va_arg(ap, int); + + if( sqlite3GlobalConfig.mnReq<1 ){ + sqlite3GlobalConfig.mnReq = 1; + }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){ + /* cap min request size at 2^12 */ + sqlite3GlobalConfig.mnReq = (1<<12); + } + + if( sqlite3GlobalConfig.pHeap==0 ){ + /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer) + ** is NULL, then SQLite reverts to using its default memory allocator + ** (the system malloc() implementation), undoing any prior invocation of + ** SQLITE_CONFIG_MALLOC. + ** + ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to + ** revert to its default implementation when sqlite3_initialize() is run + */ + memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m)); + }else{ + /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the + ** alternative memory allocator is engaged to handle all of SQLites + ** memory allocation needs. */ +#ifdef SQLITE_ENABLE_MEMSYS3 + sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3(); +#endif +#ifdef SQLITE_ENABLE_MEMSYS5 + sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5(); +#endif + } + break; + } +#endif + + case SQLITE_CONFIG_LOOKASIDE: { + sqlite3GlobalConfig.szLookaside = va_arg(ap, int); + sqlite3GlobalConfig.nLookaside = va_arg(ap, int); + break; + } + + /* Record a pointer to the logger function and its first argument. + ** The default is NULL. Logging is disabled if the function pointer is + ** NULL. + */ + case SQLITE_CONFIG_LOG: { + /* MSVC is picky about pulling func ptrs from va lists. + ** http://support.microsoft.com/kb/47961 + ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*)); + */ + typedef void(*LOGFUNC_t)(void*,int,const char*); + sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t); + sqlite3GlobalConfig.pLogArg = va_arg(ap, void*); + break; + } + + /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames + ** can be changed at start-time using the + ** sqlite3_config(SQLITE_CONFIG_URI,1) or + ** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls. + */ + case SQLITE_CONFIG_URI: { + /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single + ** argument of type int. If non-zero, then URI handling is globally + ** enabled. If the parameter is zero, then URI handling is globally + ** disabled. */ + sqlite3GlobalConfig.bOpenUri = va_arg(ap, int); + break; + } + + case SQLITE_CONFIG_COVERING_INDEX_SCAN: { + /* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN + ** option takes a single integer argument which is interpreted as a + ** boolean in order to enable or disable the use of covering indices for + ** full table scans in the query optimizer. */ + sqlite3GlobalConfig.bUseCis = va_arg(ap, int); + break; + } + +#ifdef SQLITE_ENABLE_SQLLOG + case SQLITE_CONFIG_SQLLOG: { + typedef void(*SQLLOGFUNC_t)(void*, sqlite3*, const char*, int); + sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t); + sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *); + break; + } +#endif + + case SQLITE_CONFIG_MMAP_SIZE: { + /* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit + ** integer (sqlite3_int64) values that are the default mmap size limit + ** (the default setting for PRAGMA mmap_size) and the maximum allowed + ** mmap size limit. */ + sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64); + sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64); + /* EVIDENCE-OF: R-53367-43190 If either argument to this option is + ** negative, then that argument is changed to its compile-time default. + ** + ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be + ** silently truncated if necessary so that it does not exceed the + ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE + ** compile-time option. + */ + if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){ + mxMmap = SQLITE_MAX_MMAP_SIZE; + } + if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE; + if( szMmap>mxMmap) szMmap = mxMmap; + sqlite3GlobalConfig.mxMmap = mxMmap; + sqlite3GlobalConfig.szMmap = szMmap; + break; + } + +#if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */ + case SQLITE_CONFIG_WIN32_HEAPSIZE: { + /* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit + ** unsigned integer value that specifies the maximum size of the created + ** heap. */ + sqlite3GlobalConfig.nHeap = va_arg(ap, int); + break; + } +#endif + + case SQLITE_CONFIG_PMASZ: { + sqlite3GlobalConfig.szPma = va_arg(ap, unsigned int); + break; + } + + default: { + rc = SQLITE_ERROR; + break; + } + } + va_end(ap); + return rc; +} + +/* +** Set up the lookaside buffers for a database connection. +** Return SQLITE_OK on success. +** If lookaside is already active, return SQLITE_BUSY. +** +** The sz parameter is the number of bytes in each lookaside slot. +** The cnt parameter is the number of slots. If pStart is NULL the +** space for the lookaside memory is obtained from sqlite3_malloc(). +** If pStart is not NULL then it is sz*cnt bytes of memory to use for +** the lookaside memory. +*/ +static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){ +#ifndef SQLITE_OMIT_LOOKASIDE + void *pStart; + if( db->lookaside.nOut ){ + return SQLITE_BUSY; + } + /* Free any existing lookaside buffer for this handle before + ** allocating a new one so we don't have to have space for + ** both at the same time. + */ + if( db->lookaside.bMalloced ){ + sqlite3_free(db->lookaside.pStart); + } + /* The size of a lookaside slot after ROUNDDOWN8 needs to be larger + ** than a pointer to be useful. + */ + sz = ROUNDDOWN8(sz); /* IMP: R-33038-09382 */ + if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0; + if( cnt<0 ) cnt = 0; + if( sz==0 || cnt==0 ){ + sz = 0; + pStart = 0; + }else if( pBuf==0 ){ + sqlite3BeginBenignMalloc(); + pStart = sqlite3Malloc( sz*cnt ); /* IMP: R-61949-35727 */ + sqlite3EndBenignMalloc(); + if( pStart ) cnt = sqlite3MallocSize(pStart)/sz; + }else{ + pStart = pBuf; + } + db->lookaside.pStart = pStart; + db->lookaside.pFree = 0; + db->lookaside.sz = (u16)sz; + if( pStart ){ + int i; + LookasideSlot *p; + assert( sz > (int)sizeof(LookasideSlot*) ); + p = (LookasideSlot*)pStart; + for(i=cnt-1; i>=0; i--){ + p->pNext = db->lookaside.pFree; + db->lookaside.pFree = p; + p = (LookasideSlot*)&((u8*)p)[sz]; + } + db->lookaside.pEnd = p; + db->lookaside.bEnabled = 1; + db->lookaside.bMalloced = pBuf==0 ?1:0; + }else{ + db->lookaside.pStart = db; + db->lookaside.pEnd = db; + db->lookaside.bEnabled = 0; + db->lookaside.bMalloced = 0; + } +#endif /* SQLITE_OMIT_LOOKASIDE */ + return SQLITE_OK; +} + +/* +** Return the mutex associated with a database connection. +*/ +SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_db_mutex(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->mutex; +} + +/* +** Free up as much memory as we can from the given database +** connection. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_db_release_memory(sqlite3 *db){ + int i; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + Pager *pPager = sqlite3BtreePager(pBt); + sqlite3PagerShrink(pPager); + } + } + sqlite3BtreeLeaveAll(db); + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Configuration settings for an individual database connection +*/ +SQLITE_API int SQLITE_CDECL sqlite3_db_config(sqlite3 *db, int op, ...){ + va_list ap; + int rc; + va_start(ap, op); + switch( op ){ + case SQLITE_DBCONFIG_LOOKASIDE: { + void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */ + int sz = va_arg(ap, int); /* IMP: R-47871-25994 */ + int cnt = va_arg(ap, int); /* IMP: R-04460-53386 */ + rc = setupLookaside(db, pBuf, sz, cnt); + break; + } + default: { + static const struct { + int op; /* The opcode */ + u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */ + } aFlagOp[] = { + { SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_ForeignKeys }, + { SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_EnableTrigger }, + }; + unsigned int i; + rc = SQLITE_ERROR; /* IMP: R-42790-23372 */ + for(i=0; iflags; + if( onoff>0 ){ + db->flags |= aFlagOp[i].mask; + }else if( onoff==0 ){ + db->flags &= ~aFlagOp[i].mask; + } + if( oldFlags!=db->flags ){ + sqlite3ExpirePreparedStatements(db); + } + if( pRes ){ + *pRes = (db->flags & aFlagOp[i].mask)!=0; + } + rc = SQLITE_OK; + break; + } + } + break; + } + } + va_end(ap); + return rc; +} + + +/* +** Return true if the buffer z[0..n-1] contains all spaces. +*/ +static int allSpaces(const char *z, int n){ + while( n>0 && z[n-1]==' ' ){ n--; } + return n==0; +} + +/* +** This is the default collating function named "BINARY" which is always +** available. +** +** If the padFlag argument is not NULL then space padding at the end +** of strings is ignored. This implements the RTRIM collation. +*/ +static int binCollFunc( + void *padFlag, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + int rc, n; + n = nKey1lastRowid; +} + +/* +** Return the number of changes in the most recent call to sqlite3_exec(). +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_changes(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->nChange; +} + +/* +** Return the number of changes since the database handle was opened. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_total_changes(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->nTotalChange; +} + +/* +** Close all open savepoints. This function only manipulates fields of the +** database handle object, it does not close any savepoints that may be open +** at the b-tree/pager level. +*/ +SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){ + while( db->pSavepoint ){ + Savepoint *pTmp = db->pSavepoint; + db->pSavepoint = pTmp->pNext; + sqlite3DbFree(db, pTmp); + } + db->nSavepoint = 0; + db->nStatement = 0; + db->isTransactionSavepoint = 0; +} + +/* +** Invoke the destructor function associated with FuncDef p, if any. Except, +** if this is not the last copy of the function, do not invoke it. Multiple +** copies of a single function are created when create_function() is called +** with SQLITE_ANY as the encoding. +*/ +static void functionDestroy(sqlite3 *db, FuncDef *p){ + FuncDestructor *pDestructor = p->pDestructor; + if( pDestructor ){ + pDestructor->nRef--; + if( pDestructor->nRef==0 ){ + pDestructor->xDestroy(pDestructor->pUserData); + sqlite3DbFree(db, pDestructor); + } + } +} + +/* +** Disconnect all sqlite3_vtab objects that belong to database connection +** db. This is called when db is being closed. +*/ +static void disconnectAllVtab(sqlite3 *db){ +#ifndef SQLITE_OMIT_VIRTUALTABLE + int i; + HashElem *p; + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Schema *pSchema = db->aDb[i].pSchema; + if( db->aDb[i].pSchema ){ + for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){ + Table *pTab = (Table *)sqliteHashData(p); + if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab); + } + } + } + for(p=sqliteHashFirst(&db->aModule); p; p=sqliteHashNext(p)){ + Module *pMod = (Module *)sqliteHashData(p); + if( pMod->pEpoTab ){ + sqlite3VtabDisconnect(db, pMod->pEpoTab); + } + } + sqlite3VtabUnlockList(db); + sqlite3BtreeLeaveAll(db); +#else + UNUSED_PARAMETER(db); +#endif +} + +/* +** Return TRUE if database connection db has unfinalized prepared +** statements or unfinished sqlite3_backup objects. +*/ +static int connectionIsBusy(sqlite3 *db){ + int j; + assert( sqlite3_mutex_held(db->mutex) ); + if( db->pVdbe ) return 1; + for(j=0; jnDb; j++){ + Btree *pBt = db->aDb[j].pBt; + if( pBt && sqlite3BtreeIsInBackup(pBt) ) return 1; + } + return 0; +} + +/* +** Close an existing SQLite database +*/ +static int sqlite3Close(sqlite3 *db, int forceZombie){ + if( !db ){ + /* EVIDENCE-OF: R-63257-11740 Calling sqlite3_close() or + ** sqlite3_close_v2() with a NULL pointer argument is a harmless no-op. */ + return SQLITE_OK; + } + if( !sqlite3SafetyCheckSickOrOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + sqlite3_mutex_enter(db->mutex); + + /* Force xDisconnect calls on all virtual tables */ + disconnectAllVtab(db); + + /* If a transaction is open, the disconnectAllVtab() call above + ** will not have called the xDisconnect() method on any virtual + ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback() + ** call will do so. We need to do this before the check for active + ** SQL statements below, as the v-table implementation may be storing + ** some prepared statements internally. + */ + sqlite3VtabRollback(db); + + /* Legacy behavior (sqlite3_close() behavior) is to return + ** SQLITE_BUSY if the connection can not be closed immediately. + */ + if( !forceZombie && connectionIsBusy(db) ){ + sqlite3ErrorWithMsg(db, SQLITE_BUSY, "unable to close due to unfinalized " + "statements or unfinished backups"); + sqlite3_mutex_leave(db->mutex); + return SQLITE_BUSY; + } + +#ifdef SQLITE_ENABLE_SQLLOG + if( sqlite3GlobalConfig.xSqllog ){ + /* Closing the handle. Fourth parameter is passed the value 2. */ + sqlite3GlobalConfig.xSqllog(sqlite3GlobalConfig.pSqllogArg, db, 0, 2); + } +#endif + + /* Convert the connection into a zombie and then close it. + */ + db->magic = SQLITE_MAGIC_ZOMBIE; + sqlite3LeaveMutexAndCloseZombie(db); + return SQLITE_OK; +} + +/* +** Two variations on the public interface for closing a database +** connection. The sqlite3_close() version returns SQLITE_BUSY and +** leaves the connection option if there are unfinalized prepared +** statements or unfinished sqlite3_backups. The sqlite3_close_v2() +** version forces the connection to become a zombie if there are +** unclosed resources, and arranges for deallocation when the last +** prepare statement or sqlite3_backup closes. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_close(sqlite3 *db){ return sqlite3Close(db,0); } +SQLITE_API int SQLITE_STDCALL sqlite3_close_v2(sqlite3 *db){ return sqlite3Close(db,1); } + + +/* +** Close the mutex on database connection db. +** +** Furthermore, if database connection db is a zombie (meaning that there +** has been a prior call to sqlite3_close(db) or sqlite3_close_v2(db)) and +** every sqlite3_stmt has now been finalized and every sqlite3_backup has +** finished, then free all resources. +*/ +SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){ + HashElem *i; /* Hash table iterator */ + int j; + + /* If there are outstanding sqlite3_stmt or sqlite3_backup objects + ** or if the connection has not yet been closed by sqlite3_close_v2(), + ** then just leave the mutex and return. + */ + if( db->magic!=SQLITE_MAGIC_ZOMBIE || connectionIsBusy(db) ){ + sqlite3_mutex_leave(db->mutex); + return; + } + + /* If we reach this point, it means that the database connection has + ** closed all sqlite3_stmt and sqlite3_backup objects and has been + ** passed to sqlite3_close (meaning that it is a zombie). Therefore, + ** go ahead and free all resources. + */ + + /* If a transaction is open, roll it back. This also ensures that if + ** any database schemas have been modified by an uncommitted transaction + ** they are reset. And that the required b-tree mutex is held to make + ** the pager rollback and schema reset an atomic operation. */ + sqlite3RollbackAll(db, SQLITE_OK); + + /* Free any outstanding Savepoint structures. */ + sqlite3CloseSavepoints(db); + + /* Close all database connections */ + for(j=0; jnDb; j++){ + struct Db *pDb = &db->aDb[j]; + if( pDb->pBt ){ + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + if( j!=1 ){ + pDb->pSchema = 0; + } + } + } + /* Clear the TEMP schema separately and last */ + if( db->aDb[1].pSchema ){ + sqlite3SchemaClear(db->aDb[1].pSchema); + } + sqlite3VtabUnlockList(db); + + /* Free up the array of auxiliary databases */ + sqlite3CollapseDatabaseArray(db); + assert( db->nDb<=2 ); + assert( db->aDb==db->aDbStatic ); + + /* Tell the code in notify.c that the connection no longer holds any + ** locks and does not require any further unlock-notify callbacks. + */ + sqlite3ConnectionClosed(db); + + for(j=0; jaFunc.a); j++){ + FuncDef *pNext, *pHash, *p; + for(p=db->aFunc.a[j]; p; p=pHash){ + pHash = p->pHash; + while( p ){ + functionDestroy(db, p); + pNext = p->pNext; + sqlite3DbFree(db, p); + p = pNext; + } + } + } + for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){ + CollSeq *pColl = (CollSeq *)sqliteHashData(i); + /* Invoke any destructors registered for collation sequence user data. */ + for(j=0; j<3; j++){ + if( pColl[j].xDel ){ + pColl[j].xDel(pColl[j].pUser); + } + } + sqlite3DbFree(db, pColl); + } + sqlite3HashClear(&db->aCollSeq); +#ifndef SQLITE_OMIT_VIRTUALTABLE + for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){ + Module *pMod = (Module *)sqliteHashData(i); + if( pMod->xDestroy ){ + pMod->xDestroy(pMod->pAux); + } + sqlite3VtabEponymousTableClear(db, pMod); + sqlite3DbFree(db, pMod); + } + sqlite3HashClear(&db->aModule); +#endif + + sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */ + sqlite3ValueFree(db->pErr); + sqlite3CloseExtensions(db); +#if SQLITE_USER_AUTHENTICATION + sqlite3_free(db->auth.zAuthUser); + sqlite3_free(db->auth.zAuthPW); +#endif + + db->magic = SQLITE_MAGIC_ERROR; + + /* The temp-database schema is allocated differently from the other schema + ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()). + ** So it needs to be freed here. Todo: Why not roll the temp schema into + ** the same sqliteMalloc() as the one that allocates the database + ** structure? + */ + sqlite3DbFree(db, db->aDb[1].pSchema); + sqlite3_mutex_leave(db->mutex); + db->magic = SQLITE_MAGIC_CLOSED; + sqlite3_mutex_free(db->mutex); + assert( db->lookaside.nOut==0 ); /* Fails on a lookaside memory leak */ + if( db->lookaside.bMalloced ){ + sqlite3_free(db->lookaside.pStart); + } + sqlite3_free(db); +} + +/* +** Rollback all database files. If tripCode is not SQLITE_OK, then +** any write cursors are invalidated ("tripped" - as in "tripping a circuit +** breaker") and made to return tripCode if there are any further +** attempts to use that cursor. Read cursors remain open and valid +** but are "saved" in case the table pages are moved around. +*/ +SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){ + int i; + int inTrans = 0; + int schemaChange; + assert( sqlite3_mutex_held(db->mutex) ); + sqlite3BeginBenignMalloc(); + + /* Obtain all b-tree mutexes before making any calls to BtreeRollback(). + ** This is important in case the transaction being rolled back has + ** modified the database schema. If the b-tree mutexes are not taken + ** here, then another shared-cache connection might sneak in between + ** the database rollback and schema reset, which can cause false + ** corruption reports in some cases. */ + sqlite3BtreeEnterAll(db); + schemaChange = (db->flags & SQLITE_InternChanges)!=0 && db->init.busy==0; + + for(i=0; inDb; i++){ + Btree *p = db->aDb[i].pBt; + if( p ){ + if( sqlite3BtreeIsInTrans(p) ){ + inTrans = 1; + } + sqlite3BtreeRollback(p, tripCode, !schemaChange); + } + } + sqlite3VtabRollback(db); + sqlite3EndBenignMalloc(); + + if( (db->flags&SQLITE_InternChanges)!=0 && db->init.busy==0 ){ + sqlite3ExpirePreparedStatements(db); + sqlite3ResetAllSchemasOfConnection(db); + } + sqlite3BtreeLeaveAll(db); + + /* Any deferred constraint violations have now been resolved. */ + db->nDeferredCons = 0; + db->nDeferredImmCons = 0; + db->flags &= ~SQLITE_DeferFKs; + + /* If one has been configured, invoke the rollback-hook callback */ + if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){ + db->xRollbackCallback(db->pRollbackArg); + } +} + +/* +** Return a static string containing the name corresponding to the error code +** specified in the argument. +*/ +#if defined(SQLITE_NEED_ERR_NAME) +SQLITE_PRIVATE const char *sqlite3ErrName(int rc){ + const char *zName = 0; + int i, origRc = rc; + for(i=0; i<2 && zName==0; i++, rc &= 0xff){ + switch( rc ){ + case SQLITE_OK: zName = "SQLITE_OK"; break; + case SQLITE_ERROR: zName = "SQLITE_ERROR"; break; + case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break; + case SQLITE_PERM: zName = "SQLITE_PERM"; break; + case SQLITE_ABORT: zName = "SQLITE_ABORT"; break; + case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break; + case SQLITE_BUSY: zName = "SQLITE_BUSY"; break; + case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break; + case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break; + case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break; + case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break; + case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break; + case SQLITE_READONLY: zName = "SQLITE_READONLY"; break; + case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break; + case SQLITE_READONLY_CANTLOCK: zName = "SQLITE_READONLY_CANTLOCK"; break; + case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break; + case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break; + case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break; + case SQLITE_IOERR: zName = "SQLITE_IOERR"; break; + case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break; + case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break; + case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break; + case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break; + case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break; + case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break; + case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break; + case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break; + case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break; + case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break; + case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break; + case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break; + case SQLITE_IOERR_CHECKRESERVEDLOCK: + zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break; + case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break; + case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break; + case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break; + case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break; + case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break; + case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break; + case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break; + case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break; + case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break; + case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break; + case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break; + case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break; + case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break; + case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break; + case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break; + case SQLITE_FULL: zName = "SQLITE_FULL"; break; + case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break; + case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break; + case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break; + case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break; + case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break; + case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break; + case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break; + case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break; + case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break; + case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break; + case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break; + case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break; + case SQLITE_CONSTRAINT_FOREIGNKEY: + zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break; + case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break; + case SQLITE_CONSTRAINT_PRIMARYKEY: + zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break; + case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break; + case SQLITE_CONSTRAINT_COMMITHOOK: + zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break; + case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break; + case SQLITE_CONSTRAINT_FUNCTION: + zName = "SQLITE_CONSTRAINT_FUNCTION"; break; + case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break; + case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break; + case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break; + case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break; + case SQLITE_AUTH: zName = "SQLITE_AUTH"; break; + case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break; + case SQLITE_RANGE: zName = "SQLITE_RANGE"; break; + case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break; + case SQLITE_ROW: zName = "SQLITE_ROW"; break; + case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break; + case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break; + case SQLITE_NOTICE_RECOVER_ROLLBACK: + zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break; + case SQLITE_WARNING: zName = "SQLITE_WARNING"; break; + case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break; + case SQLITE_DONE: zName = "SQLITE_DONE"; break; + } + } + if( zName==0 ){ + static char zBuf[50]; + sqlite3_snprintf(sizeof(zBuf), zBuf, "SQLITE_UNKNOWN(%d)", origRc); + zName = zBuf; + } + return zName; +} +#endif + +/* +** Return a static string that describes the kind of error specified in the +** argument. +*/ +SQLITE_PRIVATE const char *sqlite3ErrStr(int rc){ + static const char* const aMsg[] = { + /* SQLITE_OK */ "not an error", + /* SQLITE_ERROR */ "SQL logic error or missing database", + /* SQLITE_INTERNAL */ 0, + /* SQLITE_PERM */ "access permission denied", + /* SQLITE_ABORT */ "callback requested query abort", + /* SQLITE_BUSY */ "database is locked", + /* SQLITE_LOCKED */ "database table is locked", + /* SQLITE_NOMEM */ "out of memory", + /* SQLITE_READONLY */ "attempt to write a readonly database", + /* SQLITE_INTERRUPT */ "interrupted", + /* SQLITE_IOERR */ "disk I/O error", + /* SQLITE_CORRUPT */ "database disk image is malformed", + /* SQLITE_NOTFOUND */ "unknown operation", + /* SQLITE_FULL */ "database or disk is full", + /* SQLITE_CANTOPEN */ "unable to open database file", + /* SQLITE_PROTOCOL */ "locking protocol", + /* SQLITE_EMPTY */ "table contains no data", + /* SQLITE_SCHEMA */ "database schema has changed", + /* SQLITE_TOOBIG */ "string or blob too big", + /* SQLITE_CONSTRAINT */ "constraint failed", + /* SQLITE_MISMATCH */ "datatype mismatch", + /* SQLITE_MISUSE */ "library routine called out of sequence", + /* SQLITE_NOLFS */ "large file support is disabled", + /* SQLITE_AUTH */ "authorization denied", + /* SQLITE_FORMAT */ "auxiliary database format error", + /* SQLITE_RANGE */ "bind or column index out of range", + /* SQLITE_NOTADB */ "file is encrypted or is not a database", + }; + const char *zErr = "unknown error"; + switch( rc ){ + case SQLITE_ABORT_ROLLBACK: { + zErr = "abort due to ROLLBACK"; + break; + } + default: { + rc &= 0xff; + if( ALWAYS(rc>=0) && rcbusyTimeout; + int delay, prior; + + assert( count>=0 ); + if( count < NDELAY ){ + delay = delays[count]; + prior = totals[count]; + }else{ + delay = delays[NDELAY-1]; + prior = totals[NDELAY-1] + delay*(count-(NDELAY-1)); + } + if( prior + delay > timeout ){ + delay = timeout - prior; + if( delay<=0 ) return 0; + } + sqlite3OsSleep(db->pVfs, delay*1000); + return 1; +#else + sqlite3 *db = (sqlite3 *)ptr; + int timeout = ((sqlite3 *)ptr)->busyTimeout; + if( (count+1)*1000 > timeout ){ + return 0; + } + sqlite3OsSleep(db->pVfs, 1000000); + return 1; +#endif +} + +/* +** Invoke the given busy handler. +** +** This routine is called when an operation failed with a lock. +** If this routine returns non-zero, the lock is retried. If it +** returns 0, the operation aborts with an SQLITE_BUSY error. +*/ +SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler *p){ + int rc; + if( NEVER(p==0) || p->xFunc==0 || p->nBusy<0 ) return 0; + rc = p->xFunc(p->pArg, p->nBusy); + if( rc==0 ){ + p->nBusy = -1; + }else{ + p->nBusy++; + } + return rc; +} + +/* +** This routine sets the busy callback for an Sqlite database to the +** given callback function with the given argument. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_busy_handler( + sqlite3 *db, + int (*xBusy)(void*,int), + void *pArg +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->busyHandler.xFunc = xBusy; + db->busyHandler.pArg = pArg; + db->busyHandler.nBusy = 0; + db->busyTimeout = 0; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK +/* +** This routine sets the progress callback for an Sqlite database to the +** given callback function with the given argument. The progress callback will +** be invoked every nOps opcodes. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_progress_handler( + sqlite3 *db, + int nOps, + int (*xProgress)(void*), + void *pArg +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( nOps>0 ){ + db->xProgress = xProgress; + db->nProgressOps = (unsigned)nOps; + db->pProgressArg = pArg; + }else{ + db->xProgress = 0; + db->nProgressOps = 0; + db->pProgressArg = 0; + } + sqlite3_mutex_leave(db->mutex); +} +#endif + + +/* +** This routine installs a default busy handler that waits for the +** specified number of milliseconds before returning 0. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_busy_timeout(sqlite3 *db, int ms){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + if( ms>0 ){ + sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db); + db->busyTimeout = ms; + }else{ + sqlite3_busy_handler(db, 0, 0); + } + return SQLITE_OK; +} + +/* +** Cause any pending operation to stop at its earliest opportunity. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_interrupt(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return; + } +#endif + db->u1.isInterrupted = 1; +} + + +/* +** This function is exactly the same as sqlite3_create_function(), except +** that it is designed to be called by internal code. The difference is +** that if a malloc() fails in sqlite3_create_function(), an error code +** is returned and the mallocFailed flag cleared. +*/ +SQLITE_PRIVATE int sqlite3CreateFunc( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int enc, + void *pUserData, + void (*xFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*), + FuncDestructor *pDestructor +){ + FuncDef *p; + int nName; + int extraFlags; + + assert( sqlite3_mutex_held(db->mutex) ); + if( zFunctionName==0 || + (xFunc && (xFinal || xStep)) || + (!xFunc && (xFinal && !xStep)) || + (!xFunc && (!xFinal && xStep)) || + (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) || + (255<(nName = sqlite3Strlen30( zFunctionName))) ){ + return SQLITE_MISUSE_BKPT; + } + + assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC ); + extraFlags = enc & SQLITE_DETERMINISTIC; + enc &= (SQLITE_FUNC_ENCMASK|SQLITE_ANY); + +#ifndef SQLITE_OMIT_UTF16 + /* If SQLITE_UTF16 is specified as the encoding type, transform this + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally. + ** + ** If SQLITE_ANY is specified, add three versions of the function + ** to the hash table. + */ + if( enc==SQLITE_UTF16 ){ + enc = SQLITE_UTF16NATIVE; + }else if( enc==SQLITE_ANY ){ + int rc; + rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8|extraFlags, + pUserData, xFunc, xStep, xFinal, pDestructor); + if( rc==SQLITE_OK ){ + rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE|extraFlags, + pUserData, xFunc, xStep, xFinal, pDestructor); + } + if( rc!=SQLITE_OK ){ + return rc; + } + enc = SQLITE_UTF16BE; + } +#else + enc = SQLITE_UTF8; +#endif + + /* Check if an existing function is being overridden or deleted. If so, + ** and there are active VMs, then return SQLITE_BUSY. If a function + ** is being overridden/deleted but there are no active VMs, allow the + ** operation to continue but invalidate all precompiled statements. + */ + p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 0); + if( p && (p->funcFlags & SQLITE_FUNC_ENCMASK)==enc && p->nArg==nArg ){ + if( db->nVdbeActive ){ + sqlite3ErrorWithMsg(db, SQLITE_BUSY, + "unable to delete/modify user-function due to active statements"); + assert( !db->mallocFailed ); + return SQLITE_BUSY; + }else{ + sqlite3ExpirePreparedStatements(db); + } + } + + p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 1); + assert(p || db->mallocFailed); + if( !p ){ + return SQLITE_NOMEM; + } + + /* If an older version of the function with a configured destructor is + ** being replaced invoke the destructor function here. */ + functionDestroy(db, p); + + if( pDestructor ){ + pDestructor->nRef++; + } + p->pDestructor = pDestructor; + p->funcFlags = (p->funcFlags & SQLITE_FUNC_ENCMASK) | extraFlags; + testcase( p->funcFlags & SQLITE_DETERMINISTIC ); + p->xFunc = xFunc; + p->xStep = xStep; + p->xFinalize = xFinal; + p->pUserData = pUserData; + p->nArg = (u16)nArg; + return SQLITE_OK; +} + +/* +** Create new user functions. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_create_function( + sqlite3 *db, + const char *zFunc, + int nArg, + int enc, + void *p, + void (*xFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*) +){ + return sqlite3_create_function_v2(db, zFunc, nArg, enc, p, xFunc, xStep, + xFinal, 0); +} + +SQLITE_API int SQLITE_STDCALL sqlite3_create_function_v2( + sqlite3 *db, + const char *zFunc, + int nArg, + int enc, + void *p, + void (*xFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*), + void (*xDestroy)(void *) +){ + int rc = SQLITE_ERROR; + FuncDestructor *pArg = 0; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( xDestroy ){ + pArg = (FuncDestructor *)sqlite3DbMallocZero(db, sizeof(FuncDestructor)); + if( !pArg ){ + xDestroy(p); + goto out; + } + pArg->xDestroy = xDestroy; + pArg->pUserData = p; + } + rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xFunc, xStep, xFinal, pArg); + if( pArg && pArg->nRef==0 ){ + assert( rc!=SQLITE_OK ); + xDestroy(p); + sqlite3DbFree(db, pArg); + } + + out: + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API int SQLITE_STDCALL sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *p, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +){ + int rc; + char *zFunc8; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zFunctionName==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE); + rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal,0); + sqlite3DbFree(db, zFunc8); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} +#endif + + +/* +** Declare that a function has been overloaded by a virtual table. +** +** If the function already exists as a regular global function, then +** this routine is a no-op. If the function does not exist, then create +** a new one that always throws a run-time error. +** +** When virtual tables intend to provide an overloaded function, they +** should call this routine to make sure the global function exists. +** A global function must exist in order for name resolution to work +** properly. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_overload_function( + sqlite3 *db, + const char *zName, + int nArg +){ + int nName = sqlite3Strlen30(zName); + int rc = SQLITE_OK; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){ + rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8, + 0, sqlite3InvalidFunction, 0, 0, 0); + } + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#ifndef SQLITE_OMIT_TRACE +/* +** Register a trace function. The pArg from the previously registered trace +** is returned. +** +** A NULL trace function means that no tracing is executes. A non-NULL +** trace is a pointer to a function that is invoked at the start of each +** SQL statement. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){ + void *pOld; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pOld = db->pTraceArg; + db->xTrace = xTrace; + db->pTraceArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pOld; +} +/* +** Register a profile function. The pArg from the previously registered +** profile function is returned. +** +** A NULL profile function means that no profiling is executes. A non-NULL +** profile is a pointer to a function that is invoked at the conclusion of +** each SQL statement that is run. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_profile( + sqlite3 *db, + void (*xProfile)(void*,const char*,sqlite_uint64), + void *pArg +){ + void *pOld; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pOld = db->pProfileArg; + db->xProfile = xProfile; + db->pProfileArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pOld; +} +#endif /* SQLITE_OMIT_TRACE */ + +/* +** Register a function to be invoked when a transaction commits. +** If the invoked function returns non-zero, then the commit becomes a +** rollback. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_commit_hook( + sqlite3 *db, /* Attach the hook to this database */ + int (*xCallback)(void*), /* Function to invoke on each commit */ + void *pArg /* Argument to the function */ +){ + void *pOld; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pOld = db->pCommitArg; + db->xCommitCallback = xCallback; + db->pCommitArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pOld; +} + +/* +** Register a callback to be invoked each time a row is updated, +** inserted or deleted using this database connection. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_update_hook( + sqlite3 *db, /* Attach the hook to this database */ + void (*xCallback)(void*,int,char const *,char const *,sqlite_int64), + void *pArg /* Argument to the function */ +){ + void *pRet; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pRet = db->pUpdateArg; + db->xUpdateCallback = xCallback; + db->pUpdateArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +} + +/* +** Register a callback to be invoked each time a transaction is rolled +** back by this database connection. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_rollback_hook( + sqlite3 *db, /* Attach the hook to this database */ + void (*xCallback)(void*), /* Callback function */ + void *pArg /* Argument to the function */ +){ + void *pRet; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pRet = db->pRollbackArg; + db->xRollbackCallback = xCallback; + db->pRollbackArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +} + +#ifndef SQLITE_OMIT_WAL +/* +** The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint(). +** Invoke sqlite3_wal_checkpoint if the number of frames in the log file +** is greater than sqlite3.pWalArg cast to an integer (the value configured by +** wal_autocheckpoint()). +*/ +SQLITE_PRIVATE int sqlite3WalDefaultHook( + void *pClientData, /* Argument */ + sqlite3 *db, /* Connection */ + const char *zDb, /* Database */ + int nFrame /* Size of WAL */ +){ + if( nFrame>=SQLITE_PTR_TO_INT(pClientData) ){ + sqlite3BeginBenignMalloc(); + sqlite3_wal_checkpoint(db, zDb); + sqlite3EndBenignMalloc(); + } + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_WAL */ + +/* +** Configure an sqlite3_wal_hook() callback to automatically checkpoint +** a database after committing a transaction if there are nFrame or +** more frames in the log file. Passing zero or a negative value as the +** nFrame parameter disables automatic checkpoints entirely. +** +** The callback registered by this function replaces any existing callback +** registered using sqlite3_wal_hook(). Likewise, registering a callback +** using sqlite3_wal_hook() disables the automatic checkpoint mechanism +** configured by this function. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){ +#ifdef SQLITE_OMIT_WAL + UNUSED_PARAMETER(db); + UNUSED_PARAMETER(nFrame); +#else +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + if( nFrame>0 ){ + sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame)); + }else{ + sqlite3_wal_hook(db, 0, 0); + } +#endif + return SQLITE_OK; +} + +/* +** Register a callback to be invoked each time a transaction is written +** into the write-ahead-log by this database connection. +*/ +SQLITE_API void *SQLITE_STDCALL sqlite3_wal_hook( + sqlite3 *db, /* Attach the hook to this db handle */ + int(*xCallback)(void *, sqlite3*, const char*, int), + void *pArg /* First argument passed to xCallback() */ +){ +#ifndef SQLITE_OMIT_WAL + void *pRet; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pRet = db->pWalArg; + db->xWalCallback = xCallback; + db->pWalArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +#else + return 0; +#endif +} + +/* +** Checkpoint database zDb. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint_v2( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of attached database (or NULL) */ + int eMode, /* SQLITE_CHECKPOINT_* value */ + int *pnLog, /* OUT: Size of WAL log in frames */ + int *pnCkpt /* OUT: Total number of frames checkpointed */ +){ +#ifdef SQLITE_OMIT_WAL + return SQLITE_OK; +#else + int rc; /* Return code */ + int iDb = SQLITE_MAX_ATTACHED; /* sqlite3.aDb[] index of db to checkpoint */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + + /* Initialize the output variables to -1 in case an error occurs. */ + if( pnLog ) *pnLog = -1; + if( pnCkpt ) *pnCkpt = -1; + + assert( SQLITE_CHECKPOINT_PASSIVE==0 ); + assert( SQLITE_CHECKPOINT_FULL==1 ); + assert( SQLITE_CHECKPOINT_RESTART==2 ); + assert( SQLITE_CHECKPOINT_TRUNCATE==3 ); + if( eModeSQLITE_CHECKPOINT_TRUNCATE ){ + /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint + ** mode: */ + return SQLITE_MISUSE; + } + + sqlite3_mutex_enter(db->mutex); + if( zDb && zDb[0] ){ + iDb = sqlite3FindDbName(db, zDb); + } + if( iDb<0 ){ + rc = SQLITE_ERROR; + sqlite3ErrorWithMsg(db, SQLITE_ERROR, "unknown database: %s", zDb); + }else{ + db->busyHandler.nBusy = 0; + rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt); + sqlite3Error(db, rc); + } + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +#endif +} + + +/* +** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points +** to contains a zero-length string, all attached databases are +** checkpointed. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){ + /* EVIDENCE-OF: R-41613-20553 The sqlite3_wal_checkpoint(D,X) is equivalent to + ** sqlite3_wal_checkpoint_v2(D,X,SQLITE_CHECKPOINT_PASSIVE,0,0). */ + return sqlite3_wal_checkpoint_v2(db,zDb,SQLITE_CHECKPOINT_PASSIVE,0,0); +} + +#ifndef SQLITE_OMIT_WAL +/* +** Run a checkpoint on database iDb. This is a no-op if database iDb is +** not currently open in WAL mode. +** +** If a transaction is open on the database being checkpointed, this +** function returns SQLITE_LOCKED and a checkpoint is not attempted. If +** an error occurs while running the checkpoint, an SQLite error code is +** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK. +** +** The mutex on database handle db should be held by the caller. The mutex +** associated with the specific b-tree being checkpointed is taken by +** this function while the checkpoint is running. +** +** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are +** checkpointed. If an error is encountered it is returned immediately - +** no attempt is made to checkpoint any remaining databases. +** +** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART. +*/ +SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){ + int rc = SQLITE_OK; /* Return code */ + int i; /* Used to iterate through attached dbs */ + int bBusy = 0; /* True if SQLITE_BUSY has been encountered */ + + assert( sqlite3_mutex_held(db->mutex) ); + assert( !pnLog || *pnLog==-1 ); + assert( !pnCkpt || *pnCkpt==-1 ); + + for(i=0; inDb && rc==SQLITE_OK; i++){ + if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){ + rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt); + pnLog = 0; + pnCkpt = 0; + if( rc==SQLITE_BUSY ){ + bBusy = 1; + rc = SQLITE_OK; + } + } + } + + return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc; +} +#endif /* SQLITE_OMIT_WAL */ + +/* +** This function returns true if main-memory should be used instead of +** a temporary file for transient pager files and statement journals. +** The value returned depends on the value of db->temp_store (runtime +** parameter) and the compile time value of SQLITE_TEMP_STORE. The +** following table describes the relationship between these two values +** and this functions return value. +** +** SQLITE_TEMP_STORE db->temp_store Location of temporary database +** ----------------- -------------- ------------------------------ +** 0 any file (return 0) +** 1 1 file (return 0) +** 1 2 memory (return 1) +** 1 0 file (return 0) +** 2 1 file (return 0) +** 2 2 memory (return 1) +** 2 0 memory (return 1) +** 3 any memory (return 1) +*/ +SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3 *db){ +#if SQLITE_TEMP_STORE==1 + return ( db->temp_store==2 ); +#endif +#if SQLITE_TEMP_STORE==2 + return ( db->temp_store!=1 ); +#endif +#if SQLITE_TEMP_STORE==3 + UNUSED_PARAMETER(db); + return 1; +#endif +#if SQLITE_TEMP_STORE<1 || SQLITE_TEMP_STORE>3 + UNUSED_PARAMETER(db); + return 0; +#endif +} + +/* +** Return UTF-8 encoded English language explanation of the most recent +** error. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_errmsg(sqlite3 *db){ + const char *z; + if( !db ){ + return sqlite3ErrStr(SQLITE_NOMEM); + } + if( !sqlite3SafetyCheckSickOrOk(db) ){ + return sqlite3ErrStr(SQLITE_MISUSE_BKPT); + } + sqlite3_mutex_enter(db->mutex); + if( db->mallocFailed ){ + z = sqlite3ErrStr(SQLITE_NOMEM); + }else{ + testcase( db->pErr==0 ); + z = (char*)sqlite3_value_text(db->pErr); + assert( !db->mallocFailed ); + if( z==0 ){ + z = sqlite3ErrStr(db->errCode); + } + } + sqlite3_mutex_leave(db->mutex); + return z; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Return UTF-16 encoded English language explanation of the most recent +** error. +*/ +SQLITE_API const void *SQLITE_STDCALL sqlite3_errmsg16(sqlite3 *db){ + static const u16 outOfMem[] = { + 'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0 + }; + static const u16 misuse[] = { + 'l', 'i', 'b', 'r', 'a', 'r', 'y', ' ', + 'r', 'o', 'u', 't', 'i', 'n', 'e', ' ', + 'c', 'a', 'l', 'l', 'e', 'd', ' ', + 'o', 'u', 't', ' ', + 'o', 'f', ' ', + 's', 'e', 'q', 'u', 'e', 'n', 'c', 'e', 0 + }; + + const void *z; + if( !db ){ + return (void *)outOfMem; + } + if( !sqlite3SafetyCheckSickOrOk(db) ){ + return (void *)misuse; + } + sqlite3_mutex_enter(db->mutex); + if( db->mallocFailed ){ + z = (void *)outOfMem; + }else{ + z = sqlite3_value_text16(db->pErr); + if( z==0 ){ + sqlite3ErrorWithMsg(db, db->errCode, sqlite3ErrStr(db->errCode)); + z = sqlite3_value_text16(db->pErr); + } + /* A malloc() may have failed within the call to sqlite3_value_text16() + ** above. If this is the case, then the db->mallocFailed flag needs to + ** be cleared before returning. Do this directly, instead of via + ** sqlite3ApiExit(), to avoid setting the database handle error message. + */ + db->mallocFailed = 0; + } + sqlite3_mutex_leave(db->mutex); + return z; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the most recent error code generated by an SQLite routine. If NULL is +** passed to this function, we assume a malloc() failed during sqlite3_open(). +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_errcode(sqlite3 *db){ + if( db && !sqlite3SafetyCheckSickOrOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + if( !db || db->mallocFailed ){ + return SQLITE_NOMEM; + } + return db->errCode & db->errMask; +} +SQLITE_API int SQLITE_STDCALL sqlite3_extended_errcode(sqlite3 *db){ + if( db && !sqlite3SafetyCheckSickOrOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + if( !db || db->mallocFailed ){ + return SQLITE_NOMEM; + } + return db->errCode; +} + +/* +** Return a string that describes the kind of error specified in the +** argument. For now, this simply calls the internal sqlite3ErrStr() +** function. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_errstr(int rc){ + return sqlite3ErrStr(rc); +} + +/* +** Create a new collating function for database "db". The name is zName +** and the encoding is enc. +*/ +static int createCollation( + sqlite3* db, + const char *zName, + u8 enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDel)(void*) +){ + CollSeq *pColl; + int enc2; + + assert( sqlite3_mutex_held(db->mutex) ); + + /* If SQLITE_UTF16 is specified as the encoding type, transform this + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally. + */ + enc2 = enc; + testcase( enc2==SQLITE_UTF16 ); + testcase( enc2==SQLITE_UTF16_ALIGNED ); + if( enc2==SQLITE_UTF16 || enc2==SQLITE_UTF16_ALIGNED ){ + enc2 = SQLITE_UTF16NATIVE; + } + if( enc2SQLITE_UTF16BE ){ + return SQLITE_MISUSE_BKPT; + } + + /* Check if this call is removing or replacing an existing collation + ** sequence. If so, and there are active VMs, return busy. If there + ** are no active VMs, invalidate any pre-compiled statements. + */ + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0); + if( pColl && pColl->xCmp ){ + if( db->nVdbeActive ){ + sqlite3ErrorWithMsg(db, SQLITE_BUSY, + "unable to delete/modify collation sequence due to active statements"); + return SQLITE_BUSY; + } + sqlite3ExpirePreparedStatements(db); + + /* If collation sequence pColl was created directly by a call to + ** sqlite3_create_collation, and not generated by synthCollSeq(), + ** then any copies made by synthCollSeq() need to be invalidated. + ** Also, collation destructor - CollSeq.xDel() - function may need + ** to be called. + */ + if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){ + CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName); + int j; + for(j=0; j<3; j++){ + CollSeq *p = &aColl[j]; + if( p->enc==pColl->enc ){ + if( p->xDel ){ + p->xDel(p->pUser); + } + p->xCmp = 0; + } + } + } + } + + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1); + if( pColl==0 ) return SQLITE_NOMEM; + pColl->xCmp = xCompare; + pColl->pUser = pCtx; + pColl->xDel = xDel; + pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED)); + sqlite3Error(db, SQLITE_OK); + return SQLITE_OK; +} + + +/* +** This array defines hard upper bounds on limit values. The +** initializer must be kept in sync with the SQLITE_LIMIT_* +** #defines in sqlite3.h. +*/ +static const int aHardLimit[] = { + SQLITE_MAX_LENGTH, + SQLITE_MAX_SQL_LENGTH, + SQLITE_MAX_COLUMN, + SQLITE_MAX_EXPR_DEPTH, + SQLITE_MAX_COMPOUND_SELECT, + SQLITE_MAX_VDBE_OP, + SQLITE_MAX_FUNCTION_ARG, + SQLITE_MAX_ATTACHED, + SQLITE_MAX_LIKE_PATTERN_LENGTH, + SQLITE_MAX_VARIABLE_NUMBER, /* IMP: R-38091-32352 */ + SQLITE_MAX_TRIGGER_DEPTH, + SQLITE_MAX_WORKER_THREADS, +}; + +/* +** Make sure the hard limits are set to reasonable values +*/ +#if SQLITE_MAX_LENGTH<100 +# error SQLITE_MAX_LENGTH must be at least 100 +#endif +#if SQLITE_MAX_SQL_LENGTH<100 +# error SQLITE_MAX_SQL_LENGTH must be at least 100 +#endif +#if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH +# error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH +#endif +#if SQLITE_MAX_COMPOUND_SELECT<2 +# error SQLITE_MAX_COMPOUND_SELECT must be at least 2 +#endif +#if SQLITE_MAX_VDBE_OP<40 +# error SQLITE_MAX_VDBE_OP must be at least 40 +#endif +#if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>1000 +# error SQLITE_MAX_FUNCTION_ARG must be between 0 and 1000 +#endif +#if SQLITE_MAX_ATTACHED<0 || SQLITE_MAX_ATTACHED>125 +# error SQLITE_MAX_ATTACHED must be between 0 and 125 +#endif +#if SQLITE_MAX_LIKE_PATTERN_LENGTH<1 +# error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1 +#endif +#if SQLITE_MAX_COLUMN>32767 +# error SQLITE_MAX_COLUMN must not exceed 32767 +#endif +#if SQLITE_MAX_TRIGGER_DEPTH<1 +# error SQLITE_MAX_TRIGGER_DEPTH must be at least 1 +#endif +#if SQLITE_MAX_WORKER_THREADS<0 || SQLITE_MAX_WORKER_THREADS>50 +# error SQLITE_MAX_WORKER_THREADS must be between 0 and 50 +#endif + + +/* +** Change the value of a limit. Report the old value. +** If an invalid limit index is supplied, report -1. +** Make no changes but still report the old value if the +** new limit is negative. +** +** A new lower limit does not shrink existing constructs. +** It merely prevents new constructs that exceed the limit +** from forming. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_limit(sqlite3 *db, int limitId, int newLimit){ + int oldLimit; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return -1; + } +#endif + + /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME + ** there is a hard upper bound set at compile-time by a C preprocessor + ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to + ** "_MAX_".) + */ + assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH ); + assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH ); + assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN ); + assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH ); + assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT); + assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP ); + assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG ); + assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED ); + assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]== + SQLITE_MAX_LIKE_PATTERN_LENGTH ); + assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER); + assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH ); + assert( aHardLimit[SQLITE_LIMIT_WORKER_THREADS]==SQLITE_MAX_WORKER_THREADS ); + assert( SQLITE_LIMIT_WORKER_THREADS==(SQLITE_N_LIMIT-1) ); + + + if( limitId<0 || limitId>=SQLITE_N_LIMIT ){ + return -1; + } + oldLimit = db->aLimit[limitId]; + if( newLimit>=0 ){ /* IMP: R-52476-28732 */ + if( newLimit>aHardLimit[limitId] ){ + newLimit = aHardLimit[limitId]; /* IMP: R-51463-25634 */ + } + db->aLimit[limitId] = newLimit; + } + return oldLimit; /* IMP: R-53341-35419 */ +} + +/* +** This function is used to parse both URIs and non-URI filenames passed by the +** user to API functions sqlite3_open() or sqlite3_open_v2(), and for database +** URIs specified as part of ATTACH statements. +** +** The first argument to this function is the name of the VFS to use (or +** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx" +** query parameter. The second argument contains the URI (or non-URI filename) +** itself. When this function is called the *pFlags variable should contain +** the default flags to open the database handle with. The value stored in +** *pFlags may be updated before returning if the URI filename contains +** "cache=xxx" or "mode=xxx" query parameters. +** +** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to +** the VFS that should be used to open the database file. *pzFile is set to +** point to a buffer containing the name of the file to open. It is the +** responsibility of the caller to eventually call sqlite3_free() to release +** this buffer. +** +** If an error occurs, then an SQLite error code is returned and *pzErrMsg +** may be set to point to a buffer containing an English language error +** message. It is the responsibility of the caller to eventually release +** this buffer by calling sqlite3_free(). +*/ +SQLITE_PRIVATE int sqlite3ParseUri( + const char *zDefaultVfs, /* VFS to use if no "vfs=xxx" query option */ + const char *zUri, /* Nul-terminated URI to parse */ + unsigned int *pFlags, /* IN/OUT: SQLITE_OPEN_XXX flags */ + sqlite3_vfs **ppVfs, /* OUT: VFS to use */ + char **pzFile, /* OUT: Filename component of URI */ + char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */ +){ + int rc = SQLITE_OK; + unsigned int flags = *pFlags; + const char *zVfs = zDefaultVfs; + char *zFile; + char c; + int nUri = sqlite3Strlen30(zUri); + + assert( *pzErrMsg==0 ); + + if( ((flags & SQLITE_OPEN_URI) /* IMP: R-48725-32206 */ + || sqlite3GlobalConfig.bOpenUri) /* IMP: R-51689-46548 */ + && nUri>=5 && memcmp(zUri, "file:", 5)==0 /* IMP: R-57884-37496 */ + ){ + char *zOpt; + int eState; /* Parser state when parsing URI */ + int iIn; /* Input character index */ + int iOut = 0; /* Output character index */ + u64 nByte = nUri+2; /* Bytes of space to allocate */ + + /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen + ** method that there may be extra parameters following the file-name. */ + flags |= SQLITE_OPEN_URI; + + for(iIn=0; iIn=0 && octet<256 ); + if( octet==0 ){ + /* This branch is taken when "%00" appears within the URI. In this + ** case we ignore all text in the remainder of the path, name or + ** value currently being parsed. So ignore the current character + ** and skip to the next "?", "=" or "&", as appropriate. */ + while( (c = zUri[iIn])!=0 && c!='#' + && (eState!=0 || c!='?') + && (eState!=1 || (c!='=' && c!='&')) + && (eState!=2 || c!='&') + ){ + iIn++; + } + continue; + } + c = octet; + }else if( eState==1 && (c=='&' || c=='=') ){ + if( zFile[iOut-1]==0 ){ + /* An empty option name. Ignore this option altogether. */ + while( zUri[iIn] && zUri[iIn]!='#' && zUri[iIn-1]!='&' ) iIn++; + continue; + } + if( c=='&' ){ + zFile[iOut++] = '\0'; + }else{ + eState = 2; + } + c = 0; + }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){ + c = 0; + eState = 1; + } + zFile[iOut++] = c; + } + if( eState==1 ) zFile[iOut++] = '\0'; + zFile[iOut++] = '\0'; + zFile[iOut++] = '\0'; + + /* Check if there were any options specified that should be interpreted + ** here. Options that are interpreted here include "vfs" and those that + ** correspond to flags that may be passed to the sqlite3_open_v2() + ** method. */ + zOpt = &zFile[sqlite3Strlen30(zFile)+1]; + while( zOpt[0] ){ + int nOpt = sqlite3Strlen30(zOpt); + char *zVal = &zOpt[nOpt+1]; + int nVal = sqlite3Strlen30(zVal); + + if( nOpt==3 && memcmp("vfs", zOpt, 3)==0 ){ + zVfs = zVal; + }else{ + struct OpenMode { + const char *z; + int mode; + } *aMode = 0; + char *zModeType = 0; + int mask = 0; + int limit = 0; + + if( nOpt==5 && memcmp("cache", zOpt, 5)==0 ){ + static struct OpenMode aCacheMode[] = { + { "shared", SQLITE_OPEN_SHAREDCACHE }, + { "private", SQLITE_OPEN_PRIVATECACHE }, + { 0, 0 } + }; + + mask = SQLITE_OPEN_SHAREDCACHE|SQLITE_OPEN_PRIVATECACHE; + aMode = aCacheMode; + limit = mask; + zModeType = "cache"; + } + if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){ + static struct OpenMode aOpenMode[] = { + { "ro", SQLITE_OPEN_READONLY }, + { "rw", SQLITE_OPEN_READWRITE }, + { "rwc", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE }, + { "memory", SQLITE_OPEN_MEMORY }, + { 0, 0 } + }; + + mask = SQLITE_OPEN_READONLY | SQLITE_OPEN_READWRITE + | SQLITE_OPEN_CREATE | SQLITE_OPEN_MEMORY; + aMode = aOpenMode; + limit = mask & flags; + zModeType = "access"; + } + + if( aMode ){ + int i; + int mode = 0; + for(i=0; aMode[i].z; i++){ + const char *z = aMode[i].z; + if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){ + mode = aMode[i].mode; + break; + } + } + if( mode==0 ){ + *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal); + rc = SQLITE_ERROR; + goto parse_uri_out; + } + if( (mode & ~SQLITE_OPEN_MEMORY)>limit ){ + *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s", + zModeType, zVal); + rc = SQLITE_PERM; + goto parse_uri_out; + } + flags = (flags & ~mask) | mode; + } + } + + zOpt = &zVal[nVal+1]; + } + + }else{ + zFile = sqlite3_malloc64(nUri+2); + if( !zFile ) return SQLITE_NOMEM; + memcpy(zFile, zUri, nUri); + zFile[nUri] = '\0'; + zFile[nUri+1] = '\0'; + flags &= ~SQLITE_OPEN_URI; + } + + *ppVfs = sqlite3_vfs_find(zVfs); + if( *ppVfs==0 ){ + *pzErrMsg = sqlite3_mprintf("no such vfs: %s", zVfs); + rc = SQLITE_ERROR; + } + parse_uri_out: + if( rc!=SQLITE_OK ){ + sqlite3_free(zFile); + zFile = 0; + } + *pFlags = flags; + *pzFile = zFile; + return rc; +} + + +/* +** This routine does the work of opening a database on behalf of +** sqlite3_open() and sqlite3_open16(). The database filename "zFilename" +** is UTF-8 encoded. +*/ +static int openDatabase( + const char *zFilename, /* Database filename UTF-8 encoded */ + sqlite3 **ppDb, /* OUT: Returned database handle */ + unsigned int flags, /* Operational flags */ + const char *zVfs /* Name of the VFS to use */ +){ + sqlite3 *db; /* Store allocated handle here */ + int rc; /* Return code */ + int isThreadsafe; /* True for threadsafe connections */ + char *zOpen = 0; /* Filename argument to pass to BtreeOpen() */ + char *zErrMsg = 0; /* Error message from sqlite3ParseUri() */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppDb==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppDb = 0; +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + + /* Only allow sensible combinations of bits in the flags argument. + ** Throw an error if any non-sense combination is used. If we + ** do not block illegal combinations here, it could trigger + ** assert() statements in deeper layers. Sensible combinations + ** are: + ** + ** 1: SQLITE_OPEN_READONLY + ** 2: SQLITE_OPEN_READWRITE + ** 6: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE + */ + assert( SQLITE_OPEN_READONLY == 0x01 ); + assert( SQLITE_OPEN_READWRITE == 0x02 ); + assert( SQLITE_OPEN_CREATE == 0x04 ); + testcase( (1<<(flags&7))==0x02 ); /* READONLY */ + testcase( (1<<(flags&7))==0x04 ); /* READWRITE */ + testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */ + if( ((1<<(flags&7)) & 0x46)==0 ){ + return SQLITE_MISUSE_BKPT; /* IMP: R-65497-44594 */ + } + + if( sqlite3GlobalConfig.bCoreMutex==0 ){ + isThreadsafe = 0; + }else if( flags & SQLITE_OPEN_NOMUTEX ){ + isThreadsafe = 0; + }else if( flags & SQLITE_OPEN_FULLMUTEX ){ + isThreadsafe = 1; + }else{ + isThreadsafe = sqlite3GlobalConfig.bFullMutex; + } + if( flags & SQLITE_OPEN_PRIVATECACHE ){ + flags &= ~SQLITE_OPEN_SHAREDCACHE; + }else if( sqlite3GlobalConfig.sharedCacheEnabled ){ + flags |= SQLITE_OPEN_SHAREDCACHE; + } + + /* Remove harmful bits from the flags parameter + ** + ** The SQLITE_OPEN_NOMUTEX and SQLITE_OPEN_FULLMUTEX flags were + ** dealt with in the previous code block. Besides these, the only + ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY, + ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE, + ** SQLITE_OPEN_PRIVATECACHE, and some reserved bits. Silently mask + ** off all other flags. + */ + flags &= ~( SQLITE_OPEN_DELETEONCLOSE | + SQLITE_OPEN_EXCLUSIVE | + SQLITE_OPEN_MAIN_DB | + SQLITE_OPEN_TEMP_DB | + SQLITE_OPEN_TRANSIENT_DB | + SQLITE_OPEN_MAIN_JOURNAL | + SQLITE_OPEN_TEMP_JOURNAL | + SQLITE_OPEN_SUBJOURNAL | + SQLITE_OPEN_MASTER_JOURNAL | + SQLITE_OPEN_NOMUTEX | + SQLITE_OPEN_FULLMUTEX | + SQLITE_OPEN_WAL + ); + + /* Allocate the sqlite data structure */ + db = sqlite3MallocZero( sizeof(sqlite3) ); + if( db==0 ) goto opendb_out; + if( isThreadsafe ){ + db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE); + if( db->mutex==0 ){ + sqlite3_free(db); + db = 0; + goto opendb_out; + } + } + sqlite3_mutex_enter(db->mutex); + db->errMask = 0xff; + db->nDb = 2; + db->magic = SQLITE_MAGIC_BUSY; + db->aDb = db->aDbStatic; + + assert( sizeof(db->aLimit)==sizeof(aHardLimit) ); + memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit)); + db->aLimit[SQLITE_LIMIT_WORKER_THREADS] = SQLITE_DEFAULT_WORKER_THREADS; + db->autoCommit = 1; + db->nextAutovac = -1; + db->szMmap = sqlite3GlobalConfig.szMmap; + db->nextPagesize = 0; + db->nMaxSorterMmap = 0x7FFFFFFF; + db->flags |= SQLITE_ShortColNames | SQLITE_EnableTrigger | SQLITE_CacheSpill +#if !defined(SQLITE_DEFAULT_AUTOMATIC_INDEX) || SQLITE_DEFAULT_AUTOMATIC_INDEX + | SQLITE_AutoIndex +#endif +#if SQLITE_DEFAULT_CKPTFULLFSYNC + | SQLITE_CkptFullFSync +#endif +#if SQLITE_DEFAULT_FILE_FORMAT<4 + | SQLITE_LegacyFileFmt +#endif +#ifdef SQLITE_ENABLE_LOAD_EXTENSION + | SQLITE_LoadExtension +#endif +#if SQLITE_DEFAULT_RECURSIVE_TRIGGERS + | SQLITE_RecTriggers +#endif +#if defined(SQLITE_DEFAULT_FOREIGN_KEYS) && SQLITE_DEFAULT_FOREIGN_KEYS + | SQLITE_ForeignKeys +#endif +#if defined(SQLITE_REVERSE_UNORDERED_SELECTS) + | SQLITE_ReverseOrder +#endif +#if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK) + | SQLITE_CellSizeCk +#endif + ; + sqlite3HashInit(&db->aCollSeq); +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3HashInit(&db->aModule); +#endif + + /* Add the default collation sequence BINARY. BINARY works for both UTF-8 + ** and UTF-16, so add a version for each to avoid any unnecessary + ** conversions. The only error that can occur here is a malloc() failure. + ** + ** EVIDENCE-OF: R-52786-44878 SQLite defines three built-in collating + ** functions: + */ + createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0); + createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0); + createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0); + createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0); + createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0); + if( db->mallocFailed ){ + goto opendb_out; + } + /* EVIDENCE-OF: R-08308-17224 The default collating function for all + ** strings is BINARY. + */ + db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 0); + assert( db->pDfltColl!=0 ); + + /* Parse the filename/URI argument. */ + db->openFlags = flags; + rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM ) db->mallocFailed = 1; + sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg); + sqlite3_free(zErrMsg); + goto opendb_out; + } + + /* Open the backend database driver */ + rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0, + flags | SQLITE_OPEN_MAIN_DB); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_IOERR_NOMEM ){ + rc = SQLITE_NOMEM; + } + sqlite3Error(db, rc); + goto opendb_out; + } + sqlite3BtreeEnter(db->aDb[0].pBt); + db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt); + if( !db->mallocFailed ) ENC(db) = SCHEMA_ENC(db); + sqlite3BtreeLeave(db->aDb[0].pBt); + db->aDb[1].pSchema = sqlite3SchemaGet(db, 0); + + /* The default safety_level for the main database is 'full'; for the temp + ** database it is 'NONE'. This matches the pager layer defaults. + */ + db->aDb[0].zName = "main"; + db->aDb[0].safety_level = 3; + db->aDb[1].zName = "temp"; + db->aDb[1].safety_level = 1; + + db->magic = SQLITE_MAGIC_OPEN; + if( db->mallocFailed ){ + goto opendb_out; + } + + /* Register all built-in functions, but do not attempt to read the + ** database schema yet. This is delayed until the first time the database + ** is accessed. + */ + sqlite3Error(db, SQLITE_OK); + sqlite3RegisterBuiltinFunctions(db); + + /* Load automatic extensions - extensions that have been registered + ** using the sqlite3_automatic_extension() API. + */ + rc = sqlite3_errcode(db); + if( rc==SQLITE_OK ){ + sqlite3AutoLoadExtensions(db); + rc = sqlite3_errcode(db); + if( rc!=SQLITE_OK ){ + goto opendb_out; + } + } + +#ifdef SQLITE_ENABLE_FTS1 + if( !db->mallocFailed ){ + extern int sqlite3Fts1Init(sqlite3*); + rc = sqlite3Fts1Init(db); + } +#endif + +#ifdef SQLITE_ENABLE_FTS2 + if( !db->mallocFailed && rc==SQLITE_OK ){ + extern int sqlite3Fts2Init(sqlite3*); + rc = sqlite3Fts2Init(db); + } +#endif + +#ifdef SQLITE_ENABLE_FTS3 /* automatically defined by SQLITE_ENABLE_FTS4 */ + if( !db->mallocFailed && rc==SQLITE_OK ){ + rc = sqlite3Fts3Init(db); + } +#endif + +#ifdef SQLITE_ENABLE_FTS5 + if( !db->mallocFailed && rc==SQLITE_OK ){ + rc = sqlite3Fts5Init(db); + } +#endif + +#ifdef SQLITE_ENABLE_ICU + if( !db->mallocFailed && rc==SQLITE_OK ){ + rc = sqlite3IcuInit(db); + } +#endif + +#ifdef SQLITE_ENABLE_RTREE + if( !db->mallocFailed && rc==SQLITE_OK){ + rc = sqlite3RtreeInit(db); + } +#endif + +#ifdef SQLITE_ENABLE_DBSTAT_VTAB + if( !db->mallocFailed && rc==SQLITE_OK){ + rc = sqlite3DbstatRegister(db); + } +#endif + +#ifdef SQLITE_ENABLE_JSON1 + if( !db->mallocFailed && rc==SQLITE_OK){ + rc = sqlite3Json1Init(db); + } +#endif + + /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking + ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking + ** mode. Doing nothing at all also makes NORMAL the default. + */ +#ifdef SQLITE_DEFAULT_LOCKING_MODE + db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE; + sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt), + SQLITE_DEFAULT_LOCKING_MODE); +#endif + + if( rc ) sqlite3Error(db, rc); + + /* Enable the lookaside-malloc subsystem */ + setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside, + sqlite3GlobalConfig.nLookaside); + + sqlite3_wal_autocheckpoint(db, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT); + +opendb_out: + sqlite3_free(zOpen); + if( db ){ + assert( db->mutex!=0 || isThreadsafe==0 + || sqlite3GlobalConfig.bFullMutex==0 ); + sqlite3_mutex_leave(db->mutex); + } + rc = sqlite3_errcode(db); + assert( db!=0 || rc==SQLITE_NOMEM ); + if( rc==SQLITE_NOMEM ){ + sqlite3_close(db); + db = 0; + }else if( rc!=SQLITE_OK ){ + db->magic = SQLITE_MAGIC_SICK; + } + *ppDb = db; +#ifdef SQLITE_ENABLE_SQLLOG + if( sqlite3GlobalConfig.xSqllog ){ + /* Opening a db handle. Fourth parameter is passed 0. */ + void *pArg = sqlite3GlobalConfig.pSqllogArg; + sqlite3GlobalConfig.xSqllog(pArg, db, zFilename, 0); + } +#endif + return rc & 0xff; +} + +/* +** Open a new database handle. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_open( + const char *zFilename, + sqlite3 **ppDb +){ + return openDatabase(zFilename, ppDb, + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0); +} +SQLITE_API int SQLITE_STDCALL sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +){ + return openDatabase(filename, ppDb, (unsigned int)flags, zVfs); +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Open a new database handle. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_open16( + const void *zFilename, + sqlite3 **ppDb +){ + char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */ + sqlite3_value *pVal; + int rc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppDb==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppDb = 0; +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + if( zFilename==0 ) zFilename = "\000\000"; + pVal = sqlite3ValueNew(0); + sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC); + zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8); + if( zFilename8 ){ + rc = openDatabase(zFilename8, ppDb, + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0); + assert( *ppDb || rc==SQLITE_NOMEM ); + if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){ + SCHEMA_ENC(*ppDb) = ENC(*ppDb) = SQLITE_UTF16NATIVE; + } + }else{ + rc = SQLITE_NOMEM; + } + sqlite3ValueFree(pVal); + + return rc & 0xff; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Register a new collation sequence with the database handle db. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_create_collation( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0); +} + +/* +** Register a new collation sequence with the database handle db. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_create_collation_v2( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDel)(void*) +){ + int rc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Register a new collation sequence with the database handle db. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_create_collation16( + sqlite3* db, + const void *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + int rc = SQLITE_OK; + char *zName8; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE); + if( zName8 ){ + rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0); + sqlite3DbFree(db, zName8); + } + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Register a collation sequence factory callback with the database handle +** db. Replace any previously installed collation sequence factory. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed( + sqlite3 *db, + void *pCollNeededArg, + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*) +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->xCollNeeded = xCollNeeded; + db->xCollNeeded16 = 0; + db->pCollNeededArg = pCollNeededArg; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Register a collation sequence factory callback with the database handle +** db. Replace any previously installed collation sequence factory. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed16( + sqlite3 *db, + void *pCollNeededArg, + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*) +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->xCollNeeded = 0; + db->xCollNeeded16 = xCollNeeded16; + db->pCollNeededArg = pCollNeededArg; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** This function is now an anachronism. It used to be used to recover from a +** malloc() failure, but SQLite now does this automatically. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_global_recover(void){ + return SQLITE_OK; +} +#endif + +/* +** Test to see whether or not the database connection is in autocommit +** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on +** by default. Autocommit is disabled by a BEGIN statement and reenabled +** by the next COMMIT or ROLLBACK. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_get_autocommit(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->autoCommit; +} + +/* +** The following routines are substitutes for constants SQLITE_CORRUPT, +** SQLITE_MISUSE, SQLITE_CANTOPEN, SQLITE_IOERR and possibly other error +** constants. They serve two purposes: +** +** 1. Serve as a convenient place to set a breakpoint in a debugger +** to detect when version error conditions occurs. +** +** 2. Invoke sqlite3_log() to provide the source code location where +** a low-level error is first detected. +*/ +SQLITE_PRIVATE int sqlite3CorruptError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_CORRUPT, + "database corruption at line %d of [%.10s]", + lineno, 20+sqlite3_sourceid()); + return SQLITE_CORRUPT; +} +SQLITE_PRIVATE int sqlite3MisuseError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_MISUSE, + "misuse at line %d of [%.10s]", + lineno, 20+sqlite3_sourceid()); + return SQLITE_MISUSE; +} +SQLITE_PRIVATE int sqlite3CantopenError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_CANTOPEN, + "cannot open file at line %d of [%.10s]", + lineno, 20+sqlite3_sourceid()); + return SQLITE_CANTOPEN; +} + + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** This is a convenience routine that makes sure that all thread-specific +** data for this thread has been deallocated. +** +** SQLite no longer uses thread-specific data so this routine is now a +** no-op. It is retained for historical compatibility. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3_thread_cleanup(void){ +} +#endif + +/* +** Return meta information about a specific column of a database table. +** See comment in sqlite3.h (sqlite.h.in) for details. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +){ + int rc; + char *zErrMsg = 0; + Table *pTab = 0; + Column *pCol = 0; + int iCol = 0; + char const *zDataType = 0; + char const *zCollSeq = 0; + int notnull = 0; + int primarykey = 0; + int autoinc = 0; + + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + + /* Ensure the database schema has been loaded */ + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + rc = sqlite3Init(db, &zErrMsg); + if( SQLITE_OK!=rc ){ + goto error_out; + } + + /* Locate the table in question */ + pTab = sqlite3FindTable(db, zTableName, zDbName); + if( !pTab || pTab->pSelect ){ + pTab = 0; + goto error_out; + } + + /* Find the column for which info is requested */ + if( zColumnName==0 ){ + /* Query for existance of table only */ + }else{ + for(iCol=0; iColnCol; iCol++){ + pCol = &pTab->aCol[iCol]; + if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){ + break; + } + } + if( iCol==pTab->nCol ){ + if( HasRowid(pTab) && sqlite3IsRowid(zColumnName) ){ + iCol = pTab->iPKey; + pCol = iCol>=0 ? &pTab->aCol[iCol] : 0; + }else{ + pTab = 0; + goto error_out; + } + } + } + + /* The following block stores the meta information that will be returned + ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey + ** and autoinc. At this point there are two possibilities: + ** + ** 1. The specified column name was rowid", "oid" or "_rowid_" + ** and there is no explicitly declared IPK column. + ** + ** 2. The table is not a view and the column name identified an + ** explicitly declared column. Copy meta information from *pCol. + */ + if( pCol ){ + zDataType = pCol->zType; + zCollSeq = pCol->zColl; + notnull = pCol->notNull!=0; + primarykey = (pCol->colFlags & COLFLAG_PRIMKEY)!=0; + autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0; + }else{ + zDataType = "INTEGER"; + primarykey = 1; + } + if( !zCollSeq ){ + zCollSeq = "BINARY"; + } + +error_out: + sqlite3BtreeLeaveAll(db); + + /* Whether the function call succeeded or failed, set the output parameters + ** to whatever their local counterparts contain. If an error did occur, + ** this has the effect of zeroing all output parameters. + */ + if( pzDataType ) *pzDataType = zDataType; + if( pzCollSeq ) *pzCollSeq = zCollSeq; + if( pNotNull ) *pNotNull = notnull; + if( pPrimaryKey ) *pPrimaryKey = primarykey; + if( pAutoinc ) *pAutoinc = autoinc; + + if( SQLITE_OK==rc && !pTab ){ + sqlite3DbFree(db, zErrMsg); + zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName, + zColumnName); + rc = SQLITE_ERROR; + } + sqlite3ErrorWithMsg(db, rc, (zErrMsg?"%s":0), zErrMsg); + sqlite3DbFree(db, zErrMsg); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Sleep for a little while. Return the amount of time slept. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_sleep(int ms){ + sqlite3_vfs *pVfs; + int rc; + pVfs = sqlite3_vfs_find(0); + if( pVfs==0 ) return 0; + + /* This function works in milliseconds, but the underlying OsSleep() + ** API uses microseconds. Hence the 1000's. + */ + rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000); + return rc; +} + +/* +** Enable or disable the extended result codes. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_extended_result_codes(sqlite3 *db, int onoff){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->errMask = onoff ? 0xffffffff : 0xff; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Invoke the xFileControl method on a particular database. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){ + int rc = SQLITE_ERROR; + Btree *pBtree; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + pBtree = sqlite3DbNameToBtree(db, zDbName); + if( pBtree ){ + Pager *pPager; + sqlite3_file *fd; + sqlite3BtreeEnter(pBtree); + pPager = sqlite3BtreePager(pBtree); + assert( pPager!=0 ); + fd = sqlite3PagerFile(pPager); + assert( fd!=0 ); + if( op==SQLITE_FCNTL_FILE_POINTER ){ + *(sqlite3_file**)pArg = fd; + rc = SQLITE_OK; + }else if( fd->pMethods ){ + rc = sqlite3OsFileControl(fd, op, pArg); + }else{ + rc = SQLITE_NOTFOUND; + } + sqlite3BtreeLeave(pBtree); + } + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Interface to the testing logic. +*/ +SQLITE_API int SQLITE_CDECL sqlite3_test_control(int op, ...){ + int rc = 0; +#ifdef SQLITE_OMIT_BUILTIN_TEST + UNUSED_PARAMETER(op); +#else + va_list ap; + va_start(ap, op); + switch( op ){ + + /* + ** Save the current state of the PRNG. + */ + case SQLITE_TESTCTRL_PRNG_SAVE: { + sqlite3PrngSaveState(); + break; + } + + /* + ** Restore the state of the PRNG to the last state saved using + ** PRNG_SAVE. If PRNG_SAVE has never before been called, then + ** this verb acts like PRNG_RESET. + */ + case SQLITE_TESTCTRL_PRNG_RESTORE: { + sqlite3PrngRestoreState(); + break; + } + + /* + ** Reset the PRNG back to its uninitialized state. The next call + ** to sqlite3_randomness() will reseed the PRNG using a single call + ** to the xRandomness method of the default VFS. + */ + case SQLITE_TESTCTRL_PRNG_RESET: { + sqlite3_randomness(0,0); + break; + } + + /* + ** sqlite3_test_control(BITVEC_TEST, size, program) + ** + ** Run a test against a Bitvec object of size. The program argument + ** is an array of integers that defines the test. Return -1 on a + ** memory allocation error, 0 on success, or non-zero for an error. + ** See the sqlite3BitvecBuiltinTest() for additional information. + */ + case SQLITE_TESTCTRL_BITVEC_TEST: { + int sz = va_arg(ap, int); + int *aProg = va_arg(ap, int*); + rc = sqlite3BitvecBuiltinTest(sz, aProg); + break; + } + + /* + ** sqlite3_test_control(FAULT_INSTALL, xCallback) + ** + ** Arrange to invoke xCallback() whenever sqlite3FaultSim() is called, + ** if xCallback is not NULL. + ** + ** As a test of the fault simulator mechanism itself, sqlite3FaultSim(0) + ** is called immediately after installing the new callback and the return + ** value from sqlite3FaultSim(0) becomes the return from + ** sqlite3_test_control(). + */ + case SQLITE_TESTCTRL_FAULT_INSTALL: { + /* MSVC is picky about pulling func ptrs from va lists. + ** http://support.microsoft.com/kb/47961 + ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int)); + */ + typedef int(*TESTCALLBACKFUNC_t)(int); + sqlite3GlobalConfig.xTestCallback = va_arg(ap, TESTCALLBACKFUNC_t); + rc = sqlite3FaultSim(0); + break; + } + + /* + ** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd) + ** + ** Register hooks to call to indicate which malloc() failures + ** are benign. + */ + case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: { + typedef void (*void_function)(void); + void_function xBenignBegin; + void_function xBenignEnd; + xBenignBegin = va_arg(ap, void_function); + xBenignEnd = va_arg(ap, void_function); + sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd); + break; + } + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X) + ** + ** Set the PENDING byte to the value in the argument, if X>0. + ** Make no changes if X==0. Return the value of the pending byte + ** as it existing before this routine was called. + ** + ** IMPORTANT: Changing the PENDING byte from 0x40000000 results in + ** an incompatible database file format. Changing the PENDING byte + ** while any database connection is open results in undefined and + ** deleterious behavior. + */ + case SQLITE_TESTCTRL_PENDING_BYTE: { + rc = PENDING_BYTE; +#ifndef SQLITE_OMIT_WSD + { + unsigned int newVal = va_arg(ap, unsigned int); + if( newVal ) sqlite3PendingByte = newVal; + } +#endif + break; + } + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X) + ** + ** This action provides a run-time test to see whether or not + ** assert() was enabled at compile-time. If X is true and assert() + ** is enabled, then the return value is true. If X is true and + ** assert() is disabled, then the return value is zero. If X is + ** false and assert() is enabled, then the assertion fires and the + ** process aborts. If X is false and assert() is disabled, then the + ** return value is zero. + */ + case SQLITE_TESTCTRL_ASSERT: { + volatile int x = 0; + assert( (x = va_arg(ap,int))!=0 ); + rc = x; + break; + } + + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X) + ** + ** This action provides a run-time test to see how the ALWAYS and + ** NEVER macros were defined at compile-time. + ** + ** The return value is ALWAYS(X). + ** + ** The recommended test is X==2. If the return value is 2, that means + ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the + ** default setting. If the return value is 1, then ALWAYS() is either + ** hard-coded to true or else it asserts if its argument is false. + ** The first behavior (hard-coded to true) is the case if + ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second + ** behavior (assert if the argument to ALWAYS() is false) is the case if + ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled. + ** + ** The run-time test procedure might look something like this: + ** + ** if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){ + ** // ALWAYS() and NEVER() are no-op pass-through macros + ** }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){ + ** // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false. + ** }else{ + ** // ALWAYS(x) is a constant 1. NEVER(x) is a constant 0. + ** } + */ + case SQLITE_TESTCTRL_ALWAYS: { + int x = va_arg(ap,int); + rc = ALWAYS(x); + break; + } + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_BYTEORDER); + ** + ** The integer returned reveals the byte-order of the computer on which + ** SQLite is running: + ** + ** 1 big-endian, determined at run-time + ** 10 little-endian, determined at run-time + ** 432101 big-endian, determined at compile-time + ** 123410 little-endian, determined at compile-time + */ + case SQLITE_TESTCTRL_BYTEORDER: { + rc = SQLITE_BYTEORDER*100 + SQLITE_LITTLEENDIAN*10 + SQLITE_BIGENDIAN; + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_RESERVE, sqlite3 *db, int N) + ** + ** Set the nReserve size to N for the main database on the database + ** connection db. + */ + case SQLITE_TESTCTRL_RESERVE: { + sqlite3 *db = va_arg(ap, sqlite3*); + int x = va_arg(ap,int); + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0); + sqlite3_mutex_leave(db->mutex); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N) + ** + ** Enable or disable various optimizations for testing purposes. The + ** argument N is a bitmask of optimizations to be disabled. For normal + ** operation N should be 0. The idea is that a test program (like the + ** SQL Logic Test or SLT test module) can run the same SQL multiple times + ** with various optimizations disabled to verify that the same answer + ** is obtained in every case. + */ + case SQLITE_TESTCTRL_OPTIMIZATIONS: { + sqlite3 *db = va_arg(ap, sqlite3*); + db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff); + break; + } + +#ifdef SQLITE_N_KEYWORD + /* sqlite3_test_control(SQLITE_TESTCTRL_ISKEYWORD, const char *zWord) + ** + ** If zWord is a keyword recognized by the parser, then return the + ** number of keywords. Or if zWord is not a keyword, return 0. + ** + ** This test feature is only available in the amalgamation since + ** the SQLITE_N_KEYWORD macro is not defined in this file if SQLite + ** is built using separate source files. + */ + case SQLITE_TESTCTRL_ISKEYWORD: { + const char *zWord = va_arg(ap, const char*); + int n = sqlite3Strlen30(zWord); + rc = (sqlite3KeywordCode((u8*)zWord, n)!=TK_ID) ? SQLITE_N_KEYWORD : 0; + break; + } +#endif + + /* sqlite3_test_control(SQLITE_TESTCTRL_SCRATCHMALLOC, sz, &pNew, pFree); + ** + ** Pass pFree into sqlite3ScratchFree(). + ** If sz>0 then allocate a scratch buffer into pNew. + */ + case SQLITE_TESTCTRL_SCRATCHMALLOC: { + void *pFree, **ppNew; + int sz; + sz = va_arg(ap, int); + ppNew = va_arg(ap, void**); + pFree = va_arg(ap, void*); + if( sz ) *ppNew = sqlite3ScratchMalloc(sz); + sqlite3ScratchFree(pFree); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff); + ** + ** If parameter onoff is non-zero, configure the wrappers so that all + ** subsequent calls to localtime() and variants fail. If onoff is zero, + ** undo this setting. + */ + case SQLITE_TESTCTRL_LOCALTIME_FAULT: { + sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int); + ** + ** Set or clear a flag that indicates that the database file is always well- + ** formed and never corrupt. This flag is clear by default, indicating that + ** database files might have arbitrary corruption. Setting the flag during + ** testing causes certain assert() statements in the code to be activated + ** that demonstrat invariants on well-formed database files. + */ + case SQLITE_TESTCTRL_NEVER_CORRUPT: { + sqlite3GlobalConfig.neverCorrupt = va_arg(ap, int); + break; + } + + + /* sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr); + ** + ** Set the VDBE coverage callback function to xCallback with context + ** pointer ptr. + */ + case SQLITE_TESTCTRL_VDBE_COVERAGE: { +#ifdef SQLITE_VDBE_COVERAGE + typedef void (*branch_callback)(void*,int,u8,u8); + sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback); + sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*); +#endif + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */ + case SQLITE_TESTCTRL_SORTER_MMAP: { + sqlite3 *db = va_arg(ap, sqlite3*); + db->nMaxSorterMmap = va_arg(ap, int); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_ISINIT); + ** + ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if + ** not. + */ + case SQLITE_TESTCTRL_ISINIT: { + if( sqlite3GlobalConfig.isInit==0 ) rc = SQLITE_ERROR; + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum); + ** + ** This test control is used to create imposter tables. "db" is a pointer + ** to the database connection. dbName is the database name (ex: "main" or + ** "temp") which will receive the imposter. "onOff" turns imposter mode on + ** or off. "tnum" is the root page of the b-tree to which the imposter + ** table should connect. + ** + ** Enable imposter mode only when the schema has already been parsed. Then + ** run a single CREATE TABLE statement to construct the imposter table in + ** the parsed schema. Then turn imposter mode back off again. + ** + ** If onOff==0 and tnum>0 then reset the schema for all databases, causing + ** the schema to be reparsed the next time it is needed. This has the + ** effect of erasing all imposter tables. + */ + case SQLITE_TESTCTRL_IMPOSTER: { + sqlite3 *db = va_arg(ap, sqlite3*); + sqlite3_mutex_enter(db->mutex); + db->init.iDb = sqlite3FindDbName(db, va_arg(ap,const char*)); + db->init.busy = db->init.imposterTable = va_arg(ap,int); + db->init.newTnum = va_arg(ap,int); + if( db->init.busy==0 && db->init.newTnum>0 ){ + sqlite3ResetAllSchemasOfConnection(db); + } + sqlite3_mutex_leave(db->mutex); + break; + } + } + va_end(ap); +#endif /* SQLITE_OMIT_BUILTIN_TEST */ + return rc; +} + +/* +** This is a utility routine, useful to VFS implementations, that checks +** to see if a database file was a URI that contained a specific query +** parameter, and if so obtains the value of the query parameter. +** +** The zFilename argument is the filename pointer passed into the xOpen() +** method of a VFS implementation. The zParam argument is the name of the +** query parameter we seek. This routine returns the value of the zParam +** parameter if it exists. If the parameter does not exist, this routine +** returns a NULL pointer. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_uri_parameter(const char *zFilename, const char *zParam){ + if( zFilename==0 || zParam==0 ) return 0; + zFilename += sqlite3Strlen30(zFilename) + 1; + while( zFilename[0] ){ + int x = strcmp(zFilename, zParam); + zFilename += sqlite3Strlen30(zFilename) + 1; + if( x==0 ) return zFilename; + zFilename += sqlite3Strlen30(zFilename) + 1; + } + return 0; +} + +/* +** Return a boolean value for a query parameter. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_uri_boolean(const char *zFilename, const char *zParam, int bDflt){ + const char *z = sqlite3_uri_parameter(zFilename, zParam); + bDflt = bDflt!=0; + return z ? sqlite3GetBoolean(z, bDflt) : bDflt; +} + +/* +** Return a 64-bit integer value for a query parameter. +*/ +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_uri_int64( + const char *zFilename, /* Filename as passed to xOpen */ + const char *zParam, /* URI parameter sought */ + sqlite3_int64 bDflt /* return if parameter is missing */ +){ + const char *z = sqlite3_uri_parameter(zFilename, zParam); + sqlite3_int64 v; + if( z && sqlite3DecOrHexToI64(z, &v)==SQLITE_OK ){ + bDflt = v; + } + return bDflt; +} + +/* +** Return the Btree pointer identified by zDbName. Return NULL if not found. +*/ +SQLITE_PRIVATE Btree *sqlite3DbNameToBtree(sqlite3 *db, const char *zDbName){ + int i; + for(i=0; inDb; i++){ + if( db->aDb[i].pBt + && (zDbName==0 || sqlite3StrICmp(zDbName, db->aDb[i].zName)==0) + ){ + return db->aDb[i].pBt; + } + } + return 0; +} + +/* +** Return the filename of the database associated with a database +** connection. +*/ +SQLITE_API const char *SQLITE_STDCALL sqlite3_db_filename(sqlite3 *db, const char *zDbName){ + Btree *pBt; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + pBt = sqlite3DbNameToBtree(db, zDbName); + return pBt ? sqlite3BtreeGetFilename(pBt) : 0; +} + +/* +** Return 1 if database is read-only or 0 if read/write. Return -1 if +** no such database exists. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_db_readonly(sqlite3 *db, const char *zDbName){ + Btree *pBt; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return -1; + } +#endif + pBt = sqlite3DbNameToBtree(db, zDbName); + return pBt ? sqlite3BtreeIsReadonly(pBt) : -1; +} + +/************** End of main.c ************************************************/ +/************** Begin file notify.c ******************************************/ +/* +** 2009 March 3 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the implementation of the sqlite3_unlock_notify() +** API method and its associated functionality. +*/ +/* #include "sqliteInt.h" */ +/* #include "btreeInt.h" */ + +/* Omit this entire file if SQLITE_ENABLE_UNLOCK_NOTIFY is not defined. */ +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY + +/* +** Public interfaces: +** +** sqlite3ConnectionBlocked() +** sqlite3ConnectionUnlocked() +** sqlite3ConnectionClosed() +** sqlite3_unlock_notify() +*/ + +#define assertMutexHeld() \ + assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) ) + +/* +** Head of a linked list of all sqlite3 objects created by this process +** for which either sqlite3.pBlockingConnection or sqlite3.pUnlockConnection +** is not NULL. This variable may only accessed while the STATIC_MASTER +** mutex is held. +*/ +static sqlite3 *SQLITE_WSD sqlite3BlockedList = 0; + +#ifndef NDEBUG +/* +** This function is a complex assert() that verifies the following +** properties of the blocked connections list: +** +** 1) Each entry in the list has a non-NULL value for either +** pUnlockConnection or pBlockingConnection, or both. +** +** 2) All entries in the list that share a common value for +** xUnlockNotify are grouped together. +** +** 3) If the argument db is not NULL, then none of the entries in the +** blocked connections list have pUnlockConnection or pBlockingConnection +** set to db. This is used when closing connection db. +*/ +static void checkListProperties(sqlite3 *db){ + sqlite3 *p; + for(p=sqlite3BlockedList; p; p=p->pNextBlocked){ + int seen = 0; + sqlite3 *p2; + + /* Verify property (1) */ + assert( p->pUnlockConnection || p->pBlockingConnection ); + + /* Verify property (2) */ + for(p2=sqlite3BlockedList; p2!=p; p2=p2->pNextBlocked){ + if( p2->xUnlockNotify==p->xUnlockNotify ) seen = 1; + assert( p2->xUnlockNotify==p->xUnlockNotify || !seen ); + assert( db==0 || p->pUnlockConnection!=db ); + assert( db==0 || p->pBlockingConnection!=db ); + } + } +} +#else +# define checkListProperties(x) +#endif + +/* +** Remove connection db from the blocked connections list. If connection +** db is not currently a part of the list, this function is a no-op. +*/ +static void removeFromBlockedList(sqlite3 *db){ + sqlite3 **pp; + assertMutexHeld(); + for(pp=&sqlite3BlockedList; *pp; pp = &(*pp)->pNextBlocked){ + if( *pp==db ){ + *pp = (*pp)->pNextBlocked; + break; + } + } +} + +/* +** Add connection db to the blocked connections list. It is assumed +** that it is not already a part of the list. +*/ +static void addToBlockedList(sqlite3 *db){ + sqlite3 **pp; + assertMutexHeld(); + for( + pp=&sqlite3BlockedList; + *pp && (*pp)->xUnlockNotify!=db->xUnlockNotify; + pp=&(*pp)->pNextBlocked + ); + db->pNextBlocked = *pp; + *pp = db; +} + +/* +** Obtain the STATIC_MASTER mutex. +*/ +static void enterMutex(void){ + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)); + checkListProperties(0); +} + +/* +** Release the STATIC_MASTER mutex. +*/ +static void leaveMutex(void){ + assertMutexHeld(); + checkListProperties(0); + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)); +} + +/* +** Register an unlock-notify callback. +** +** This is called after connection "db" has attempted some operation +** but has received an SQLITE_LOCKED error because another connection +** (call it pOther) in the same process was busy using the same shared +** cache. pOther is found by looking at db->pBlockingConnection. +** +** If there is no blocking connection, the callback is invoked immediately, +** before this routine returns. +** +** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate +** a deadlock. +** +** Otherwise, make arrangements to invoke xNotify when pOther drops +** its locks. +** +** Each call to this routine overrides any prior callbacks registered +** on the same "db". If xNotify==0 then any prior callbacks are immediately +** cancelled. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_unlock_notify( + sqlite3 *db, + void (*xNotify)(void **, int), + void *pArg +){ + int rc = SQLITE_OK; + + sqlite3_mutex_enter(db->mutex); + enterMutex(); + + if( xNotify==0 ){ + removeFromBlockedList(db); + db->pBlockingConnection = 0; + db->pUnlockConnection = 0; + db->xUnlockNotify = 0; + db->pUnlockArg = 0; + }else if( 0==db->pBlockingConnection ){ + /* The blocking transaction has been concluded. Or there never was a + ** blocking transaction. In either case, invoke the notify callback + ** immediately. + */ + xNotify(&pArg, 1); + }else{ + sqlite3 *p; + + for(p=db->pBlockingConnection; p && p!=db; p=p->pUnlockConnection){} + if( p ){ + rc = SQLITE_LOCKED; /* Deadlock detected. */ + }else{ + db->pUnlockConnection = db->pBlockingConnection; + db->xUnlockNotify = xNotify; + db->pUnlockArg = pArg; + removeFromBlockedList(db); + addToBlockedList(db); + } + } + + leaveMutex(); + assert( !db->mallocFailed ); + sqlite3ErrorWithMsg(db, rc, (rc?"database is deadlocked":0)); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** This function is called while stepping or preparing a statement +** associated with connection db. The operation will return SQLITE_LOCKED +** to the user because it requires a lock that will not be available +** until connection pBlocker concludes its current transaction. +*/ +SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *db, sqlite3 *pBlocker){ + enterMutex(); + if( db->pBlockingConnection==0 && db->pUnlockConnection==0 ){ + addToBlockedList(db); + } + db->pBlockingConnection = pBlocker; + leaveMutex(); +} + +/* +** This function is called when +** the transaction opened by database db has just finished. Locks held +** by database connection db have been released. +** +** This function loops through each entry in the blocked connections +** list and does the following: +** +** 1) If the sqlite3.pBlockingConnection member of a list entry is +** set to db, then set pBlockingConnection=0. +** +** 2) If the sqlite3.pUnlockConnection member of a list entry is +** set to db, then invoke the configured unlock-notify callback and +** set pUnlockConnection=0. +** +** 3) If the two steps above mean that pBlockingConnection==0 and +** pUnlockConnection==0, remove the entry from the blocked connections +** list. +*/ +SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db){ + void (*xUnlockNotify)(void **, int) = 0; /* Unlock-notify cb to invoke */ + int nArg = 0; /* Number of entries in aArg[] */ + sqlite3 **pp; /* Iterator variable */ + void **aArg; /* Arguments to the unlock callback */ + void **aDyn = 0; /* Dynamically allocated space for aArg[] */ + void *aStatic[16]; /* Starter space for aArg[]. No malloc required */ + + aArg = aStatic; + enterMutex(); /* Enter STATIC_MASTER mutex */ + + /* This loop runs once for each entry in the blocked-connections list. */ + for(pp=&sqlite3BlockedList; *pp; /* no-op */ ){ + sqlite3 *p = *pp; + + /* Step 1. */ + if( p->pBlockingConnection==db ){ + p->pBlockingConnection = 0; + } + + /* Step 2. */ + if( p->pUnlockConnection==db ){ + assert( p->xUnlockNotify ); + if( p->xUnlockNotify!=xUnlockNotify && nArg!=0 ){ + xUnlockNotify(aArg, nArg); + nArg = 0; + } + + sqlite3BeginBenignMalloc(); + assert( aArg==aDyn || (aDyn==0 && aArg==aStatic) ); + assert( nArg<=(int)ArraySize(aStatic) || aArg==aDyn ); + if( (!aDyn && nArg==(int)ArraySize(aStatic)) + || (aDyn && nArg==(int)(sqlite3MallocSize(aDyn)/sizeof(void*))) + ){ + /* The aArg[] array needs to grow. */ + void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2); + if( pNew ){ + memcpy(pNew, aArg, nArg*sizeof(void *)); + sqlite3_free(aDyn); + aDyn = aArg = pNew; + }else{ + /* This occurs when the array of context pointers that need to + ** be passed to the unlock-notify callback is larger than the + ** aStatic[] array allocated on the stack and the attempt to + ** allocate a larger array from the heap has failed. + ** + ** This is a difficult situation to handle. Returning an error + ** code to the caller is insufficient, as even if an error code + ** is returned the transaction on connection db will still be + ** closed and the unlock-notify callbacks on blocked connections + ** will go unissued. This might cause the application to wait + ** indefinitely for an unlock-notify callback that will never + ** arrive. + ** + ** Instead, invoke the unlock-notify callback with the context + ** array already accumulated. We can then clear the array and + ** begin accumulating any further context pointers without + ** requiring any dynamic allocation. This is sub-optimal because + ** it means that instead of one callback with a large array of + ** context pointers the application will receive two or more + ** callbacks with smaller arrays of context pointers, which will + ** reduce the applications ability to prioritize multiple + ** connections. But it is the best that can be done under the + ** circumstances. + */ + xUnlockNotify(aArg, nArg); + nArg = 0; + } + } + sqlite3EndBenignMalloc(); + + aArg[nArg++] = p->pUnlockArg; + xUnlockNotify = p->xUnlockNotify; + p->pUnlockConnection = 0; + p->xUnlockNotify = 0; + p->pUnlockArg = 0; + } + + /* Step 3. */ + if( p->pBlockingConnection==0 && p->pUnlockConnection==0 ){ + /* Remove connection p from the blocked connections list. */ + *pp = p->pNextBlocked; + p->pNextBlocked = 0; + }else{ + pp = &p->pNextBlocked; + } + } + + if( nArg!=0 ){ + xUnlockNotify(aArg, nArg); + } + sqlite3_free(aDyn); + leaveMutex(); /* Leave STATIC_MASTER mutex */ +} + +/* +** This is called when the database connection passed as an argument is +** being closed. The connection is removed from the blocked list. +*/ +SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db){ + sqlite3ConnectionUnlocked(db); + enterMutex(); + removeFromBlockedList(db); + checkListProperties(db); + leaveMutex(); +} +#endif + +/************** End of notify.c **********************************************/ +/************** Begin file fts3.c ********************************************/ +/* +** 2006 Oct 10 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This is an SQLite module implementing full-text search. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ + +/* The full-text index is stored in a series of b+tree (-like) +** structures called segments which map terms to doclists. The +** structures are like b+trees in layout, but are constructed from the +** bottom up in optimal fashion and are not updatable. Since trees +** are built from the bottom up, things will be described from the +** bottom up. +** +** +**** Varints **** +** The basic unit of encoding is a variable-length integer called a +** varint. We encode variable-length integers in little-endian order +** using seven bits * per byte as follows: +** +** KEY: +** A = 0xxxxxxx 7 bits of data and one flag bit +** B = 1xxxxxxx 7 bits of data and one flag bit +** +** 7 bits - A +** 14 bits - BA +** 21 bits - BBA +** and so on. +** +** This is similar in concept to how sqlite encodes "varints" but +** the encoding is not the same. SQLite varints are big-endian +** are are limited to 9 bytes in length whereas FTS3 varints are +** little-endian and can be up to 10 bytes in length (in theory). +** +** Example encodings: +** +** 1: 0x01 +** 127: 0x7f +** 128: 0x81 0x00 +** +** +**** Document lists **** +** A doclist (document list) holds a docid-sorted list of hits for a +** given term. Doclists hold docids and associated token positions. +** A docid is the unique integer identifier for a single document. +** A position is the index of a word within the document. The first +** word of the document has a position of 0. +** +** FTS3 used to optionally store character offsets using a compile-time +** option. But that functionality is no longer supported. +** +** A doclist is stored like this: +** +** array { +** varint docid; (delta from previous doclist) +** array { (position list for column 0) +** varint position; (2 more than the delta from previous position) +** } +** array { +** varint POS_COLUMN; (marks start of position list for new column) +** varint column; (index of new column) +** array { +** varint position; (2 more than the delta from previous position) +** } +** } +** varint POS_END; (marks end of positions for this document. +** } +** +** Here, array { X } means zero or more occurrences of X, adjacent in +** memory. A "position" is an index of a token in the token stream +** generated by the tokenizer. Note that POS_END and POS_COLUMN occur +** in the same logical place as the position element, and act as sentinals +** ending a position list array. POS_END is 0. POS_COLUMN is 1. +** The positions numbers are not stored literally but rather as two more +** than the difference from the prior position, or the just the position plus +** 2 for the first position. Example: +** +** label: A B C D E F G H I J K +** value: 123 5 9 1 1 14 35 0 234 72 0 +** +** The 123 value is the first docid. For column zero in this document +** there are two matches at positions 3 and 10 (5-2 and 9-2+3). The 1 +** at D signals the start of a new column; the 1 at E indicates that the +** new column is column number 1. There are two positions at 12 and 45 +** (14-2 and 35-2+12). The 0 at H indicate the end-of-document. The +** 234 at I is the delta to next docid (357). It has one position 70 +** (72-2) and then terminates with the 0 at K. +** +** A "position-list" is the list of positions for multiple columns for +** a single docid. A "column-list" is the set of positions for a single +** column. Hence, a position-list consists of one or more column-lists, +** a document record consists of a docid followed by a position-list and +** a doclist consists of one or more document records. +** +** A bare doclist omits the position information, becoming an +** array of varint-encoded docids. +** +**** Segment leaf nodes **** +** Segment leaf nodes store terms and doclists, ordered by term. Leaf +** nodes are written using LeafWriter, and read using LeafReader (to +** iterate through a single leaf node's data) and LeavesReader (to +** iterate through a segment's entire leaf layer). Leaf nodes have +** the format: +** +** varint iHeight; (height from leaf level, always 0) +** varint nTerm; (length of first term) +** char pTerm[nTerm]; (content of first term) +** varint nDoclist; (length of term's associated doclist) +** char pDoclist[nDoclist]; (content of doclist) +** array { +** (further terms are delta-encoded) +** varint nPrefix; (length of prefix shared with previous term) +** varint nSuffix; (length of unshared suffix) +** char pTermSuffix[nSuffix];(unshared suffix of next term) +** varint nDoclist; (length of term's associated doclist) +** char pDoclist[nDoclist]; (content of doclist) +** } +** +** Here, array { X } means zero or more occurrences of X, adjacent in +** memory. +** +** Leaf nodes are broken into blocks which are stored contiguously in +** the %_segments table in sorted order. This means that when the end +** of a node is reached, the next term is in the node with the next +** greater node id. +** +** New data is spilled to a new leaf node when the current node +** exceeds LEAF_MAX bytes (default 2048). New data which itself is +** larger than STANDALONE_MIN (default 1024) is placed in a standalone +** node (a leaf node with a single term and doclist). The goal of +** these settings is to pack together groups of small doclists while +** making it efficient to directly access large doclists. The +** assumption is that large doclists represent terms which are more +** likely to be query targets. +** +** TODO(shess) It may be useful for blocking decisions to be more +** dynamic. For instance, it may make more sense to have a 2.5k leaf +** node rather than splitting into 2k and .5k nodes. My intuition is +** that this might extend through 2x or 4x the pagesize. +** +** +**** Segment interior nodes **** +** Segment interior nodes store blockids for subtree nodes and terms +** to describe what data is stored by the each subtree. Interior +** nodes are written using InteriorWriter, and read using +** InteriorReader. InteriorWriters are created as needed when +** SegmentWriter creates new leaf nodes, or when an interior node +** itself grows too big and must be split. The format of interior +** nodes: +** +** varint iHeight; (height from leaf level, always >0) +** varint iBlockid; (block id of node's leftmost subtree) +** optional { +** varint nTerm; (length of first term) +** char pTerm[nTerm]; (content of first term) +** array { +** (further terms are delta-encoded) +** varint nPrefix; (length of shared prefix with previous term) +** varint nSuffix; (length of unshared suffix) +** char pTermSuffix[nSuffix]; (unshared suffix of next term) +** } +** } +** +** Here, optional { X } means an optional element, while array { X } +** means zero or more occurrences of X, adjacent in memory. +** +** An interior node encodes n terms separating n+1 subtrees. The +** subtree blocks are contiguous, so only the first subtree's blockid +** is encoded. The subtree at iBlockid will contain all terms less +** than the first term encoded (or all terms if no term is encoded). +** Otherwise, for terms greater than or equal to pTerm[i] but less +** than pTerm[i+1], the subtree for that term will be rooted at +** iBlockid+i. Interior nodes only store enough term data to +** distinguish adjacent children (if the rightmost term of the left +** child is "something", and the leftmost term of the right child is +** "wicked", only "w" is stored). +** +** New data is spilled to a new interior node at the same height when +** the current node exceeds INTERIOR_MAX bytes (default 2048). +** INTERIOR_MIN_TERMS (default 7) keeps large terms from monopolizing +** interior nodes and making the tree too skinny. The interior nodes +** at a given height are naturally tracked by interior nodes at +** height+1, and so on. +** +** +**** Segment directory **** +** The segment directory in table %_segdir stores meta-information for +** merging and deleting segments, and also the root node of the +** segment's tree. +** +** The root node is the top node of the segment's tree after encoding +** the entire segment, restricted to ROOT_MAX bytes (default 1024). +** This could be either a leaf node or an interior node. If the top +** node requires more than ROOT_MAX bytes, it is flushed to %_segments +** and a new root interior node is generated (which should always fit +** within ROOT_MAX because it only needs space for 2 varints, the +** height and the blockid of the previous root). +** +** The meta-information in the segment directory is: +** level - segment level (see below) +** idx - index within level +** - (level,idx uniquely identify a segment) +** start_block - first leaf node +** leaves_end_block - last leaf node +** end_block - last block (including interior nodes) +** root - contents of root node +** +** If the root node is a leaf node, then start_block, +** leaves_end_block, and end_block are all 0. +** +** +**** Segment merging **** +** To amortize update costs, segments are grouped into levels and +** merged in batches. Each increase in level represents exponentially +** more documents. +** +** New documents (actually, document updates) are tokenized and +** written individually (using LeafWriter) to a level 0 segment, with +** incrementing idx. When idx reaches MERGE_COUNT (default 16), all +** level 0 segments are merged into a single level 1 segment. Level 1 +** is populated like level 0, and eventually MERGE_COUNT level 1 +** segments are merged to a single level 2 segment (representing +** MERGE_COUNT^2 updates), and so on. +** +** A segment merge traverses all segments at a given level in +** parallel, performing a straightforward sorted merge. Since segment +** leaf nodes are written in to the %_segments table in order, this +** merge traverses the underlying sqlite disk structures efficiently. +** After the merge, all segment blocks from the merged level are +** deleted. +** +** MERGE_COUNT controls how often we merge segments. 16 seems to be +** somewhat of a sweet spot for insertion performance. 32 and 64 show +** very similar performance numbers to 16 on insertion, though they're +** a tiny bit slower (perhaps due to more overhead in merge-time +** sorting). 8 is about 20% slower than 16, 4 about 50% slower than +** 16, 2 about 66% slower than 16. +** +** At query time, high MERGE_COUNT increases the number of segments +** which need to be scanned and merged. For instance, with 100k docs +** inserted: +** +** MERGE_COUNT segments +** 16 25 +** 8 12 +** 4 10 +** 2 6 +** +** This appears to have only a moderate impact on queries for very +** frequent terms (which are somewhat dominated by segment merge +** costs), and infrequent and non-existent terms still seem to be fast +** even with many segments. +** +** TODO(shess) That said, it would be nice to have a better query-side +** argument for MERGE_COUNT of 16. Also, it is possible/likely that +** optimizations to things like doclist merging will swing the sweet +** spot around. +** +** +** +**** Handling of deletions and updates **** +** Since we're using a segmented structure, with no docid-oriented +** index into the term index, we clearly cannot simply update the term +** index when a document is deleted or updated. For deletions, we +** write an empty doclist (varint(docid) varint(POS_END)), for updates +** we simply write the new doclist. Segment merges overwrite older +** data for a particular docid with newer data, so deletes or updates +** will eventually overtake the earlier data and knock it out. The +** query logic likewise merges doclists so that newer data knocks out +** older data. +*/ + +/************** Include fts3Int.h in the middle of fts3.c ********************/ +/************** Begin file fts3Int.h *****************************************/ +/* +** 2009 Nov 12 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +*/ +#ifndef _FTSINT_H +#define _FTSINT_H + +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif + +/* +** FTS4 is really an extension for FTS3. It is enabled using the +** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also all +** the SQLITE_ENABLE_FTS4 macro to serve as an alisse for SQLITE_ENABLE_FTS3. +*/ +#if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3) +# define SQLITE_ENABLE_FTS3 +#endif + +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* If not building as part of the core, include sqlite3ext.h. */ +#ifndef SQLITE_CORE +/* # include "sqlite3ext.h" */ +SQLITE_EXTENSION_INIT3 +#endif + +/* #include "sqlite3.h" */ +/************** Include fts3_tokenizer.h in the middle of fts3Int.h **********/ +/************** Begin file fts3_tokenizer.h **********************************/ +/* +** 2006 July 10 +** +** The author disclaims copyright to this source code. +** +************************************************************************* +** Defines the interface to tokenizers used by fulltext-search. There +** are three basic components: +** +** sqlite3_tokenizer_module is a singleton defining the tokenizer +** interface functions. This is essentially the class structure for +** tokenizers. +** +** sqlite3_tokenizer is used to define a particular tokenizer, perhaps +** including customization information defined at creation time. +** +** sqlite3_tokenizer_cursor is generated by a tokenizer to generate +** tokens from a particular input. +*/ +#ifndef _FTS3_TOKENIZER_H_ +#define _FTS3_TOKENIZER_H_ + +/* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time. +** If tokenizers are to be allowed to call sqlite3_*() functions, then +** we will need a way to register the API consistently. +*/ +/* #include "sqlite3.h" */ + +/* +** Structures used by the tokenizer interface. When a new tokenizer +** implementation is registered, the caller provides a pointer to +** an sqlite3_tokenizer_module containing pointers to the callback +** functions that make up an implementation. +** +** When an fts3 table is created, it passes any arguments passed to +** the tokenizer clause of the CREATE VIRTUAL TABLE statement to the +** sqlite3_tokenizer_module.xCreate() function of the requested tokenizer +** implementation. The xCreate() function in turn returns an +** sqlite3_tokenizer structure representing the specific tokenizer to +** be used for the fts3 table (customized by the tokenizer clause arguments). +** +** To tokenize an input buffer, the sqlite3_tokenizer_module.xOpen() +** method is called. It returns an sqlite3_tokenizer_cursor object +** that may be used to tokenize a specific input buffer based on +** the tokenization rules supplied by a specific sqlite3_tokenizer +** object. +*/ +typedef struct sqlite3_tokenizer_module sqlite3_tokenizer_module; +typedef struct sqlite3_tokenizer sqlite3_tokenizer; +typedef struct sqlite3_tokenizer_cursor sqlite3_tokenizer_cursor; + +struct sqlite3_tokenizer_module { + + /* + ** Structure version. Should always be set to 0 or 1. + */ + int iVersion; + + /* + ** Create a new tokenizer. The values in the argv[] array are the + ** arguments passed to the "tokenizer" clause of the CREATE VIRTUAL + ** TABLE statement that created the fts3 table. For example, if + ** the following SQL is executed: + ** + ** CREATE .. USING fts3( ... , tokenizer arg1 arg2) + ** + ** then argc is set to 2, and the argv[] array contains pointers + ** to the strings "arg1" and "arg2". + ** + ** This method should return either SQLITE_OK (0), or an SQLite error + ** code. If SQLITE_OK is returned, then *ppTokenizer should be set + ** to point at the newly created tokenizer structure. The generic + ** sqlite3_tokenizer.pModule variable should not be initialized by + ** this callback. The caller will do so. + */ + int (*xCreate)( + int argc, /* Size of argv array */ + const char *const*argv, /* Tokenizer argument strings */ + sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */ + ); + + /* + ** Destroy an existing tokenizer. The fts3 module calls this method + ** exactly once for each successful call to xCreate(). + */ + int (*xDestroy)(sqlite3_tokenizer *pTokenizer); + + /* + ** Create a tokenizer cursor to tokenize an input buffer. The caller + ** is responsible for ensuring that the input buffer remains valid + ** until the cursor is closed (using the xClose() method). + */ + int (*xOpen)( + sqlite3_tokenizer *pTokenizer, /* Tokenizer object */ + const char *pInput, int nBytes, /* Input buffer */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Created tokenizer cursor */ + ); + + /* + ** Destroy an existing tokenizer cursor. The fts3 module calls this + ** method exactly once for each successful call to xOpen(). + */ + int (*xClose)(sqlite3_tokenizer_cursor *pCursor); + + /* + ** Retrieve the next token from the tokenizer cursor pCursor. This + ** method should either return SQLITE_OK and set the values of the + ** "OUT" variables identified below, or SQLITE_DONE to indicate that + ** the end of the buffer has been reached, or an SQLite error code. + ** + ** *ppToken should be set to point at a buffer containing the + ** normalized version of the token (i.e. after any case-folding and/or + ** stemming has been performed). *pnBytes should be set to the length + ** of this buffer in bytes. The input text that generated the token is + ** identified by the byte offsets returned in *piStartOffset and + ** *piEndOffset. *piStartOffset should be set to the index of the first + ** byte of the token in the input buffer. *piEndOffset should be set + ** to the index of the first byte just past the end of the token in + ** the input buffer. + ** + ** The buffer *ppToken is set to point at is managed by the tokenizer + ** implementation. It is only required to be valid until the next call + ** to xNext() or xClose(). + */ + /* TODO(shess) current implementation requires pInput to be + ** nul-terminated. This should either be fixed, or pInput/nBytes + ** should be converted to zInput. + */ + int (*xNext)( + sqlite3_tokenizer_cursor *pCursor, /* Tokenizer cursor */ + const char **ppToken, int *pnBytes, /* OUT: Normalized text for token */ + int *piStartOffset, /* OUT: Byte offset of token in input buffer */ + int *piEndOffset, /* OUT: Byte offset of end of token in input buffer */ + int *piPosition /* OUT: Number of tokens returned before this one */ + ); + + /*********************************************************************** + ** Methods below this point are only available if iVersion>=1. + */ + + /* + ** Configure the language id of a tokenizer cursor. + */ + int (*xLanguageid)(sqlite3_tokenizer_cursor *pCsr, int iLangid); +}; + +struct sqlite3_tokenizer { + const sqlite3_tokenizer_module *pModule; /* The module for this tokenizer */ + /* Tokenizer implementations will typically add additional fields */ +}; + +struct sqlite3_tokenizer_cursor { + sqlite3_tokenizer *pTokenizer; /* Tokenizer for this cursor. */ + /* Tokenizer implementations will typically add additional fields */ +}; + +int fts3_global_term_cnt(int iTerm, int iCol); +int fts3_term_cnt(int iTerm, int iCol); + + +#endif /* _FTS3_TOKENIZER_H_ */ + +/************** End of fts3_tokenizer.h **************************************/ +/************** Continuing where we left off in fts3Int.h ********************/ +/************** Include fts3_hash.h in the middle of fts3Int.h ***************/ +/************** Begin file fts3_hash.h ***************************************/ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the header file for the generic hash-table implementation +** used in SQLite. We've modified it slightly to serve as a standalone +** hash table implementation for the full-text indexing module. +** +*/ +#ifndef _FTS3_HASH_H_ +#define _FTS3_HASH_H_ + +/* Forward declarations of structures. */ +typedef struct Fts3Hash Fts3Hash; +typedef struct Fts3HashElem Fts3HashElem; + +/* A complete hash table is an instance of the following structure. +** The internals of this structure are intended to be opaque -- client +** code should not attempt to access or modify the fields of this structure +** directly. Change this structure only by using the routines below. +** However, many of the "procedures" and "functions" for modifying and +** accessing this structure are really macros, so we can't really make +** this structure opaque. +*/ +struct Fts3Hash { + char keyClass; /* HASH_INT, _POINTER, _STRING, _BINARY */ + char copyKey; /* True if copy of key made on insert */ + int count; /* Number of entries in this table */ + Fts3HashElem *first; /* The first element of the array */ + int htsize; /* Number of buckets in the hash table */ + struct _fts3ht { /* the hash table */ + int count; /* Number of entries with this hash */ + Fts3HashElem *chain; /* Pointer to first entry with this hash */ + } *ht; +}; + +/* Each element in the hash table is an instance of the following +** structure. All elements are stored on a single doubly-linked list. +** +** Again, this structure is intended to be opaque, but it can't really +** be opaque because it is used by macros. +*/ +struct Fts3HashElem { + Fts3HashElem *next, *prev; /* Next and previous elements in the table */ + void *data; /* Data associated with this element */ + void *pKey; int nKey; /* Key associated with this element */ +}; + +/* +** There are 2 different modes of operation for a hash table: +** +** FTS3_HASH_STRING pKey points to a string that is nKey bytes long +** (including the null-terminator, if any). Case +** is respected in comparisons. +** +** FTS3_HASH_BINARY pKey points to binary data nKey bytes long. +** memcmp() is used to compare keys. +** +** A copy of the key is made if the copyKey parameter to fts3HashInit is 1. +*/ +#define FTS3_HASH_STRING 1 +#define FTS3_HASH_BINARY 2 + +/* +** Access routines. To delete, insert a NULL pointer. +*/ +SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey); +SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData); +SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey); +SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash*); +SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const void *, int); + +/* +** Shorthand for the functions above +*/ +#define fts3HashInit sqlite3Fts3HashInit +#define fts3HashInsert sqlite3Fts3HashInsert +#define fts3HashFind sqlite3Fts3HashFind +#define fts3HashClear sqlite3Fts3HashClear +#define fts3HashFindElem sqlite3Fts3HashFindElem + +/* +** Macros for looping over all elements of a hash table. The idiom is +** like this: +** +** Fts3Hash h; +** Fts3HashElem *p; +** ... +** for(p=fts3HashFirst(&h); p; p=fts3HashNext(p)){ +** SomeStructure *pData = fts3HashData(p); +** // do something with pData +** } +*/ +#define fts3HashFirst(H) ((H)->first) +#define fts3HashNext(E) ((E)->next) +#define fts3HashData(E) ((E)->data) +#define fts3HashKey(E) ((E)->pKey) +#define fts3HashKeysize(E) ((E)->nKey) + +/* +** Number of entries in a hash table +*/ +#define fts3HashCount(H) ((H)->count) + +#endif /* _FTS3_HASH_H_ */ + +/************** End of fts3_hash.h *******************************************/ +/************** Continuing where we left off in fts3Int.h ********************/ + +/* +** This constant determines the maximum depth of an FTS expression tree +** that the library will create and use. FTS uses recursion to perform +** various operations on the query tree, so the disadvantage of a large +** limit is that it may allow very large queries to use large amounts +** of stack space (perhaps causing a stack overflow). +*/ +#ifndef SQLITE_FTS3_MAX_EXPR_DEPTH +# define SQLITE_FTS3_MAX_EXPR_DEPTH 12 +#endif + + +/* +** This constant controls how often segments are merged. Once there are +** FTS3_MERGE_COUNT segments of level N, they are merged into a single +** segment of level N+1. +*/ +#define FTS3_MERGE_COUNT 16 + +/* +** This is the maximum amount of data (in bytes) to store in the +** Fts3Table.pendingTerms hash table. Normally, the hash table is +** populated as documents are inserted/updated/deleted in a transaction +** and used to create a new segment when the transaction is committed. +** However if this limit is reached midway through a transaction, a new +** segment is created and the hash table cleared immediately. +*/ +#define FTS3_MAX_PENDING_DATA (1*1024*1024) + +/* +** Macro to return the number of elements in an array. SQLite has a +** similar macro called ArraySize(). Use a different name to avoid +** a collision when building an amalgamation with built-in FTS3. +*/ +#define SizeofArray(X) ((int)(sizeof(X)/sizeof(X[0]))) + + +#ifndef MIN +# define MIN(x,y) ((x)<(y)?(x):(y)) +#endif +#ifndef MAX +# define MAX(x,y) ((x)>(y)?(x):(y)) +#endif + +/* +** Maximum length of a varint encoded integer. The varint format is different +** from that used by SQLite, so the maximum length is 10, not 9. +*/ +#define FTS3_VARINT_MAX 10 + +/* +** FTS4 virtual tables may maintain multiple indexes - one index of all terms +** in the document set and zero or more prefix indexes. All indexes are stored +** as one or more b+-trees in the %_segments and %_segdir tables. +** +** It is possible to determine which index a b+-tree belongs to based on the +** value stored in the "%_segdir.level" column. Given this value L, the index +** that the b+-tree belongs to is (L<<10). In other words, all b+-trees with +** level values between 0 and 1023 (inclusive) belong to index 0, all levels +** between 1024 and 2047 to index 1, and so on. +** +** It is considered impossible for an index to use more than 1024 levels. In +** theory though this may happen, but only after at least +** (FTS3_MERGE_COUNT^1024) separate flushes of the pending-terms tables. +*/ +#define FTS3_SEGDIR_MAXLEVEL 1024 +#define FTS3_SEGDIR_MAXLEVEL_STR "1024" + +/* +** The testcase() macro is only used by the amalgamation. If undefined, +** make it a no-op. +*/ +#ifndef testcase +# define testcase(X) +#endif + +/* +** Terminator values for position-lists and column-lists. +*/ +#define POS_COLUMN (1) /* Column-list terminator */ +#define POS_END (0) /* Position-list terminator */ + +/* +** This section provides definitions to allow the +** FTS3 extension to be compiled outside of the +** amalgamation. +*/ +#ifndef SQLITE_AMALGAMATION +/* +** Macros indicating that conditional expressions are always true or +** false. +*/ +#ifdef SQLITE_COVERAGE_TEST +# define ALWAYS(x) (1) +# define NEVER(X) (0) +#elif defined(SQLITE_DEBUG) +# define ALWAYS(x) sqlite3Fts3Always((x)!=0) +# define NEVER(x) sqlite3Fts3Never((x)!=0) +SQLITE_PRIVATE int sqlite3Fts3Always(int b); +SQLITE_PRIVATE int sqlite3Fts3Never(int b); +#else +# define ALWAYS(x) (x) +# define NEVER(x) (x) +#endif + +/* +** Internal types used by SQLite. +*/ +typedef unsigned char u8; /* 1-byte (or larger) unsigned integer */ +typedef short int i16; /* 2-byte (or larger) signed integer */ +typedef unsigned int u32; /* 4-byte unsigned integer */ +typedef sqlite3_uint64 u64; /* 8-byte unsigned integer */ +typedef sqlite3_int64 i64; /* 8-byte signed integer */ + +/* +** Macro used to suppress compiler warnings for unused parameters. +*/ +#define UNUSED_PARAMETER(x) (void)(x) + +/* +** Activate assert() only if SQLITE_TEST is enabled. +*/ +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif + +/* +** The TESTONLY macro is used to enclose variable declarations or +** other bits of code that are needed to support the arguments +** within testcase() and assert() macros. +*/ +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) +# define TESTONLY(X) X +#else +# define TESTONLY(X) +#endif + +#endif /* SQLITE_AMALGAMATION */ + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3Fts3Corrupt(void); +# define FTS_CORRUPT_VTAB sqlite3Fts3Corrupt() +#else +# define FTS_CORRUPT_VTAB SQLITE_CORRUPT_VTAB +#endif + +typedef struct Fts3Table Fts3Table; +typedef struct Fts3Cursor Fts3Cursor; +typedef struct Fts3Expr Fts3Expr; +typedef struct Fts3Phrase Fts3Phrase; +typedef struct Fts3PhraseToken Fts3PhraseToken; + +typedef struct Fts3Doclist Fts3Doclist; +typedef struct Fts3SegFilter Fts3SegFilter; +typedef struct Fts3DeferredToken Fts3DeferredToken; +typedef struct Fts3SegReader Fts3SegReader; +typedef struct Fts3MultiSegReader Fts3MultiSegReader; + +typedef struct MatchinfoBuffer MatchinfoBuffer; + +/* +** A connection to a fulltext index is an instance of the following +** structure. The xCreate and xConnect methods create an instance +** of this structure and xDestroy and xDisconnect free that instance. +** All other methods receive a pointer to the structure as one of their +** arguments. +*/ +struct Fts3Table { + sqlite3_vtab base; /* Base class used by SQLite core */ + sqlite3 *db; /* The database connection */ + const char *zDb; /* logical database name */ + const char *zName; /* virtual table name */ + int nColumn; /* number of named columns in virtual table */ + char **azColumn; /* column names. malloced */ + u8 *abNotindexed; /* True for 'notindexed' columns */ + sqlite3_tokenizer *pTokenizer; /* tokenizer for inserts and queries */ + char *zContentTbl; /* content=xxx option, or NULL */ + char *zLanguageid; /* languageid=xxx option, or NULL */ + int nAutoincrmerge; /* Value configured by 'automerge' */ + u32 nLeafAdd; /* Number of leaf blocks added this trans */ + + /* Precompiled statements used by the implementation. Each of these + ** statements is run and reset within a single virtual table API call. + */ + sqlite3_stmt *aStmt[40]; + + char *zReadExprlist; + char *zWriteExprlist; + + int nNodeSize; /* Soft limit for node size */ + u8 bFts4; /* True for FTS4, false for FTS3 */ + u8 bHasStat; /* True if %_stat table exists (2==unknown) */ + u8 bHasDocsize; /* True if %_docsize table exists */ + u8 bDescIdx; /* True if doclists are in reverse order */ + u8 bIgnoreSavepoint; /* True to ignore xSavepoint invocations */ + int nPgsz; /* Page size for host database */ + char *zSegmentsTbl; /* Name of %_segments table */ + sqlite3_blob *pSegments; /* Blob handle open on %_segments table */ + + /* + ** The following array of hash tables is used to buffer pending index + ** updates during transactions. All pending updates buffered at any one + ** time must share a common language-id (see the FTS4 langid= feature). + ** The current language id is stored in variable iPrevLangid. + ** + ** A single FTS4 table may have multiple full-text indexes. For each index + ** there is an entry in the aIndex[] array. Index 0 is an index of all the + ** terms that appear in the document set. Each subsequent index in aIndex[] + ** is an index of prefixes of a specific length. + ** + ** Variable nPendingData contains an estimate the memory consumed by the + ** pending data structures, including hash table overhead, but not including + ** malloc overhead. When nPendingData exceeds nMaxPendingData, all hash + ** tables are flushed to disk. Variable iPrevDocid is the docid of the most + ** recently inserted record. + */ + int nIndex; /* Size of aIndex[] */ + struct Fts3Index { + int nPrefix; /* Prefix length (0 for main terms index) */ + Fts3Hash hPending; /* Pending terms table for this index */ + } *aIndex; + int nMaxPendingData; /* Max pending data before flush to disk */ + int nPendingData; /* Current bytes of pending data */ + sqlite_int64 iPrevDocid; /* Docid of most recently inserted document */ + int iPrevLangid; /* Langid of recently inserted document */ + int bPrevDelete; /* True if last operation was a delete */ + +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) + /* State variables used for validating that the transaction control + ** methods of the virtual table are called at appropriate times. These + ** values do not contribute to FTS functionality; they are used for + ** verifying the operation of the SQLite core. + */ + int inTransaction; /* True after xBegin but before xCommit/xRollback */ + int mxSavepoint; /* Largest valid xSavepoint integer */ +#endif + +#ifdef SQLITE_TEST + /* True to disable the incremental doclist optimization. This is controled + ** by special insert command 'test-no-incr-doclist'. */ + int bNoIncrDoclist; +#endif +}; + +/* +** When the core wants to read from the virtual table, it creates a +** virtual table cursor (an instance of the following structure) using +** the xOpen method. Cursors are destroyed using the xClose method. +*/ +struct Fts3Cursor { + sqlite3_vtab_cursor base; /* Base class used by SQLite core */ + i16 eSearch; /* Search strategy (see below) */ + u8 isEof; /* True if at End Of Results */ + u8 isRequireSeek; /* True if must seek pStmt to %_content row */ + sqlite3_stmt *pStmt; /* Prepared statement in use by the cursor */ + Fts3Expr *pExpr; /* Parsed MATCH query string */ + int iLangid; /* Language being queried for */ + int nPhrase; /* Number of matchable phrases in query */ + Fts3DeferredToken *pDeferred; /* Deferred search tokens, if any */ + sqlite3_int64 iPrevId; /* Previous id read from aDoclist */ + char *pNextId; /* Pointer into the body of aDoclist */ + char *aDoclist; /* List of docids for full-text queries */ + int nDoclist; /* Size of buffer at aDoclist */ + u8 bDesc; /* True to sort in descending order */ + int eEvalmode; /* An FTS3_EVAL_XX constant */ + int nRowAvg; /* Average size of database rows, in pages */ + sqlite3_int64 nDoc; /* Documents in table */ + i64 iMinDocid; /* Minimum docid to return */ + i64 iMaxDocid; /* Maximum docid to return */ + int isMatchinfoNeeded; /* True when aMatchinfo[] needs filling in */ + MatchinfoBuffer *pMIBuffer; /* Buffer for matchinfo data */ +}; + +#define FTS3_EVAL_FILTER 0 +#define FTS3_EVAL_NEXT 1 +#define FTS3_EVAL_MATCHINFO 2 + +/* +** The Fts3Cursor.eSearch member is always set to one of the following. +** Actualy, Fts3Cursor.eSearch can be greater than or equal to +** FTS3_FULLTEXT_SEARCH. If so, then Fts3Cursor.eSearch - 2 is the index +** of the column to be searched. For example, in +** +** CREATE VIRTUAL TABLE ex1 USING fts3(a,b,c,d); +** SELECT docid FROM ex1 WHERE b MATCH 'one two three'; +** +** Because the LHS of the MATCH operator is 2nd column "b", +** Fts3Cursor.eSearch will be set to FTS3_FULLTEXT_SEARCH+1. (+0 for a, +** +1 for b, +2 for c, +3 for d.) If the LHS of MATCH were "ex1" +** indicating that all columns should be searched, +** then eSearch would be set to FTS3_FULLTEXT_SEARCH+4. +*/ +#define FTS3_FULLSCAN_SEARCH 0 /* Linear scan of %_content table */ +#define FTS3_DOCID_SEARCH 1 /* Lookup by rowid on %_content table */ +#define FTS3_FULLTEXT_SEARCH 2 /* Full-text index search */ + +/* +** The lower 16-bits of the sqlite3_index_info.idxNum value set by +** the xBestIndex() method contains the Fts3Cursor.eSearch value described +** above. The upper 16-bits contain a combination of the following +** bits, used to describe extra constraints on full-text searches. +*/ +#define FTS3_HAVE_LANGID 0x00010000 /* languageid=? */ +#define FTS3_HAVE_DOCID_GE 0x00020000 /* docid>=? */ +#define FTS3_HAVE_DOCID_LE 0x00040000 /* docid<=? */ + +struct Fts3Doclist { + char *aAll; /* Array containing doclist (or NULL) */ + int nAll; /* Size of a[] in bytes */ + char *pNextDocid; /* Pointer to next docid */ + + sqlite3_int64 iDocid; /* Current docid (if pList!=0) */ + int bFreeList; /* True if pList should be sqlite3_free()d */ + char *pList; /* Pointer to position list following iDocid */ + int nList; /* Length of position list */ +}; + +/* +** A "phrase" is a sequence of one or more tokens that must match in +** sequence. A single token is the base case and the most common case. +** For a sequence of tokens contained in double-quotes (i.e. "one two three") +** nToken will be the number of tokens in the string. +*/ +struct Fts3PhraseToken { + char *z; /* Text of the token */ + int n; /* Number of bytes in buffer z */ + int isPrefix; /* True if token ends with a "*" character */ + int bFirst; /* True if token must appear at position 0 */ + + /* Variables above this point are populated when the expression is + ** parsed (by code in fts3_expr.c). Below this point the variables are + ** used when evaluating the expression. */ + Fts3DeferredToken *pDeferred; /* Deferred token object for this token */ + Fts3MultiSegReader *pSegcsr; /* Segment-reader for this token */ +}; + +struct Fts3Phrase { + /* Cache of doclist for this phrase. */ + Fts3Doclist doclist; + int bIncr; /* True if doclist is loaded incrementally */ + int iDoclistToken; + + /* Used by sqlite3Fts3EvalPhrasePoslist() if this is a descendent of an + ** OR condition. */ + char *pOrPoslist; + i64 iOrDocid; + + /* Variables below this point are populated by fts3_expr.c when parsing + ** a MATCH expression. Everything above is part of the evaluation phase. + */ + int nToken; /* Number of tokens in the phrase */ + int iColumn; /* Index of column this phrase must match */ + Fts3PhraseToken aToken[1]; /* One entry for each token in the phrase */ +}; + +/* +** A tree of these objects forms the RHS of a MATCH operator. +** +** If Fts3Expr.eType is FTSQUERY_PHRASE and isLoaded is true, then aDoclist +** points to a malloced buffer, size nDoclist bytes, containing the results +** of this phrase query in FTS3 doclist format. As usual, the initial +** "Length" field found in doclists stored on disk is omitted from this +** buffer. +** +** Variable aMI is used only for FTSQUERY_NEAR nodes to store the global +** matchinfo data. If it is not NULL, it points to an array of size nCol*3, +** where nCol is the number of columns in the queried FTS table. The array +** is populated as follows: +** +** aMI[iCol*3 + 0] = Undefined +** aMI[iCol*3 + 1] = Number of occurrences +** aMI[iCol*3 + 2] = Number of rows containing at least one instance +** +** The aMI array is allocated using sqlite3_malloc(). It should be freed +** when the expression node is. +*/ +struct Fts3Expr { + int eType; /* One of the FTSQUERY_XXX values defined below */ + int nNear; /* Valid if eType==FTSQUERY_NEAR */ + Fts3Expr *pParent; /* pParent->pLeft==this or pParent->pRight==this */ + Fts3Expr *pLeft; /* Left operand */ + Fts3Expr *pRight; /* Right operand */ + Fts3Phrase *pPhrase; /* Valid if eType==FTSQUERY_PHRASE */ + + /* The following are used by the fts3_eval.c module. */ + sqlite3_int64 iDocid; /* Current docid */ + u8 bEof; /* True this expression is at EOF already */ + u8 bStart; /* True if iDocid is valid */ + u8 bDeferred; /* True if this expression is entirely deferred */ + + /* The following are used by the fts3_snippet.c module. */ + int iPhrase; /* Index of this phrase in matchinfo() results */ + u32 *aMI; /* See above */ +}; + +/* +** Candidate values for Fts3Query.eType. Note that the order of the first +** four values is in order of precedence when parsing expressions. For +** example, the following: +** +** "a OR b AND c NOT d NEAR e" +** +** is equivalent to: +** +** "a OR (b AND (c NOT (d NEAR e)))" +*/ +#define FTSQUERY_NEAR 1 +#define FTSQUERY_NOT 2 +#define FTSQUERY_AND 3 +#define FTSQUERY_OR 4 +#define FTSQUERY_PHRASE 5 + + +/* fts3_write.c */ +SQLITE_PRIVATE int sqlite3Fts3UpdateMethod(sqlite3_vtab*,int,sqlite3_value**,sqlite3_int64*); +SQLITE_PRIVATE int sqlite3Fts3PendingTermsFlush(Fts3Table *); +SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *); +SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *); +SQLITE_PRIVATE int sqlite3Fts3SegReaderNew(int, int, sqlite3_int64, + sqlite3_int64, sqlite3_int64, const char *, int, Fts3SegReader**); +SQLITE_PRIVATE int sqlite3Fts3SegReaderPending( + Fts3Table*,int,const char*,int,int,Fts3SegReader**); +SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3SegReader *); +SQLITE_PRIVATE int sqlite3Fts3AllSegdirs(Fts3Table*, int, int, int, sqlite3_stmt **); +SQLITE_PRIVATE int sqlite3Fts3ReadBlock(Fts3Table*, sqlite3_int64, char **, int*, int*); + +SQLITE_PRIVATE int sqlite3Fts3SelectDoctotal(Fts3Table *, sqlite3_stmt **); +SQLITE_PRIVATE int sqlite3Fts3SelectDocsize(Fts3Table *, sqlite3_int64, sqlite3_stmt **); + +#ifndef SQLITE_DISABLE_FTS4_DEFERRED +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *); +SQLITE_PRIVATE int sqlite3Fts3DeferToken(Fts3Cursor *, Fts3PhraseToken *, int); +SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *); +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *); +SQLITE_PRIVATE int sqlite3Fts3DeferredTokenList(Fts3DeferredToken *, char **, int *); +#else +# define sqlite3Fts3FreeDeferredTokens(x) +# define sqlite3Fts3DeferToken(x,y,z) SQLITE_OK +# define sqlite3Fts3CacheDeferredDoclists(x) SQLITE_OK +# define sqlite3Fts3FreeDeferredDoclists(x) +# define sqlite3Fts3DeferredTokenList(x,y,z) SQLITE_OK +#endif + +SQLITE_PRIVATE void sqlite3Fts3SegmentsClose(Fts3Table *); +SQLITE_PRIVATE int sqlite3Fts3MaxLevel(Fts3Table *, int *); + +/* Special values interpreted by sqlite3SegReaderCursor() */ +#define FTS3_SEGCURSOR_PENDING -1 +#define FTS3_SEGCURSOR_ALL -2 + +SQLITE_PRIVATE int sqlite3Fts3SegReaderStart(Fts3Table*, Fts3MultiSegReader*, Fts3SegFilter*); +SQLITE_PRIVATE int sqlite3Fts3SegReaderStep(Fts3Table *, Fts3MultiSegReader *); +SQLITE_PRIVATE void sqlite3Fts3SegReaderFinish(Fts3MultiSegReader *); + +SQLITE_PRIVATE int sqlite3Fts3SegReaderCursor(Fts3Table *, + int, int, int, const char *, int, int, int, Fts3MultiSegReader *); + +/* Flags allowed as part of the 4th argument to SegmentReaderIterate() */ +#define FTS3_SEGMENT_REQUIRE_POS 0x00000001 +#define FTS3_SEGMENT_IGNORE_EMPTY 0x00000002 +#define FTS3_SEGMENT_COLUMN_FILTER 0x00000004 +#define FTS3_SEGMENT_PREFIX 0x00000008 +#define FTS3_SEGMENT_SCAN 0x00000010 +#define FTS3_SEGMENT_FIRST 0x00000020 + +/* Type passed as 4th argument to SegmentReaderIterate() */ +struct Fts3SegFilter { + const char *zTerm; + int nTerm; + int iCol; + int flags; +}; + +struct Fts3MultiSegReader { + /* Used internally by sqlite3Fts3SegReaderXXX() calls */ + Fts3SegReader **apSegment; /* Array of Fts3SegReader objects */ + int nSegment; /* Size of apSegment array */ + int nAdvance; /* How many seg-readers to advance */ + Fts3SegFilter *pFilter; /* Pointer to filter object */ + char *aBuffer; /* Buffer to merge doclists in */ + int nBuffer; /* Allocated size of aBuffer[] in bytes */ + + int iColFilter; /* If >=0, filter for this column */ + int bRestart; + + /* Used by fts3.c only. */ + int nCost; /* Cost of running iterator */ + int bLookup; /* True if a lookup of a single entry. */ + + /* Output values. Valid only after Fts3SegReaderStep() returns SQLITE_ROW. */ + char *zTerm; /* Pointer to term buffer */ + int nTerm; /* Size of zTerm in bytes */ + char *aDoclist; /* Pointer to doclist buffer */ + int nDoclist; /* Size of aDoclist[] in bytes */ +}; + +SQLITE_PRIVATE int sqlite3Fts3Incrmerge(Fts3Table*,int,int); + +#define fts3GetVarint32(p, piVal) ( \ + (*(u8*)(p)&0x80) ? sqlite3Fts3GetVarint32(p, piVal) : (*piVal=*(u8*)(p), 1) \ +) + +/* fts3.c */ +SQLITE_PRIVATE void sqlite3Fts3ErrMsg(char**,const char*,...); +SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *, sqlite3_int64); +SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *, sqlite_int64 *); +SQLITE_PRIVATE int sqlite3Fts3GetVarint32(const char *, int *); +SQLITE_PRIVATE int sqlite3Fts3VarintLen(sqlite3_uint64); +SQLITE_PRIVATE void sqlite3Fts3Dequote(char *); +SQLITE_PRIVATE void sqlite3Fts3DoclistPrev(int,char*,int,char**,sqlite3_int64*,int*,u8*); +SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats(Fts3Cursor *, Fts3Expr *, u32 *); +SQLITE_PRIVATE int sqlite3Fts3FirstFilter(sqlite3_int64, char *, int, char *); +SQLITE_PRIVATE void sqlite3Fts3CreateStatTable(int*, Fts3Table*); +SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc); + +/* fts3_tokenizer.c */ +SQLITE_PRIVATE const char *sqlite3Fts3NextToken(const char *, int *); +SQLITE_PRIVATE int sqlite3Fts3InitHashTable(sqlite3 *, Fts3Hash *, const char *); +SQLITE_PRIVATE int sqlite3Fts3InitTokenizer(Fts3Hash *pHash, const char *, + sqlite3_tokenizer **, char ** +); +SQLITE_PRIVATE int sqlite3Fts3IsIdChar(char); + +/* fts3_snippet.c */ +SQLITE_PRIVATE void sqlite3Fts3Offsets(sqlite3_context*, Fts3Cursor*); +SQLITE_PRIVATE void sqlite3Fts3Snippet(sqlite3_context *, Fts3Cursor *, const char *, + const char *, const char *, int, int +); +SQLITE_PRIVATE void sqlite3Fts3Matchinfo(sqlite3_context *, Fts3Cursor *, const char *); +SQLITE_PRIVATE void sqlite3Fts3MIBufferFree(MatchinfoBuffer *p); + +/* fts3_expr.c */ +SQLITE_PRIVATE int sqlite3Fts3ExprParse(sqlite3_tokenizer *, int, + char **, int, int, int, const char *, int, Fts3Expr **, char ** +); +SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *); +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db); +SQLITE_PRIVATE int sqlite3Fts3InitTerm(sqlite3 *db); +#endif + +SQLITE_PRIVATE int sqlite3Fts3OpenTokenizer(sqlite3_tokenizer *, int, const char *, int, + sqlite3_tokenizer_cursor ** +); + +/* fts3_aux.c */ +SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db); + +SQLITE_PRIVATE void sqlite3Fts3EvalPhraseCleanup(Fts3Phrase *); + +SQLITE_PRIVATE int sqlite3Fts3MsrIncrStart( + Fts3Table*, Fts3MultiSegReader*, int, const char*, int); +SQLITE_PRIVATE int sqlite3Fts3MsrIncrNext( + Fts3Table *, Fts3MultiSegReader *, sqlite3_int64 *, char **, int *); +SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **); +SQLITE_PRIVATE int sqlite3Fts3MsrOvfl(Fts3Cursor *, Fts3MultiSegReader *, int *); +SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr); + +/* fts3_tokenize_vtab.c */ +SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3*, Fts3Hash *); + +/* fts3_unicode2.c (functions generated by parsing unicode text files) */ +#ifndef SQLITE_DISABLE_FTS3_UNICODE +SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int, int); +SQLITE_PRIVATE int sqlite3FtsUnicodeIsalnum(int); +SQLITE_PRIVATE int sqlite3FtsUnicodeIsdiacritic(int); +#endif + +#endif /* !SQLITE_CORE || SQLITE_ENABLE_FTS3 */ +#endif /* _FTSINT_H */ + +/************** End of fts3Int.h *********************************************/ +/************** Continuing where we left off in fts3.c ***********************/ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +#if defined(SQLITE_ENABLE_FTS3) && !defined(SQLITE_CORE) +# define SQLITE_CORE 1 +#endif + +/* #include */ +/* #include */ +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3.h" */ +#ifndef SQLITE_CORE +/* # include "sqlite3ext.h" */ + SQLITE_EXTENSION_INIT1 +#endif + +static int fts3EvalNext(Fts3Cursor *pCsr); +static int fts3EvalStart(Fts3Cursor *pCsr); +static int fts3TermSegReaderCursor( + Fts3Cursor *, const char *, int, int, Fts3MultiSegReader **); + +#ifndef SQLITE_AMALGAMATION +# if defined(SQLITE_DEBUG) +SQLITE_PRIVATE int sqlite3Fts3Always(int b) { assert( b ); return b; } +SQLITE_PRIVATE int sqlite3Fts3Never(int b) { assert( !b ); return b; } +# endif +#endif + +/* +** Write a 64-bit variable-length integer to memory starting at p[0]. +** The length of data written will be between 1 and FTS3_VARINT_MAX bytes. +** The number of bytes written is returned. +*/ +SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *p, sqlite_int64 v){ + unsigned char *q = (unsigned char *) p; + sqlite_uint64 vu = v; + do{ + *q++ = (unsigned char) ((vu & 0x7f) | 0x80); + vu >>= 7; + }while( vu!=0 ); + q[-1] &= 0x7f; /* turn off high bit in final byte */ + assert( q - (unsigned char *)p <= FTS3_VARINT_MAX ); + return (int) (q - (unsigned char *)p); +} + +#define GETVARINT_STEP(v, ptr, shift, mask1, mask2, var, ret) \ + v = (v & mask1) | ( (*ptr++) << shift ); \ + if( (v & mask2)==0 ){ var = v; return ret; } +#define GETVARINT_INIT(v, ptr, shift, mask1, mask2, var, ret) \ + v = (*ptr++); \ + if( (v & mask2)==0 ){ var = v; return ret; } + +/* +** Read a 64-bit variable-length integer from memory starting at p[0]. +** Return the number of bytes read, or 0 on error. +** The value is stored in *v. +*/ +SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *p, sqlite_int64 *v){ + const char *pStart = p; + u32 a; + u64 b; + int shift; + + GETVARINT_INIT(a, p, 0, 0x00, 0x80, *v, 1); + GETVARINT_STEP(a, p, 7, 0x7F, 0x4000, *v, 2); + GETVARINT_STEP(a, p, 14, 0x3FFF, 0x200000, *v, 3); + GETVARINT_STEP(a, p, 21, 0x1FFFFF, 0x10000000, *v, 4); + b = (a & 0x0FFFFFFF ); + + for(shift=28; shift<=63; shift+=7){ + u64 c = *p++; + b += (c&0x7F) << shift; + if( (c & 0x80)==0 ) break; + } + *v = b; + return (int)(p - pStart); +} + +/* +** Similar to sqlite3Fts3GetVarint(), except that the output is truncated to a +** 32-bit integer before it is returned. +*/ +SQLITE_PRIVATE int sqlite3Fts3GetVarint32(const char *p, int *pi){ + u32 a; + +#ifndef fts3GetVarint32 + GETVARINT_INIT(a, p, 0, 0x00, 0x80, *pi, 1); +#else + a = (*p++); + assert( a & 0x80 ); +#endif + + GETVARINT_STEP(a, p, 7, 0x7F, 0x4000, *pi, 2); + GETVARINT_STEP(a, p, 14, 0x3FFF, 0x200000, *pi, 3); + GETVARINT_STEP(a, p, 21, 0x1FFFFF, 0x10000000, *pi, 4); + a = (a & 0x0FFFFFFF ); + *pi = (int)(a | ((u32)(*p & 0x0F) << 28)); + return 5; +} + +/* +** Return the number of bytes required to encode v as a varint +*/ +SQLITE_PRIVATE int sqlite3Fts3VarintLen(sqlite3_uint64 v){ + int i = 0; + do{ + i++; + v >>= 7; + }while( v!=0 ); + return i; +} + +/* +** Convert an SQL-style quoted string into a normal string by removing +** the quote characters. The conversion is done in-place. If the +** input does not begin with a quote character, then this routine +** is a no-op. +** +** Examples: +** +** "abc" becomes abc +** 'xyz' becomes xyz +** [pqr] becomes pqr +** `mno` becomes mno +** +*/ +SQLITE_PRIVATE void sqlite3Fts3Dequote(char *z){ + char quote; /* Quote character (if any ) */ + + quote = z[0]; + if( quote=='[' || quote=='\'' || quote=='"' || quote=='`' ){ + int iIn = 1; /* Index of next byte to read from input */ + int iOut = 0; /* Index of next byte to write to output */ + + /* If the first byte was a '[', then the close-quote character is a ']' */ + if( quote=='[' ) quote = ']'; + + while( z[iIn] ){ + if( z[iIn]==quote ){ + if( z[iIn+1]!=quote ) break; + z[iOut++] = quote; + iIn += 2; + }else{ + z[iOut++] = z[iIn++]; + } + } + z[iOut] = '\0'; + } +} + +/* +** Read a single varint from the doclist at *pp and advance *pp to point +** to the first byte past the end of the varint. Add the value of the varint +** to *pVal. +*/ +static void fts3GetDeltaVarint(char **pp, sqlite3_int64 *pVal){ + sqlite3_int64 iVal; + *pp += sqlite3Fts3GetVarint(*pp, &iVal); + *pVal += iVal; +} + +/* +** When this function is called, *pp points to the first byte following a +** varint that is part of a doclist (or position-list, or any other list +** of varints). This function moves *pp to point to the start of that varint, +** and sets *pVal by the varint value. +** +** Argument pStart points to the first byte of the doclist that the +** varint is part of. +*/ +static void fts3GetReverseVarint( + char **pp, + char *pStart, + sqlite3_int64 *pVal +){ + sqlite3_int64 iVal; + char *p; + + /* Pointer p now points at the first byte past the varint we are + ** interested in. So, unless the doclist is corrupt, the 0x80 bit is + ** clear on character p[-1]. */ + for(p = (*pp)-2; p>=pStart && *p&0x80; p--); + p++; + *pp = p; + + sqlite3Fts3GetVarint(p, &iVal); + *pVal = iVal; +} + +/* +** The xDisconnect() virtual table method. +*/ +static int fts3DisconnectMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table *)pVtab; + int i; + + assert( p->nPendingData==0 ); + assert( p->pSegments==0 ); + + /* Free any prepared statements held */ + for(i=0; iaStmt); i++){ + sqlite3_finalize(p->aStmt[i]); + } + sqlite3_free(p->zSegmentsTbl); + sqlite3_free(p->zReadExprlist); + sqlite3_free(p->zWriteExprlist); + sqlite3_free(p->zContentTbl); + sqlite3_free(p->zLanguageid); + + /* Invoke the tokenizer destructor to free the tokenizer. */ + p->pTokenizer->pModule->xDestroy(p->pTokenizer); + + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Write an error message into *pzErr +*/ +SQLITE_PRIVATE void sqlite3Fts3ErrMsg(char **pzErr, const char *zFormat, ...){ + va_list ap; + sqlite3_free(*pzErr); + va_start(ap, zFormat); + *pzErr = sqlite3_vmprintf(zFormat, ap); + va_end(ap); +} + +/* +** Construct one or more SQL statements from the format string given +** and then evaluate those statements. The success code is written +** into *pRc. +** +** If *pRc is initially non-zero then this routine is a no-op. +*/ +static void fts3DbExec( + int *pRc, /* Success code */ + sqlite3 *db, /* Database in which to run SQL */ + const char *zFormat, /* Format string for SQL */ + ... /* Arguments to the format string */ +){ + va_list ap; + char *zSql; + if( *pRc ) return; + va_start(ap, zFormat); + zSql = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + if( zSql==0 ){ + *pRc = SQLITE_NOMEM; + }else{ + *pRc = sqlite3_exec(db, zSql, 0, 0, 0); + sqlite3_free(zSql); + } +} + +/* +** The xDestroy() virtual table method. +*/ +static int fts3DestroyMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table *)pVtab; + int rc = SQLITE_OK; /* Return code */ + const char *zDb = p->zDb; /* Name of database (e.g. "main", "temp") */ + sqlite3 *db = p->db; /* Database handle */ + + /* Drop the shadow tables */ + if( p->zContentTbl==0 ){ + fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_content'", zDb, p->zName); + } + fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segments'", zDb,p->zName); + fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segdir'", zDb, p->zName); + fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_docsize'", zDb, p->zName); + fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_stat'", zDb, p->zName); + + /* If everything has worked, invoke fts3DisconnectMethod() to free the + ** memory associated with the Fts3Table structure and return SQLITE_OK. + ** Otherwise, return an SQLite error code. + */ + return (rc==SQLITE_OK ? fts3DisconnectMethod(pVtab) : rc); +} + + +/* +** Invoke sqlite3_declare_vtab() to declare the schema for the FTS3 table +** passed as the first argument. This is done as part of the xConnect() +** and xCreate() methods. +** +** If *pRc is non-zero when this function is called, it is a no-op. +** Otherwise, if an error occurs, an SQLite error code is stored in *pRc +** before returning. +*/ +static void fts3DeclareVtab(int *pRc, Fts3Table *p){ + if( *pRc==SQLITE_OK ){ + int i; /* Iterator variable */ + int rc; /* Return code */ + char *zSql; /* SQL statement passed to declare_vtab() */ + char *zCols; /* List of user defined columns */ + const char *zLanguageid; + + zLanguageid = (p->zLanguageid ? p->zLanguageid : "__langid"); + sqlite3_vtab_config(p->db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1); + + /* Create a list of user columns for the virtual table */ + zCols = sqlite3_mprintf("%Q, ", p->azColumn[0]); + for(i=1; zCols && inColumn; i++){ + zCols = sqlite3_mprintf("%z%Q, ", zCols, p->azColumn[i]); + } + + /* Create the whole "CREATE TABLE" statement to pass to SQLite */ + zSql = sqlite3_mprintf( + "CREATE TABLE x(%s %Q HIDDEN, docid HIDDEN, %Q HIDDEN)", + zCols, p->zName, zLanguageid + ); + if( !zCols || !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_declare_vtab(p->db, zSql); + } + + sqlite3_free(zSql); + sqlite3_free(zCols); + *pRc = rc; + } +} + +/* +** Create the %_stat table if it does not already exist. +*/ +SQLITE_PRIVATE void sqlite3Fts3CreateStatTable(int *pRc, Fts3Table *p){ + fts3DbExec(pRc, p->db, + "CREATE TABLE IF NOT EXISTS %Q.'%q_stat'" + "(id INTEGER PRIMARY KEY, value BLOB);", + p->zDb, p->zName + ); + if( (*pRc)==SQLITE_OK ) p->bHasStat = 1; +} + +/* +** Create the backing store tables (%_content, %_segments and %_segdir) +** required by the FTS3 table passed as the only argument. This is done +** as part of the vtab xCreate() method. +** +** If the p->bHasDocsize boolean is true (indicating that this is an +** FTS4 table, not an FTS3 table) then also create the %_docsize and +** %_stat tables required by FTS4. +*/ +static int fts3CreateTables(Fts3Table *p){ + int rc = SQLITE_OK; /* Return code */ + int i; /* Iterator variable */ + sqlite3 *db = p->db; /* The database connection */ + + if( p->zContentTbl==0 ){ + const char *zLanguageid = p->zLanguageid; + char *zContentCols; /* Columns of %_content table */ + + /* Create a list of user columns for the content table */ + zContentCols = sqlite3_mprintf("docid INTEGER PRIMARY KEY"); + for(i=0; zContentCols && inColumn; i++){ + char *z = p->azColumn[i]; + zContentCols = sqlite3_mprintf("%z, 'c%d%q'", zContentCols, i, z); + } + if( zLanguageid && zContentCols ){ + zContentCols = sqlite3_mprintf("%z, langid", zContentCols, zLanguageid); + } + if( zContentCols==0 ) rc = SQLITE_NOMEM; + + /* Create the content table */ + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_content'(%s)", + p->zDb, p->zName, zContentCols + ); + sqlite3_free(zContentCols); + } + + /* Create other tables */ + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_segments'(blockid INTEGER PRIMARY KEY, block BLOB);", + p->zDb, p->zName + ); + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_segdir'(" + "level INTEGER," + "idx INTEGER," + "start_block INTEGER," + "leaves_end_block INTEGER," + "end_block INTEGER," + "root BLOB," + "PRIMARY KEY(level, idx)" + ");", + p->zDb, p->zName + ); + if( p->bHasDocsize ){ + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_docsize'(docid INTEGER PRIMARY KEY, size BLOB);", + p->zDb, p->zName + ); + } + assert( p->bHasStat==p->bFts4 ); + if( p->bHasStat ){ + sqlite3Fts3CreateStatTable(&rc, p); + } + return rc; +} + +/* +** Store the current database page-size in bytes in p->nPgsz. +** +** If *pRc is non-zero when this function is called, it is a no-op. +** Otherwise, if an error occurs, an SQLite error code is stored in *pRc +** before returning. +*/ +static void fts3DatabasePageSize(int *pRc, Fts3Table *p){ + if( *pRc==SQLITE_OK ){ + int rc; /* Return code */ + char *zSql; /* SQL text "PRAGMA %Q.page_size" */ + sqlite3_stmt *pStmt; /* Compiled "PRAGMA %Q.page_size" statement */ + + zSql = sqlite3_mprintf("PRAGMA %Q.page_size", p->zDb); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_step(pStmt); + p->nPgsz = sqlite3_column_int(pStmt, 0); + rc = sqlite3_finalize(pStmt); + }else if( rc==SQLITE_AUTH ){ + p->nPgsz = 1024; + rc = SQLITE_OK; + } + } + assert( p->nPgsz>0 || rc!=SQLITE_OK ); + sqlite3_free(zSql); + *pRc = rc; + } +} + +/* +** "Special" FTS4 arguments are column specifications of the following form: +** +** = +** +** There may not be whitespace surrounding the "=" character. The +** term may be quoted, but the may not. +*/ +static int fts3IsSpecialColumn( + const char *z, + int *pnKey, + char **pzValue +){ + char *zValue; + const char *zCsr = z; + + while( *zCsr!='=' ){ + if( *zCsr=='\0' ) return 0; + zCsr++; + } + + *pnKey = (int)(zCsr-z); + zValue = sqlite3_mprintf("%s", &zCsr[1]); + if( zValue ){ + sqlite3Fts3Dequote(zValue); + } + *pzValue = zValue; + return 1; +} + +/* +** Append the output of a printf() style formatting to an existing string. +*/ +static void fts3Appendf( + int *pRc, /* IN/OUT: Error code */ + char **pz, /* IN/OUT: Pointer to string buffer */ + const char *zFormat, /* Printf format string to append */ + ... /* Arguments for printf format string */ +){ + if( *pRc==SQLITE_OK ){ + va_list ap; + char *z; + va_start(ap, zFormat); + z = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + if( z && *pz ){ + char *z2 = sqlite3_mprintf("%s%s", *pz, z); + sqlite3_free(z); + z = z2; + } + if( z==0 ) *pRc = SQLITE_NOMEM; + sqlite3_free(*pz); + *pz = z; + } +} + +/* +** Return a copy of input string zInput enclosed in double-quotes (") and +** with all double quote characters escaped. For example: +** +** fts3QuoteId("un \"zip\"") -> "un \"\"zip\"\"" +** +** The pointer returned points to memory obtained from sqlite3_malloc(). It +** is the callers responsibility to call sqlite3_free() to release this +** memory. +*/ +static char *fts3QuoteId(char const *zInput){ + int nRet; + char *zRet; + nRet = 2 + (int)strlen(zInput)*2 + 1; + zRet = sqlite3_malloc(nRet); + if( zRet ){ + int i; + char *z = zRet; + *(z++) = '"'; + for(i=0; zInput[i]; i++){ + if( zInput[i]=='"' ) *(z++) = '"'; + *(z++) = zInput[i]; + } + *(z++) = '"'; + *(z++) = '\0'; + } + return zRet; +} + +/* +** Return a list of comma separated SQL expressions and a FROM clause that +** could be used in a SELECT statement such as the following: +** +** SELECT FROM %_content AS x ... +** +** to return the docid, followed by each column of text data in order +** from left to write. If parameter zFunc is not NULL, then instead of +** being returned directly each column of text data is passed to an SQL +** function named zFunc first. For example, if zFunc is "unzip" and the +** table has the three user-defined columns "a", "b", and "c", the following +** string is returned: +** +** "docid, unzip(x.'a'), unzip(x.'b'), unzip(x.'c') FROM %_content AS x" +** +** The pointer returned points to a buffer allocated by sqlite3_malloc(). It +** is the responsibility of the caller to eventually free it. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and +** a NULL pointer is returned). Otherwise, if an OOM error is encountered +** by this function, NULL is returned and *pRc is set to SQLITE_NOMEM. If +** no error occurs, *pRc is left unmodified. +*/ +static char *fts3ReadExprList(Fts3Table *p, const char *zFunc, int *pRc){ + char *zRet = 0; + char *zFree = 0; + char *zFunction; + int i; + + if( p->zContentTbl==0 ){ + if( !zFunc ){ + zFunction = ""; + }else{ + zFree = zFunction = fts3QuoteId(zFunc); + } + fts3Appendf(pRc, &zRet, "docid"); + for(i=0; inColumn; i++){ + fts3Appendf(pRc, &zRet, ",%s(x.'c%d%q')", zFunction, i, p->azColumn[i]); + } + if( p->zLanguageid ){ + fts3Appendf(pRc, &zRet, ", x.%Q", "langid"); + } + sqlite3_free(zFree); + }else{ + fts3Appendf(pRc, &zRet, "rowid"); + for(i=0; inColumn; i++){ + fts3Appendf(pRc, &zRet, ", x.'%q'", p->azColumn[i]); + } + if( p->zLanguageid ){ + fts3Appendf(pRc, &zRet, ", x.%Q", p->zLanguageid); + } + } + fts3Appendf(pRc, &zRet, " FROM '%q'.'%q%s' AS x", + p->zDb, + (p->zContentTbl ? p->zContentTbl : p->zName), + (p->zContentTbl ? "" : "_content") + ); + return zRet; +} + +/* +** Return a list of N comma separated question marks, where N is the number +** of columns in the %_content table (one for the docid plus one for each +** user-defined text column). +** +** If argument zFunc is not NULL, then all but the first question mark +** is preceded by zFunc and an open bracket, and followed by a closed +** bracket. For example, if zFunc is "zip" and the FTS3 table has three +** user-defined text columns, the following string is returned: +** +** "?, zip(?), zip(?), zip(?)" +** +** The pointer returned points to a buffer allocated by sqlite3_malloc(). It +** is the responsibility of the caller to eventually free it. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and +** a NULL pointer is returned). Otherwise, if an OOM error is encountered +** by this function, NULL is returned and *pRc is set to SQLITE_NOMEM. If +** no error occurs, *pRc is left unmodified. +*/ +static char *fts3WriteExprList(Fts3Table *p, const char *zFunc, int *pRc){ + char *zRet = 0; + char *zFree = 0; + char *zFunction; + int i; + + if( !zFunc ){ + zFunction = ""; + }else{ + zFree = zFunction = fts3QuoteId(zFunc); + } + fts3Appendf(pRc, &zRet, "?"); + for(i=0; inColumn; i++){ + fts3Appendf(pRc, &zRet, ",%s(?)", zFunction); + } + if( p->zLanguageid ){ + fts3Appendf(pRc, &zRet, ", ?"); + } + sqlite3_free(zFree); + return zRet; +} + +/* +** This function interprets the string at (*pp) as a non-negative integer +** value. It reads the integer and sets *pnOut to the value read, then +** sets *pp to point to the byte immediately following the last byte of +** the integer value. +** +** Only decimal digits ('0'..'9') may be part of an integer value. +** +** If *pp does not being with a decimal digit SQLITE_ERROR is returned and +** the output value undefined. Otherwise SQLITE_OK is returned. +** +** This function is used when parsing the "prefix=" FTS4 parameter. +*/ +static int fts3GobbleInt(const char **pp, int *pnOut){ + const int MAX_NPREFIX = 10000000; + const char *p; /* Iterator pointer */ + int nInt = 0; /* Output value */ + + for(p=*pp; p[0]>='0' && p[0]<='9'; p++){ + nInt = nInt * 10 + (p[0] - '0'); + if( nInt>MAX_NPREFIX ){ + nInt = 0; + break; + } + } + if( p==*pp ) return SQLITE_ERROR; + *pnOut = nInt; + *pp = p; + return SQLITE_OK; +} + +/* +** This function is called to allocate an array of Fts3Index structures +** representing the indexes maintained by the current FTS table. FTS tables +** always maintain the main "terms" index, but may also maintain one or +** more "prefix" indexes, depending on the value of the "prefix=" parameter +** (if any) specified as part of the CREATE VIRTUAL TABLE statement. +** +** Argument zParam is passed the value of the "prefix=" option if one was +** specified, or NULL otherwise. +** +** If no error occurs, SQLITE_OK is returned and *apIndex set to point to +** the allocated array. *pnIndex is set to the number of elements in the +** array. If an error does occur, an SQLite error code is returned. +** +** Regardless of whether or not an error is returned, it is the responsibility +** of the caller to call sqlite3_free() on the output array to free it. +*/ +static int fts3PrefixParameter( + const char *zParam, /* ABC in prefix=ABC parameter to parse */ + int *pnIndex, /* OUT: size of *apIndex[] array */ + struct Fts3Index **apIndex /* OUT: Array of indexes for this table */ +){ + struct Fts3Index *aIndex; /* Allocated array */ + int nIndex = 1; /* Number of entries in array */ + + if( zParam && zParam[0] ){ + const char *p; + nIndex++; + for(p=zParam; *p; p++){ + if( *p==',' ) nIndex++; + } + } + + aIndex = sqlite3_malloc(sizeof(struct Fts3Index) * nIndex); + *apIndex = aIndex; + if( !aIndex ){ + return SQLITE_NOMEM; + } + + memset(aIndex, 0, sizeof(struct Fts3Index) * nIndex); + if( zParam ){ + const char *p = zParam; + int i; + for(i=1; i=0 ); + if( nPrefix==0 ){ + nIndex--; + i--; + }else{ + aIndex[i].nPrefix = nPrefix; + } + p++; + } + } + + *pnIndex = nIndex; + return SQLITE_OK; +} + +/* +** This function is called when initializing an FTS4 table that uses the +** content=xxx option. It determines the number of and names of the columns +** of the new FTS4 table. +** +** The third argument passed to this function is the value passed to the +** config=xxx option (i.e. "xxx"). This function queries the database for +** a table of that name. If found, the output variables are populated +** as follows: +** +** *pnCol: Set to the number of columns table xxx has, +** +** *pnStr: Set to the total amount of space required to store a copy +** of each columns name, including the nul-terminator. +** +** *pazCol: Set to point to an array of *pnCol strings. Each string is +** the name of the corresponding column in table xxx. The array +** and its contents are allocated using a single allocation. It +** is the responsibility of the caller to free this allocation +** by eventually passing the *pazCol value to sqlite3_free(). +** +** If the table cannot be found, an error code is returned and the output +** variables are undefined. Or, if an OOM is encountered, SQLITE_NOMEM is +** returned (and the output variables are undefined). +*/ +static int fts3ContentColumns( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of db (i.e. "main", "temp" etc.) */ + const char *zTbl, /* Name of content table */ + const char ***pazCol, /* OUT: Malloc'd array of column names */ + int *pnCol, /* OUT: Size of array *pazCol */ + int *pnStr, /* OUT: Bytes of string content */ + char **pzErr /* OUT: error message */ +){ + int rc = SQLITE_OK; /* Return code */ + char *zSql; /* "SELECT *" statement on zTbl */ + sqlite3_stmt *pStmt = 0; /* Compiled version of zSql */ + + zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", zDb, zTbl); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ){ + sqlite3Fts3ErrMsg(pzErr, "%s", sqlite3_errmsg(db)); + } + } + sqlite3_free(zSql); + + if( rc==SQLITE_OK ){ + const char **azCol; /* Output array */ + int nStr = 0; /* Size of all column names (incl. 0x00) */ + int nCol; /* Number of table columns */ + int i; /* Used to iterate through columns */ + + /* Loop through the returned columns. Set nStr to the number of bytes of + ** space required to store a copy of each column name, including the + ** nul-terminator byte. */ + nCol = sqlite3_column_count(pStmt); + for(i=0; i module name ("fts3" or "fts4") +** argv[1] -> database name +** argv[2] -> table name +** argv[...] -> "column name" and other module argument fields. +*/ +static int fts3InitVtab( + int isCreate, /* True for xCreate, false for xConnect */ + sqlite3 *db, /* The SQLite database connection */ + void *pAux, /* Hash table containing tokenizers */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */ + char **pzErr /* Write any error message here */ +){ + Fts3Hash *pHash = (Fts3Hash *)pAux; + Fts3Table *p = 0; /* Pointer to allocated vtab */ + int rc = SQLITE_OK; /* Return code */ + int i; /* Iterator variable */ + int nByte; /* Size of allocation used for *p */ + int iCol; /* Column index */ + int nString = 0; /* Bytes required to hold all column names */ + int nCol = 0; /* Number of columns in the FTS table */ + char *zCsr; /* Space for holding column names */ + int nDb; /* Bytes required to hold database name */ + int nName; /* Bytes required to hold table name */ + int isFts4 = (argv[0][3]=='4'); /* True for FTS4, false for FTS3 */ + const char **aCol; /* Array of column names */ + sqlite3_tokenizer *pTokenizer = 0; /* Tokenizer for this table */ + + int nIndex = 0; /* Size of aIndex[] array */ + struct Fts3Index *aIndex = 0; /* Array of indexes for this table */ + + /* The results of parsing supported FTS4 key=value options: */ + int bNoDocsize = 0; /* True to omit %_docsize table */ + int bDescIdx = 0; /* True to store descending indexes */ + char *zPrefix = 0; /* Prefix parameter value (or NULL) */ + char *zCompress = 0; /* compress=? parameter (or NULL) */ + char *zUncompress = 0; /* uncompress=? parameter (or NULL) */ + char *zContent = 0; /* content=? parameter (or NULL) */ + char *zLanguageid = 0; /* languageid=? parameter (or NULL) */ + char **azNotindexed = 0; /* The set of notindexed= columns */ + int nNotindexed = 0; /* Size of azNotindexed[] array */ + + assert( strlen(argv[0])==4 ); + assert( (sqlite3_strnicmp(argv[0], "fts4", 4)==0 && isFts4) + || (sqlite3_strnicmp(argv[0], "fts3", 4)==0 && !isFts4) + ); + + nDb = (int)strlen(argv[1]) + 1; + nName = (int)strlen(argv[2]) + 1; + + nByte = sizeof(const char *) * (argc-2); + aCol = (const char **)sqlite3_malloc(nByte); + if( aCol ){ + memset((void*)aCol, 0, nByte); + azNotindexed = (char **)sqlite3_malloc(nByte); + } + if( azNotindexed ){ + memset(azNotindexed, 0, nByte); + } + if( !aCol || !azNotindexed ){ + rc = SQLITE_NOMEM; + goto fts3_init_out; + } + + /* Loop through all of the arguments passed by the user to the FTS3/4 + ** module (i.e. all the column names and special arguments). This loop + ** does the following: + ** + ** + Figures out the number of columns the FTSX table will have, and + ** the number of bytes of space that must be allocated to store copies + ** of the column names. + ** + ** + If there is a tokenizer specification included in the arguments, + ** initializes the tokenizer pTokenizer. + */ + for(i=3; rc==SQLITE_OK && i8 + && 0==sqlite3_strnicmp(z, "tokenize", 8) + && 0==sqlite3Fts3IsIdChar(z[8]) + ){ + rc = sqlite3Fts3InitTokenizer(pHash, &z[9], &pTokenizer, pzErr); + } + + /* Check if it is an FTS4 special argument. */ + else if( isFts4 && fts3IsSpecialColumn(z, &nKey, &zVal) ){ + struct Fts4Option { + const char *zOpt; + int nOpt; + } aFts4Opt[] = { + { "matchinfo", 9 }, /* 0 -> MATCHINFO */ + { "prefix", 6 }, /* 1 -> PREFIX */ + { "compress", 8 }, /* 2 -> COMPRESS */ + { "uncompress", 10 }, /* 3 -> UNCOMPRESS */ + { "order", 5 }, /* 4 -> ORDER */ + { "content", 7 }, /* 5 -> CONTENT */ + { "languageid", 10 }, /* 6 -> LANGUAGEID */ + { "notindexed", 10 } /* 7 -> NOTINDEXED */ + }; + + int iOpt; + if( !zVal ){ + rc = SQLITE_NOMEM; + }else{ + for(iOpt=0; iOptnOpt && !sqlite3_strnicmp(z, pOp->zOpt, pOp->nOpt) ){ + break; + } + } + if( iOpt==SizeofArray(aFts4Opt) ){ + sqlite3Fts3ErrMsg(pzErr, "unrecognized parameter: %s", z); + rc = SQLITE_ERROR; + }else{ + switch( iOpt ){ + case 0: /* MATCHINFO */ + if( strlen(zVal)!=4 || sqlite3_strnicmp(zVal, "fts3", 4) ){ + sqlite3Fts3ErrMsg(pzErr, "unrecognized matchinfo: %s", zVal); + rc = SQLITE_ERROR; + } + bNoDocsize = 1; + break; + + case 1: /* PREFIX */ + sqlite3_free(zPrefix); + zPrefix = zVal; + zVal = 0; + break; + + case 2: /* COMPRESS */ + sqlite3_free(zCompress); + zCompress = zVal; + zVal = 0; + break; + + case 3: /* UNCOMPRESS */ + sqlite3_free(zUncompress); + zUncompress = zVal; + zVal = 0; + break; + + case 4: /* ORDER */ + if( (strlen(zVal)!=3 || sqlite3_strnicmp(zVal, "asc", 3)) + && (strlen(zVal)!=4 || sqlite3_strnicmp(zVal, "desc", 4)) + ){ + sqlite3Fts3ErrMsg(pzErr, "unrecognized order: %s", zVal); + rc = SQLITE_ERROR; + } + bDescIdx = (zVal[0]=='d' || zVal[0]=='D'); + break; + + case 5: /* CONTENT */ + sqlite3_free(zContent); + zContent = zVal; + zVal = 0; + break; + + case 6: /* LANGUAGEID */ + assert( iOpt==6 ); + sqlite3_free(zLanguageid); + zLanguageid = zVal; + zVal = 0; + break; + + case 7: /* NOTINDEXED */ + azNotindexed[nNotindexed++] = zVal; + zVal = 0; + break; + } + } + sqlite3_free(zVal); + } + } + + /* Otherwise, the argument is a column name. */ + else { + nString += (int)(strlen(z) + 1); + aCol[nCol++] = z; + } + } + + /* If a content=xxx option was specified, the following: + ** + ** 1. Ignore any compress= and uncompress= options. + ** + ** 2. If no column names were specified as part of the CREATE VIRTUAL + ** TABLE statement, use all columns from the content table. + */ + if( rc==SQLITE_OK && zContent ){ + sqlite3_free(zCompress); + sqlite3_free(zUncompress); + zCompress = 0; + zUncompress = 0; + if( nCol==0 ){ + sqlite3_free((void*)aCol); + aCol = 0; + rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr); + + /* If a languageid= option was specified, remove the language id + ** column from the aCol[] array. */ + if( rc==SQLITE_OK && zLanguageid ){ + int j; + for(j=0; jdb = db; + p->nColumn = nCol; + p->nPendingData = 0; + p->azColumn = (char **)&p[1]; + p->pTokenizer = pTokenizer; + p->nMaxPendingData = FTS3_MAX_PENDING_DATA; + p->bHasDocsize = (isFts4 && bNoDocsize==0); + p->bHasStat = isFts4; + p->bFts4 = isFts4; + p->bDescIdx = bDescIdx; + p->nAutoincrmerge = 0xff; /* 0xff means setting unknown */ + p->zContentTbl = zContent; + p->zLanguageid = zLanguageid; + zContent = 0; + zLanguageid = 0; + TESTONLY( p->inTransaction = -1 ); + TESTONLY( p->mxSavepoint = -1 ); + + p->aIndex = (struct Fts3Index *)&p->azColumn[nCol]; + memcpy(p->aIndex, aIndex, sizeof(struct Fts3Index) * nIndex); + p->nIndex = nIndex; + for(i=0; iaIndex[i].hPending, FTS3_HASH_STRING, 1); + } + p->abNotindexed = (u8 *)&p->aIndex[nIndex]; + + /* Fill in the zName and zDb fields of the vtab structure. */ + zCsr = (char *)&p->abNotindexed[nCol]; + p->zName = zCsr; + memcpy(zCsr, argv[2], nName); + zCsr += nName; + p->zDb = zCsr; + memcpy(zCsr, argv[1], nDb); + zCsr += nDb; + + /* Fill in the azColumn array */ + for(iCol=0; iColazColumn[iCol] = zCsr; + zCsr += n+1; + assert( zCsr <= &((char *)p)[nByte] ); + } + + /* Fill in the abNotindexed array */ + for(iCol=0; iColazColumn[iCol]); + for(i=0; iazColumn[iCol], zNot, n) + ){ + p->abNotindexed[iCol] = 1; + sqlite3_free(zNot); + azNotindexed[i] = 0; + } + } + } + for(i=0; izReadExprlist = fts3ReadExprList(p, zUncompress, &rc); + p->zWriteExprlist = fts3WriteExprList(p, zCompress, &rc); + if( rc!=SQLITE_OK ) goto fts3_init_out; + + /* If this is an xCreate call, create the underlying tables in the + ** database. TODO: For xConnect(), it could verify that said tables exist. + */ + if( isCreate ){ + rc = fts3CreateTables(p); + } + + /* Check to see if a legacy fts3 table has been "upgraded" by the + ** addition of a %_stat table so that it can use incremental merge. + */ + if( !isFts4 && !isCreate ){ + p->bHasStat = 2; + } + + /* Figure out the page-size for the database. This is required in order to + ** estimate the cost of loading large doclists from the database. */ + fts3DatabasePageSize(&rc, p); + p->nNodeSize = p->nPgsz-35; + + /* Declare the table schema to SQLite. */ + fts3DeclareVtab(&rc, p); + +fts3_init_out: + sqlite3_free(zPrefix); + sqlite3_free(aIndex); + sqlite3_free(zCompress); + sqlite3_free(zUncompress); + sqlite3_free(zContent); + sqlite3_free(zLanguageid); + for(i=0; ipModule->xDestroy(pTokenizer); + } + }else{ + assert( p->pSegments==0 ); + *ppVTab = &p->base; + } + return rc; +} + +/* +** The xConnect() and xCreate() methods for the virtual table. All the +** work is done in function fts3InitVtab(). +*/ +static int fts3ConnectMethod( + sqlite3 *db, /* Database connection */ + void *pAux, /* Pointer to tokenizer hash table */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */ + char **pzErr /* OUT: sqlite3_malloc'd error message */ +){ + return fts3InitVtab(0, db, pAux, argc, argv, ppVtab, pzErr); +} +static int fts3CreateMethod( + sqlite3 *db, /* Database connection */ + void *pAux, /* Pointer to tokenizer hash table */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */ + char **pzErr /* OUT: sqlite3_malloc'd error message */ +){ + return fts3InitVtab(1, db, pAux, argc, argv, ppVtab, pzErr); +} + +/* +** Set the pIdxInfo->estimatedRows variable to nRow. Unless this +** extension is currently being used by a version of SQLite too old to +** support estimatedRows. In that case this function is a no-op. +*/ +static void fts3SetEstimatedRows(sqlite3_index_info *pIdxInfo, i64 nRow){ +#if SQLITE_VERSION_NUMBER>=3008002 + if( sqlite3_libversion_number()>=3008002 ){ + pIdxInfo->estimatedRows = nRow; + } +#endif +} + +/* +** Set the SQLITE_INDEX_SCAN_UNIQUE flag in pIdxInfo->flags. Unless this +** extension is currently being used by a version of SQLite too old to +** support index-info flags. In that case this function is a no-op. +*/ +static void fts3SetUniqueFlag(sqlite3_index_info *pIdxInfo){ +#if SQLITE_VERSION_NUMBER>=3008012 + if( sqlite3_libversion_number()>=3008012 ){ + pIdxInfo->idxFlags |= SQLITE_INDEX_SCAN_UNIQUE; + } +#endif +} + +/* +** Implementation of the xBestIndex method for FTS3 tables. There +** are three possible strategies, in order of preference: +** +** 1. Direct lookup by rowid or docid. +** 2. Full-text search using a MATCH operator on a non-docid column. +** 3. Linear scan of %_content table. +*/ +static int fts3BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){ + Fts3Table *p = (Fts3Table *)pVTab; + int i; /* Iterator variable */ + int iCons = -1; /* Index of constraint to use */ + + int iLangidCons = -1; /* Index of langid=x constraint, if present */ + int iDocidGe = -1; /* Index of docid>=x constraint, if present */ + int iDocidLe = -1; /* Index of docid<=x constraint, if present */ + int iIdx; + + /* By default use a full table scan. This is an expensive option, + ** so search through the constraints to see if a more efficient + ** strategy is possible. + */ + pInfo->idxNum = FTS3_FULLSCAN_SEARCH; + pInfo->estimatedCost = 5000000; + for(i=0; inConstraint; i++){ + int bDocid; /* True if this constraint is on docid */ + struct sqlite3_index_constraint *pCons = &pInfo->aConstraint[i]; + if( pCons->usable==0 ){ + if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH ){ + /* There exists an unusable MATCH constraint. This means that if + ** the planner does elect to use the results of this call as part + ** of the overall query plan the user will see an "unable to use + ** function MATCH in the requested context" error. To discourage + ** this, return a very high cost here. */ + pInfo->idxNum = FTS3_FULLSCAN_SEARCH; + pInfo->estimatedCost = 1e50; + fts3SetEstimatedRows(pInfo, ((sqlite3_int64)1) << 50); + return SQLITE_OK; + } + continue; + } + + bDocid = (pCons->iColumn<0 || pCons->iColumn==p->nColumn+1); + + /* A direct lookup on the rowid or docid column. Assign a cost of 1.0. */ + if( iCons<0 && pCons->op==SQLITE_INDEX_CONSTRAINT_EQ && bDocid ){ + pInfo->idxNum = FTS3_DOCID_SEARCH; + pInfo->estimatedCost = 1.0; + iCons = i; + } + + /* A MATCH constraint. Use a full-text search. + ** + ** If there is more than one MATCH constraint available, use the first + ** one encountered. If there is both a MATCH constraint and a direct + ** rowid/docid lookup, prefer the MATCH strategy. This is done even + ** though the rowid/docid lookup is faster than a MATCH query, selecting + ** it would lead to an "unable to use function MATCH in the requested + ** context" error. + */ + if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH + && pCons->iColumn>=0 && pCons->iColumn<=p->nColumn + ){ + pInfo->idxNum = FTS3_FULLTEXT_SEARCH + pCons->iColumn; + pInfo->estimatedCost = 2.0; + iCons = i; + } + + /* Equality constraint on the langid column */ + if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ + && pCons->iColumn==p->nColumn + 2 + ){ + iLangidCons = i; + } + + if( bDocid ){ + switch( pCons->op ){ + case SQLITE_INDEX_CONSTRAINT_GE: + case SQLITE_INDEX_CONSTRAINT_GT: + iDocidGe = i; + break; + + case SQLITE_INDEX_CONSTRAINT_LE: + case SQLITE_INDEX_CONSTRAINT_LT: + iDocidLe = i; + break; + } + } + } + + /* If using a docid=? or rowid=? strategy, set the UNIQUE flag. */ + if( pInfo->idxNum==FTS3_DOCID_SEARCH ) fts3SetUniqueFlag(pInfo); + + iIdx = 1; + if( iCons>=0 ){ + pInfo->aConstraintUsage[iCons].argvIndex = iIdx++; + pInfo->aConstraintUsage[iCons].omit = 1; + } + if( iLangidCons>=0 ){ + pInfo->idxNum |= FTS3_HAVE_LANGID; + pInfo->aConstraintUsage[iLangidCons].argvIndex = iIdx++; + } + if( iDocidGe>=0 ){ + pInfo->idxNum |= FTS3_HAVE_DOCID_GE; + pInfo->aConstraintUsage[iDocidGe].argvIndex = iIdx++; + } + if( iDocidLe>=0 ){ + pInfo->idxNum |= FTS3_HAVE_DOCID_LE; + pInfo->aConstraintUsage[iDocidLe].argvIndex = iIdx++; + } + + /* Regardless of the strategy selected, FTS can deliver rows in rowid (or + ** docid) order. Both ascending and descending are possible. + */ + if( pInfo->nOrderBy==1 ){ + struct sqlite3_index_orderby *pOrder = &pInfo->aOrderBy[0]; + if( pOrder->iColumn<0 || pOrder->iColumn==p->nColumn+1 ){ + if( pOrder->desc ){ + pInfo->idxStr = "DESC"; + }else{ + pInfo->idxStr = "ASC"; + } + pInfo->orderByConsumed = 1; + } + } + + assert( p->pSegments==0 ); + return SQLITE_OK; +} + +/* +** Implementation of xOpen method. +*/ +static int fts3OpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){ + sqlite3_vtab_cursor *pCsr; /* Allocated cursor */ + + UNUSED_PARAMETER(pVTab); + + /* Allocate a buffer large enough for an Fts3Cursor structure. If the + ** allocation succeeds, zero it and return SQLITE_OK. Otherwise, + ** if the allocation fails, return SQLITE_NOMEM. + */ + *ppCsr = pCsr = (sqlite3_vtab_cursor *)sqlite3_malloc(sizeof(Fts3Cursor)); + if( !pCsr ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(Fts3Cursor)); + return SQLITE_OK; +} + +/* +** Close the cursor. For additional information see the documentation +** on the xClose method of the virtual table interface. +*/ +static int fts3CloseMethod(sqlite3_vtab_cursor *pCursor){ + Fts3Cursor *pCsr = (Fts3Cursor *)pCursor; + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + sqlite3_finalize(pCsr->pStmt); + sqlite3Fts3ExprFree(pCsr->pExpr); + sqlite3Fts3FreeDeferredTokens(pCsr); + sqlite3_free(pCsr->aDoclist); + sqlite3Fts3MIBufferFree(pCsr->pMIBuffer); + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then +** compose and prepare an SQL statement of the form: +** +** "SELECT FROM %_content WHERE rowid = ?" +** +** (or the equivalent for a content=xxx table) and set pCsr->pStmt to +** it. If an error occurs, return an SQLite error code. +** +** Otherwise, set *ppStmt to point to pCsr->pStmt and return SQLITE_OK. +*/ +static int fts3CursorSeekStmt(Fts3Cursor *pCsr, sqlite3_stmt **ppStmt){ + int rc = SQLITE_OK; + if( pCsr->pStmt==0 ){ + Fts3Table *p = (Fts3Table *)pCsr->base.pVtab; + char *zSql; + zSql = sqlite3_mprintf("SELECT %s WHERE rowid = ?", p->zReadExprlist); + if( !zSql ) return SQLITE_NOMEM; + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0); + sqlite3_free(zSql); + } + *ppStmt = pCsr->pStmt; + return rc; +} + +/* +** Position the pCsr->pStmt statement so that it is on the row +** of the %_content table that contains the last match. Return +** SQLITE_OK on success. +*/ +static int fts3CursorSeek(sqlite3_context *pContext, Fts3Cursor *pCsr){ + int rc = SQLITE_OK; + if( pCsr->isRequireSeek ){ + sqlite3_stmt *pStmt = 0; + + rc = fts3CursorSeekStmt(pCsr, &pStmt); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iPrevId); + pCsr->isRequireSeek = 0; + if( SQLITE_ROW==sqlite3_step(pCsr->pStmt) ){ + return SQLITE_OK; + }else{ + rc = sqlite3_reset(pCsr->pStmt); + if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){ + /* If no row was found and no error has occurred, then the %_content + ** table is missing a row that is present in the full-text index. + ** The data structures are corrupt. */ + rc = FTS_CORRUPT_VTAB; + pCsr->isEof = 1; + } + } + } + } + + if( rc!=SQLITE_OK && pContext ){ + sqlite3_result_error_code(pContext, rc); + } + return rc; +} + +/* +** This function is used to process a single interior node when searching +** a b-tree for a term or term prefix. The node data is passed to this +** function via the zNode/nNode parameters. The term to search for is +** passed in zTerm/nTerm. +** +** If piFirst is not NULL, then this function sets *piFirst to the blockid +** of the child node that heads the sub-tree that may contain the term. +** +** If piLast is not NULL, then *piLast is set to the right-most child node +** that heads a sub-tree that may contain a term for which zTerm/nTerm is +** a prefix. +** +** If an OOM error occurs, SQLITE_NOMEM is returned. Otherwise, SQLITE_OK. +*/ +static int fts3ScanInteriorNode( + const char *zTerm, /* Term to select leaves for */ + int nTerm, /* Size of term zTerm in bytes */ + const char *zNode, /* Buffer containing segment interior node */ + int nNode, /* Size of buffer at zNode */ + sqlite3_int64 *piFirst, /* OUT: Selected child node */ + sqlite3_int64 *piLast /* OUT: Selected child node */ +){ + int rc = SQLITE_OK; /* Return code */ + const char *zCsr = zNode; /* Cursor to iterate through node */ + const char *zEnd = &zCsr[nNode];/* End of interior node buffer */ + char *zBuffer = 0; /* Buffer to load terms into */ + int nAlloc = 0; /* Size of allocated buffer */ + int isFirstTerm = 1; /* True when processing first term on page */ + sqlite3_int64 iChild; /* Block id of child node to descend to */ + + /* Skip over the 'height' varint that occurs at the start of every + ** interior node. Then load the blockid of the left-child of the b-tree + ** node into variable iChild. + ** + ** Even if the data structure on disk is corrupted, this (reading two + ** varints from the buffer) does not risk an overread. If zNode is a + ** root node, then the buffer comes from a SELECT statement. SQLite does + ** not make this guarantee explicitly, but in practice there are always + ** either more than 20 bytes of allocated space following the nNode bytes of + ** contents, or two zero bytes. Or, if the node is read from the %_segments + ** table, then there are always 20 bytes of zeroed padding following the + ** nNode bytes of content (see sqlite3Fts3ReadBlock() for details). + */ + zCsr += sqlite3Fts3GetVarint(zCsr, &iChild); + zCsr += sqlite3Fts3GetVarint(zCsr, &iChild); + if( zCsr>zEnd ){ + return FTS_CORRUPT_VTAB; + } + + while( zCsrzEnd ){ + rc = FTS_CORRUPT_VTAB; + goto finish_scan; + } + if( nPrefix+nSuffix>nAlloc ){ + char *zNew; + nAlloc = (nPrefix+nSuffix) * 2; + zNew = (char *)sqlite3_realloc(zBuffer, nAlloc); + if( !zNew ){ + rc = SQLITE_NOMEM; + goto finish_scan; + } + zBuffer = zNew; + } + assert( zBuffer ); + memcpy(&zBuffer[nPrefix], zCsr, nSuffix); + nBuffer = nPrefix + nSuffix; + zCsr += nSuffix; + + /* Compare the term we are searching for with the term just loaded from + ** the interior node. If the specified term is greater than or equal + ** to the term from the interior node, then all terms on the sub-tree + ** headed by node iChild are smaller than zTerm. No need to search + ** iChild. + ** + ** If the interior node term is larger than the specified term, then + ** the tree headed by iChild may contain the specified term. + */ + cmp = memcmp(zTerm, zBuffer, (nBuffer>nTerm ? nTerm : nBuffer)); + if( piFirst && (cmp<0 || (cmp==0 && nBuffer>nTerm)) ){ + *piFirst = iChild; + piFirst = 0; + } + + if( piLast && cmp<0 ){ + *piLast = iChild; + piLast = 0; + } + + iChild++; + }; + + if( piFirst ) *piFirst = iChild; + if( piLast ) *piLast = iChild; + + finish_scan: + sqlite3_free(zBuffer); + return rc; +} + + +/* +** The buffer pointed to by argument zNode (size nNode bytes) contains an +** interior node of a b-tree segment. The zTerm buffer (size nTerm bytes) +** contains a term. This function searches the sub-tree headed by the zNode +** node for the range of leaf nodes that may contain the specified term +** or terms for which the specified term is a prefix. +** +** If piLeaf is not NULL, then *piLeaf is set to the blockid of the +** left-most leaf node in the tree that may contain the specified term. +** If piLeaf2 is not NULL, then *piLeaf2 is set to the blockid of the +** right-most leaf node that may contain a term for which the specified +** term is a prefix. +** +** It is possible that the range of returned leaf nodes does not contain +** the specified term or any terms for which it is a prefix. However, if the +** segment does contain any such terms, they are stored within the identified +** range. Because this function only inspects interior segment nodes (and +** never loads leaf nodes into memory), it is not possible to be sure. +** +** If an error occurs, an error code other than SQLITE_OK is returned. +*/ +static int fts3SelectLeaf( + Fts3Table *p, /* Virtual table handle */ + const char *zTerm, /* Term to select leaves for */ + int nTerm, /* Size of term zTerm in bytes */ + const char *zNode, /* Buffer containing segment interior node */ + int nNode, /* Size of buffer at zNode */ + sqlite3_int64 *piLeaf, /* Selected leaf node */ + sqlite3_int64 *piLeaf2 /* Selected leaf node */ +){ + int rc = SQLITE_OK; /* Return code */ + int iHeight; /* Height of this node in tree */ + + assert( piLeaf || piLeaf2 ); + + fts3GetVarint32(zNode, &iHeight); + rc = fts3ScanInteriorNode(zTerm, nTerm, zNode, nNode, piLeaf, piLeaf2); + assert( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) ); + + if( rc==SQLITE_OK && iHeight>1 ){ + char *zBlob = 0; /* Blob read from %_segments table */ + int nBlob = 0; /* Size of zBlob in bytes */ + + if( piLeaf && piLeaf2 && (*piLeaf!=*piLeaf2) ){ + rc = sqlite3Fts3ReadBlock(p, *piLeaf, &zBlob, &nBlob, 0); + if( rc==SQLITE_OK ){ + rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, 0); + } + sqlite3_free(zBlob); + piLeaf = 0; + zBlob = 0; + } + + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3ReadBlock(p, piLeaf?*piLeaf:*piLeaf2, &zBlob, &nBlob, 0); + } + if( rc==SQLITE_OK ){ + rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, piLeaf2); + } + sqlite3_free(zBlob); + } + + return rc; +} + +/* +** This function is used to create delta-encoded serialized lists of FTS3 +** varints. Each call to this function appends a single varint to a list. +*/ +static void fts3PutDeltaVarint( + char **pp, /* IN/OUT: Output pointer */ + sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */ + sqlite3_int64 iVal /* Write this value to the list */ +){ + assert( iVal-*piPrev > 0 || (*piPrev==0 && iVal==0) ); + *pp += sqlite3Fts3PutVarint(*pp, iVal-*piPrev); + *piPrev = iVal; +} + +/* +** When this function is called, *ppPoslist is assumed to point to the +** start of a position-list. After it returns, *ppPoslist points to the +** first byte after the position-list. +** +** A position list is list of positions (delta encoded) and columns for +** a single document record of a doclist. So, in other words, this +** routine advances *ppPoslist so that it points to the next docid in +** the doclist, or to the first byte past the end of the doclist. +** +** If pp is not NULL, then the contents of the position list are copied +** to *pp. *pp is set to point to the first byte past the last byte copied +** before this function returns. +*/ +static void fts3PoslistCopy(char **pp, char **ppPoslist){ + char *pEnd = *ppPoslist; + char c = 0; + + /* The end of a position list is marked by a zero encoded as an FTS3 + ** varint. A single POS_END (0) byte. Except, if the 0 byte is preceded by + ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail + ** of some other, multi-byte, value. + ** + ** The following while-loop moves pEnd to point to the first byte that is not + ** immediately preceded by a byte with the 0x80 bit set. Then increments + ** pEnd once more so that it points to the byte immediately following the + ** last byte in the position-list. + */ + while( *pEnd | c ){ + c = *pEnd++ & 0x80; + testcase( c!=0 && (*pEnd)==0 ); + } + pEnd++; /* Advance past the POS_END terminator byte */ + + if( pp ){ + int n = (int)(pEnd - *ppPoslist); + char *p = *pp; + memcpy(p, *ppPoslist, n); + p += n; + *pp = p; + } + *ppPoslist = pEnd; +} + +/* +** When this function is called, *ppPoslist is assumed to point to the +** start of a column-list. After it returns, *ppPoslist points to the +** to the terminator (POS_COLUMN or POS_END) byte of the column-list. +** +** A column-list is list of delta-encoded positions for a single column +** within a single document within a doclist. +** +** The column-list is terminated either by a POS_COLUMN varint (1) or +** a POS_END varint (0). This routine leaves *ppPoslist pointing to +** the POS_COLUMN or POS_END that terminates the column-list. +** +** If pp is not NULL, then the contents of the column-list are copied +** to *pp. *pp is set to point to the first byte past the last byte copied +** before this function returns. The POS_COLUMN or POS_END terminator +** is not copied into *pp. +*/ +static void fts3ColumnlistCopy(char **pp, char **ppPoslist){ + char *pEnd = *ppPoslist; + char c = 0; + + /* A column-list is terminated by either a 0x01 or 0x00 byte that is + ** not part of a multi-byte varint. + */ + while( 0xFE & (*pEnd | c) ){ + c = *pEnd++ & 0x80; + testcase( c!=0 && ((*pEnd)&0xfe)==0 ); + } + if( pp ){ + int n = (int)(pEnd - *ppPoslist); + char *p = *pp; + memcpy(p, *ppPoslist, n); + p += n; + *pp = p; + } + *ppPoslist = pEnd; +} + +/* +** Value used to signify the end of an position-list. This is safe because +** it is not possible to have a document with 2^31 terms. +*/ +#define POSITION_LIST_END 0x7fffffff + +/* +** This function is used to help parse position-lists. When this function is +** called, *pp may point to the start of the next varint in the position-list +** being parsed, or it may point to 1 byte past the end of the position-list +** (in which case **pp will be a terminator bytes POS_END (0) or +** (1)). +** +** If *pp points past the end of the current position-list, set *pi to +** POSITION_LIST_END and return. Otherwise, read the next varint from *pp, +** increment the current value of *pi by the value read, and set *pp to +** point to the next value before returning. +** +** Before calling this routine *pi must be initialized to the value of +** the previous position, or zero if we are reading the first position +** in the position-list. Because positions are delta-encoded, the value +** of the previous position is needed in order to compute the value of +** the next position. +*/ +static void fts3ReadNextPos( + char **pp, /* IN/OUT: Pointer into position-list buffer */ + sqlite3_int64 *pi /* IN/OUT: Value read from position-list */ +){ + if( (**pp)&0xFE ){ + fts3GetDeltaVarint(pp, pi); + *pi -= 2; + }else{ + *pi = POSITION_LIST_END; + } +} + +/* +** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by +** the value of iCol encoded as a varint to *pp. This will start a new +** column list. +** +** Set *pp to point to the byte just after the last byte written before +** returning (do not modify it if iCol==0). Return the total number of bytes +** written (0 if iCol==0). +*/ +static int fts3PutColNumber(char **pp, int iCol){ + int n = 0; /* Number of bytes written */ + if( iCol ){ + char *p = *pp; /* Output pointer */ + n = 1 + sqlite3Fts3PutVarint(&p[1], iCol); + *p = 0x01; + *pp = &p[n]; + } + return n; +} + +/* +** Compute the union of two position lists. The output written +** into *pp contains all positions of both *pp1 and *pp2 in sorted +** order and with any duplicates removed. All pointers are +** updated appropriately. The caller is responsible for insuring +** that there is enough space in *pp to hold the complete output. +*/ +static void fts3PoslistMerge( + char **pp, /* Output buffer */ + char **pp1, /* Left input list */ + char **pp2 /* Right input list */ +){ + char *p = *pp; + char *p1 = *pp1; + char *p2 = *pp2; + + while( *p1 || *p2 ){ + int iCol1; /* The current column index in pp1 */ + int iCol2; /* The current column index in pp2 */ + + if( *p1==POS_COLUMN ) fts3GetVarint32(&p1[1], &iCol1); + else if( *p1==POS_END ) iCol1 = POSITION_LIST_END; + else iCol1 = 0; + + if( *p2==POS_COLUMN ) fts3GetVarint32(&p2[1], &iCol2); + else if( *p2==POS_END ) iCol2 = POSITION_LIST_END; + else iCol2 = 0; + + if( iCol1==iCol2 ){ + sqlite3_int64 i1 = 0; /* Last position from pp1 */ + sqlite3_int64 i2 = 0; /* Last position from pp2 */ + sqlite3_int64 iPrev = 0; + int n = fts3PutColNumber(&p, iCol1); + p1 += n; + p2 += n; + + /* At this point, both p1 and p2 point to the start of column-lists + ** for the same column (the column with index iCol1 and iCol2). + ** A column-list is a list of non-negative delta-encoded varints, each + ** incremented by 2 before being stored. Each list is terminated by a + ** POS_END (0) or POS_COLUMN (1). The following block merges the two lists + ** and writes the results to buffer p. p is left pointing to the byte + ** after the list written. No terminator (POS_END or POS_COLUMN) is + ** written to the output. + */ + fts3GetDeltaVarint(&p1, &i1); + fts3GetDeltaVarint(&p2, &i2); + do { + fts3PutDeltaVarint(&p, &iPrev, (i1pos(*pp1) && pos(*pp2)-pos(*pp1)<=nToken). i.e. +** when the *pp1 token appears before the *pp2 token, but not more than nToken +** slots before it. +** +** e.g. nToken==1 searches for adjacent positions. +*/ +static int fts3PoslistPhraseMerge( + char **pp, /* IN/OUT: Preallocated output buffer */ + int nToken, /* Maximum difference in token positions */ + int isSaveLeft, /* Save the left position */ + int isExact, /* If *pp1 is exactly nTokens before *pp2 */ + char **pp1, /* IN/OUT: Left input list */ + char **pp2 /* IN/OUT: Right input list */ +){ + char *p = *pp; + char *p1 = *pp1; + char *p2 = *pp2; + int iCol1 = 0; + int iCol2 = 0; + + /* Never set both isSaveLeft and isExact for the same invocation. */ + assert( isSaveLeft==0 || isExact==0 ); + + assert( p!=0 && *p1!=0 && *p2!=0 ); + if( *p1==POS_COLUMN ){ + p1++; + p1 += fts3GetVarint32(p1, &iCol1); + } + if( *p2==POS_COLUMN ){ + p2++; + p2 += fts3GetVarint32(p2, &iCol2); + } + + while( 1 ){ + if( iCol1==iCol2 ){ + char *pSave = p; + sqlite3_int64 iPrev = 0; + sqlite3_int64 iPos1 = 0; + sqlite3_int64 iPos2 = 0; + + if( iCol1 ){ + *p++ = POS_COLUMN; + p += sqlite3Fts3PutVarint(p, iCol1); + } + + assert( *p1!=POS_END && *p1!=POS_COLUMN ); + assert( *p2!=POS_END && *p2!=POS_COLUMN ); + fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2; + fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2; + + while( 1 ){ + if( iPos2==iPos1+nToken + || (isExact==0 && iPos2>iPos1 && iPos2<=iPos1+nToken) + ){ + sqlite3_int64 iSave; + iSave = isSaveLeft ? iPos1 : iPos2; + fts3PutDeltaVarint(&p, &iPrev, iSave+2); iPrev -= 2; + pSave = 0; + assert( p ); + } + if( (!isSaveLeft && iPos2<=(iPos1+nToken)) || iPos2<=iPos1 ){ + if( (*p2&0xFE)==0 ) break; + fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2; + }else{ + if( (*p1&0xFE)==0 ) break; + fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2; + } + } + + if( pSave ){ + assert( pp && p ); + p = pSave; + } + + fts3ColumnlistCopy(0, &p1); + fts3ColumnlistCopy(0, &p2); + assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 ); + if( 0==*p1 || 0==*p2 ) break; + + p1++; + p1 += fts3GetVarint32(p1, &iCol1); + p2++; + p2 += fts3GetVarint32(p2, &iCol2); + } + + /* Advance pointer p1 or p2 (whichever corresponds to the smaller of + ** iCol1 and iCol2) so that it points to either the 0x00 that marks the + ** end of the position list, or the 0x01 that precedes the next + ** column-number in the position list. + */ + else if( iCol1=pEnd ){ + *pp = 0; + }else{ + sqlite3_int64 iVal; + *pp += sqlite3Fts3GetVarint(*pp, &iVal); + if( bDescIdx ){ + *pVal -= iVal; + }else{ + *pVal += iVal; + } + } +} + +/* +** This function is used to write a single varint to a buffer. The varint +** is written to *pp. Before returning, *pp is set to point 1 byte past the +** end of the value written. +** +** If *pbFirst is zero when this function is called, the value written to +** the buffer is that of parameter iVal. +** +** If *pbFirst is non-zero when this function is called, then the value +** written is either (iVal-*piPrev) (if bDescIdx is zero) or (*piPrev-iVal) +** (if bDescIdx is non-zero). +** +** Before returning, this function always sets *pbFirst to 1 and *piPrev +** to the value of parameter iVal. +*/ +static void fts3PutDeltaVarint3( + char **pp, /* IN/OUT: Output pointer */ + int bDescIdx, /* True for descending docids */ + sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */ + int *pbFirst, /* IN/OUT: True after first int written */ + sqlite3_int64 iVal /* Write this value to the list */ +){ + sqlite3_int64 iWrite; + if( bDescIdx==0 || *pbFirst==0 ){ + iWrite = iVal - *piPrev; + }else{ + iWrite = *piPrev - iVal; + } + assert( *pbFirst || *piPrev==0 ); + assert( *pbFirst==0 || iWrite>0 ); + *pp += sqlite3Fts3PutVarint(*pp, iWrite); + *piPrev = iVal; + *pbFirst = 1; +} + + +/* +** This macro is used by various functions that merge doclists. The two +** arguments are 64-bit docid values. If the value of the stack variable +** bDescDoclist is 0 when this macro is invoked, then it returns (i1-i2). +** Otherwise, (i2-i1). +** +** Using this makes it easier to write code that can merge doclists that are +** sorted in either ascending or descending order. +*/ +#define DOCID_CMP(i1, i2) ((bDescDoclist?-1:1) * (i1-i2)) + +/* +** This function does an "OR" merge of two doclists (output contains all +** positions contained in either argument doclist). If the docids in the +** input doclists are sorted in ascending order, parameter bDescDoclist +** should be false. If they are sorted in ascending order, it should be +** passed a non-zero value. +** +** If no error occurs, *paOut is set to point at an sqlite3_malloc'd buffer +** containing the output doclist and SQLITE_OK is returned. In this case +** *pnOut is set to the number of bytes in the output doclist. +** +** If an error occurs, an SQLite error code is returned. The output values +** are undefined in this case. +*/ +static int fts3DoclistOrMerge( + int bDescDoclist, /* True if arguments are desc */ + char *a1, int n1, /* First doclist */ + char *a2, int n2, /* Second doclist */ + char **paOut, int *pnOut /* OUT: Malloc'd doclist */ +){ + sqlite3_int64 i1 = 0; + sqlite3_int64 i2 = 0; + sqlite3_int64 iPrev = 0; + char *pEnd1 = &a1[n1]; + char *pEnd2 = &a2[n2]; + char *p1 = a1; + char *p2 = a2; + char *p; + char *aOut; + int bFirstOut = 0; + + *paOut = 0; + *pnOut = 0; + + /* Allocate space for the output. Both the input and output doclists + ** are delta encoded. If they are in ascending order (bDescDoclist==0), + ** then the first docid in each list is simply encoded as a varint. For + ** each subsequent docid, the varint stored is the difference between the + ** current and previous docid (a positive number - since the list is in + ** ascending order). + ** + ** The first docid written to the output is therefore encoded using the + ** same number of bytes as it is in whichever of the input lists it is + ** read from. And each subsequent docid read from the same input list + ** consumes either the same or less bytes as it did in the input (since + ** the difference between it and the previous value in the output must + ** be a positive value less than or equal to the delta value read from + ** the input list). The same argument applies to all but the first docid + ** read from the 'other' list. And to the contents of all position lists + ** that will be copied and merged from the input to the output. + ** + ** However, if the first docid copied to the output is a negative number, + ** then the encoding of the first docid from the 'other' input list may + ** be larger in the output than it was in the input (since the delta value + ** may be a larger positive integer than the actual docid). + ** + ** The space required to store the output is therefore the sum of the + ** sizes of the two inputs, plus enough space for exactly one of the input + ** docids to grow. + ** + ** A symetric argument may be made if the doclists are in descending + ** order. + */ + aOut = sqlite3_malloc(n1+n2+FTS3_VARINT_MAX-1); + if( !aOut ) return SQLITE_NOMEM; + + p = aOut; + fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2); + while( p1 || p2 ){ + sqlite3_int64 iDiff = DOCID_CMP(i1, i2); + + if( p2 && p1 && iDiff==0 ){ + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1); + fts3PoslistMerge(&p, &p1, &p2); + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + }else if( !p2 || (p1 && iDiff<0) ){ + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1); + fts3PoslistCopy(&p, &p1); + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + }else{ + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i2); + fts3PoslistCopy(&p, &p2); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + } + } + + *paOut = aOut; + *pnOut = (int)(p-aOut); + assert( *pnOut<=n1+n2+FTS3_VARINT_MAX-1 ); + return SQLITE_OK; +} + +/* +** This function does a "phrase" merge of two doclists. In a phrase merge, +** the output contains a copy of each position from the right-hand input +** doclist for which there is a position in the left-hand input doclist +** exactly nDist tokens before it. +** +** If the docids in the input doclists are sorted in ascending order, +** parameter bDescDoclist should be false. If they are sorted in ascending +** order, it should be passed a non-zero value. +** +** The right-hand input doclist is overwritten by this function. +*/ +static int fts3DoclistPhraseMerge( + int bDescDoclist, /* True if arguments are desc */ + int nDist, /* Distance from left to right (1=adjacent) */ + char *aLeft, int nLeft, /* Left doclist */ + char **paRight, int *pnRight /* IN/OUT: Right/output doclist */ +){ + sqlite3_int64 i1 = 0; + sqlite3_int64 i2 = 0; + sqlite3_int64 iPrev = 0; + char *aRight = *paRight; + char *pEnd1 = &aLeft[nLeft]; + char *pEnd2 = &aRight[*pnRight]; + char *p1 = aLeft; + char *p2 = aRight; + char *p; + int bFirstOut = 0; + char *aOut; + + assert( nDist>0 ); + if( bDescDoclist ){ + aOut = sqlite3_malloc(*pnRight + FTS3_VARINT_MAX); + if( aOut==0 ) return SQLITE_NOMEM; + }else{ + aOut = aRight; + } + p = aOut; + + fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2); + + while( p1 && p2 ){ + sqlite3_int64 iDiff = DOCID_CMP(i1, i2); + if( iDiff==0 ){ + char *pSave = p; + sqlite3_int64 iPrevSave = iPrev; + int bFirstOutSave = bFirstOut; + + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1); + if( 0==fts3PoslistPhraseMerge(&p, nDist, 0, 1, &p1, &p2) ){ + p = pSave; + iPrev = iPrevSave; + bFirstOut = bFirstOutSave; + } + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + }else if( iDiff<0 ){ + fts3PoslistCopy(0, &p1); + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + }else{ + fts3PoslistCopy(0, &p2); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + } + } + + *pnRight = (int)(p - aOut); + if( bDescDoclist ){ + sqlite3_free(aRight); + *paRight = aOut; + } + + return SQLITE_OK; +} + +/* +** Argument pList points to a position list nList bytes in size. This +** function checks to see if the position list contains any entries for +** a token in position 0 (of any column). If so, it writes argument iDelta +** to the output buffer pOut, followed by a position list consisting only +** of the entries from pList at position 0, and terminated by an 0x00 byte. +** The value returned is the number of bytes written to pOut (if any). +*/ +SQLITE_PRIVATE int sqlite3Fts3FirstFilter( + sqlite3_int64 iDelta, /* Varint that may be written to pOut */ + char *pList, /* Position list (no 0x00 term) */ + int nList, /* Size of pList in bytes */ + char *pOut /* Write output here */ +){ + int nOut = 0; + int bWritten = 0; /* True once iDelta has been written */ + char *p = pList; + char *pEnd = &pList[nList]; + + if( *p!=0x01 ){ + if( *p==0x02 ){ + nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta); + pOut[nOut++] = 0x02; + bWritten = 1; + } + fts3ColumnlistCopy(0, &p); + } + + while( paaOutput); i++){ + if( pTS->aaOutput[i] ){ + if( !aOut ){ + aOut = pTS->aaOutput[i]; + nOut = pTS->anOutput[i]; + pTS->aaOutput[i] = 0; + }else{ + int nNew; + char *aNew; + + int rc = fts3DoclistOrMerge(p->bDescIdx, + pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut, &aNew, &nNew + ); + if( rc!=SQLITE_OK ){ + sqlite3_free(aOut); + return rc; + } + + sqlite3_free(pTS->aaOutput[i]); + sqlite3_free(aOut); + pTS->aaOutput[i] = 0; + aOut = aNew; + nOut = nNew; + } + } + } + + pTS->aaOutput[0] = aOut; + pTS->anOutput[0] = nOut; + return SQLITE_OK; +} + +/* +** Merge the doclist aDoclist/nDoclist into the TermSelect object passed +** as the first argument. The merge is an "OR" merge (see function +** fts3DoclistOrMerge() for details). +** +** This function is called with the doclist for each term that matches +** a queried prefix. It merges all these doclists into one, the doclist +** for the specified prefix. Since there can be a very large number of +** doclists to merge, the merging is done pair-wise using the TermSelect +** object. +** +** This function returns SQLITE_OK if the merge is successful, or an +** SQLite error code (SQLITE_NOMEM) if an error occurs. +*/ +static int fts3TermSelectMerge( + Fts3Table *p, /* FTS table handle */ + TermSelect *pTS, /* TermSelect object to merge into */ + char *aDoclist, /* Pointer to doclist */ + int nDoclist /* Size of aDoclist in bytes */ +){ + if( pTS->aaOutput[0]==0 ){ + /* If this is the first term selected, copy the doclist to the output + ** buffer using memcpy(). + ** + ** Add FTS3_VARINT_MAX bytes of unused space to the end of the + ** allocation. This is so as to ensure that the buffer is big enough + ** to hold the current doclist AND'd with any other doclist. If the + ** doclists are stored in order=ASC order, this padding would not be + ** required (since the size of [doclistA AND doclistB] is always less + ** than or equal to the size of [doclistA] in that case). But this is + ** not true for order=DESC. For example, a doclist containing (1, -1) + ** may be smaller than (-1), as in the first example the -1 may be stored + ** as a single-byte delta, whereas in the second it must be stored as a + ** FTS3_VARINT_MAX byte varint. + ** + ** Similar padding is added in the fts3DoclistOrMerge() function. + */ + pTS->aaOutput[0] = sqlite3_malloc(nDoclist + FTS3_VARINT_MAX + 1); + pTS->anOutput[0] = nDoclist; + if( pTS->aaOutput[0] ){ + memcpy(pTS->aaOutput[0], aDoclist, nDoclist); + }else{ + return SQLITE_NOMEM; + } + }else{ + char *aMerge = aDoclist; + int nMerge = nDoclist; + int iOut; + + for(iOut=0; iOutaaOutput); iOut++){ + if( pTS->aaOutput[iOut]==0 ){ + assert( iOut>0 ); + pTS->aaOutput[iOut] = aMerge; + pTS->anOutput[iOut] = nMerge; + break; + }else{ + char *aNew; + int nNew; + + int rc = fts3DoclistOrMerge(p->bDescIdx, aMerge, nMerge, + pTS->aaOutput[iOut], pTS->anOutput[iOut], &aNew, &nNew + ); + if( rc!=SQLITE_OK ){ + if( aMerge!=aDoclist ) sqlite3_free(aMerge); + return rc; + } + + if( aMerge!=aDoclist ) sqlite3_free(aMerge); + sqlite3_free(pTS->aaOutput[iOut]); + pTS->aaOutput[iOut] = 0; + + aMerge = aNew; + nMerge = nNew; + if( (iOut+1)==SizeofArray(pTS->aaOutput) ){ + pTS->aaOutput[iOut] = aMerge; + pTS->anOutput[iOut] = nMerge; + } + } + } + } + return SQLITE_OK; +} + +/* +** Append SegReader object pNew to the end of the pCsr->apSegment[] array. +*/ +static int fts3SegReaderCursorAppend( + Fts3MultiSegReader *pCsr, + Fts3SegReader *pNew +){ + if( (pCsr->nSegment%16)==0 ){ + Fts3SegReader **apNew; + int nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*); + apNew = (Fts3SegReader **)sqlite3_realloc(pCsr->apSegment, nByte); + if( !apNew ){ + sqlite3Fts3SegReaderFree(pNew); + return SQLITE_NOMEM; + } + pCsr->apSegment = apNew; + } + pCsr->apSegment[pCsr->nSegment++] = pNew; + return SQLITE_OK; +} + +/* +** Add seg-reader objects to the Fts3MultiSegReader object passed as the +** 8th argument. +** +** This function returns SQLITE_OK if successful, or an SQLite error code +** otherwise. +*/ +static int fts3SegReaderCursor( + Fts3Table *p, /* FTS3 table handle */ + int iLangid, /* Language id */ + int iIndex, /* Index to search (from 0 to p->nIndex-1) */ + int iLevel, /* Level of segments to scan */ + const char *zTerm, /* Term to query for */ + int nTerm, /* Size of zTerm in bytes */ + int isPrefix, /* True for a prefix search */ + int isScan, /* True to scan from zTerm to EOF */ + Fts3MultiSegReader *pCsr /* Cursor object to populate */ +){ + int rc = SQLITE_OK; /* Error code */ + sqlite3_stmt *pStmt = 0; /* Statement to iterate through segments */ + int rc2; /* Result of sqlite3_reset() */ + + /* If iLevel is less than 0 and this is not a scan, include a seg-reader + ** for the pending-terms. If this is a scan, then this call must be being + ** made by an fts4aux module, not an FTS table. In this case calling + ** Fts3SegReaderPending might segfault, as the data structures used by + ** fts4aux are not completely populated. So it's easiest to filter these + ** calls out here. */ + if( iLevel<0 && p->aIndex ){ + Fts3SegReader *pSeg = 0; + rc = sqlite3Fts3SegReaderPending(p, iIndex, zTerm, nTerm, isPrefix||isScan, &pSeg); + if( rc==SQLITE_OK && pSeg ){ + rc = fts3SegReaderCursorAppend(pCsr, pSeg); + } + } + + if( iLevel!=FTS3_SEGCURSOR_PENDING ){ + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3AllSegdirs(p, iLangid, iIndex, iLevel, &pStmt); + } + + while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){ + Fts3SegReader *pSeg = 0; + + /* Read the values returned by the SELECT into local variables. */ + sqlite3_int64 iStartBlock = sqlite3_column_int64(pStmt, 1); + sqlite3_int64 iLeavesEndBlock = sqlite3_column_int64(pStmt, 2); + sqlite3_int64 iEndBlock = sqlite3_column_int64(pStmt, 3); + int nRoot = sqlite3_column_bytes(pStmt, 4); + char const *zRoot = sqlite3_column_blob(pStmt, 4); + + /* If zTerm is not NULL, and this segment is not stored entirely on its + ** root node, the range of leaves scanned can be reduced. Do this. */ + if( iStartBlock && zTerm ){ + sqlite3_int64 *pi = (isPrefix ? &iLeavesEndBlock : 0); + rc = fts3SelectLeaf(p, zTerm, nTerm, zRoot, nRoot, &iStartBlock, pi); + if( rc!=SQLITE_OK ) goto finished; + if( isPrefix==0 && isScan==0 ) iLeavesEndBlock = iStartBlock; + } + + rc = sqlite3Fts3SegReaderNew(pCsr->nSegment+1, + (isPrefix==0 && isScan==0), + iStartBlock, iLeavesEndBlock, + iEndBlock, zRoot, nRoot, &pSeg + ); + if( rc!=SQLITE_OK ) goto finished; + rc = fts3SegReaderCursorAppend(pCsr, pSeg); + } + } + + finished: + rc2 = sqlite3_reset(pStmt); + if( rc==SQLITE_DONE ) rc = rc2; + + return rc; +} + +/* +** Set up a cursor object for iterating through a full-text index or a +** single level therein. +*/ +SQLITE_PRIVATE int sqlite3Fts3SegReaderCursor( + Fts3Table *p, /* FTS3 table handle */ + int iLangid, /* Language-id to search */ + int iIndex, /* Index to search (from 0 to p->nIndex-1) */ + int iLevel, /* Level of segments to scan */ + const char *zTerm, /* Term to query for */ + int nTerm, /* Size of zTerm in bytes */ + int isPrefix, /* True for a prefix search */ + int isScan, /* True to scan from zTerm to EOF */ + Fts3MultiSegReader *pCsr /* Cursor object to populate */ +){ + assert( iIndex>=0 && iIndexnIndex ); + assert( iLevel==FTS3_SEGCURSOR_ALL + || iLevel==FTS3_SEGCURSOR_PENDING + || iLevel>=0 + ); + assert( iLevelbase.pVtab; + + if( isPrefix ){ + for(i=1; bFound==0 && inIndex; i++){ + if( p->aIndex[i].nPrefix==nTerm ){ + bFound = 1; + rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid, + i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0, pSegcsr + ); + pSegcsr->bLookup = 1; + } + } + + for(i=1; bFound==0 && inIndex; i++){ + if( p->aIndex[i].nPrefix==nTerm+1 ){ + bFound = 1; + rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid, + i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 1, 0, pSegcsr + ); + if( rc==SQLITE_OK ){ + rc = fts3SegReaderCursorAddZero( + p, pCsr->iLangid, zTerm, nTerm, pSegcsr + ); + } + } + } + } + + if( bFound==0 ){ + rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid, + 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, isPrefix, 0, pSegcsr + ); + pSegcsr->bLookup = !isPrefix; + } + } + + *ppSegcsr = pSegcsr; + return rc; +} + +/* +** Free an Fts3MultiSegReader allocated by fts3TermSegReaderCursor(). +*/ +static void fts3SegReaderCursorFree(Fts3MultiSegReader *pSegcsr){ + sqlite3Fts3SegReaderFinish(pSegcsr); + sqlite3_free(pSegcsr); +} + +/* +** This function retrieves the doclist for the specified term (or term +** prefix) from the database. +*/ +static int fts3TermSelect( + Fts3Table *p, /* Virtual table handle */ + Fts3PhraseToken *pTok, /* Token to query for */ + int iColumn, /* Column to query (or -ve for all columns) */ + int *pnOut, /* OUT: Size of buffer at *ppOut */ + char **ppOut /* OUT: Malloced result buffer */ +){ + int rc; /* Return code */ + Fts3MultiSegReader *pSegcsr; /* Seg-reader cursor for this term */ + TermSelect tsc; /* Object for pair-wise doclist merging */ + Fts3SegFilter filter; /* Segment term filter configuration */ + + pSegcsr = pTok->pSegcsr; + memset(&tsc, 0, sizeof(TermSelect)); + + filter.flags = FTS3_SEGMENT_IGNORE_EMPTY | FTS3_SEGMENT_REQUIRE_POS + | (pTok->isPrefix ? FTS3_SEGMENT_PREFIX : 0) + | (pTok->bFirst ? FTS3_SEGMENT_FIRST : 0) + | (iColumnnColumn ? FTS3_SEGMENT_COLUMN_FILTER : 0); + filter.iCol = iColumn; + filter.zTerm = pTok->z; + filter.nTerm = pTok->n; + + rc = sqlite3Fts3SegReaderStart(p, pSegcsr, &filter); + while( SQLITE_OK==rc + && SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, pSegcsr)) + ){ + rc = fts3TermSelectMerge(p, &tsc, pSegcsr->aDoclist, pSegcsr->nDoclist); + } + + if( rc==SQLITE_OK ){ + rc = fts3TermSelectFinishMerge(p, &tsc); + } + if( rc==SQLITE_OK ){ + *ppOut = tsc.aaOutput[0]; + *pnOut = tsc.anOutput[0]; + }else{ + int i; + for(i=0; ipSegcsr = 0; + return rc; +} + +/* +** This function counts the total number of docids in the doclist stored +** in buffer aList[], size nList bytes. +** +** If the isPoslist argument is true, then it is assumed that the doclist +** contains a position-list following each docid. Otherwise, it is assumed +** that the doclist is simply a list of docids stored as delta encoded +** varints. +*/ +static int fts3DoclistCountDocids(char *aList, int nList){ + int nDoc = 0; /* Return value */ + if( aList ){ + char *aEnd = &aList[nList]; /* Pointer to one byte after EOF */ + char *p = aList; /* Cursor */ + while( peSearch==FTS3_DOCID_SEARCH || pCsr->eSearch==FTS3_FULLSCAN_SEARCH ){ + if( SQLITE_ROW!=sqlite3_step(pCsr->pStmt) ){ + pCsr->isEof = 1; + rc = sqlite3_reset(pCsr->pStmt); + }else{ + pCsr->iPrevId = sqlite3_column_int64(pCsr->pStmt, 0); + rc = SQLITE_OK; + } + }else{ + rc = fts3EvalNext((Fts3Cursor *)pCursor); + } + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + return rc; +} + +/* +** The following are copied from sqliteInt.h. +** +** Constants for the largest and smallest possible 64-bit signed integers. +** These macros are designed to work correctly on both 32-bit and 64-bit +** compilers. +*/ +#ifndef SQLITE_AMALGAMATION +# define LARGEST_INT64 (0xffffffff|(((sqlite3_int64)0x7fffffff)<<32)) +# define SMALLEST_INT64 (((sqlite3_int64)-1) - LARGEST_INT64) +#endif + +/* +** If the numeric type of argument pVal is "integer", then return it +** converted to a 64-bit signed integer. Otherwise, return a copy of +** the second parameter, iDefault. +*/ +static sqlite3_int64 fts3DocidRange(sqlite3_value *pVal, i64 iDefault){ + if( pVal ){ + int eType = sqlite3_value_numeric_type(pVal); + if( eType==SQLITE_INTEGER ){ + return sqlite3_value_int64(pVal); + } + } + return iDefault; +} + +/* +** This is the xFilter interface for the virtual table. See +** the virtual table xFilter method documentation for additional +** information. +** +** If idxNum==FTS3_FULLSCAN_SEARCH then do a full table scan against +** the %_content table. +** +** If idxNum==FTS3_DOCID_SEARCH then do a docid lookup for a single entry +** in the %_content table. +** +** If idxNum>=FTS3_FULLTEXT_SEARCH then use the full text index. The +** column on the left-hand side of the MATCH operator is column +** number idxNum-FTS3_FULLTEXT_SEARCH, 0 indexed. argv[0] is the right-hand +** side of the MATCH operator. +*/ +static int fts3FilterMethod( + sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */ + int idxNum, /* Strategy index */ + const char *idxStr, /* Unused */ + int nVal, /* Number of elements in apVal */ + sqlite3_value **apVal /* Arguments for the indexing scheme */ +){ + int rc = SQLITE_OK; + char *zSql; /* SQL statement used to access %_content */ + int eSearch; + Fts3Table *p = (Fts3Table *)pCursor->pVtab; + Fts3Cursor *pCsr = (Fts3Cursor *)pCursor; + + sqlite3_value *pCons = 0; /* The MATCH or rowid constraint, if any */ + sqlite3_value *pLangid = 0; /* The "langid = ?" constraint, if any */ + sqlite3_value *pDocidGe = 0; /* The "docid >= ?" constraint, if any */ + sqlite3_value *pDocidLe = 0; /* The "docid <= ?" constraint, if any */ + int iIdx; + + UNUSED_PARAMETER(idxStr); + UNUSED_PARAMETER(nVal); + + eSearch = (idxNum & 0x0000FFFF); + assert( eSearch>=0 && eSearch<=(FTS3_FULLTEXT_SEARCH+p->nColumn) ); + assert( p->pSegments==0 ); + + /* Collect arguments into local variables */ + iIdx = 0; + if( eSearch!=FTS3_FULLSCAN_SEARCH ) pCons = apVal[iIdx++]; + if( idxNum & FTS3_HAVE_LANGID ) pLangid = apVal[iIdx++]; + if( idxNum & FTS3_HAVE_DOCID_GE ) pDocidGe = apVal[iIdx++]; + if( idxNum & FTS3_HAVE_DOCID_LE ) pDocidLe = apVal[iIdx++]; + assert( iIdx==nVal ); + + /* In case the cursor has been used before, clear it now. */ + sqlite3_finalize(pCsr->pStmt); + sqlite3_free(pCsr->aDoclist); + sqlite3Fts3MIBufferFree(pCsr->pMIBuffer); + sqlite3Fts3ExprFree(pCsr->pExpr); + memset(&pCursor[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor)); + + /* Set the lower and upper bounds on docids to return */ + pCsr->iMinDocid = fts3DocidRange(pDocidGe, SMALLEST_INT64); + pCsr->iMaxDocid = fts3DocidRange(pDocidLe, LARGEST_INT64); + + if( idxStr ){ + pCsr->bDesc = (idxStr[0]=='D'); + }else{ + pCsr->bDesc = p->bDescIdx; + } + pCsr->eSearch = (i16)eSearch; + + if( eSearch!=FTS3_DOCID_SEARCH && eSearch!=FTS3_FULLSCAN_SEARCH ){ + int iCol = eSearch-FTS3_FULLTEXT_SEARCH; + const char *zQuery = (const char *)sqlite3_value_text(pCons); + + if( zQuery==0 && sqlite3_value_type(pCons)!=SQLITE_NULL ){ + return SQLITE_NOMEM; + } + + pCsr->iLangid = 0; + if( pLangid ) pCsr->iLangid = sqlite3_value_int(pLangid); + + assert( p->base.zErrMsg==0 ); + rc = sqlite3Fts3ExprParse(p->pTokenizer, pCsr->iLangid, + p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr, + &p->base.zErrMsg + ); + if( rc!=SQLITE_OK ){ + return rc; + } + + rc = fts3EvalStart(pCsr); + sqlite3Fts3SegmentsClose(p); + if( rc!=SQLITE_OK ) return rc; + pCsr->pNextId = pCsr->aDoclist; + pCsr->iPrevId = 0; + } + + /* Compile a SELECT statement for this cursor. For a full-table-scan, the + ** statement loops through all rows of the %_content table. For a + ** full-text query or docid lookup, the statement retrieves a single + ** row by docid. + */ + if( eSearch==FTS3_FULLSCAN_SEARCH ){ + if( pDocidGe || pDocidLe ){ + zSql = sqlite3_mprintf( + "SELECT %s WHERE rowid BETWEEN %lld AND %lld ORDER BY rowid %s", + p->zReadExprlist, pCsr->iMinDocid, pCsr->iMaxDocid, + (pCsr->bDesc ? "DESC" : "ASC") + ); + }else{ + zSql = sqlite3_mprintf("SELECT %s ORDER BY rowid %s", + p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC") + ); + } + if( zSql ){ + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0); + sqlite3_free(zSql); + }else{ + rc = SQLITE_NOMEM; + } + }else if( eSearch==FTS3_DOCID_SEARCH ){ + rc = fts3CursorSeekStmt(pCsr, &pCsr->pStmt); + if( rc==SQLITE_OK ){ + rc = sqlite3_bind_value(pCsr->pStmt, 1, pCons); + } + } + if( rc!=SQLITE_OK ) return rc; + + return fts3NextMethod(pCursor); +} + +/* +** This is the xEof method of the virtual table. SQLite calls this +** routine to find out if it has reached the end of a result set. +*/ +static int fts3EofMethod(sqlite3_vtab_cursor *pCursor){ + return ((Fts3Cursor *)pCursor)->isEof; +} + +/* +** This is the xRowid method. The SQLite core calls this routine to +** retrieve the rowid for the current row of the result set. fts3 +** exposes %_content.docid as the rowid for the virtual table. The +** rowid should be written to *pRowid. +*/ +static int fts3RowidMethod(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){ + Fts3Cursor *pCsr = (Fts3Cursor *) pCursor; + *pRowid = pCsr->iPrevId; + return SQLITE_OK; +} + +/* +** This is the xColumn method, called by SQLite to request a value from +** the row that the supplied cursor currently points to. +** +** If: +** +** (iCol < p->nColumn) -> The value of the iCol'th user column. +** (iCol == p->nColumn) -> Magic column with the same name as the table. +** (iCol == p->nColumn+1) -> Docid column +** (iCol == p->nColumn+2) -> Langid column +*/ +static int fts3ColumnMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */ + int iCol /* Index of column to read value from */ +){ + int rc = SQLITE_OK; /* Return Code */ + Fts3Cursor *pCsr = (Fts3Cursor *) pCursor; + Fts3Table *p = (Fts3Table *)pCursor->pVtab; + + /* The column value supplied by SQLite must be in range. */ + assert( iCol>=0 && iCol<=p->nColumn+2 ); + + if( iCol==p->nColumn+1 ){ + /* This call is a request for the "docid" column. Since "docid" is an + ** alias for "rowid", use the xRowid() method to obtain the value. + */ + sqlite3_result_int64(pCtx, pCsr->iPrevId); + }else if( iCol==p->nColumn ){ + /* The extra column whose name is the same as the table. + ** Return a blob which is a pointer to the cursor. */ + sqlite3_result_blob(pCtx, &pCsr, sizeof(pCsr), SQLITE_TRANSIENT); + }else if( iCol==p->nColumn+2 && pCsr->pExpr ){ + sqlite3_result_int64(pCtx, pCsr->iLangid); + }else{ + /* The requested column is either a user column (one that contains + ** indexed data), or the language-id column. */ + rc = fts3CursorSeek(0, pCsr); + + if( rc==SQLITE_OK ){ + if( iCol==p->nColumn+2 ){ + int iLangid = 0; + if( p->zLanguageid ){ + iLangid = sqlite3_column_int(pCsr->pStmt, p->nColumn+1); + } + sqlite3_result_int(pCtx, iLangid); + }else if( sqlite3_data_count(pCsr->pStmt)>(iCol+1) ){ + sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1)); + } + } + } + + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + return rc; +} + +/* +** This function is the implementation of the xUpdate callback used by +** FTS3 virtual tables. It is invoked by SQLite each time a row is to be +** inserted, updated or deleted. +*/ +static int fts3UpdateMethod( + sqlite3_vtab *pVtab, /* Virtual table handle */ + int nArg, /* Size of argument array */ + sqlite3_value **apVal, /* Array of arguments */ + sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */ +){ + return sqlite3Fts3UpdateMethod(pVtab, nArg, apVal, pRowid); +} + +/* +** Implementation of xSync() method. Flush the contents of the pending-terms +** hash-table to the database. +*/ +static int fts3SyncMethod(sqlite3_vtab *pVtab){ + + /* Following an incremental-merge operation, assuming that the input + ** segments are not completely consumed (the usual case), they are updated + ** in place to remove the entries that have already been merged. This + ** involves updating the leaf block that contains the smallest unmerged + ** entry and each block (if any) between the leaf and the root node. So + ** if the height of the input segment b-trees is N, and input segments + ** are merged eight at a time, updating the input segments at the end + ** of an incremental-merge requires writing (8*(1+N)) blocks. N is usually + ** small - often between 0 and 2. So the overhead of the incremental + ** merge is somewhere between 8 and 24 blocks. To avoid this overhead + ** dwarfing the actual productive work accomplished, the incremental merge + ** is only attempted if it will write at least 64 leaf blocks. Hence + ** nMinMerge. + ** + ** Of course, updating the input segments also involves deleting a bunch + ** of blocks from the segments table. But this is not considered overhead + ** as it would also be required by a crisis-merge that used the same input + ** segments. + */ + const u32 nMinMerge = 64; /* Minimum amount of incr-merge work to do */ + + Fts3Table *p = (Fts3Table*)pVtab; + int rc = sqlite3Fts3PendingTermsFlush(p); + + if( rc==SQLITE_OK + && p->nLeafAdd>(nMinMerge/16) + && p->nAutoincrmerge && p->nAutoincrmerge!=0xff + ){ + int mxLevel = 0; /* Maximum relative level value in db */ + int A; /* Incr-merge parameter A */ + + rc = sqlite3Fts3MaxLevel(p, &mxLevel); + assert( rc==SQLITE_OK || mxLevel==0 ); + A = p->nLeafAdd * mxLevel; + A += (A/2); + if( A>(int)nMinMerge ) rc = sqlite3Fts3Incrmerge(p, A, p->nAutoincrmerge); + } + sqlite3Fts3SegmentsClose(p); + return rc; +} + +/* +** If it is currently unknown whether or not the FTS table has an %_stat +** table (if p->bHasStat==2), attempt to determine this (set p->bHasStat +** to 0 or 1). Return SQLITE_OK if successful, or an SQLite error code +** if an error occurs. +*/ +static int fts3SetHasStat(Fts3Table *p){ + int rc = SQLITE_OK; + if( p->bHasStat==2 ){ + const char *zFmt ="SELECT 1 FROM %Q.sqlite_master WHERE tbl_name='%q_stat'"; + char *zSql = sqlite3_mprintf(zFmt, p->zDb, p->zName); + if( zSql ){ + sqlite3_stmt *pStmt = 0; + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + if( rc==SQLITE_OK ){ + int bHasStat = (sqlite3_step(pStmt)==SQLITE_ROW); + rc = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ) p->bHasStat = bHasStat; + } + sqlite3_free(zSql); + }else{ + rc = SQLITE_NOMEM; + } + } + return rc; +} + +/* +** Implementation of xBegin() method. +*/ +static int fts3BeginMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table*)pVtab; + UNUSED_PARAMETER(pVtab); + assert( p->pSegments==0 ); + assert( p->nPendingData==0 ); + assert( p->inTransaction!=1 ); + TESTONLY( p->inTransaction = 1 ); + TESTONLY( p->mxSavepoint = -1; ); + p->nLeafAdd = 0; + return fts3SetHasStat(p); +} + +/* +** Implementation of xCommit() method. This is a no-op. The contents of +** the pending-terms hash-table have already been flushed into the database +** by fts3SyncMethod(). +*/ +static int fts3CommitMethod(sqlite3_vtab *pVtab){ + TESTONLY( Fts3Table *p = (Fts3Table*)pVtab ); + UNUSED_PARAMETER(pVtab); + assert( p->nPendingData==0 ); + assert( p->inTransaction!=0 ); + assert( p->pSegments==0 ); + TESTONLY( p->inTransaction = 0 ); + TESTONLY( p->mxSavepoint = -1; ); + return SQLITE_OK; +} + +/* +** Implementation of xRollback(). Discard the contents of the pending-terms +** hash-table. Any changes made to the database are reverted by SQLite. +*/ +static int fts3RollbackMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table*)pVtab; + sqlite3Fts3PendingTermsClear(p); + assert( p->inTransaction!=0 ); + TESTONLY( p->inTransaction = 0 ); + TESTONLY( p->mxSavepoint = -1; ); + return SQLITE_OK; +} + +/* +** When called, *ppPoslist must point to the byte immediately following the +** end of a position-list. i.e. ( (*ppPoslist)[-1]==POS_END ). This function +** moves *ppPoslist so that it instead points to the first byte of the +** same position list. +*/ +static void fts3ReversePoslist(char *pStart, char **ppPoslist){ + char *p = &(*ppPoslist)[-2]; + char c = 0; + + /* Skip backwards passed any trailing 0x00 bytes added by NearTrim() */ + while( p>pStart && (c=*p--)==0 ); + + /* Search backwards for a varint with value zero (the end of the previous + ** poslist). This is an 0x00 byte preceded by some byte that does not + ** have the 0x80 bit set. */ + while( p>pStart && (*p & 0x80) | c ){ + c = *p--; + } + assert( p==pStart || c==0 ); + + /* At this point p points to that preceding byte without the 0x80 bit + ** set. So to find the start of the poslist, skip forward 2 bytes then + ** over a varint. + ** + ** Normally. The other case is that p==pStart and the poslist to return + ** is the first in the doclist. In this case do not skip forward 2 bytes. + ** The second part of the if condition (c==0 && *ppPoslist>&p[2]) + ** is required for cases where the first byte of a doclist and the + ** doclist is empty. For example, if the first docid is 10, a doclist + ** that begins with: + ** + ** 0x0A 0x00 + */ + if( p>pStart || (c==0 && *ppPoslist>&p[2]) ){ p = &p[2]; } + while( *p++&0x80 ); + *ppPoslist = p; +} + +/* +** Helper function used by the implementation of the overloaded snippet(), +** offsets() and optimize() SQL functions. +** +** If the value passed as the third argument is a blob of size +** sizeof(Fts3Cursor*), then the blob contents are copied to the +** output variable *ppCsr and SQLITE_OK is returned. Otherwise, an error +** message is written to context pContext and SQLITE_ERROR returned. The +** string passed via zFunc is used as part of the error message. +*/ +static int fts3FunctionArg( + sqlite3_context *pContext, /* SQL function call context */ + const char *zFunc, /* Function name */ + sqlite3_value *pVal, /* argv[0] passed to function */ + Fts3Cursor **ppCsr /* OUT: Store cursor handle here */ +){ + Fts3Cursor *pRet; + if( sqlite3_value_type(pVal)!=SQLITE_BLOB + || sqlite3_value_bytes(pVal)!=sizeof(Fts3Cursor *) + ){ + char *zErr = sqlite3_mprintf("illegal first argument to %s", zFunc); + sqlite3_result_error(pContext, zErr, -1); + sqlite3_free(zErr); + return SQLITE_ERROR; + } + memcpy(&pRet, sqlite3_value_blob(pVal), sizeof(Fts3Cursor *)); + *ppCsr = pRet; + return SQLITE_OK; +} + +/* +** Implementation of the snippet() function for FTS3 +*/ +static void fts3SnippetFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of apVal[] array */ + sqlite3_value **apVal /* Array of arguments */ +){ + Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */ + const char *zStart = ""; + const char *zEnd = ""; + const char *zEllipsis = "..."; + int iCol = -1; + int nToken = 15; /* Default number of tokens in snippet */ + + /* There must be at least one argument passed to this function (otherwise + ** the non-overloaded version would have been called instead of this one). + */ + assert( nVal>=1 ); + + if( nVal>6 ){ + sqlite3_result_error(pContext, + "wrong number of arguments to function snippet()", -1); + return; + } + if( fts3FunctionArg(pContext, "snippet", apVal[0], &pCsr) ) return; + + switch( nVal ){ + case 6: nToken = sqlite3_value_int(apVal[5]); + case 5: iCol = sqlite3_value_int(apVal[4]); + case 4: zEllipsis = (const char*)sqlite3_value_text(apVal[3]); + case 3: zEnd = (const char*)sqlite3_value_text(apVal[2]); + case 2: zStart = (const char*)sqlite3_value_text(apVal[1]); + } + if( !zEllipsis || !zEnd || !zStart ){ + sqlite3_result_error_nomem(pContext); + }else if( nToken==0 ){ + sqlite3_result_text(pContext, "", -1, SQLITE_STATIC); + }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){ + sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken); + } +} + +/* +** Implementation of the offsets() function for FTS3 +*/ +static void fts3OffsetsFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of argument array */ + sqlite3_value **apVal /* Array of arguments */ +){ + Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */ + + UNUSED_PARAMETER(nVal); + + assert( nVal==1 ); + if( fts3FunctionArg(pContext, "offsets", apVal[0], &pCsr) ) return; + assert( pCsr ); + if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){ + sqlite3Fts3Offsets(pContext, pCsr); + } +} + +/* +** Implementation of the special optimize() function for FTS3. This +** function merges all segments in the database to a single segment. +** Example usage is: +** +** SELECT optimize(t) FROM t LIMIT 1; +** +** where 't' is the name of an FTS3 table. +*/ +static void fts3OptimizeFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of argument array */ + sqlite3_value **apVal /* Array of arguments */ +){ + int rc; /* Return code */ + Fts3Table *p; /* Virtual table handle */ + Fts3Cursor *pCursor; /* Cursor handle passed through apVal[0] */ + + UNUSED_PARAMETER(nVal); + + assert( nVal==1 ); + if( fts3FunctionArg(pContext, "optimize", apVal[0], &pCursor) ) return; + p = (Fts3Table *)pCursor->base.pVtab; + assert( p ); + + rc = sqlite3Fts3Optimize(p); + + switch( rc ){ + case SQLITE_OK: + sqlite3_result_text(pContext, "Index optimized", -1, SQLITE_STATIC); + break; + case SQLITE_DONE: + sqlite3_result_text(pContext, "Index already optimal", -1, SQLITE_STATIC); + break; + default: + sqlite3_result_error_code(pContext, rc); + break; + } +} + +/* +** Implementation of the matchinfo() function for FTS3 +*/ +static void fts3MatchinfoFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of argument array */ + sqlite3_value **apVal /* Array of arguments */ +){ + Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */ + assert( nVal==1 || nVal==2 ); + if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){ + const char *zArg = 0; + if( nVal>1 ){ + zArg = (const char *)sqlite3_value_text(apVal[1]); + } + sqlite3Fts3Matchinfo(pContext, pCsr, zArg); + } +} + +/* +** This routine implements the xFindFunction method for the FTS3 +** virtual table. +*/ +static int fts3FindFunctionMethod( + sqlite3_vtab *pVtab, /* Virtual table handle */ + int nArg, /* Number of SQL function arguments */ + const char *zName, /* Name of SQL function */ + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */ + void **ppArg /* Unused */ +){ + struct Overloaded { + const char *zName; + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + } aOverload[] = { + { "snippet", fts3SnippetFunc }, + { "offsets", fts3OffsetsFunc }, + { "optimize", fts3OptimizeFunc }, + { "matchinfo", fts3MatchinfoFunc }, + }; + int i; /* Iterator variable */ + + UNUSED_PARAMETER(pVtab); + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(ppArg); + + for(i=0; idb; /* Database connection */ + int rc; /* Return Code */ + + /* At this point it must be known if the %_stat table exists or not. + ** So bHasStat may not be 2. */ + rc = fts3SetHasStat(p); + + /* As it happens, the pending terms table is always empty here. This is + ** because an "ALTER TABLE RENAME TABLE" statement inside a transaction + ** always opens a savepoint transaction. And the xSavepoint() method + ** flushes the pending terms table. But leave the (no-op) call to + ** PendingTermsFlush() in in case that changes. + */ + assert( p->nPendingData==0 ); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3PendingTermsFlush(p); + } + + if( p->zContentTbl==0 ){ + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_content' RENAME TO '%q_content';", + p->zDb, p->zName, zName + ); + } + + if( p->bHasDocsize ){ + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_docsize' RENAME TO '%q_docsize';", + p->zDb, p->zName, zName + ); + } + if( p->bHasStat ){ + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_stat' RENAME TO '%q_stat';", + p->zDb, p->zName, zName + ); + } + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_segments' RENAME TO '%q_segments';", + p->zDb, p->zName, zName + ); + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_segdir' RENAME TO '%q_segdir';", + p->zDb, p->zName, zName + ); + return rc; +} + +/* +** The xSavepoint() method. +** +** Flush the contents of the pending-terms table to disk. +*/ +static int fts3SavepointMethod(sqlite3_vtab *pVtab, int iSavepoint){ + int rc = SQLITE_OK; + UNUSED_PARAMETER(iSavepoint); + assert( ((Fts3Table *)pVtab)->inTransaction ); + assert( ((Fts3Table *)pVtab)->mxSavepoint < iSavepoint ); + TESTONLY( ((Fts3Table *)pVtab)->mxSavepoint = iSavepoint ); + if( ((Fts3Table *)pVtab)->bIgnoreSavepoint==0 ){ + rc = fts3SyncMethod(pVtab); + } + return rc; +} + +/* +** The xRelease() method. +** +** This is a no-op. +*/ +static int fts3ReleaseMethod(sqlite3_vtab *pVtab, int iSavepoint){ + TESTONLY( Fts3Table *p = (Fts3Table*)pVtab ); + UNUSED_PARAMETER(iSavepoint); + UNUSED_PARAMETER(pVtab); + assert( p->inTransaction ); + assert( p->mxSavepoint >= iSavepoint ); + TESTONLY( p->mxSavepoint = iSavepoint-1 ); + return SQLITE_OK; +} + +/* +** The xRollbackTo() method. +** +** Discard the contents of the pending terms table. +*/ +static int fts3RollbackToMethod(sqlite3_vtab *pVtab, int iSavepoint){ + Fts3Table *p = (Fts3Table*)pVtab; + UNUSED_PARAMETER(iSavepoint); + assert( p->inTransaction ); + assert( p->mxSavepoint >= iSavepoint ); + TESTONLY( p->mxSavepoint = iSavepoint ); + sqlite3Fts3PendingTermsClear(p); + return SQLITE_OK; +} + +static const sqlite3_module fts3Module = { + /* iVersion */ 2, + /* xCreate */ fts3CreateMethod, + /* xConnect */ fts3ConnectMethod, + /* xBestIndex */ fts3BestIndexMethod, + /* xDisconnect */ fts3DisconnectMethod, + /* xDestroy */ fts3DestroyMethod, + /* xOpen */ fts3OpenMethod, + /* xClose */ fts3CloseMethod, + /* xFilter */ fts3FilterMethod, + /* xNext */ fts3NextMethod, + /* xEof */ fts3EofMethod, + /* xColumn */ fts3ColumnMethod, + /* xRowid */ fts3RowidMethod, + /* xUpdate */ fts3UpdateMethod, + /* xBegin */ fts3BeginMethod, + /* xSync */ fts3SyncMethod, + /* xCommit */ fts3CommitMethod, + /* xRollback */ fts3RollbackMethod, + /* xFindFunction */ fts3FindFunctionMethod, + /* xRename */ fts3RenameMethod, + /* xSavepoint */ fts3SavepointMethod, + /* xRelease */ fts3ReleaseMethod, + /* xRollbackTo */ fts3RollbackToMethod, +}; + +/* +** This function is registered as the module destructor (called when an +** FTS3 enabled database connection is closed). It frees the memory +** allocated for the tokenizer hash table. +*/ +static void hashDestroy(void *p){ + Fts3Hash *pHash = (Fts3Hash *)p; + sqlite3Fts3HashClear(pHash); + sqlite3_free(pHash); +} + +/* +** The fts3 built-in tokenizers - "simple", "porter" and "icu"- are +** implemented in files fts3_tokenizer1.c, fts3_porter.c and fts3_icu.c +** respectively. The following three forward declarations are for functions +** declared in these files used to retrieve the respective implementations. +** +** Calling sqlite3Fts3SimpleTokenizerModule() sets the value pointed +** to by the argument to point to the "simple" tokenizer implementation. +** And so on. +*/ +SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule); +SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule(sqlite3_tokenizer_module const**ppModule); +#ifndef SQLITE_DISABLE_FTS3_UNICODE +SQLITE_PRIVATE void sqlite3Fts3UnicodeTokenizer(sqlite3_tokenizer_module const**ppModule); +#endif +#ifdef SQLITE_ENABLE_ICU +SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule(sqlite3_tokenizer_module const**ppModule); +#endif + +/* +** Initialize the fts3 extension. If this extension is built as part +** of the sqlite library, then this function is called directly by +** SQLite. If fts3 is built as a dynamically loadable extension, this +** function is called by the sqlite3_extension_init() entry point. +*/ +SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db){ + int rc = SQLITE_OK; + Fts3Hash *pHash = 0; + const sqlite3_tokenizer_module *pSimple = 0; + const sqlite3_tokenizer_module *pPorter = 0; +#ifndef SQLITE_DISABLE_FTS3_UNICODE + const sqlite3_tokenizer_module *pUnicode = 0; +#endif + +#ifdef SQLITE_ENABLE_ICU + const sqlite3_tokenizer_module *pIcu = 0; + sqlite3Fts3IcuTokenizerModule(&pIcu); +#endif + +#ifndef SQLITE_DISABLE_FTS3_UNICODE + sqlite3Fts3UnicodeTokenizer(&pUnicode); +#endif + +#ifdef SQLITE_TEST + rc = sqlite3Fts3InitTerm(db); + if( rc!=SQLITE_OK ) return rc; +#endif + + rc = sqlite3Fts3InitAux(db); + if( rc!=SQLITE_OK ) return rc; + + sqlite3Fts3SimpleTokenizerModule(&pSimple); + sqlite3Fts3PorterTokenizerModule(&pPorter); + + /* Allocate and initialize the hash-table used to store tokenizers. */ + pHash = sqlite3_malloc(sizeof(Fts3Hash)); + if( !pHash ){ + rc = SQLITE_NOMEM; + }else{ + sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1); + } + + /* Load the built-in tokenizers into the hash table */ + if( rc==SQLITE_OK ){ + if( sqlite3Fts3HashInsert(pHash, "simple", 7, (void *)pSimple) + || sqlite3Fts3HashInsert(pHash, "porter", 7, (void *)pPorter) + +#ifndef SQLITE_DISABLE_FTS3_UNICODE + || sqlite3Fts3HashInsert(pHash, "unicode61", 10, (void *)pUnicode) +#endif +#ifdef SQLITE_ENABLE_ICU + || (pIcu && sqlite3Fts3HashInsert(pHash, "icu", 4, (void *)pIcu)) +#endif + ){ + rc = SQLITE_NOMEM; + } + } + +#ifdef SQLITE_TEST + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3ExprInitTestInterface(db); + } +#endif + + /* Create the virtual table wrapper around the hash-table and overload + ** the two scalar functions. If this is successful, register the + ** module with sqlite. + */ + if( SQLITE_OK==rc + && SQLITE_OK==(rc = sqlite3Fts3InitHashTable(db, pHash, "fts3_tokenizer")) + && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1)) + && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", 1)) + && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 1)) + && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 2)) + && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", 1)) + ){ + rc = sqlite3_create_module_v2( + db, "fts3", &fts3Module, (void *)pHash, hashDestroy + ); + if( rc==SQLITE_OK ){ + rc = sqlite3_create_module_v2( + db, "fts4", &fts3Module, (void *)pHash, 0 + ); + } + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3InitTok(db, (void *)pHash); + } + return rc; + } + + + /* An error has occurred. Delete the hash table and return the error code. */ + assert( rc!=SQLITE_OK ); + if( pHash ){ + sqlite3Fts3HashClear(pHash); + sqlite3_free(pHash); + } + return rc; +} + +/* +** Allocate an Fts3MultiSegReader for each token in the expression headed +** by pExpr. +** +** An Fts3SegReader object is a cursor that can seek or scan a range of +** entries within a single segment b-tree. An Fts3MultiSegReader uses multiple +** Fts3SegReader objects internally to provide an interface to seek or scan +** within the union of all segments of a b-tree. Hence the name. +** +** If the allocated Fts3MultiSegReader just seeks to a single entry in a +** segment b-tree (if the term is not a prefix or it is a prefix for which +** there exists prefix b-tree of the right length) then it may be traversed +** and merged incrementally. Otherwise, it has to be merged into an in-memory +** doclist and then traversed. +*/ +static void fts3EvalAllocateReaders( + Fts3Cursor *pCsr, /* FTS cursor handle */ + Fts3Expr *pExpr, /* Allocate readers for this expression */ + int *pnToken, /* OUT: Total number of tokens in phrase. */ + int *pnOr, /* OUT: Total number of OR nodes in expr. */ + int *pRc /* IN/OUT: Error code */ +){ + if( pExpr && SQLITE_OK==*pRc ){ + if( pExpr->eType==FTSQUERY_PHRASE ){ + int i; + int nToken = pExpr->pPhrase->nToken; + *pnToken += nToken; + for(i=0; ipPhrase->aToken[i]; + int rc = fts3TermSegReaderCursor(pCsr, + pToken->z, pToken->n, pToken->isPrefix, &pToken->pSegcsr + ); + if( rc!=SQLITE_OK ){ + *pRc = rc; + return; + } + } + assert( pExpr->pPhrase->iDoclistToken==0 ); + pExpr->pPhrase->iDoclistToken = -1; + }else{ + *pnOr += (pExpr->eType==FTSQUERY_OR); + fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc); + fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc); + } + } +} + +/* +** Arguments pList/nList contain the doclist for token iToken of phrase p. +** It is merged into the main doclist stored in p->doclist.aAll/nAll. +** +** This function assumes that pList points to a buffer allocated using +** sqlite3_malloc(). This function takes responsibility for eventually +** freeing the buffer. +** +** SQLITE_OK is returned if successful, or SQLITE_NOMEM if an error occurs. +*/ +static int fts3EvalPhraseMergeToken( + Fts3Table *pTab, /* FTS Table pointer */ + Fts3Phrase *p, /* Phrase to merge pList/nList into */ + int iToken, /* Token pList/nList corresponds to */ + char *pList, /* Pointer to doclist */ + int nList /* Number of bytes in pList */ +){ + int rc = SQLITE_OK; + assert( iToken!=p->iDoclistToken ); + + if( pList==0 ){ + sqlite3_free(p->doclist.aAll); + p->doclist.aAll = 0; + p->doclist.nAll = 0; + } + + else if( p->iDoclistToken<0 ){ + p->doclist.aAll = pList; + p->doclist.nAll = nList; + } + + else if( p->doclist.aAll==0 ){ + sqlite3_free(pList); + } + + else { + char *pLeft; + char *pRight; + int nLeft; + int nRight; + int nDiff; + + if( p->iDoclistTokendoclist.aAll; + nLeft = p->doclist.nAll; + pRight = pList; + nRight = nList; + nDiff = iToken - p->iDoclistToken; + }else{ + pRight = p->doclist.aAll; + nRight = p->doclist.nAll; + pLeft = pList; + nLeft = nList; + nDiff = p->iDoclistToken - iToken; + } + + rc = fts3DoclistPhraseMerge( + pTab->bDescIdx, nDiff, pLeft, nLeft, &pRight, &nRight + ); + sqlite3_free(pLeft); + p->doclist.aAll = pRight; + p->doclist.nAll = nRight; + } + + if( iToken>p->iDoclistToken ) p->iDoclistToken = iToken; + return rc; +} + +/* +** Load the doclist for phrase p into p->doclist.aAll/nAll. The loaded doclist +** does not take deferred tokens into account. +** +** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code. +*/ +static int fts3EvalPhraseLoad( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Phrase *p /* Phrase object */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int iToken; + int rc = SQLITE_OK; + + for(iToken=0; rc==SQLITE_OK && iTokennToken; iToken++){ + Fts3PhraseToken *pToken = &p->aToken[iToken]; + assert( pToken->pDeferred==0 || pToken->pSegcsr==0 ); + + if( pToken->pSegcsr ){ + int nThis = 0; + char *pThis = 0; + rc = fts3TermSelect(pTab, pToken, p->iColumn, &nThis, &pThis); + if( rc==SQLITE_OK ){ + rc = fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis); + } + } + assert( pToken->pSegcsr==0 ); + } + + return rc; +} + +/* +** This function is called on each phrase after the position lists for +** any deferred tokens have been loaded into memory. It updates the phrases +** current position list to include only those positions that are really +** instances of the phrase (after considering deferred tokens). If this +** means that the phrase does not appear in the current row, doclist.pList +** and doclist.nList are both zeroed. +** +** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code. +*/ +static int fts3EvalDeferredPhrase(Fts3Cursor *pCsr, Fts3Phrase *pPhrase){ + int iToken; /* Used to iterate through phrase tokens */ + char *aPoslist = 0; /* Position list for deferred tokens */ + int nPoslist = 0; /* Number of bytes in aPoslist */ + int iPrev = -1; /* Token number of previous deferred token */ + + assert( pPhrase->doclist.bFreeList==0 ); + + for(iToken=0; iTokennToken; iToken++){ + Fts3PhraseToken *pToken = &pPhrase->aToken[iToken]; + Fts3DeferredToken *pDeferred = pToken->pDeferred; + + if( pDeferred ){ + char *pList; + int nList; + int rc = sqlite3Fts3DeferredTokenList(pDeferred, &pList, &nList); + if( rc!=SQLITE_OK ) return rc; + + if( pList==0 ){ + sqlite3_free(aPoslist); + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + return SQLITE_OK; + + }else if( aPoslist==0 ){ + aPoslist = pList; + nPoslist = nList; + + }else{ + char *aOut = pList; + char *p1 = aPoslist; + char *p2 = aOut; + + assert( iPrev>=0 ); + fts3PoslistPhraseMerge(&aOut, iToken-iPrev, 0, 1, &p1, &p2); + sqlite3_free(aPoslist); + aPoslist = pList; + nPoslist = (int)(aOut - aPoslist); + if( nPoslist==0 ){ + sqlite3_free(aPoslist); + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + return SQLITE_OK; + } + } + iPrev = iToken; + } + } + + if( iPrev>=0 ){ + int nMaxUndeferred = pPhrase->iDoclistToken; + if( nMaxUndeferred<0 ){ + pPhrase->doclist.pList = aPoslist; + pPhrase->doclist.nList = nPoslist; + pPhrase->doclist.iDocid = pCsr->iPrevId; + pPhrase->doclist.bFreeList = 1; + }else{ + int nDistance; + char *p1; + char *p2; + char *aOut; + + if( nMaxUndeferred>iPrev ){ + p1 = aPoslist; + p2 = pPhrase->doclist.pList; + nDistance = nMaxUndeferred - iPrev; + }else{ + p1 = pPhrase->doclist.pList; + p2 = aPoslist; + nDistance = iPrev - nMaxUndeferred; + } + + aOut = (char *)sqlite3_malloc(nPoslist+8); + if( !aOut ){ + sqlite3_free(aPoslist); + return SQLITE_NOMEM; + } + + pPhrase->doclist.pList = aOut; + if( fts3PoslistPhraseMerge(&aOut, nDistance, 0, 1, &p1, &p2) ){ + pPhrase->doclist.bFreeList = 1; + pPhrase->doclist.nList = (int)(aOut - pPhrase->doclist.pList); + }else{ + sqlite3_free(aOut); + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + } + sqlite3_free(aPoslist); + } + } + + return SQLITE_OK; +} + +/* +** Maximum number of tokens a phrase may have to be considered for the +** incremental doclists strategy. +*/ +#define MAX_INCR_PHRASE_TOKENS 4 + +/* +** This function is called for each Fts3Phrase in a full-text query +** expression to initialize the mechanism for returning rows. Once this +** function has been called successfully on an Fts3Phrase, it may be +** used with fts3EvalPhraseNext() to iterate through the matching docids. +** +** If parameter bOptOk is true, then the phrase may (or may not) use the +** incremental loading strategy. Otherwise, the entire doclist is loaded into +** memory within this call. +** +** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code. +*/ +static int fts3EvalPhraseStart(Fts3Cursor *pCsr, int bOptOk, Fts3Phrase *p){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; /* Error code */ + int i; + + /* Determine if doclists may be loaded from disk incrementally. This is + ** possible if the bOptOk argument is true, the FTS doclists will be + ** scanned in forward order, and the phrase consists of + ** MAX_INCR_PHRASE_TOKENS or fewer tokens, none of which are are "^first" + ** tokens or prefix tokens that cannot use a prefix-index. */ + int bHaveIncr = 0; + int bIncrOk = (bOptOk + && pCsr->bDesc==pTab->bDescIdx + && p->nToken<=MAX_INCR_PHRASE_TOKENS && p->nToken>0 +#ifdef SQLITE_TEST + && pTab->bNoIncrDoclist==0 +#endif + ); + for(i=0; bIncrOk==1 && inToken; i++){ + Fts3PhraseToken *pToken = &p->aToken[i]; + if( pToken->bFirst || (pToken->pSegcsr!=0 && !pToken->pSegcsr->bLookup) ){ + bIncrOk = 0; + } + if( pToken->pSegcsr ) bHaveIncr = 1; + } + + if( bIncrOk && bHaveIncr ){ + /* Use the incremental approach. */ + int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn); + for(i=0; rc==SQLITE_OK && inToken; i++){ + Fts3PhraseToken *pToken = &p->aToken[i]; + Fts3MultiSegReader *pSegcsr = pToken->pSegcsr; + if( pSegcsr ){ + rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n); + } + } + p->bIncr = 1; + }else{ + /* Load the full doclist for the phrase into memory. */ + rc = fts3EvalPhraseLoad(pCsr, p); + p->bIncr = 0; + } + + assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr ); + return rc; +} + +/* +** This function is used to iterate backwards (from the end to start) +** through doclists. It is used by this module to iterate through phrase +** doclists in reverse and by the fts3_write.c module to iterate through +** pending-terms lists when writing to databases with "order=desc". +** +** The doclist may be sorted in ascending (parameter bDescIdx==0) or +** descending (parameter bDescIdx==1) order of docid. Regardless, this +** function iterates from the end of the doclist to the beginning. +*/ +SQLITE_PRIVATE void sqlite3Fts3DoclistPrev( + int bDescIdx, /* True if the doclist is desc */ + char *aDoclist, /* Pointer to entire doclist */ + int nDoclist, /* Length of aDoclist in bytes */ + char **ppIter, /* IN/OUT: Iterator pointer */ + sqlite3_int64 *piDocid, /* IN/OUT: Docid pointer */ + int *pnList, /* OUT: List length pointer */ + u8 *pbEof /* OUT: End-of-file flag */ +){ + char *p = *ppIter; + + assert( nDoclist>0 ); + assert( *pbEof==0 ); + assert( p || *piDocid==0 ); + assert( !p || (p>aDoclist && p<&aDoclist[nDoclist]) ); + + if( p==0 ){ + sqlite3_int64 iDocid = 0; + char *pNext = 0; + char *pDocid = aDoclist; + char *pEnd = &aDoclist[nDoclist]; + int iMul = 1; + + while( pDocid0 ); + assert( *pbEof==0 ); + assert( p || *piDocid==0 ); + assert( !p || (p>=aDoclist && p<=&aDoclist[nDoclist]) ); + + if( p==0 ){ + p = aDoclist; + p += sqlite3Fts3GetVarint(p, piDocid); + }else{ + fts3PoslistCopy(0, &p); + while( p<&aDoclist[nDoclist] && *p==0 ) p++; + if( p>=&aDoclist[nDoclist] ){ + *pbEof = 1; + }else{ + sqlite3_int64 iVar; + p += sqlite3Fts3GetVarint(p, &iVar); + *piDocid += ((bDescIdx ? -1 : 1) * iVar); + } + } + + *ppIter = p; +} + +/* +** Advance the iterator pDL to the next entry in pDL->aAll/nAll. Set *pbEof +** to true if EOF is reached. +*/ +static void fts3EvalDlPhraseNext( + Fts3Table *pTab, + Fts3Doclist *pDL, + u8 *pbEof +){ + char *pIter; /* Used to iterate through aAll */ + char *pEnd = &pDL->aAll[pDL->nAll]; /* 1 byte past end of aAll */ + + if( pDL->pNextDocid ){ + pIter = pDL->pNextDocid; + }else{ + pIter = pDL->aAll; + } + + if( pIter>=pEnd ){ + /* We have already reached the end of this doclist. EOF. */ + *pbEof = 1; + }else{ + sqlite3_int64 iDelta; + pIter += sqlite3Fts3GetVarint(pIter, &iDelta); + if( pTab->bDescIdx==0 || pDL->pNextDocid==0 ){ + pDL->iDocid += iDelta; + }else{ + pDL->iDocid -= iDelta; + } + pDL->pList = pIter; + fts3PoslistCopy(0, &pIter); + pDL->nList = (int)(pIter - pDL->pList); + + /* pIter now points just past the 0x00 that terminates the position- + ** list for document pDL->iDocid. However, if this position-list was + ** edited in place by fts3EvalNearTrim(), then pIter may not actually + ** point to the start of the next docid value. The following line deals + ** with this case by advancing pIter past the zero-padding added by + ** fts3EvalNearTrim(). */ + while( pIterpNextDocid = pIter; + assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter ); + *pbEof = 0; + } +} + +/* +** Helper type used by fts3EvalIncrPhraseNext() and incrPhraseTokenNext(). +*/ +typedef struct TokenDoclist TokenDoclist; +struct TokenDoclist { + int bIgnore; + sqlite3_int64 iDocid; + char *pList; + int nList; +}; + +/* +** Token pToken is an incrementally loaded token that is part of a +** multi-token phrase. Advance it to the next matching document in the +** database and populate output variable *p with the details of the new +** entry. Or, if the iterator has reached EOF, set *pbEof to true. +** +** If an error occurs, return an SQLite error code. Otherwise, return +** SQLITE_OK. +*/ +static int incrPhraseTokenNext( + Fts3Table *pTab, /* Virtual table handle */ + Fts3Phrase *pPhrase, /* Phrase to advance token of */ + int iToken, /* Specific token to advance */ + TokenDoclist *p, /* OUT: Docid and doclist for new entry */ + u8 *pbEof /* OUT: True if iterator is at EOF */ +){ + int rc = SQLITE_OK; + + if( pPhrase->iDoclistToken==iToken ){ + assert( p->bIgnore==0 ); + assert( pPhrase->aToken[iToken].pSegcsr==0 ); + fts3EvalDlPhraseNext(pTab, &pPhrase->doclist, pbEof); + p->pList = pPhrase->doclist.pList; + p->nList = pPhrase->doclist.nList; + p->iDocid = pPhrase->doclist.iDocid; + }else{ + Fts3PhraseToken *pToken = &pPhrase->aToken[iToken]; + assert( pToken->pDeferred==0 ); + assert( pToken->pSegcsr || pPhrase->iDoclistToken>=0 ); + if( pToken->pSegcsr ){ + assert( p->bIgnore==0 ); + rc = sqlite3Fts3MsrIncrNext( + pTab, pToken->pSegcsr, &p->iDocid, &p->pList, &p->nList + ); + if( p->pList==0 ) *pbEof = 1; + }else{ + p->bIgnore = 1; + } + } + + return rc; +} + + +/* +** The phrase iterator passed as the second argument: +** +** * features at least one token that uses an incremental doclist, and +** +** * does not contain any deferred tokens. +** +** Advance it to the next matching documnent in the database and populate +** the Fts3Doclist.pList and nList fields. +** +** If there is no "next" entry and no error occurs, then *pbEof is set to +** 1 before returning. Otherwise, if no error occurs and the iterator is +** successfully advanced, *pbEof is set to 0. +** +** If an error occurs, return an SQLite error code. Otherwise, return +** SQLITE_OK. +*/ +static int fts3EvalIncrPhraseNext( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Phrase *p, /* Phrase object to advance to next docid */ + u8 *pbEof /* OUT: Set to 1 if EOF */ +){ + int rc = SQLITE_OK; + Fts3Doclist *pDL = &p->doclist; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + u8 bEof = 0; + + /* This is only called if it is guaranteed that the phrase has at least + ** one incremental token. In which case the bIncr flag is set. */ + assert( p->bIncr==1 ); + + if( p->nToken==1 && p->bIncr ){ + rc = sqlite3Fts3MsrIncrNext(pTab, p->aToken[0].pSegcsr, + &pDL->iDocid, &pDL->pList, &pDL->nList + ); + if( pDL->pList==0 ) bEof = 1; + }else{ + int bDescDoclist = pCsr->bDesc; + struct TokenDoclist a[MAX_INCR_PHRASE_TOKENS]; + + memset(a, 0, sizeof(a)); + assert( p->nToken<=MAX_INCR_PHRASE_TOKENS ); + assert( p->iDoclistTokennToken && bEof==0; i++){ + rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof); + if( a[i].bIgnore==0 && (bMaxSet==0 || DOCID_CMP(iMax, a[i].iDocid)<0) ){ + iMax = a[i].iDocid; + bMaxSet = 1; + } + } + assert( rc!=SQLITE_OK || (p->nToken>=1 && a[p->nToken-1].bIgnore==0) ); + assert( rc!=SQLITE_OK || bMaxSet ); + + /* Keep advancing iterators until they all point to the same document */ + for(i=0; inToken; i++){ + while( rc==SQLITE_OK && bEof==0 + && a[i].bIgnore==0 && DOCID_CMP(a[i].iDocid, iMax)<0 + ){ + rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof); + if( DOCID_CMP(a[i].iDocid, iMax)>0 ){ + iMax = a[i].iDocid; + i = 0; + } + } + } + + /* Check if the current entries really are a phrase match */ + if( bEof==0 ){ + int nList = 0; + int nByte = a[p->nToken-1].nList; + char *aDoclist = sqlite3_malloc(nByte+1); + if( !aDoclist ) return SQLITE_NOMEM; + memcpy(aDoclist, a[p->nToken-1].pList, nByte+1); + + for(i=0; i<(p->nToken-1); i++){ + if( a[i].bIgnore==0 ){ + char *pL = a[i].pList; + char *pR = aDoclist; + char *pOut = aDoclist; + int nDist = p->nToken-1-i; + int res = fts3PoslistPhraseMerge(&pOut, nDist, 0, 1, &pL, &pR); + if( res==0 ) break; + nList = (int)(pOut - aDoclist); + } + } + if( i==(p->nToken-1) ){ + pDL->iDocid = iMax; + pDL->pList = aDoclist; + pDL->nList = nList; + pDL->bFreeList = 1; + break; + } + sqlite3_free(aDoclist); + } + } + } + + *pbEof = bEof; + return rc; +} + +/* +** Attempt to move the phrase iterator to point to the next matching docid. +** If an error occurs, return an SQLite error code. Otherwise, return +** SQLITE_OK. +** +** If there is no "next" entry and no error occurs, then *pbEof is set to +** 1 before returning. Otherwise, if no error occurs and the iterator is +** successfully advanced, *pbEof is set to 0. +*/ +static int fts3EvalPhraseNext( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Phrase *p, /* Phrase object to advance to next docid */ + u8 *pbEof /* OUT: Set to 1 if EOF */ +){ + int rc = SQLITE_OK; + Fts3Doclist *pDL = &p->doclist; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + + if( p->bIncr ){ + rc = fts3EvalIncrPhraseNext(pCsr, p, pbEof); + }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){ + sqlite3Fts3DoclistPrev(pTab->bDescIdx, pDL->aAll, pDL->nAll, + &pDL->pNextDocid, &pDL->iDocid, &pDL->nList, pbEof + ); + pDL->pList = pDL->pNextDocid; + }else{ + fts3EvalDlPhraseNext(pTab, pDL, pbEof); + } + + return rc; +} + +/* +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, fts3EvalPhraseStart() is called on all phrases within the +** expression. Also the Fts3Expr.bDeferred variable is set to true for any +** expressions for which all descendent tokens are deferred. +** +** If parameter bOptOk is zero, then it is guaranteed that the +** Fts3Phrase.doclist.aAll/nAll variables contain the entire doclist for +** each phrase in the expression (subject to deferred token processing). +** Or, if bOptOk is non-zero, then one or more tokens within the expression +** may be loaded incrementally, meaning doclist.aAll/nAll is not available. +** +** If an error occurs within this function, *pRc is set to an SQLite error +** code before returning. +*/ +static void fts3EvalStartReaders( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pExpr, /* Expression to initialize phrases in */ + int *pRc /* IN/OUT: Error code */ +){ + if( pExpr && SQLITE_OK==*pRc ){ + if( pExpr->eType==FTSQUERY_PHRASE ){ + int nToken = pExpr->pPhrase->nToken; + if( nToken ){ + int i; + for(i=0; ipPhrase->aToken[i].pDeferred==0 ) break; + } + pExpr->bDeferred = (i==nToken); + } + *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase); + }else{ + fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc); + fts3EvalStartReaders(pCsr, pExpr->pRight, pRc); + pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred); + } + } +} + +/* +** An array of the following structures is assembled as part of the process +** of selecting tokens to defer before the query starts executing (as part +** of the xFilter() method). There is one element in the array for each +** token in the FTS expression. +** +** Tokens are divided into AND/NEAR clusters. All tokens in a cluster belong +** to phrases that are connected only by AND and NEAR operators (not OR or +** NOT). When determining tokens to defer, each AND/NEAR cluster is considered +** separately. The root of a tokens AND/NEAR cluster is stored in +** Fts3TokenAndCost.pRoot. +*/ +typedef struct Fts3TokenAndCost Fts3TokenAndCost; +struct Fts3TokenAndCost { + Fts3Phrase *pPhrase; /* The phrase the token belongs to */ + int iToken; /* Position of token in phrase */ + Fts3PhraseToken *pToken; /* The token itself */ + Fts3Expr *pRoot; /* Root of NEAR/AND cluster */ + int nOvfl; /* Number of overflow pages to load doclist */ + int iCol; /* The column the token must match */ +}; + +/* +** This function is used to populate an allocated Fts3TokenAndCost array. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, if an error occurs during execution, *pRc is set to an +** SQLite error code. +*/ +static void fts3EvalTokenCosts( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pRoot, /* Root of current AND/NEAR cluster */ + Fts3Expr *pExpr, /* Expression to consider */ + Fts3TokenAndCost **ppTC, /* Write new entries to *(*ppTC)++ */ + Fts3Expr ***ppOr, /* Write new OR root to *(*ppOr)++ */ + int *pRc /* IN/OUT: Error code */ +){ + if( *pRc==SQLITE_OK ){ + if( pExpr->eType==FTSQUERY_PHRASE ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + int i; + for(i=0; *pRc==SQLITE_OK && inToken; i++){ + Fts3TokenAndCost *pTC = (*ppTC)++; + pTC->pPhrase = pPhrase; + pTC->iToken = i; + pTC->pRoot = pRoot; + pTC->pToken = &pPhrase->aToken[i]; + pTC->iCol = pPhrase->iColumn; + *pRc = sqlite3Fts3MsrOvfl(pCsr, pTC->pToken->pSegcsr, &pTC->nOvfl); + } + }else if( pExpr->eType!=FTSQUERY_NOT ){ + assert( pExpr->eType==FTSQUERY_OR + || pExpr->eType==FTSQUERY_AND + || pExpr->eType==FTSQUERY_NEAR + ); + assert( pExpr->pLeft && pExpr->pRight ); + if( pExpr->eType==FTSQUERY_OR ){ + pRoot = pExpr->pLeft; + **ppOr = pRoot; + (*ppOr)++; + } + fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc); + if( pExpr->eType==FTSQUERY_OR ){ + pRoot = pExpr->pRight; + **ppOr = pRoot; + (*ppOr)++; + } + fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc); + } + } +} + +/* +** Determine the average document (row) size in pages. If successful, +** write this value to *pnPage and return SQLITE_OK. Otherwise, return +** an SQLite error code. +** +** The average document size in pages is calculated by first calculating +** determining the average size in bytes, B. If B is less than the amount +** of data that will fit on a single leaf page of an intkey table in +** this database, then the average docsize is 1. Otherwise, it is 1 plus +** the number of overflow pages consumed by a record B bytes in size. +*/ +static int fts3EvalAverageDocsize(Fts3Cursor *pCsr, int *pnPage){ + if( pCsr->nRowAvg==0 ){ + /* The average document size, which is required to calculate the cost + ** of each doclist, has not yet been determined. Read the required + ** data from the %_stat table to calculate it. + ** + ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3 + ** varints, where nCol is the number of columns in the FTS3 table. + ** The first varint is the number of documents currently stored in + ** the table. The following nCol varints contain the total amount of + ** data stored in all rows of each column of the table, from left + ** to right. + */ + int rc; + Fts3Table *p = (Fts3Table*)pCsr->base.pVtab; + sqlite3_stmt *pStmt; + sqlite3_int64 nDoc = 0; + sqlite3_int64 nByte = 0; + const char *pEnd; + const char *a; + + rc = sqlite3Fts3SelectDoctotal(p, &pStmt); + if( rc!=SQLITE_OK ) return rc; + a = sqlite3_column_blob(pStmt, 0); + assert( a ); + + pEnd = &a[sqlite3_column_bytes(pStmt, 0)]; + a += sqlite3Fts3GetVarint(a, &nDoc); + while( anDoc = nDoc; + pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz); + assert( pCsr->nRowAvg>0 ); + rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ) return rc; + } + + *pnPage = pCsr->nRowAvg; + return SQLITE_OK; +} + +/* +** This function is called to select the tokens (if any) that will be +** deferred. The array aTC[] has already been populated when this is +** called. +** +** This function is called once for each AND/NEAR cluster in the +** expression. Each invocation determines which tokens to defer within +** the cluster with root node pRoot. See comments above the definition +** of struct Fts3TokenAndCost for more details. +** +** If no error occurs, SQLITE_OK is returned and sqlite3Fts3DeferToken() +** called on each token to defer. Otherwise, an SQLite error code is +** returned. +*/ +static int fts3EvalSelectDeferred( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pRoot, /* Consider tokens with this root node */ + Fts3TokenAndCost *aTC, /* Array of expression tokens and costs */ + int nTC /* Number of entries in aTC[] */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int nDocSize = 0; /* Number of pages per doc loaded */ + int rc = SQLITE_OK; /* Return code */ + int ii; /* Iterator variable for various purposes */ + int nOvfl = 0; /* Total overflow pages used by doclists */ + int nToken = 0; /* Total number of tokens in cluster */ + + int nMinEst = 0; /* The minimum count for any phrase so far. */ + int nLoad4 = 1; /* (Phrases that will be loaded)^4. */ + + /* Tokens are never deferred for FTS tables created using the content=xxx + ** option. The reason being that it is not guaranteed that the content + ** table actually contains the same data as the index. To prevent this from + ** causing any problems, the deferred token optimization is completely + ** disabled for content=xxx tables. */ + if( pTab->zContentTbl ){ + return SQLITE_OK; + } + + /* Count the tokens in this AND/NEAR cluster. If none of the doclists + ** associated with the tokens spill onto overflow pages, or if there is + ** only 1 token, exit early. No tokens to defer in this case. */ + for(ii=0; ii0 ); + + + /* Iterate through all tokens in this AND/NEAR cluster, in ascending order + ** of the number of overflow pages that will be loaded by the pager layer + ** to retrieve the entire doclist for the token from the full-text index. + ** Load the doclists for tokens that are either: + ** + ** a. The cheapest token in the entire query (i.e. the one visited by the + ** first iteration of this loop), or + ** + ** b. Part of a multi-token phrase. + ** + ** After each token doclist is loaded, merge it with the others from the + ** same phrase and count the number of documents that the merged doclist + ** contains. Set variable "nMinEst" to the smallest number of documents in + ** any phrase doclist for which 1 or more token doclists have been loaded. + ** Let nOther be the number of other phrases for which it is certain that + ** one or more tokens will not be deferred. + ** + ** Then, for each token, defer it if loading the doclist would result in + ** loading N or more overflow pages into memory, where N is computed as: + ** + ** (nMinEst + 4^nOther - 1) / (4^nOther) + */ + for(ii=0; iinOvfl) + ){ + pTC = &aTC[iTC]; + } + } + assert( pTC ); + + if( ii && pTC->nOvfl>=((nMinEst+(nLoad4/4)-1)/(nLoad4/4))*nDocSize ){ + /* The number of overflow pages to load for this (and therefore all + ** subsequent) tokens is greater than the estimated number of pages + ** that will be loaded if all subsequent tokens are deferred. + */ + Fts3PhraseToken *pToken = pTC->pToken; + rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol); + fts3SegReaderCursorFree(pToken->pSegcsr); + pToken->pSegcsr = 0; + }else{ + /* Set nLoad4 to the value of (4^nOther) for the next iteration of the + ** for-loop. Except, limit the value to 2^24 to prevent it from + ** overflowing the 32-bit integer it is stored in. */ + if( ii<12 ) nLoad4 = nLoad4*4; + + if( ii==0 || (pTC->pPhrase->nToken>1 && ii!=nToken-1) ){ + /* Either this is the cheapest token in the entire query, or it is + ** part of a multi-token phrase. Either way, the entire doclist will + ** (eventually) be loaded into memory. It may as well be now. */ + Fts3PhraseToken *pToken = pTC->pToken; + int nList = 0; + char *pList = 0; + rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList); + assert( rc==SQLITE_OK || pList==0 ); + if( rc==SQLITE_OK ){ + rc = fts3EvalPhraseMergeToken( + pTab, pTC->pPhrase, pTC->iToken,pList,nList + ); + } + if( rc==SQLITE_OK ){ + int nCount; + nCount = fts3DoclistCountDocids( + pTC->pPhrase->doclist.aAll, pTC->pPhrase->doclist.nAll + ); + if( ii==0 || nCountpToken = 0; + } + + return rc; +} + +/* +** This function is called from within the xFilter method. It initializes +** the full-text query currently stored in pCsr->pExpr. To iterate through +** the results of a query, the caller does: +** +** fts3EvalStart(pCsr); +** while( 1 ){ +** fts3EvalNext(pCsr); +** if( pCsr->bEof ) break; +** ... return row pCsr->iPrevId to the caller ... +** } +*/ +static int fts3EvalStart(Fts3Cursor *pCsr){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int nToken = 0; + int nOr = 0; + + /* Allocate a MultiSegReader for each token in the expression. */ + fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc); + + /* Determine which, if any, tokens in the expression should be deferred. */ +#ifndef SQLITE_DISABLE_FTS4_DEFERRED + if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){ + Fts3TokenAndCost *aTC; + Fts3Expr **apOr; + aTC = (Fts3TokenAndCost *)sqlite3_malloc( + sizeof(Fts3TokenAndCost) * nToken + + sizeof(Fts3Expr *) * nOr * 2 + ); + apOr = (Fts3Expr **)&aTC[nToken]; + + if( !aTC ){ + rc = SQLITE_NOMEM; + }else{ + int ii; + Fts3TokenAndCost *pTC = aTC; + Fts3Expr **ppOr = apOr; + + fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc); + nToken = (int)(pTC-aTC); + nOr = (int)(ppOr-apOr); + + if( rc==SQLITE_OK ){ + rc = fts3EvalSelectDeferred(pCsr, 0, aTC, nToken); + for(ii=0; rc==SQLITE_OK && iipExpr, &rc); + return rc; +} + +/* +** Invalidate the current position list for phrase pPhrase. +*/ +static void fts3EvalInvalidatePoslist(Fts3Phrase *pPhrase){ + if( pPhrase->doclist.bFreeList ){ + sqlite3_free(pPhrase->doclist.pList); + } + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + pPhrase->doclist.bFreeList = 0; +} + +/* +** This function is called to edit the position list associated with +** the phrase object passed as the fifth argument according to a NEAR +** condition. For example: +** +** abc NEAR/5 "def ghi" +** +** Parameter nNear is passed the NEAR distance of the expression (5 in +** the example above). When this function is called, *paPoslist points to +** the position list, and *pnToken is the number of phrase tokens in, the +** phrase on the other side of the NEAR operator to pPhrase. For example, +** if pPhrase refers to the "def ghi" phrase, then *paPoslist points to +** the position list associated with phrase "abc". +** +** All positions in the pPhrase position list that are not sufficiently +** close to a position in the *paPoslist position list are removed. If this +** leaves 0 positions, zero is returned. Otherwise, non-zero. +** +** Before returning, *paPoslist is set to point to the position lsit +** associated with pPhrase. And *pnToken is set to the number of tokens in +** pPhrase. +*/ +static int fts3EvalNearTrim( + int nNear, /* NEAR distance. As in "NEAR/nNear". */ + char *aTmp, /* Temporary space to use */ + char **paPoslist, /* IN/OUT: Position list */ + int *pnToken, /* IN/OUT: Tokens in phrase of *paPoslist */ + Fts3Phrase *pPhrase /* The phrase object to trim the doclist of */ +){ + int nParam1 = nNear + pPhrase->nToken; + int nParam2 = nNear + *pnToken; + int nNew; + char *p2; + char *pOut; + int res; + + assert( pPhrase->doclist.pList ); + + p2 = pOut = pPhrase->doclist.pList; + res = fts3PoslistNearMerge( + &pOut, aTmp, nParam1, nParam2, paPoslist, &p2 + ); + if( res ){ + nNew = (int)(pOut - pPhrase->doclist.pList) - 1; + assert( pPhrase->doclist.pList[nNew]=='\0' ); + assert( nNew<=pPhrase->doclist.nList && nNew>0 ); + memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew); + pPhrase->doclist.nList = nNew; + *paPoslist = pPhrase->doclist.pList; + *pnToken = pPhrase->nToken; + } + + return res; +} + +/* +** This function is a no-op if *pRc is other than SQLITE_OK when it is called. +** Otherwise, it advances the expression passed as the second argument to +** point to the next matching row in the database. Expressions iterate through +** matching rows in docid order. Ascending order if Fts3Cursor.bDesc is zero, +** or descending if it is non-zero. +** +** If an error occurs, *pRc is set to an SQLite error code. Otherwise, if +** successful, the following variables in pExpr are set: +** +** Fts3Expr.bEof (non-zero if EOF - there is no next row) +** Fts3Expr.iDocid (valid if bEof==0. The docid of the next row) +** +** If the expression is of type FTSQUERY_PHRASE, and the expression is not +** at EOF, then the following variables are populated with the position list +** for the phrase for the visited row: +** +** FTs3Expr.pPhrase->doclist.nList (length of pList in bytes) +** FTs3Expr.pPhrase->doclist.pList (pointer to position list) +** +** It says above that this function advances the expression to the next +** matching row. This is usually true, but there are the following exceptions: +** +** 1. Deferred tokens are not taken into account. If a phrase consists +** entirely of deferred tokens, it is assumed to match every row in +** the db. In this case the position-list is not populated at all. +** +** Or, if a phrase contains one or more deferred tokens and one or +** more non-deferred tokens, then the expression is advanced to the +** next possible match, considering only non-deferred tokens. In other +** words, if the phrase is "A B C", and "B" is deferred, the expression +** is advanced to the next row that contains an instance of "A * C", +** where "*" may match any single token. The position list in this case +** is populated as for "A * C" before returning. +** +** 2. NEAR is treated as AND. If the expression is "x NEAR y", it is +** advanced to point to the next row that matches "x AND y". +** +** See sqlite3Fts3EvalTestDeferred() for details on testing if a row is +** really a match, taking into account deferred tokens and NEAR operators. +*/ +static void fts3EvalNextRow( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pExpr, /* Expr. to advance to next matching row */ + int *pRc /* IN/OUT: Error code */ +){ + if( *pRc==SQLITE_OK ){ + int bDescDoclist = pCsr->bDesc; /* Used by DOCID_CMP() macro */ + assert( pExpr->bEof==0 ); + pExpr->bStart = 1; + + switch( pExpr->eType ){ + case FTSQUERY_NEAR: + case FTSQUERY_AND: { + Fts3Expr *pLeft = pExpr->pLeft; + Fts3Expr *pRight = pExpr->pRight; + assert( !pLeft->bDeferred || !pRight->bDeferred ); + + if( pLeft->bDeferred ){ + /* LHS is entirely deferred. So we assume it matches every row. + ** Advance the RHS iterator to find the next row visited. */ + fts3EvalNextRow(pCsr, pRight, pRc); + pExpr->iDocid = pRight->iDocid; + pExpr->bEof = pRight->bEof; + }else if( pRight->bDeferred ){ + /* RHS is entirely deferred. So we assume it matches every row. + ** Advance the LHS iterator to find the next row visited. */ + fts3EvalNextRow(pCsr, pLeft, pRc); + pExpr->iDocid = pLeft->iDocid; + pExpr->bEof = pLeft->bEof; + }else{ + /* Neither the RHS or LHS are deferred. */ + fts3EvalNextRow(pCsr, pLeft, pRc); + fts3EvalNextRow(pCsr, pRight, pRc); + while( !pLeft->bEof && !pRight->bEof && *pRc==SQLITE_OK ){ + sqlite3_int64 iDiff = DOCID_CMP(pLeft->iDocid, pRight->iDocid); + if( iDiff==0 ) break; + if( iDiff<0 ){ + fts3EvalNextRow(pCsr, pLeft, pRc); + }else{ + fts3EvalNextRow(pCsr, pRight, pRc); + } + } + pExpr->iDocid = pLeft->iDocid; + pExpr->bEof = (pLeft->bEof || pRight->bEof); + if( pExpr->eType==FTSQUERY_NEAR && pExpr->bEof ){ + if( pRight->pPhrase && pRight->pPhrase->doclist.aAll ){ + Fts3Doclist *pDl = &pRight->pPhrase->doclist; + while( *pRc==SQLITE_OK && pRight->bEof==0 ){ + memset(pDl->pList, 0, pDl->nList); + fts3EvalNextRow(pCsr, pRight, pRc); + } + } + if( pLeft->pPhrase && pLeft->pPhrase->doclist.aAll ){ + Fts3Doclist *pDl = &pLeft->pPhrase->doclist; + while( *pRc==SQLITE_OK && pLeft->bEof==0 ){ + memset(pDl->pList, 0, pDl->nList); + fts3EvalNextRow(pCsr, pLeft, pRc); + } + } + } + } + break; + } + + case FTSQUERY_OR: { + Fts3Expr *pLeft = pExpr->pLeft; + Fts3Expr *pRight = pExpr->pRight; + sqlite3_int64 iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid); + + assert( pLeft->bStart || pLeft->iDocid==pRight->iDocid ); + assert( pRight->bStart || pLeft->iDocid==pRight->iDocid ); + + if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){ + fts3EvalNextRow(pCsr, pLeft, pRc); + }else if( pLeft->bEof || (pRight->bEof==0 && iCmp>0) ){ + fts3EvalNextRow(pCsr, pRight, pRc); + }else{ + fts3EvalNextRow(pCsr, pLeft, pRc); + fts3EvalNextRow(pCsr, pRight, pRc); + } + + pExpr->bEof = (pLeft->bEof && pRight->bEof); + iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid); + if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){ + pExpr->iDocid = pLeft->iDocid; + }else{ + pExpr->iDocid = pRight->iDocid; + } + + break; + } + + case FTSQUERY_NOT: { + Fts3Expr *pLeft = pExpr->pLeft; + Fts3Expr *pRight = pExpr->pRight; + + if( pRight->bStart==0 ){ + fts3EvalNextRow(pCsr, pRight, pRc); + assert( *pRc!=SQLITE_OK || pRight->bStart ); + } + + fts3EvalNextRow(pCsr, pLeft, pRc); + if( pLeft->bEof==0 ){ + while( !*pRc + && !pRight->bEof + && DOCID_CMP(pLeft->iDocid, pRight->iDocid)>0 + ){ + fts3EvalNextRow(pCsr, pRight, pRc); + } + } + pExpr->iDocid = pLeft->iDocid; + pExpr->bEof = pLeft->bEof; + break; + } + + default: { + Fts3Phrase *pPhrase = pExpr->pPhrase; + fts3EvalInvalidatePoslist(pPhrase); + *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof); + pExpr->iDocid = pPhrase->doclist.iDocid; + break; + } + } + } +} + +/* +** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR +** cluster, then this function returns 1 immediately. +** +** Otherwise, it checks if the current row really does match the NEAR +** expression, using the data currently stored in the position lists +** (Fts3Expr->pPhrase.doclist.pList/nList) for each phrase in the expression. +** +** If the current row is a match, the position list associated with each +** phrase in the NEAR expression is edited in place to contain only those +** phrase instances sufficiently close to their peers to satisfy all NEAR +** constraints. In this case it returns 1. If the NEAR expression does not +** match the current row, 0 is returned. The position lists may or may not +** be edited if 0 is returned. +*/ +static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){ + int res = 1; + + /* The following block runs if pExpr is the root of a NEAR query. + ** For example, the query: + ** + ** "w" NEAR "x" NEAR "y" NEAR "z" + ** + ** which is represented in tree form as: + ** + ** | + ** +--NEAR--+ <-- root of NEAR query + ** | | + ** +--NEAR--+ "z" + ** | | + ** +--NEAR--+ "y" + ** | | + ** "w" "x" + ** + ** The right-hand child of a NEAR node is always a phrase. The + ** left-hand child may be either a phrase or a NEAR node. There are + ** no exceptions to this - it's the way the parser in fts3_expr.c works. + */ + if( *pRc==SQLITE_OK + && pExpr->eType==FTSQUERY_NEAR + && pExpr->bEof==0 + && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR) + ){ + Fts3Expr *p; + int nTmp = 0; /* Bytes of temp space */ + char *aTmp; /* Temp space for PoslistNearMerge() */ + + /* Allocate temporary working space. */ + for(p=pExpr; p->pLeft; p=p->pLeft){ + nTmp += p->pRight->pPhrase->doclist.nList; + } + nTmp += p->pPhrase->doclist.nList; + if( nTmp==0 ){ + res = 0; + }else{ + aTmp = sqlite3_malloc(nTmp*2); + if( !aTmp ){ + *pRc = SQLITE_NOMEM; + res = 0; + }else{ + char *aPoslist = p->pPhrase->doclist.pList; + int nToken = p->pPhrase->nToken; + + for(p=p->pParent;res && p && p->eType==FTSQUERY_NEAR; p=p->pParent){ + Fts3Phrase *pPhrase = p->pRight->pPhrase; + int nNear = p->nNear; + res = fts3EvalNearTrim(nNear, aTmp, &aPoslist, &nToken, pPhrase); + } + + aPoslist = pExpr->pRight->pPhrase->doclist.pList; + nToken = pExpr->pRight->pPhrase->nToken; + for(p=pExpr->pLeft; p && res; p=p->pLeft){ + int nNear; + Fts3Phrase *pPhrase; + assert( p->pParent && p->pParent->pLeft==p ); + nNear = p->pParent->nNear; + pPhrase = ( + p->eType==FTSQUERY_NEAR ? p->pRight->pPhrase : p->pPhrase + ); + res = fts3EvalNearTrim(nNear, aTmp, &aPoslist, &nToken, pPhrase); + } + } + + sqlite3_free(aTmp); + } + } + + return res; +} + +/* +** This function is a helper function for sqlite3Fts3EvalTestDeferred(). +** Assuming no error occurs or has occurred, It returns non-zero if the +** expression passed as the second argument matches the row that pCsr +** currently points to, or zero if it does not. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** If an error occurs during execution of this function, *pRc is set to +** the appropriate SQLite error code. In this case the returned value is +** undefined. +*/ +static int fts3EvalTestExpr( + Fts3Cursor *pCsr, /* FTS cursor handle */ + Fts3Expr *pExpr, /* Expr to test. May or may not be root. */ + int *pRc /* IN/OUT: Error code */ +){ + int bHit = 1; /* Return value */ + if( *pRc==SQLITE_OK ){ + switch( pExpr->eType ){ + case FTSQUERY_NEAR: + case FTSQUERY_AND: + bHit = ( + fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc) + && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc) + && fts3EvalNearTest(pExpr, pRc) + ); + + /* If the NEAR expression does not match any rows, zero the doclist for + ** all phrases involved in the NEAR. This is because the snippet(), + ** offsets() and matchinfo() functions are not supposed to recognize + ** any instances of phrases that are part of unmatched NEAR queries. + ** For example if this expression: + ** + ** ... MATCH 'a OR (b NEAR c)' + ** + ** is matched against a row containing: + ** + ** 'a b d e' + ** + ** then any snippet() should ony highlight the "a" term, not the "b" + ** (as "b" is part of a non-matching NEAR clause). + */ + if( bHit==0 + && pExpr->eType==FTSQUERY_NEAR + && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR) + ){ + Fts3Expr *p; + for(p=pExpr; p->pPhrase==0; p=p->pLeft){ + if( p->pRight->iDocid==pCsr->iPrevId ){ + fts3EvalInvalidatePoslist(p->pRight->pPhrase); + } + } + if( p->iDocid==pCsr->iPrevId ){ + fts3EvalInvalidatePoslist(p->pPhrase); + } + } + + break; + + case FTSQUERY_OR: { + int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc); + int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc); + bHit = bHit1 || bHit2; + break; + } + + case FTSQUERY_NOT: + bHit = ( + fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc) + && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc) + ); + break; + + default: { +#ifndef SQLITE_DISABLE_FTS4_DEFERRED + if( pCsr->pDeferred + && (pExpr->iDocid==pCsr->iPrevId || pExpr->bDeferred) + ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + assert( pExpr->bDeferred || pPhrase->doclist.bFreeList==0 ); + if( pExpr->bDeferred ){ + fts3EvalInvalidatePoslist(pPhrase); + } + *pRc = fts3EvalDeferredPhrase(pCsr, pPhrase); + bHit = (pPhrase->doclist.pList!=0); + pExpr->iDocid = pCsr->iPrevId; + }else +#endif + { + bHit = (pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId); + } + break; + } + } + } + return bHit; +} + +/* +** This function is called as the second part of each xNext operation when +** iterating through the results of a full-text query. At this point the +** cursor points to a row that matches the query expression, with the +** following caveats: +** +** * Up until this point, "NEAR" operators in the expression have been +** treated as "AND". +** +** * Deferred tokens have not yet been considered. +** +** If *pRc is not SQLITE_OK when this function is called, it immediately +** returns 0. Otherwise, it tests whether or not after considering NEAR +** operators and deferred tokens the current row is still a match for the +** expression. It returns 1 if both of the following are true: +** +** 1. *pRc is SQLITE_OK when this function returns, and +** +** 2. After scanning the current FTS table row for the deferred tokens, +** it is determined that the row does *not* match the query. +** +** Or, if no error occurs and it seems the current row does match the FTS +** query, return 0. +*/ +SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc){ + int rc = *pRc; + int bMiss = 0; + if( rc==SQLITE_OK ){ + + /* If there are one or more deferred tokens, load the current row into + ** memory and scan it to determine the position list for each deferred + ** token. Then, see if this row is really a match, considering deferred + ** tokens and NEAR operators (neither of which were taken into account + ** earlier, by fts3EvalNextRow()). + */ + if( pCsr->pDeferred ){ + rc = fts3CursorSeek(0, pCsr); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3CacheDeferredDoclists(pCsr); + } + } + bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc)); + + /* Free the position-lists accumulated for each deferred token above. */ + sqlite3Fts3FreeDeferredDoclists(pCsr); + *pRc = rc; + } + return (rc==SQLITE_OK && bMiss); +} + +/* +** Advance to the next document that matches the FTS expression in +** Fts3Cursor.pExpr. +*/ +static int fts3EvalNext(Fts3Cursor *pCsr){ + int rc = SQLITE_OK; /* Return Code */ + Fts3Expr *pExpr = pCsr->pExpr; + assert( pCsr->isEof==0 ); + if( pExpr==0 ){ + pCsr->isEof = 1; + }else{ + do { + if( pCsr->isRequireSeek==0 ){ + sqlite3_reset(pCsr->pStmt); + } + assert( sqlite3_data_count(pCsr->pStmt)==0 ); + fts3EvalNextRow(pCsr, pExpr, &rc); + pCsr->isEof = pExpr->bEof; + pCsr->isRequireSeek = 1; + pCsr->isMatchinfoNeeded = 1; + pCsr->iPrevId = pExpr->iDocid; + }while( pCsr->isEof==0 && sqlite3Fts3EvalTestDeferred(pCsr, &rc) ); + } + + /* Check if the cursor is past the end of the docid range specified + ** by Fts3Cursor.iMinDocid/iMaxDocid. If so, set the EOF flag. */ + if( rc==SQLITE_OK && ( + (pCsr->bDesc==0 && pCsr->iPrevId>pCsr->iMaxDocid) + || (pCsr->bDesc!=0 && pCsr->iPrevIdiMinDocid) + )){ + pCsr->isEof = 1; + } + + return rc; +} + +/* +** Restart interation for expression pExpr so that the next call to +** fts3EvalNext() visits the first row. Do not allow incremental +** loading or merging of phrase doclists for this iteration. +** +** If *pRc is other than SQLITE_OK when this function is called, it is +** a no-op. If an error occurs within this function, *pRc is set to an +** SQLite error code before returning. +*/ +static void fts3EvalRestart( + Fts3Cursor *pCsr, + Fts3Expr *pExpr, + int *pRc +){ + if( pExpr && *pRc==SQLITE_OK ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + + if( pPhrase ){ + fts3EvalInvalidatePoslist(pPhrase); + if( pPhrase->bIncr ){ + int i; + for(i=0; inToken; i++){ + Fts3PhraseToken *pToken = &pPhrase->aToken[i]; + assert( pToken->pDeferred==0 ); + if( pToken->pSegcsr ){ + sqlite3Fts3MsrIncrRestart(pToken->pSegcsr); + } + } + *pRc = fts3EvalPhraseStart(pCsr, 0, pPhrase); + } + pPhrase->doclist.pNextDocid = 0; + pPhrase->doclist.iDocid = 0; + pPhrase->pOrPoslist = 0; + } + + pExpr->iDocid = 0; + pExpr->bEof = 0; + pExpr->bStart = 0; + + fts3EvalRestart(pCsr, pExpr->pLeft, pRc); + fts3EvalRestart(pCsr, pExpr->pRight, pRc); + } +} + +/* +** After allocating the Fts3Expr.aMI[] array for each phrase in the +** expression rooted at pExpr, the cursor iterates through all rows matched +** by pExpr, calling this function for each row. This function increments +** the values in Fts3Expr.aMI[] according to the position-list currently +** found in Fts3Expr.pPhrase->doclist.pList for each of the phrase +** expression nodes. +*/ +static void fts3EvalUpdateCounts(Fts3Expr *pExpr){ + if( pExpr ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + if( pPhrase && pPhrase->doclist.pList ){ + int iCol = 0; + char *p = pPhrase->doclist.pList; + + assert( *p ); + while( 1 ){ + u8 c = 0; + int iCnt = 0; + while( 0xFE & (*p | c) ){ + if( (c&0x80)==0 ) iCnt++; + c = *p++ & 0x80; + } + + /* aMI[iCol*3 + 1] = Number of occurrences + ** aMI[iCol*3 + 2] = Number of rows containing at least one instance + */ + pExpr->aMI[iCol*3 + 1] += iCnt; + pExpr->aMI[iCol*3 + 2] += (iCnt>0); + if( *p==0x00 ) break; + p++; + p += fts3GetVarint32(p, &iCol); + } + } + + fts3EvalUpdateCounts(pExpr->pLeft); + fts3EvalUpdateCounts(pExpr->pRight); + } +} + +/* +** Expression pExpr must be of type FTSQUERY_PHRASE. +** +** If it is not already allocated and populated, this function allocates and +** populates the Fts3Expr.aMI[] array for expression pExpr. If pExpr is part +** of a NEAR expression, then it also allocates and populates the same array +** for all other phrases that are part of the NEAR expression. +** +** SQLITE_OK is returned if the aMI[] array is successfully allocated and +** populated. Otherwise, if an error occurs, an SQLite error code is returned. +*/ +static int fts3EvalGatherStats( + Fts3Cursor *pCsr, /* Cursor object */ + Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */ +){ + int rc = SQLITE_OK; /* Return code */ + + assert( pExpr->eType==FTSQUERY_PHRASE ); + if( pExpr->aMI==0 ){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + Fts3Expr *pRoot; /* Root of NEAR expression */ + Fts3Expr *p; /* Iterator used for several purposes */ + + sqlite3_int64 iPrevId = pCsr->iPrevId; + sqlite3_int64 iDocid; + u8 bEof; + + /* Find the root of the NEAR expression */ + pRoot = pExpr; + while( pRoot->pParent && pRoot->pParent->eType==FTSQUERY_NEAR ){ + pRoot = pRoot->pParent; + } + iDocid = pRoot->iDocid; + bEof = pRoot->bEof; + assert( pRoot->bStart ); + + /* Allocate space for the aMSI[] array of each FTSQUERY_PHRASE node */ + for(p=pRoot; p; p=p->pLeft){ + Fts3Expr *pE = (p->eType==FTSQUERY_PHRASE?p:p->pRight); + assert( pE->aMI==0 ); + pE->aMI = (u32 *)sqlite3_malloc(pTab->nColumn * 3 * sizeof(u32)); + if( !pE->aMI ) return SQLITE_NOMEM; + memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32)); + } + + fts3EvalRestart(pCsr, pRoot, &rc); + + while( pCsr->isEof==0 && rc==SQLITE_OK ){ + + do { + /* Ensure the %_content statement is reset. */ + if( pCsr->isRequireSeek==0 ) sqlite3_reset(pCsr->pStmt); + assert( sqlite3_data_count(pCsr->pStmt)==0 ); + + /* Advance to the next document */ + fts3EvalNextRow(pCsr, pRoot, &rc); + pCsr->isEof = pRoot->bEof; + pCsr->isRequireSeek = 1; + pCsr->isMatchinfoNeeded = 1; + pCsr->iPrevId = pRoot->iDocid; + }while( pCsr->isEof==0 + && pRoot->eType==FTSQUERY_NEAR + && sqlite3Fts3EvalTestDeferred(pCsr, &rc) + ); + + if( rc==SQLITE_OK && pCsr->isEof==0 ){ + fts3EvalUpdateCounts(pRoot); + } + } + + pCsr->isEof = 0; + pCsr->iPrevId = iPrevId; + + if( bEof ){ + pRoot->bEof = bEof; + }else{ + /* Caution: pRoot may iterate through docids in ascending or descending + ** order. For this reason, even though it seems more defensive, the + ** do loop can not be written: + ** + ** do {...} while( pRoot->iDocidbEof==0 ); + }while( pRoot->iDocid!=iDocid && rc==SQLITE_OK ); + } + } + return rc; +} + +/* +** This function is used by the matchinfo() module to query a phrase +** expression node for the following information: +** +** 1. The total number of occurrences of the phrase in each column of +** the FTS table (considering all rows), and +** +** 2. For each column, the number of rows in the table for which the +** column contains at least one instance of the phrase. +** +** If no error occurs, SQLITE_OK is returned and the values for each column +** written into the array aiOut as follows: +** +** aiOut[iCol*3 + 1] = Number of occurrences +** aiOut[iCol*3 + 2] = Number of rows containing at least one instance +** +** Caveats: +** +** * If a phrase consists entirely of deferred tokens, then all output +** values are set to the number of documents in the table. In other +** words we assume that very common tokens occur exactly once in each +** column of each row of the table. +** +** * If a phrase contains some deferred tokens (and some non-deferred +** tokens), count the potential occurrence identified by considering +** the non-deferred tokens instead of actual phrase occurrences. +** +** * If the phrase is part of a NEAR expression, then only phrase instances +** that meet the NEAR constraint are included in the counts. +*/ +SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats( + Fts3Cursor *pCsr, /* FTS cursor handle */ + Fts3Expr *pExpr, /* Phrase expression */ + u32 *aiOut /* Array to write results into (see above) */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int iCol; + + if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){ + assert( pCsr->nDoc>0 ); + for(iCol=0; iColnColumn; iCol++){ + aiOut[iCol*3 + 1] = (u32)pCsr->nDoc; + aiOut[iCol*3 + 2] = (u32)pCsr->nDoc; + } + }else{ + rc = fts3EvalGatherStats(pCsr, pExpr); + if( rc==SQLITE_OK ){ + assert( pExpr->aMI ); + for(iCol=0; iColnColumn; iCol++){ + aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1]; + aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2]; + } + } + } + + return rc; +} + +/* +** The expression pExpr passed as the second argument to this function +** must be of type FTSQUERY_PHRASE. +** +** The returned value is either NULL or a pointer to a buffer containing +** a position-list indicating the occurrences of the phrase in column iCol +** of the current row. +** +** More specifically, the returned buffer contains 1 varint for each +** occurrence of the phrase in the column, stored using the normal (delta+2) +** compression and is terminated by either an 0x01 or 0x00 byte. For example, +** if the requested column contains "a b X c d X X" and the position-list +** for 'X' is requested, the buffer returned may contain: +** +** 0x04 0x05 0x03 0x01 or 0x04 0x05 0x03 0x00 +** +** This function works regardless of whether or not the phrase is deferred, +** incremental, or neither. +*/ +SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist( + Fts3Cursor *pCsr, /* FTS3 cursor object */ + Fts3Expr *pExpr, /* Phrase to return doclist for */ + int iCol, /* Column to return position list for */ + char **ppOut /* OUT: Pointer to position list */ +){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + char *pIter; + int iThis; + sqlite3_int64 iDocid; + + /* If this phrase is applies specifically to some column other than + ** column iCol, return a NULL pointer. */ + *ppOut = 0; + assert( iCol>=0 && iColnColumn ); + if( (pPhrase->iColumnnColumn && pPhrase->iColumn!=iCol) ){ + return SQLITE_OK; + } + + iDocid = pExpr->iDocid; + pIter = pPhrase->doclist.pList; + if( iDocid!=pCsr->iPrevId || pExpr->bEof ){ + int rc = SQLITE_OK; + int bDescDoclist = pTab->bDescIdx; /* For DOCID_CMP macro */ + int bOr = 0; + u8 bTreeEof = 0; + Fts3Expr *p; /* Used to iterate from pExpr to root */ + Fts3Expr *pNear; /* Most senior NEAR ancestor (or pExpr) */ + int bMatch; + + /* Check if this phrase descends from an OR expression node. If not, + ** return NULL. Otherwise, the entry that corresponds to docid + ** pCsr->iPrevId may lie earlier in the doclist buffer. Or, if the + ** tree that the node is part of has been marked as EOF, but the node + ** itself is not EOF, then it may point to an earlier entry. */ + pNear = pExpr; + for(p=pExpr->pParent; p; p=p->pParent){ + if( p->eType==FTSQUERY_OR ) bOr = 1; + if( p->eType==FTSQUERY_NEAR ) pNear = p; + if( p->bEof ) bTreeEof = 1; + } + if( bOr==0 ) return SQLITE_OK; + + /* This is the descendent of an OR node. In this case we cannot use + ** an incremental phrase. Load the entire doclist for the phrase + ** into memory in this case. */ + if( pPhrase->bIncr ){ + int bEofSave = pNear->bEof; + fts3EvalRestart(pCsr, pNear, &rc); + while( rc==SQLITE_OK && !pNear->bEof ){ + fts3EvalNextRow(pCsr, pNear, &rc); + if( bEofSave==0 && pNear->iDocid==iDocid ) break; + } + assert( rc!=SQLITE_OK || pPhrase->bIncr==0 ); + } + if( bTreeEof ){ + while( rc==SQLITE_OK && !pNear->bEof ){ + fts3EvalNextRow(pCsr, pNear, &rc); + } + } + if( rc!=SQLITE_OK ) return rc; + + bMatch = 1; + for(p=pNear; p; p=p->pLeft){ + u8 bEof = 0; + Fts3Expr *pTest = p; + Fts3Phrase *pPh; + assert( pTest->eType==FTSQUERY_NEAR || pTest->eType==FTSQUERY_PHRASE ); + if( pTest->eType==FTSQUERY_NEAR ) pTest = pTest->pRight; + assert( pTest->eType==FTSQUERY_PHRASE ); + pPh = pTest->pPhrase; + + pIter = pPh->pOrPoslist; + iDocid = pPh->iOrDocid; + if( pCsr->bDesc==bDescDoclist ){ + bEof = !pPh->doclist.nAll || + (pIter >= (pPh->doclist.aAll + pPh->doclist.nAll)); + while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){ + sqlite3Fts3DoclistNext( + bDescDoclist, pPh->doclist.aAll, pPh->doclist.nAll, + &pIter, &iDocid, &bEof + ); + } + }else{ + bEof = !pPh->doclist.nAll || (pIter && pIter<=pPh->doclist.aAll); + while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){ + int dummy; + sqlite3Fts3DoclistPrev( + bDescDoclist, pPh->doclist.aAll, pPh->doclist.nAll, + &pIter, &iDocid, &dummy, &bEof + ); + } + } + pPh->pOrPoslist = pIter; + pPh->iOrDocid = iDocid; + if( bEof || iDocid!=pCsr->iPrevId ) bMatch = 0; + } + + if( bMatch ){ + pIter = pPhrase->pOrPoslist; + }else{ + pIter = 0; + } + } + if( pIter==0 ) return SQLITE_OK; + + if( *pIter==0x01 ){ + pIter++; + pIter += fts3GetVarint32(pIter, &iThis); + }else{ + iThis = 0; + } + while( iThisdoclist, and +** * any Fts3MultiSegReader objects held by phrase tokens. +*/ +SQLITE_PRIVATE void sqlite3Fts3EvalPhraseCleanup(Fts3Phrase *pPhrase){ + if( pPhrase ){ + int i; + sqlite3_free(pPhrase->doclist.aAll); + fts3EvalInvalidatePoslist(pPhrase); + memset(&pPhrase->doclist, 0, sizeof(Fts3Doclist)); + for(i=0; inToken; i++){ + fts3SegReaderCursorFree(pPhrase->aToken[i].pSegcsr); + pPhrase->aToken[i].pSegcsr = 0; + } + } +} + + +/* +** Return SQLITE_CORRUPT_VTAB. +*/ +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3Fts3Corrupt(){ + return SQLITE_CORRUPT_VTAB; +} +#endif + +#if !SQLITE_CORE +/* +** Initialize API pointer table, if required. +*/ +#ifdef _WIN32 +__declspec(dllexport) +#endif +SQLITE_API int SQLITE_STDCALL sqlite3_fts3_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + SQLITE_EXTENSION_INIT2(pApi) + return sqlite3Fts3Init(db); +} +#endif + +#endif + +/************** End of fts3.c ************************************************/ +/************** Begin file fts3_aux.c ****************************************/ +/* +** 2011 Jan 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +typedef struct Fts3auxTable Fts3auxTable; +typedef struct Fts3auxCursor Fts3auxCursor; + +struct Fts3auxTable { + sqlite3_vtab base; /* Base class used by SQLite core */ + Fts3Table *pFts3Tab; +}; + +struct Fts3auxCursor { + sqlite3_vtab_cursor base; /* Base class used by SQLite core */ + Fts3MultiSegReader csr; /* Must be right after "base" */ + Fts3SegFilter filter; + char *zStop; + int nStop; /* Byte-length of string zStop */ + int iLangid; /* Language id to query */ + int isEof; /* True if cursor is at EOF */ + sqlite3_int64 iRowid; /* Current rowid */ + + int iCol; /* Current value of 'col' column */ + int nStat; /* Size of aStat[] array */ + struct Fts3auxColstats { + sqlite3_int64 nDoc; /* 'documents' values for current csr row */ + sqlite3_int64 nOcc; /* 'occurrences' values for current csr row */ + } *aStat; +}; + +/* +** Schema of the terms table. +*/ +#define FTS3_AUX_SCHEMA \ + "CREATE TABLE x(term, col, documents, occurrences, languageid HIDDEN)" + +/* +** This function does all the work for both the xConnect and xCreate methods. +** These tables have no persistent representation of their own, so xConnect +** and xCreate are identical operations. +*/ +static int fts3auxConnectMethod( + sqlite3 *db, /* Database connection */ + void *pUnused, /* Unused */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */ + char **pzErr /* OUT: sqlite3_malloc'd error message */ +){ + char const *zDb; /* Name of database (e.g. "main") */ + char const *zFts3; /* Name of fts3 table */ + int nDb; /* Result of strlen(zDb) */ + int nFts3; /* Result of strlen(zFts3) */ + int nByte; /* Bytes of space to allocate here */ + int rc; /* value returned by declare_vtab() */ + Fts3auxTable *p; /* Virtual table object to return */ + + UNUSED_PARAMETER(pUnused); + + /* The user should invoke this in one of two forms: + ** + ** CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table); + ** CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table-db, fts4-table); + */ + if( argc!=4 && argc!=5 ) goto bad_args; + + zDb = argv[1]; + nDb = (int)strlen(zDb); + if( argc==5 ){ + if( nDb==4 && 0==sqlite3_strnicmp("temp", zDb, 4) ){ + zDb = argv[3]; + nDb = (int)strlen(zDb); + zFts3 = argv[4]; + }else{ + goto bad_args; + } + }else{ + zFts3 = argv[3]; + } + nFts3 = (int)strlen(zFts3); + + rc = sqlite3_declare_vtab(db, FTS3_AUX_SCHEMA); + if( rc!=SQLITE_OK ) return rc; + + nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2; + p = (Fts3auxTable *)sqlite3_malloc(nByte); + if( !p ) return SQLITE_NOMEM; + memset(p, 0, nByte); + + p->pFts3Tab = (Fts3Table *)&p[1]; + p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1]; + p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1]; + p->pFts3Tab->db = db; + p->pFts3Tab->nIndex = 1; + + memcpy((char *)p->pFts3Tab->zDb, zDb, nDb); + memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3); + sqlite3Fts3Dequote((char *)p->pFts3Tab->zName); + + *ppVtab = (sqlite3_vtab *)p; + return SQLITE_OK; + + bad_args: + sqlite3Fts3ErrMsg(pzErr, "invalid arguments to fts4aux constructor"); + return SQLITE_ERROR; +} + +/* +** This function does the work for both the xDisconnect and xDestroy methods. +** These tables have no persistent representation of their own, so xDisconnect +** and xDestroy are identical operations. +*/ +static int fts3auxDisconnectMethod(sqlite3_vtab *pVtab){ + Fts3auxTable *p = (Fts3auxTable *)pVtab; + Fts3Table *pFts3 = p->pFts3Tab; + int i; + + /* Free any prepared statements held */ + for(i=0; iaStmt); i++){ + sqlite3_finalize(pFts3->aStmt[i]); + } + sqlite3_free(pFts3->zSegmentsTbl); + sqlite3_free(p); + return SQLITE_OK; +} + +#define FTS4AUX_EQ_CONSTRAINT 1 +#define FTS4AUX_GE_CONSTRAINT 2 +#define FTS4AUX_LE_CONSTRAINT 4 + +/* +** xBestIndex - Analyze a WHERE and ORDER BY clause. +*/ +static int fts3auxBestIndexMethod( + sqlite3_vtab *pVTab, + sqlite3_index_info *pInfo +){ + int i; + int iEq = -1; + int iGe = -1; + int iLe = -1; + int iLangid = -1; + int iNext = 1; /* Next free argvIndex value */ + + UNUSED_PARAMETER(pVTab); + + /* This vtab delivers always results in "ORDER BY term ASC" order. */ + if( pInfo->nOrderBy==1 + && pInfo->aOrderBy[0].iColumn==0 + && pInfo->aOrderBy[0].desc==0 + ){ + pInfo->orderByConsumed = 1; + } + + /* Search for equality and range constraints on the "term" column. + ** And equality constraints on the hidden "languageid" column. */ + for(i=0; inConstraint; i++){ + if( pInfo->aConstraint[i].usable ){ + int op = pInfo->aConstraint[i].op; + int iCol = pInfo->aConstraint[i].iColumn; + + if( iCol==0 ){ + if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iEq = i; + if( op==SQLITE_INDEX_CONSTRAINT_LT ) iLe = i; + if( op==SQLITE_INDEX_CONSTRAINT_LE ) iLe = i; + if( op==SQLITE_INDEX_CONSTRAINT_GT ) iGe = i; + if( op==SQLITE_INDEX_CONSTRAINT_GE ) iGe = i; + } + if( iCol==4 ){ + if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iLangid = i; + } + } + } + + if( iEq>=0 ){ + pInfo->idxNum = FTS4AUX_EQ_CONSTRAINT; + pInfo->aConstraintUsage[iEq].argvIndex = iNext++; + pInfo->estimatedCost = 5; + }else{ + pInfo->idxNum = 0; + pInfo->estimatedCost = 20000; + if( iGe>=0 ){ + pInfo->idxNum += FTS4AUX_GE_CONSTRAINT; + pInfo->aConstraintUsage[iGe].argvIndex = iNext++; + pInfo->estimatedCost /= 2; + } + if( iLe>=0 ){ + pInfo->idxNum += FTS4AUX_LE_CONSTRAINT; + pInfo->aConstraintUsage[iLe].argvIndex = iNext++; + pInfo->estimatedCost /= 2; + } + } + if( iLangid>=0 ){ + pInfo->aConstraintUsage[iLangid].argvIndex = iNext++; + pInfo->estimatedCost--; + } + + return SQLITE_OK; +} + +/* +** xOpen - Open a cursor. +*/ +static int fts3auxOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){ + Fts3auxCursor *pCsr; /* Pointer to cursor object to return */ + + UNUSED_PARAMETER(pVTab); + + pCsr = (Fts3auxCursor *)sqlite3_malloc(sizeof(Fts3auxCursor)); + if( !pCsr ) return SQLITE_NOMEM; + memset(pCsr, 0, sizeof(Fts3auxCursor)); + + *ppCsr = (sqlite3_vtab_cursor *)pCsr; + return SQLITE_OK; +} + +/* +** xClose - Close a cursor. +*/ +static int fts3auxCloseMethod(sqlite3_vtab_cursor *pCursor){ + Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab; + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + + sqlite3Fts3SegmentsClose(pFts3); + sqlite3Fts3SegReaderFinish(&pCsr->csr); + sqlite3_free((void *)pCsr->filter.zTerm); + sqlite3_free(pCsr->zStop); + sqlite3_free(pCsr->aStat); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +static int fts3auxGrowStatArray(Fts3auxCursor *pCsr, int nSize){ + if( nSize>pCsr->nStat ){ + struct Fts3auxColstats *aNew; + aNew = (struct Fts3auxColstats *)sqlite3_realloc(pCsr->aStat, + sizeof(struct Fts3auxColstats) * nSize + ); + if( aNew==0 ) return SQLITE_NOMEM; + memset(&aNew[pCsr->nStat], 0, + sizeof(struct Fts3auxColstats) * (nSize - pCsr->nStat) + ); + pCsr->aStat = aNew; + pCsr->nStat = nSize; + } + return SQLITE_OK; +} + +/* +** xNext - Advance the cursor to the next row, if any. +*/ +static int fts3auxNextMethod(sqlite3_vtab_cursor *pCursor){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab; + int rc; + + /* Increment our pretend rowid value. */ + pCsr->iRowid++; + + for(pCsr->iCol++; pCsr->iColnStat; pCsr->iCol++){ + if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK; + } + + rc = sqlite3Fts3SegReaderStep(pFts3, &pCsr->csr); + if( rc==SQLITE_ROW ){ + int i = 0; + int nDoclist = pCsr->csr.nDoclist; + char *aDoclist = pCsr->csr.aDoclist; + int iCol; + + int eState = 0; + + if( pCsr->zStop ){ + int n = (pCsr->nStopcsr.nTerm) ? pCsr->nStop : pCsr->csr.nTerm; + int mc = memcmp(pCsr->zStop, pCsr->csr.zTerm, n); + if( mc<0 || (mc==0 && pCsr->csr.nTerm>pCsr->nStop) ){ + pCsr->isEof = 1; + return SQLITE_OK; + } + } + + if( fts3auxGrowStatArray(pCsr, 2) ) return SQLITE_NOMEM; + memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat); + iCol = 0; + + while( iaStat[0].nDoc++; + eState = 1; + iCol = 0; + break; + + /* State 1. In this state we are expecting either a 1, indicating + ** that the following integer will be a column number, or the + ** start of a position list for column 0. + ** + ** The only difference between state 1 and state 2 is that if the + ** integer encountered in state 1 is not 0 or 1, then we need to + ** increment the column 0 "nDoc" count for this term. + */ + case 1: + assert( iCol==0 ); + if( v>1 ){ + pCsr->aStat[1].nDoc++; + } + eState = 2; + /* fall through */ + + case 2: + if( v==0 ){ /* 0x00. Next integer will be a docid. */ + eState = 0; + }else if( v==1 ){ /* 0x01. Next integer will be a column number. */ + eState = 3; + }else{ /* 2 or greater. A position. */ + pCsr->aStat[iCol+1].nOcc++; + pCsr->aStat[0].nOcc++; + } + break; + + /* State 3. The integer just read is a column number. */ + default: assert( eState==3 ); + iCol = (int)v; + if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM; + pCsr->aStat[iCol+1].nDoc++; + eState = 2; + break; + } + } + + pCsr->iCol = 0; + rc = SQLITE_OK; + }else{ + pCsr->isEof = 1; + } + return rc; +} + +/* +** xFilter - Initialize a cursor to point at the start of its data. +*/ +static int fts3auxFilterMethod( + sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */ + int idxNum, /* Strategy index */ + const char *idxStr, /* Unused */ + int nVal, /* Number of elements in apVal */ + sqlite3_value **apVal /* Arguments for the indexing scheme */ +){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab; + int rc; + int isScan = 0; + int iLangVal = 0; /* Language id to query */ + + int iEq = -1; /* Index of term=? value in apVal */ + int iGe = -1; /* Index of term>=? value in apVal */ + int iLe = -1; /* Index of term<=? value in apVal */ + int iLangid = -1; /* Index of languageid=? value in apVal */ + int iNext = 0; + + UNUSED_PARAMETER(nVal); + UNUSED_PARAMETER(idxStr); + + assert( idxStr==0 ); + assert( idxNum==FTS4AUX_EQ_CONSTRAINT || idxNum==0 + || idxNum==FTS4AUX_LE_CONSTRAINT || idxNum==FTS4AUX_GE_CONSTRAINT + || idxNum==(FTS4AUX_LE_CONSTRAINT|FTS4AUX_GE_CONSTRAINT) + ); + + if( idxNum==FTS4AUX_EQ_CONSTRAINT ){ + iEq = iNext++; + }else{ + isScan = 1; + if( idxNum & FTS4AUX_GE_CONSTRAINT ){ + iGe = iNext++; + } + if( idxNum & FTS4AUX_LE_CONSTRAINT ){ + iLe = iNext++; + } + } + if( iNextfilter.zTerm); + sqlite3Fts3SegReaderFinish(&pCsr->csr); + sqlite3_free((void *)pCsr->filter.zTerm); + sqlite3_free(pCsr->aStat); + memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr); + + pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY; + if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN; + + if( iEq>=0 || iGe>=0 ){ + const unsigned char *zStr = sqlite3_value_text(apVal[0]); + assert( (iEq==0 && iGe==-1) || (iEq==-1 && iGe==0) ); + if( zStr ){ + pCsr->filter.zTerm = sqlite3_mprintf("%s", zStr); + pCsr->filter.nTerm = sqlite3_value_bytes(apVal[0]); + if( pCsr->filter.zTerm==0 ) return SQLITE_NOMEM; + } + } + + if( iLe>=0 ){ + pCsr->zStop = sqlite3_mprintf("%s", sqlite3_value_text(apVal[iLe])); + pCsr->nStop = sqlite3_value_bytes(apVal[iLe]); + if( pCsr->zStop==0 ) return SQLITE_NOMEM; + } + + if( iLangid>=0 ){ + iLangVal = sqlite3_value_int(apVal[iLangid]); + + /* If the user specified a negative value for the languageid, use zero + ** instead. This works, as the "languageid=?" constraint will also + ** be tested by the VDBE layer. The test will always be false (since + ** this module will not return a row with a negative languageid), and + ** so the overall query will return zero rows. */ + if( iLangVal<0 ) iLangVal = 0; + } + pCsr->iLangid = iLangVal; + + rc = sqlite3Fts3SegReaderCursor(pFts3, iLangVal, 0, FTS3_SEGCURSOR_ALL, + pCsr->filter.zTerm, pCsr->filter.nTerm, 0, isScan, &pCsr->csr + ); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3SegReaderStart(pFts3, &pCsr->csr, &pCsr->filter); + } + + if( rc==SQLITE_OK ) rc = fts3auxNextMethod(pCursor); + return rc; +} + +/* +** xEof - Return true if the cursor is at EOF, or false otherwise. +*/ +static int fts3auxEofMethod(sqlite3_vtab_cursor *pCursor){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + return pCsr->isEof; +} + +/* +** xColumn - Return a column value. +*/ +static int fts3auxColumnMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */ + int iCol /* Index of column to read value from */ +){ + Fts3auxCursor *p = (Fts3auxCursor *)pCursor; + + assert( p->isEof==0 ); + switch( iCol ){ + case 0: /* term */ + sqlite3_result_text(pCtx, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT); + break; + + case 1: /* col */ + if( p->iCol ){ + sqlite3_result_int(pCtx, p->iCol-1); + }else{ + sqlite3_result_text(pCtx, "*", -1, SQLITE_STATIC); + } + break; + + case 2: /* documents */ + sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc); + break; + + case 3: /* occurrences */ + sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc); + break; + + default: /* languageid */ + assert( iCol==4 ); + sqlite3_result_int(pCtx, p->iLangid); + break; + } + + return SQLITE_OK; +} + +/* +** xRowid - Return the current rowid for the cursor. +*/ +static int fts3auxRowidMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite_int64 *pRowid /* OUT: Rowid value */ +){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + *pRowid = pCsr->iRowid; + return SQLITE_OK; +} + +/* +** Register the fts3aux module with database connection db. Return SQLITE_OK +** if successful or an error code if sqlite3_create_module() fails. +*/ +SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db){ + static const sqlite3_module fts3aux_module = { + 0, /* iVersion */ + fts3auxConnectMethod, /* xCreate */ + fts3auxConnectMethod, /* xConnect */ + fts3auxBestIndexMethod, /* xBestIndex */ + fts3auxDisconnectMethod, /* xDisconnect */ + fts3auxDisconnectMethod, /* xDestroy */ + fts3auxOpenMethod, /* xOpen */ + fts3auxCloseMethod, /* xClose */ + fts3auxFilterMethod, /* xFilter */ + fts3auxNextMethod, /* xNext */ + fts3auxEofMethod, /* xEof */ + fts3auxColumnMethod, /* xColumn */ + fts3auxRowidMethod, /* xRowid */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindFunction */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0 /* xRollbackTo */ + }; + int rc; /* Return code */ + + rc = sqlite3_create_module(db, "fts4aux", &fts3aux_module, 0); + return rc; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_aux.c ********************************************/ +/************** Begin file fts3_expr.c ***************************************/ +/* +** 2008 Nov 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This module contains code that implements a parser for fts3 query strings +** (the right-hand argument to the MATCH operator). Because the supported +** syntax is relatively simple, the whole tokenizer/parser system is +** hand-coded. +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* +** By default, this module parses the legacy syntax that has been +** traditionally used by fts3. Or, if SQLITE_ENABLE_FTS3_PARENTHESIS +** is defined, then it uses the new syntax. The differences between +** the new and the old syntaxes are: +** +** a) The new syntax supports parenthesis. The old does not. +** +** b) The new syntax supports the AND and NOT operators. The old does not. +** +** c) The old syntax supports the "-" token qualifier. This is not +** supported by the new syntax (it is replaced by the NOT operator). +** +** d) When using the old syntax, the OR operator has a greater precedence +** than an implicit AND. When using the new, both implicity and explicit +** AND operators have a higher precedence than OR. +** +** If compiled with SQLITE_TEST defined, then this module exports the +** symbol "int sqlite3_fts3_enable_parentheses". Setting this variable +** to zero causes the module to use the old syntax. If it is set to +** non-zero the new syntax is activated. This is so both syntaxes can +** be tested using a single build of testfixture. +** +** The following describes the syntax supported by the fts3 MATCH +** operator in a similar format to that used by the lemon parser +** generator. This module does not use actually lemon, it uses a +** custom parser. +** +** query ::= andexpr (OR andexpr)*. +** +** andexpr ::= notexpr (AND? notexpr)*. +** +** notexpr ::= nearexpr (NOT nearexpr|-TOKEN)*. +** notexpr ::= LP query RP. +** +** nearexpr ::= phrase (NEAR distance_opt nearexpr)*. +** +** distance_opt ::= . +** distance_opt ::= / INTEGER. +** +** phrase ::= TOKEN. +** phrase ::= COLUMN:TOKEN. +** phrase ::= "TOKEN TOKEN TOKEN...". +*/ + +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_fts3_enable_parentheses = 0; +#else +# ifdef SQLITE_ENABLE_FTS3_PARENTHESIS +# define sqlite3_fts3_enable_parentheses 1 +# else +# define sqlite3_fts3_enable_parentheses 0 +# endif +#endif + +/* +** Default span for NEAR operators. +*/ +#define SQLITE_FTS3_DEFAULT_NEAR_PARAM 10 + +/* #include */ +/* #include */ + +/* +** isNot: +** This variable is used by function getNextNode(). When getNextNode() is +** called, it sets ParseContext.isNot to true if the 'next node' is a +** FTSQUERY_PHRASE with a unary "-" attached to it. i.e. "mysql" in the +** FTS3 query "sqlite -mysql". Otherwise, ParseContext.isNot is set to +** zero. +*/ +typedef struct ParseContext ParseContext; +struct ParseContext { + sqlite3_tokenizer *pTokenizer; /* Tokenizer module */ + int iLangid; /* Language id used with tokenizer */ + const char **azCol; /* Array of column names for fts3 table */ + int bFts4; /* True to allow FTS4-only syntax */ + int nCol; /* Number of entries in azCol[] */ + int iDefaultCol; /* Default column to query */ + int isNot; /* True if getNextNode() sees a unary - */ + sqlite3_context *pCtx; /* Write error message here */ + int nNest; /* Number of nested brackets */ +}; + +/* +** This function is equivalent to the standard isspace() function. +** +** The standard isspace() can be awkward to use safely, because although it +** is defined to accept an argument of type int, its behavior when passed +** an integer that falls outside of the range of the unsigned char type +** is undefined (and sometimes, "undefined" means segfault). This wrapper +** is defined to accept an argument of type char, and always returns 0 for +** any values that fall outside of the range of the unsigned char type (i.e. +** negative values). +*/ +static int fts3isspace(char c){ + return c==' ' || c=='\t' || c=='\n' || c=='\r' || c=='\v' || c=='\f'; +} + +/* +** Allocate nByte bytes of memory using sqlite3_malloc(). If successful, +** zero the memory before returning a pointer to it. If unsuccessful, +** return NULL. +*/ +static void *fts3MallocZero(int nByte){ + void *pRet = sqlite3_malloc(nByte); + if( pRet ) memset(pRet, 0, nByte); + return pRet; +} + +SQLITE_PRIVATE int sqlite3Fts3OpenTokenizer( + sqlite3_tokenizer *pTokenizer, + int iLangid, + const char *z, + int n, + sqlite3_tokenizer_cursor **ppCsr +){ + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + sqlite3_tokenizer_cursor *pCsr = 0; + int rc; + + rc = pModule->xOpen(pTokenizer, z, n, &pCsr); + assert( rc==SQLITE_OK || pCsr==0 ); + if( rc==SQLITE_OK ){ + pCsr->pTokenizer = pTokenizer; + if( pModule->iVersion>=1 ){ + rc = pModule->xLanguageid(pCsr, iLangid); + if( rc!=SQLITE_OK ){ + pModule->xClose(pCsr); + pCsr = 0; + } + } + } + *ppCsr = pCsr; + return rc; +} + +/* +** Function getNextNode(), which is called by fts3ExprParse(), may itself +** call fts3ExprParse(). So this forward declaration is required. +*/ +static int fts3ExprParse(ParseContext *, const char *, int, Fts3Expr **, int *); + +/* +** Extract the next token from buffer z (length n) using the tokenizer +** and other information (column names etc.) in pParse. Create an Fts3Expr +** structure of type FTSQUERY_PHRASE containing a phrase consisting of this +** single token and set *ppExpr to point to it. If the end of the buffer is +** reached before a token is found, set *ppExpr to zero. It is the +** responsibility of the caller to eventually deallocate the allocated +** Fts3Expr structure (if any) by passing it to sqlite3_free(). +** +** Return SQLITE_OK if successful, or SQLITE_NOMEM if a memory allocation +** fails. +*/ +static int getNextToken( + ParseContext *pParse, /* fts3 query parse context */ + int iCol, /* Value for Fts3Phrase.iColumn */ + const char *z, int n, /* Input string */ + Fts3Expr **ppExpr, /* OUT: expression */ + int *pnConsumed /* OUT: Number of bytes consumed */ +){ + sqlite3_tokenizer *pTokenizer = pParse->pTokenizer; + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + int rc; + sqlite3_tokenizer_cursor *pCursor; + Fts3Expr *pRet = 0; + int i = 0; + + /* Set variable i to the maximum number of bytes of input to tokenize. */ + for(i=0; iiLangid, z, i, &pCursor); + if( rc==SQLITE_OK ){ + const char *zToken; + int nToken = 0, iStart = 0, iEnd = 0, iPosition = 0; + int nByte; /* total space to allocate */ + + rc = pModule->xNext(pCursor, &zToken, &nToken, &iStart, &iEnd, &iPosition); + if( rc==SQLITE_OK ){ + nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken; + pRet = (Fts3Expr *)fts3MallocZero(nByte); + if( !pRet ){ + rc = SQLITE_NOMEM; + }else{ + pRet->eType = FTSQUERY_PHRASE; + pRet->pPhrase = (Fts3Phrase *)&pRet[1]; + pRet->pPhrase->nToken = 1; + pRet->pPhrase->iColumn = iCol; + pRet->pPhrase->aToken[0].n = nToken; + pRet->pPhrase->aToken[0].z = (char *)&pRet->pPhrase[1]; + memcpy(pRet->pPhrase->aToken[0].z, zToken, nToken); + + if( iEndpPhrase->aToken[0].isPrefix = 1; + iEnd++; + } + + while( 1 ){ + if( !sqlite3_fts3_enable_parentheses + && iStart>0 && z[iStart-1]=='-' + ){ + pParse->isNot = 1; + iStart--; + }else if( pParse->bFts4 && iStart>0 && z[iStart-1]=='^' ){ + pRet->pPhrase->aToken[0].bFirst = 1; + iStart--; + }else{ + break; + } + } + + } + *pnConsumed = iEnd; + }else if( i && rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + + pModule->xClose(pCursor); + } + + *ppExpr = pRet; + return rc; +} + + +/* +** Enlarge a memory allocation. If an out-of-memory allocation occurs, +** then free the old allocation. +*/ +static void *fts3ReallocOrFree(void *pOrig, int nNew){ + void *pRet = sqlite3_realloc(pOrig, nNew); + if( !pRet ){ + sqlite3_free(pOrig); + } + return pRet; +} + +/* +** Buffer zInput, length nInput, contains the contents of a quoted string +** that appeared as part of an fts3 query expression. Neither quote character +** is included in the buffer. This function attempts to tokenize the entire +** input buffer and create an Fts3Expr structure of type FTSQUERY_PHRASE +** containing the results. +** +** If successful, SQLITE_OK is returned and *ppExpr set to point at the +** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory +** error) or SQLITE_ERROR (tokenization error) is returned and *ppExpr set +** to 0. +*/ +static int getNextString( + ParseContext *pParse, /* fts3 query parse context */ + const char *zInput, int nInput, /* Input string */ + Fts3Expr **ppExpr /* OUT: expression */ +){ + sqlite3_tokenizer *pTokenizer = pParse->pTokenizer; + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + int rc; + Fts3Expr *p = 0; + sqlite3_tokenizer_cursor *pCursor = 0; + char *zTemp = 0; + int nTemp = 0; + + const int nSpace = sizeof(Fts3Expr) + sizeof(Fts3Phrase); + int nToken = 0; + + /* The final Fts3Expr data structure, including the Fts3Phrase, + ** Fts3PhraseToken structures token buffers are all stored as a single + ** allocation so that the expression can be freed with a single call to + ** sqlite3_free(). Setting this up requires a two pass approach. + ** + ** The first pass, in the block below, uses a tokenizer cursor to iterate + ** through the tokens in the expression. This pass uses fts3ReallocOrFree() + ** to assemble data in two dynamic buffers: + ** + ** Buffer p: Points to the Fts3Expr structure, followed by the Fts3Phrase + ** structure, followed by the array of Fts3PhraseToken + ** structures. This pass only populates the Fts3PhraseToken array. + ** + ** Buffer zTemp: Contains copies of all tokens. + ** + ** The second pass, in the block that begins "if( rc==SQLITE_DONE )" below, + ** appends buffer zTemp to buffer p, and fills in the Fts3Expr and Fts3Phrase + ** structures. + */ + rc = sqlite3Fts3OpenTokenizer( + pTokenizer, pParse->iLangid, zInput, nInput, &pCursor); + if( rc==SQLITE_OK ){ + int ii; + for(ii=0; rc==SQLITE_OK; ii++){ + const char *zByte; + int nByte = 0, iBegin = 0, iEnd = 0, iPos = 0; + rc = pModule->xNext(pCursor, &zByte, &nByte, &iBegin, &iEnd, &iPos); + if( rc==SQLITE_OK ){ + Fts3PhraseToken *pToken; + + p = fts3ReallocOrFree(p, nSpace + ii*sizeof(Fts3PhraseToken)); + if( !p ) goto no_mem; + + zTemp = fts3ReallocOrFree(zTemp, nTemp + nByte); + if( !zTemp ) goto no_mem; + + assert( nToken==ii ); + pToken = &((Fts3Phrase *)(&p[1]))->aToken[ii]; + memset(pToken, 0, sizeof(Fts3PhraseToken)); + + memcpy(&zTemp[nTemp], zByte, nByte); + nTemp += nByte; + + pToken->n = nByte; + pToken->isPrefix = (iEndbFirst = (iBegin>0 && zInput[iBegin-1]=='^'); + nToken = ii+1; + } + } + + pModule->xClose(pCursor); + pCursor = 0; + } + + if( rc==SQLITE_DONE ){ + int jj; + char *zBuf = 0; + + p = fts3ReallocOrFree(p, nSpace + nToken*sizeof(Fts3PhraseToken) + nTemp); + if( !p ) goto no_mem; + memset(p, 0, (char *)&(((Fts3Phrase *)&p[1])->aToken[0])-(char *)p); + p->eType = FTSQUERY_PHRASE; + p->pPhrase = (Fts3Phrase *)&p[1]; + p->pPhrase->iColumn = pParse->iDefaultCol; + p->pPhrase->nToken = nToken; + + zBuf = (char *)&p->pPhrase->aToken[nToken]; + if( zTemp ){ + memcpy(zBuf, zTemp, nTemp); + sqlite3_free(zTemp); + }else{ + assert( nTemp==0 ); + } + + for(jj=0; jjpPhrase->nToken; jj++){ + p->pPhrase->aToken[jj].z = zBuf; + zBuf += p->pPhrase->aToken[jj].n; + } + rc = SQLITE_OK; + } + + *ppExpr = p; + return rc; +no_mem: + + if( pCursor ){ + pModule->xClose(pCursor); + } + sqlite3_free(zTemp); + sqlite3_free(p); + *ppExpr = 0; + return SQLITE_NOMEM; +} + +/* +** The output variable *ppExpr is populated with an allocated Fts3Expr +** structure, or set to 0 if the end of the input buffer is reached. +** +** Returns an SQLite error code. SQLITE_OK if everything works, SQLITE_NOMEM +** if a malloc failure occurs, or SQLITE_ERROR if a parse error is encountered. +** If SQLITE_ERROR is returned, pContext is populated with an error message. +*/ +static int getNextNode( + ParseContext *pParse, /* fts3 query parse context */ + const char *z, int n, /* Input string */ + Fts3Expr **ppExpr, /* OUT: expression */ + int *pnConsumed /* OUT: Number of bytes consumed */ +){ + static const struct Fts3Keyword { + char *z; /* Keyword text */ + unsigned char n; /* Length of the keyword */ + unsigned char parenOnly; /* Only valid in paren mode */ + unsigned char eType; /* Keyword code */ + } aKeyword[] = { + { "OR" , 2, 0, FTSQUERY_OR }, + { "AND", 3, 1, FTSQUERY_AND }, + { "NOT", 3, 1, FTSQUERY_NOT }, + { "NEAR", 4, 0, FTSQUERY_NEAR } + }; + int ii; + int iCol; + int iColLen; + int rc; + Fts3Expr *pRet = 0; + + const char *zInput = z; + int nInput = n; + + pParse->isNot = 0; + + /* Skip over any whitespace before checking for a keyword, an open or + ** close bracket, or a quoted string. + */ + while( nInput>0 && fts3isspace(*zInput) ){ + nInput--; + zInput++; + } + if( nInput==0 ){ + return SQLITE_DONE; + } + + /* See if we are dealing with a keyword. */ + for(ii=0; ii<(int)(sizeof(aKeyword)/sizeof(struct Fts3Keyword)); ii++){ + const struct Fts3Keyword *pKey = &aKeyword[ii]; + + if( (pKey->parenOnly & ~sqlite3_fts3_enable_parentheses)!=0 ){ + continue; + } + + if( nInput>=pKey->n && 0==memcmp(zInput, pKey->z, pKey->n) ){ + int nNear = SQLITE_FTS3_DEFAULT_NEAR_PARAM; + int nKey = pKey->n; + char cNext; + + /* If this is a "NEAR" keyword, check for an explicit nearness. */ + if( pKey->eType==FTSQUERY_NEAR ){ + assert( nKey==4 ); + if( zInput[4]=='/' && zInput[5]>='0' && zInput[5]<='9' ){ + nNear = 0; + for(nKey=5; zInput[nKey]>='0' && zInput[nKey]<='9'; nKey++){ + nNear = nNear * 10 + (zInput[nKey] - '0'); + } + } + } + + /* At this point this is probably a keyword. But for that to be true, + ** the next byte must contain either whitespace, an open or close + ** parenthesis, a quote character, or EOF. + */ + cNext = zInput[nKey]; + if( fts3isspace(cNext) + || cNext=='"' || cNext=='(' || cNext==')' || cNext==0 + ){ + pRet = (Fts3Expr *)fts3MallocZero(sizeof(Fts3Expr)); + if( !pRet ){ + return SQLITE_NOMEM; + } + pRet->eType = pKey->eType; + pRet->nNear = nNear; + *ppExpr = pRet; + *pnConsumed = (int)((zInput - z) + nKey); + return SQLITE_OK; + } + + /* Turns out that wasn't a keyword after all. This happens if the + ** user has supplied a token such as "ORacle". Continue. + */ + } + } + + /* See if we are dealing with a quoted phrase. If this is the case, then + ** search for the closing quote and pass the whole string to getNextString() + ** for processing. This is easy to do, as fts3 has no syntax for escaping + ** a quote character embedded in a string. + */ + if( *zInput=='"' ){ + for(ii=1; iinNest++; + rc = fts3ExprParse(pParse, zInput+1, nInput-1, ppExpr, &nConsumed); + if( rc==SQLITE_OK && !*ppExpr ){ rc = SQLITE_DONE; } + *pnConsumed = (int)(zInput - z) + 1 + nConsumed; + return rc; + }else if( *zInput==')' ){ + pParse->nNest--; + *pnConsumed = (int)((zInput - z) + 1); + *ppExpr = 0; + return SQLITE_DONE; + } + } + + /* If control flows to this point, this must be a regular token, or + ** the end of the input. Read a regular token using the sqlite3_tokenizer + ** interface. Before doing so, figure out if there is an explicit + ** column specifier for the token. + ** + ** TODO: Strangely, it is not possible to associate a column specifier + ** with a quoted phrase, only with a single token. Not sure if this was + ** an implementation artifact or an intentional decision when fts3 was + ** first implemented. Whichever it was, this module duplicates the + ** limitation. + */ + iCol = pParse->iDefaultCol; + iColLen = 0; + for(ii=0; iinCol; ii++){ + const char *zStr = pParse->azCol[ii]; + int nStr = (int)strlen(zStr); + if( nInput>nStr && zInput[nStr]==':' + && sqlite3_strnicmp(zStr, zInput, nStr)==0 + ){ + iCol = ii; + iColLen = (int)((zInput - z) + nStr + 1); + break; + } + } + rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed); + *pnConsumed += iColLen; + return rc; +} + +/* +** The argument is an Fts3Expr structure for a binary operator (any type +** except an FTSQUERY_PHRASE). Return an integer value representing the +** precedence of the operator. Lower values have a higher precedence (i.e. +** group more tightly). For example, in the C language, the == operator +** groups more tightly than ||, and would therefore have a higher precedence. +** +** When using the new fts3 query syntax (when SQLITE_ENABLE_FTS3_PARENTHESIS +** is defined), the order of the operators in precedence from highest to +** lowest is: +** +** NEAR +** NOT +** AND (including implicit ANDs) +** OR +** +** Note that when using the old query syntax, the OR operator has a higher +** precedence than the AND operator. +*/ +static int opPrecedence(Fts3Expr *p){ + assert( p->eType!=FTSQUERY_PHRASE ); + if( sqlite3_fts3_enable_parentheses ){ + return p->eType; + }else if( p->eType==FTSQUERY_NEAR ){ + return 1; + }else if( p->eType==FTSQUERY_OR ){ + return 2; + } + assert( p->eType==FTSQUERY_AND ); + return 3; +} + +/* +** Argument ppHead contains a pointer to the current head of a query +** expression tree being parsed. pPrev is the expression node most recently +** inserted into the tree. This function adds pNew, which is always a binary +** operator node, into the expression tree based on the relative precedence +** of pNew and the existing nodes of the tree. This may result in the head +** of the tree changing, in which case *ppHead is set to the new root node. +*/ +static void insertBinaryOperator( + Fts3Expr **ppHead, /* Pointer to the root node of a tree */ + Fts3Expr *pPrev, /* Node most recently inserted into the tree */ + Fts3Expr *pNew /* New binary node to insert into expression tree */ +){ + Fts3Expr *pSplit = pPrev; + while( pSplit->pParent && opPrecedence(pSplit->pParent)<=opPrecedence(pNew) ){ + pSplit = pSplit->pParent; + } + + if( pSplit->pParent ){ + assert( pSplit->pParent->pRight==pSplit ); + pSplit->pParent->pRight = pNew; + pNew->pParent = pSplit->pParent; + }else{ + *ppHead = pNew; + } + pNew->pLeft = pSplit; + pSplit->pParent = pNew; +} + +/* +** Parse the fts3 query expression found in buffer z, length n. This function +** returns either when the end of the buffer is reached or an unmatched +** closing bracket - ')' - is encountered. +** +** If successful, SQLITE_OK is returned, *ppExpr is set to point to the +** parsed form of the expression and *pnConsumed is set to the number of +** bytes read from buffer z. Otherwise, *ppExpr is set to 0 and SQLITE_NOMEM +** (out of memory error) or SQLITE_ERROR (parse error) is returned. +*/ +static int fts3ExprParse( + ParseContext *pParse, /* fts3 query parse context */ + const char *z, int n, /* Text of MATCH query */ + Fts3Expr **ppExpr, /* OUT: Parsed query structure */ + int *pnConsumed /* OUT: Number of bytes consumed */ +){ + Fts3Expr *pRet = 0; + Fts3Expr *pPrev = 0; + Fts3Expr *pNotBranch = 0; /* Only used in legacy parse mode */ + int nIn = n; + const char *zIn = z; + int rc = SQLITE_OK; + int isRequirePhrase = 1; + + while( rc==SQLITE_OK ){ + Fts3Expr *p = 0; + int nByte = 0; + + rc = getNextNode(pParse, zIn, nIn, &p, &nByte); + assert( nByte>0 || (rc!=SQLITE_OK && p==0) ); + if( rc==SQLITE_OK ){ + if( p ){ + int isPhrase; + + if( !sqlite3_fts3_enable_parentheses + && p->eType==FTSQUERY_PHRASE && pParse->isNot + ){ + /* Create an implicit NOT operator. */ + Fts3Expr *pNot = fts3MallocZero(sizeof(Fts3Expr)); + if( !pNot ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_NOMEM; + goto exprparse_out; + } + pNot->eType = FTSQUERY_NOT; + pNot->pRight = p; + p->pParent = pNot; + if( pNotBranch ){ + pNot->pLeft = pNotBranch; + pNotBranch->pParent = pNot; + } + pNotBranch = pNot; + p = pPrev; + }else{ + int eType = p->eType; + isPhrase = (eType==FTSQUERY_PHRASE || p->pLeft); + + /* The isRequirePhrase variable is set to true if a phrase or + ** an expression contained in parenthesis is required. If a + ** binary operator (AND, OR, NOT or NEAR) is encounted when + ** isRequirePhrase is set, this is a syntax error. + */ + if( !isPhrase && isRequirePhrase ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_ERROR; + goto exprparse_out; + } + + if( isPhrase && !isRequirePhrase ){ + /* Insert an implicit AND operator. */ + Fts3Expr *pAnd; + assert( pRet && pPrev ); + pAnd = fts3MallocZero(sizeof(Fts3Expr)); + if( !pAnd ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_NOMEM; + goto exprparse_out; + } + pAnd->eType = FTSQUERY_AND; + insertBinaryOperator(&pRet, pPrev, pAnd); + pPrev = pAnd; + } + + /* This test catches attempts to make either operand of a NEAR + ** operator something other than a phrase. For example, either of + ** the following: + ** + ** (bracketed expression) NEAR phrase + ** phrase NEAR (bracketed expression) + ** + ** Return an error in either case. + */ + if( pPrev && ( + (eType==FTSQUERY_NEAR && !isPhrase && pPrev->eType!=FTSQUERY_PHRASE) + || (eType!=FTSQUERY_PHRASE && isPhrase && pPrev->eType==FTSQUERY_NEAR) + )){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_ERROR; + goto exprparse_out; + } + + if( isPhrase ){ + if( pRet ){ + assert( pPrev && pPrev->pLeft && pPrev->pRight==0 ); + pPrev->pRight = p; + p->pParent = pPrev; + }else{ + pRet = p; + } + }else{ + insertBinaryOperator(&pRet, pPrev, p); + } + isRequirePhrase = !isPhrase; + } + pPrev = p; + } + assert( nByte>0 ); + } + assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) ); + nIn -= nByte; + zIn += nByte; + } + + if( rc==SQLITE_DONE && pRet && isRequirePhrase ){ + rc = SQLITE_ERROR; + } + + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + if( !sqlite3_fts3_enable_parentheses && pNotBranch ){ + if( !pRet ){ + rc = SQLITE_ERROR; + }else{ + Fts3Expr *pIter = pNotBranch; + while( pIter->pLeft ){ + pIter = pIter->pLeft; + } + pIter->pLeft = pRet; + pRet->pParent = pIter; + pRet = pNotBranch; + } + } + } + *pnConsumed = n - nIn; + +exprparse_out: + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(pRet); + sqlite3Fts3ExprFree(pNotBranch); + pRet = 0; + } + *ppExpr = pRet; + return rc; +} + +/* +** Return SQLITE_ERROR if the maximum depth of the expression tree passed +** as the only argument is more than nMaxDepth. +*/ +static int fts3ExprCheckDepth(Fts3Expr *p, int nMaxDepth){ + int rc = SQLITE_OK; + if( p ){ + if( nMaxDepth<0 ){ + rc = SQLITE_TOOBIG; + }else{ + rc = fts3ExprCheckDepth(p->pLeft, nMaxDepth-1); + if( rc==SQLITE_OK ){ + rc = fts3ExprCheckDepth(p->pRight, nMaxDepth-1); + } + } + } + return rc; +} + +/* +** This function attempts to transform the expression tree at (*pp) to +** an equivalent but more balanced form. The tree is modified in place. +** If successful, SQLITE_OK is returned and (*pp) set to point to the +** new root expression node. +** +** nMaxDepth is the maximum allowable depth of the balanced sub-tree. +** +** Otherwise, if an error occurs, an SQLite error code is returned and +** expression (*pp) freed. +*/ +static int fts3ExprBalance(Fts3Expr **pp, int nMaxDepth){ + int rc = SQLITE_OK; /* Return code */ + Fts3Expr *pRoot = *pp; /* Initial root node */ + Fts3Expr *pFree = 0; /* List of free nodes. Linked by pParent. */ + int eType = pRoot->eType; /* Type of node in this tree */ + + if( nMaxDepth==0 ){ + rc = SQLITE_ERROR; + } + + if( rc==SQLITE_OK ){ + if( (eType==FTSQUERY_AND || eType==FTSQUERY_OR) ){ + Fts3Expr **apLeaf; + apLeaf = (Fts3Expr **)sqlite3_malloc(sizeof(Fts3Expr *) * nMaxDepth); + if( 0==apLeaf ){ + rc = SQLITE_NOMEM; + }else{ + memset(apLeaf, 0, sizeof(Fts3Expr *) * nMaxDepth); + } + + if( rc==SQLITE_OK ){ + int i; + Fts3Expr *p; + + /* Set $p to point to the left-most leaf in the tree of eType nodes. */ + for(p=pRoot; p->eType==eType; p=p->pLeft){ + assert( p->pParent==0 || p->pParent->pLeft==p ); + assert( p->pLeft && p->pRight ); + } + + /* This loop runs once for each leaf in the tree of eType nodes. */ + while( 1 ){ + int iLvl; + Fts3Expr *pParent = p->pParent; /* Current parent of p */ + + assert( pParent==0 || pParent->pLeft==p ); + p->pParent = 0; + if( pParent ){ + pParent->pLeft = 0; + }else{ + pRoot = 0; + } + rc = fts3ExprBalance(&p, nMaxDepth-1); + if( rc!=SQLITE_OK ) break; + + for(iLvl=0; p && iLvlpLeft = apLeaf[iLvl]; + pFree->pRight = p; + pFree->pLeft->pParent = pFree; + pFree->pRight->pParent = pFree; + + p = pFree; + pFree = pFree->pParent; + p->pParent = 0; + apLeaf[iLvl] = 0; + } + } + if( p ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_TOOBIG; + break; + } + + /* If that was the last leaf node, break out of the loop */ + if( pParent==0 ) break; + + /* Set $p to point to the next leaf in the tree of eType nodes */ + for(p=pParent->pRight; p->eType==eType; p=p->pLeft); + + /* Remove pParent from the original tree. */ + assert( pParent->pParent==0 || pParent->pParent->pLeft==pParent ); + pParent->pRight->pParent = pParent->pParent; + if( pParent->pParent ){ + pParent->pParent->pLeft = pParent->pRight; + }else{ + assert( pParent==pRoot ); + pRoot = pParent->pRight; + } + + /* Link pParent into the free node list. It will be used as an + ** internal node of the new tree. */ + pParent->pParent = pFree; + pFree = pParent; + } + + if( rc==SQLITE_OK ){ + p = 0; + for(i=0; ipParent = 0; + }else{ + assert( pFree!=0 ); + pFree->pRight = p; + pFree->pLeft = apLeaf[i]; + pFree->pLeft->pParent = pFree; + pFree->pRight->pParent = pFree; + + p = pFree; + pFree = pFree->pParent; + p->pParent = 0; + } + } + } + pRoot = p; + }else{ + /* An error occurred. Delete the contents of the apLeaf[] array + ** and pFree list. Everything else is cleaned up by the call to + ** sqlite3Fts3ExprFree(pRoot) below. */ + Fts3Expr *pDel; + for(i=0; ipParent; + sqlite3_free(pDel); + } + } + + assert( pFree==0 ); + sqlite3_free( apLeaf ); + } + }else if( eType==FTSQUERY_NOT ){ + Fts3Expr *pLeft = pRoot->pLeft; + Fts3Expr *pRight = pRoot->pRight; + + pRoot->pLeft = 0; + pRoot->pRight = 0; + pLeft->pParent = 0; + pRight->pParent = 0; + + rc = fts3ExprBalance(&pLeft, nMaxDepth-1); + if( rc==SQLITE_OK ){ + rc = fts3ExprBalance(&pRight, nMaxDepth-1); + } + + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(pRight); + sqlite3Fts3ExprFree(pLeft); + }else{ + assert( pLeft && pRight ); + pRoot->pLeft = pLeft; + pLeft->pParent = pRoot; + pRoot->pRight = pRight; + pRight->pParent = pRoot; + } + } + } + + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(pRoot); + pRoot = 0; + } + *pp = pRoot; + return rc; +} + +/* +** This function is similar to sqlite3Fts3ExprParse(), with the following +** differences: +** +** 1. It does not do expression rebalancing. +** 2. It does not check that the expression does not exceed the +** maximum allowable depth. +** 3. Even if it fails, *ppExpr may still be set to point to an +** expression tree. It should be deleted using sqlite3Fts3ExprFree() +** in this case. +*/ +static int fts3ExprParseUnbalanced( + sqlite3_tokenizer *pTokenizer, /* Tokenizer module */ + int iLangid, /* Language id for tokenizer */ + char **azCol, /* Array of column names for fts3 table */ + int bFts4, /* True to allow FTS4-only syntax */ + int nCol, /* Number of entries in azCol[] */ + int iDefaultCol, /* Default column to query */ + const char *z, int n, /* Text of MATCH query */ + Fts3Expr **ppExpr /* OUT: Parsed query structure */ +){ + int nParsed; + int rc; + ParseContext sParse; + + memset(&sParse, 0, sizeof(ParseContext)); + sParse.pTokenizer = pTokenizer; + sParse.iLangid = iLangid; + sParse.azCol = (const char **)azCol; + sParse.nCol = nCol; + sParse.iDefaultCol = iDefaultCol; + sParse.bFts4 = bFts4; + if( z==0 ){ + *ppExpr = 0; + return SQLITE_OK; + } + if( n<0 ){ + n = (int)strlen(z); + } + rc = fts3ExprParse(&sParse, z, n, ppExpr, &nParsed); + assert( rc==SQLITE_OK || *ppExpr==0 ); + + /* Check for mismatched parenthesis */ + if( rc==SQLITE_OK && sParse.nNest ){ + rc = SQLITE_ERROR; + } + + return rc; +} + +/* +** Parameters z and n contain a pointer to and length of a buffer containing +** an fts3 query expression, respectively. This function attempts to parse the +** query expression and create a tree of Fts3Expr structures representing the +** parsed expression. If successful, *ppExpr is set to point to the head +** of the parsed expression tree and SQLITE_OK is returned. If an error +** occurs, either SQLITE_NOMEM (out-of-memory error) or SQLITE_ERROR (parse +** error) is returned and *ppExpr is set to 0. +** +** If parameter n is a negative number, then z is assumed to point to a +** nul-terminated string and the length is determined using strlen(). +** +** The first parameter, pTokenizer, is passed the fts3 tokenizer module to +** use to normalize query tokens while parsing the expression. The azCol[] +** array, which is assumed to contain nCol entries, should contain the names +** of each column in the target fts3 table, in order from left to right. +** Column names must be nul-terminated strings. +** +** The iDefaultCol parameter should be passed the index of the table column +** that appears on the left-hand-side of the MATCH operator (the default +** column to match against for tokens for which a column name is not explicitly +** specified as part of the query string), or -1 if tokens may by default +** match any table column. +*/ +SQLITE_PRIVATE int sqlite3Fts3ExprParse( + sqlite3_tokenizer *pTokenizer, /* Tokenizer module */ + int iLangid, /* Language id for tokenizer */ + char **azCol, /* Array of column names for fts3 table */ + int bFts4, /* True to allow FTS4-only syntax */ + int nCol, /* Number of entries in azCol[] */ + int iDefaultCol, /* Default column to query */ + const char *z, int n, /* Text of MATCH query */ + Fts3Expr **ppExpr, /* OUT: Parsed query structure */ + char **pzErr /* OUT: Error message (sqlite3_malloc) */ +){ + int rc = fts3ExprParseUnbalanced( + pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr + ); + + /* Rebalance the expression. And check that its depth does not exceed + ** SQLITE_FTS3_MAX_EXPR_DEPTH. */ + if( rc==SQLITE_OK && *ppExpr ){ + rc = fts3ExprBalance(ppExpr, SQLITE_FTS3_MAX_EXPR_DEPTH); + if( rc==SQLITE_OK ){ + rc = fts3ExprCheckDepth(*ppExpr, SQLITE_FTS3_MAX_EXPR_DEPTH); + } + } + + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(*ppExpr); + *ppExpr = 0; + if( rc==SQLITE_TOOBIG ){ + sqlite3Fts3ErrMsg(pzErr, + "FTS expression tree is too large (maximum depth %d)", + SQLITE_FTS3_MAX_EXPR_DEPTH + ); + rc = SQLITE_ERROR; + }else if( rc==SQLITE_ERROR ){ + sqlite3Fts3ErrMsg(pzErr, "malformed MATCH expression: [%s]", z); + } + } + + return rc; +} + +/* +** Free a single node of an expression tree. +*/ +static void fts3FreeExprNode(Fts3Expr *p){ + assert( p->eType==FTSQUERY_PHRASE || p->pPhrase==0 ); + sqlite3Fts3EvalPhraseCleanup(p->pPhrase); + sqlite3_free(p->aMI); + sqlite3_free(p); +} + +/* +** Free a parsed fts3 query expression allocated by sqlite3Fts3ExprParse(). +** +** This function would be simpler if it recursively called itself. But +** that would mean passing a sufficiently large expression to ExprParse() +** could cause a stack overflow. +*/ +SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *pDel){ + Fts3Expr *p; + assert( pDel==0 || pDel->pParent==0 ); + for(p=pDel; p && (p->pLeft||p->pRight); p=(p->pLeft ? p->pLeft : p->pRight)){ + assert( p->pParent==0 || p==p->pParent->pRight || p==p->pParent->pLeft ); + } + while( p ){ + Fts3Expr *pParent = p->pParent; + fts3FreeExprNode(p); + if( pParent && p==pParent->pLeft && pParent->pRight ){ + p = pParent->pRight; + while( p && (p->pLeft || p->pRight) ){ + assert( p==p->pParent->pRight || p==p->pParent->pLeft ); + p = (p->pLeft ? p->pLeft : p->pRight); + } + }else{ + p = pParent; + } + } +} + +/**************************************************************************** +***************************************************************************** +** Everything after this point is just test code. +*/ + +#ifdef SQLITE_TEST + +/* #include */ + +/* +** Function to query the hash-table of tokenizers (see README.tokenizers). +*/ +static int queryTestTokenizer( + sqlite3 *db, + const char *zName, + const sqlite3_tokenizer_module **pp +){ + int rc; + sqlite3_stmt *pStmt; + const char zSql[] = "SELECT fts3_tokenizer(?)"; + + *pp = 0; + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC); + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB ){ + memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp)); + } + } + + return sqlite3_finalize(pStmt); +} + +/* +** Return a pointer to a buffer containing a text representation of the +** expression passed as the first argument. The buffer is obtained from +** sqlite3_malloc(). It is the responsibility of the caller to use +** sqlite3_free() to release the memory. If an OOM condition is encountered, +** NULL is returned. +** +** If the second argument is not NULL, then its contents are prepended to +** the returned expression text and then freed using sqlite3_free(). +*/ +static char *exprToString(Fts3Expr *pExpr, char *zBuf){ + if( pExpr==0 ){ + return sqlite3_mprintf(""); + } + switch( pExpr->eType ){ + case FTSQUERY_PHRASE: { + Fts3Phrase *pPhrase = pExpr->pPhrase; + int i; + zBuf = sqlite3_mprintf( + "%zPHRASE %d 0", zBuf, pPhrase->iColumn); + for(i=0; zBuf && inToken; i++){ + zBuf = sqlite3_mprintf("%z %.*s%s", zBuf, + pPhrase->aToken[i].n, pPhrase->aToken[i].z, + (pPhrase->aToken[i].isPrefix?"+":"") + ); + } + return zBuf; + } + + case FTSQUERY_NEAR: + zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear); + break; + case FTSQUERY_NOT: + zBuf = sqlite3_mprintf("%zNOT ", zBuf); + break; + case FTSQUERY_AND: + zBuf = sqlite3_mprintf("%zAND ", zBuf); + break; + case FTSQUERY_OR: + zBuf = sqlite3_mprintf("%zOR ", zBuf); + break; + } + + if( zBuf ) zBuf = sqlite3_mprintf("%z{", zBuf); + if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf); + if( zBuf ) zBuf = sqlite3_mprintf("%z} {", zBuf); + + if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf); + if( zBuf ) zBuf = sqlite3_mprintf("%z}", zBuf); + + return zBuf; +} + +/* +** This is the implementation of a scalar SQL function used to test the +** expression parser. It should be called as follows: +** +** fts3_exprtest(, , , ...); +** +** The first argument, , is the name of the fts3 tokenizer used +** to parse the query expression (see README.tokenizers). The second argument +** is the query expression to parse. Each subsequent argument is the name +** of a column of the fts3 table that the query expression may refer to. +** For example: +** +** SELECT fts3_exprtest('simple', 'Bill col2:Bloggs', 'col1', 'col2'); +*/ +static void fts3ExprTest( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + sqlite3_tokenizer_module const *pModule = 0; + sqlite3_tokenizer *pTokenizer = 0; + int rc; + char **azCol = 0; + const char *zExpr; + int nExpr; + int nCol; + int ii; + Fts3Expr *pExpr; + char *zBuf = 0; + sqlite3 *db = sqlite3_context_db_handle(context); + + if( argc<3 ){ + sqlite3_result_error(context, + "Usage: fts3_exprtest(tokenizer, expr, col1, ...", -1 + ); + return; + } + + rc = queryTestTokenizer(db, + (const char *)sqlite3_value_text(argv[0]), &pModule); + if( rc==SQLITE_NOMEM ){ + sqlite3_result_error_nomem(context); + goto exprtest_out; + }else if( !pModule ){ + sqlite3_result_error(context, "No such tokenizer module", -1); + goto exprtest_out; + } + + rc = pModule->xCreate(0, 0, &pTokenizer); + assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); + if( rc==SQLITE_NOMEM ){ + sqlite3_result_error_nomem(context); + goto exprtest_out; + } + pTokenizer->pModule = pModule; + + zExpr = (const char *)sqlite3_value_text(argv[1]); + nExpr = sqlite3_value_bytes(argv[1]); + nCol = argc-2; + azCol = (char **)sqlite3_malloc(nCol*sizeof(char *)); + if( !azCol ){ + sqlite3_result_error_nomem(context); + goto exprtest_out; + } + for(ii=0; iixDestroy(pTokenizer); + } + sqlite3_free(azCol); +} + +/* +** Register the query expression parser test function fts3_exprtest() +** with database connection db. +*/ +SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3* db){ + int rc = sqlite3_create_function( + db, "fts3_exprtest", -1, SQLITE_UTF8, 0, fts3ExprTest, 0, 0 + ); + if( rc==SQLITE_OK ){ + rc = sqlite3_create_function(db, "fts3_exprtest_rebalance", + -1, SQLITE_UTF8, (void *)1, fts3ExprTest, 0, 0 + ); + } + return rc; +} + +#endif +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_expr.c *******************************************/ +/************** Begin file fts3_hash.c ***************************************/ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the implementation of generic hash-tables used in SQLite. +** We've modified it slightly to serve as a standalone hash table +** implementation for the full-text indexing module. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_hash.h" */ + +/* +** Malloc and Free functions +*/ +static void *fts3HashMalloc(int n){ + void *p = sqlite3_malloc(n); + if( p ){ + memset(p, 0, n); + } + return p; +} +static void fts3HashFree(void *p){ + sqlite3_free(p); +} + +/* Turn bulk memory into a hash table object by initializing the +** fields of the Hash structure. +** +** "pNew" is a pointer to the hash table that is to be initialized. +** keyClass is one of the constants +** FTS3_HASH_BINARY or FTS3_HASH_STRING. The value of keyClass +** determines what kind of key the hash table will use. "copyKey" is +** true if the hash table should make its own private copy of keys and +** false if it should just use the supplied pointer. +*/ +SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){ + assert( pNew!=0 ); + assert( keyClass>=FTS3_HASH_STRING && keyClass<=FTS3_HASH_BINARY ); + pNew->keyClass = keyClass; + pNew->copyKey = copyKey; + pNew->first = 0; + pNew->count = 0; + pNew->htsize = 0; + pNew->ht = 0; +} + +/* Remove all entries from a hash table. Reclaim all memory. +** Call this routine to delete a hash table or to reset a hash table +** to the empty state. +*/ +SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash *pH){ + Fts3HashElem *elem; /* For looping over all elements of the table */ + + assert( pH!=0 ); + elem = pH->first; + pH->first = 0; + fts3HashFree(pH->ht); + pH->ht = 0; + pH->htsize = 0; + while( elem ){ + Fts3HashElem *next_elem = elem->next; + if( pH->copyKey && elem->pKey ){ + fts3HashFree(elem->pKey); + } + fts3HashFree(elem); + elem = next_elem; + } + pH->count = 0; +} + +/* +** Hash and comparison functions when the mode is FTS3_HASH_STRING +*/ +static int fts3StrHash(const void *pKey, int nKey){ + const char *z = (const char *)pKey; + unsigned h = 0; + if( nKey<=0 ) nKey = (int) strlen(z); + while( nKey > 0 ){ + h = (h<<3) ^ h ^ *z++; + nKey--; + } + return (int)(h & 0x7fffffff); +} +static int fts3StrCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( n1!=n2 ) return 1; + return strncmp((const char*)pKey1,(const char*)pKey2,n1); +} + +/* +** Hash and comparison functions when the mode is FTS3_HASH_BINARY +*/ +static int fts3BinHash(const void *pKey, int nKey){ + int h = 0; + const char *z = (const char *)pKey; + while( nKey-- > 0 ){ + h = (h<<3) ^ h ^ *(z++); + } + return h & 0x7fffffff; +} +static int fts3BinCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( n1!=n2 ) return 1; + return memcmp(pKey1,pKey2,n1); +} + +/* +** Return a pointer to the appropriate hash function given the key class. +** +** The C syntax in this function definition may be unfamilar to some +** programmers, so we provide the following additional explanation: +** +** The name of the function is "ftsHashFunction". The function takes a +** single parameter "keyClass". The return value of ftsHashFunction() +** is a pointer to another function. Specifically, the return value +** of ftsHashFunction() is a pointer to a function that takes two parameters +** with types "const void*" and "int" and returns an "int". +*/ +static int (*ftsHashFunction(int keyClass))(const void*,int){ + if( keyClass==FTS3_HASH_STRING ){ + return &fts3StrHash; + }else{ + assert( keyClass==FTS3_HASH_BINARY ); + return &fts3BinHash; + } +} + +/* +** Return a pointer to the appropriate hash function given the key class. +** +** For help in interpreted the obscure C code in the function definition, +** see the header comment on the previous function. +*/ +static int (*ftsCompareFunction(int keyClass))(const void*,int,const void*,int){ + if( keyClass==FTS3_HASH_STRING ){ + return &fts3StrCompare; + }else{ + assert( keyClass==FTS3_HASH_BINARY ); + return &fts3BinCompare; + } +} + +/* Link an element into the hash table +*/ +static void fts3HashInsertElement( + Fts3Hash *pH, /* The complete hash table */ + struct _fts3ht *pEntry, /* The entry into which pNew is inserted */ + Fts3HashElem *pNew /* The element to be inserted */ +){ + Fts3HashElem *pHead; /* First element already in pEntry */ + pHead = pEntry->chain; + if( pHead ){ + pNew->next = pHead; + pNew->prev = pHead->prev; + if( pHead->prev ){ pHead->prev->next = pNew; } + else { pH->first = pNew; } + pHead->prev = pNew; + }else{ + pNew->next = pH->first; + if( pH->first ){ pH->first->prev = pNew; } + pNew->prev = 0; + pH->first = pNew; + } + pEntry->count++; + pEntry->chain = pNew; +} + + +/* Resize the hash table so that it cantains "new_size" buckets. +** "new_size" must be a power of 2. The hash table might fail +** to resize if sqliteMalloc() fails. +** +** Return non-zero if a memory allocation error occurs. +*/ +static int fts3Rehash(Fts3Hash *pH, int new_size){ + struct _fts3ht *new_ht; /* The new hash table */ + Fts3HashElem *elem, *next_elem; /* For looping over existing elements */ + int (*xHash)(const void*,int); /* The hash function */ + + assert( (new_size & (new_size-1))==0 ); + new_ht = (struct _fts3ht *)fts3HashMalloc( new_size*sizeof(struct _fts3ht) ); + if( new_ht==0 ) return 1; + fts3HashFree(pH->ht); + pH->ht = new_ht; + pH->htsize = new_size; + xHash = ftsHashFunction(pH->keyClass); + for(elem=pH->first, pH->first=0; elem; elem = next_elem){ + int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1); + next_elem = elem->next; + fts3HashInsertElement(pH, &new_ht[h], elem); + } + return 0; +} + +/* This function (for internal use only) locates an element in an +** hash table that matches the given key. The hash for this key has +** already been computed and is passed as the 4th parameter. +*/ +static Fts3HashElem *fts3FindElementByHash( + const Fts3Hash *pH, /* The pH to be searched */ + const void *pKey, /* The key we are searching for */ + int nKey, + int h /* The hash for this key. */ +){ + Fts3HashElem *elem; /* Used to loop thru the element list */ + int count; /* Number of elements left to test */ + int (*xCompare)(const void*,int,const void*,int); /* comparison function */ + + if( pH->ht ){ + struct _fts3ht *pEntry = &pH->ht[h]; + elem = pEntry->chain; + count = pEntry->count; + xCompare = ftsCompareFunction(pH->keyClass); + while( count-- && elem ){ + if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ + return elem; + } + elem = elem->next; + } + } + return 0; +} + +/* Remove a single entry from the hash table given a pointer to that +** element and a hash on the element's key. +*/ +static void fts3RemoveElementByHash( + Fts3Hash *pH, /* The pH containing "elem" */ + Fts3HashElem* elem, /* The element to be removed from the pH */ + int h /* Hash value for the element */ +){ + struct _fts3ht *pEntry; + if( elem->prev ){ + elem->prev->next = elem->next; + }else{ + pH->first = elem->next; + } + if( elem->next ){ + elem->next->prev = elem->prev; + } + pEntry = &pH->ht[h]; + if( pEntry->chain==elem ){ + pEntry->chain = elem->next; + } + pEntry->count--; + if( pEntry->count<=0 ){ + pEntry->chain = 0; + } + if( pH->copyKey && elem->pKey ){ + fts3HashFree(elem->pKey); + } + fts3HashFree( elem ); + pH->count--; + if( pH->count<=0 ){ + assert( pH->first==0 ); + assert( pH->count==0 ); + fts3HashClear(pH); + } +} + +SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem( + const Fts3Hash *pH, + const void *pKey, + int nKey +){ + int h; /* A hash on key */ + int (*xHash)(const void*,int); /* The hash function */ + + if( pH==0 || pH->ht==0 ) return 0; + xHash = ftsHashFunction(pH->keyClass); + assert( xHash!=0 ); + h = (*xHash)(pKey,nKey); + assert( (pH->htsize & (pH->htsize-1))==0 ); + return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1)); +} + +/* +** Attempt to locate an element of the hash table pH with a key +** that matches pKey,nKey. Return the data for this element if it is +** found, or NULL if there is no match. +*/ +SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){ + Fts3HashElem *pElem; /* The element that matches key (if any) */ + + pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey); + return pElem ? pElem->data : 0; +} + +/* Insert an element into the hash table pH. The key is pKey,nKey +** and the data is "data". +** +** If no element exists with a matching key, then a new +** element is created. A copy of the key is made if the copyKey +** flag is set. NULL is returned. +** +** If another element already exists with the same key, then the +** new data replaces the old data and the old data is returned. +** The key is not copied in this instance. If a malloc fails, then +** the new data is returned and the hash table is unchanged. +** +** If the "data" parameter to this function is NULL, then the +** element corresponding to "key" is removed from the hash table. +*/ +SQLITE_PRIVATE void *sqlite3Fts3HashInsert( + Fts3Hash *pH, /* The hash table to insert into */ + const void *pKey, /* The key */ + int nKey, /* Number of bytes in the key */ + void *data /* The data */ +){ + int hraw; /* Raw hash value of the key */ + int h; /* the hash of the key modulo hash table size */ + Fts3HashElem *elem; /* Used to loop thru the element list */ + Fts3HashElem *new_elem; /* New element added to the pH */ + int (*xHash)(const void*,int); /* The hash function */ + + assert( pH!=0 ); + xHash = ftsHashFunction(pH->keyClass); + assert( xHash!=0 ); + hraw = (*xHash)(pKey, nKey); + assert( (pH->htsize & (pH->htsize-1))==0 ); + h = hraw & (pH->htsize-1); + elem = fts3FindElementByHash(pH,pKey,nKey,h); + if( elem ){ + void *old_data = elem->data; + if( data==0 ){ + fts3RemoveElementByHash(pH,elem,h); + }else{ + elem->data = data; + } + return old_data; + } + if( data==0 ) return 0; + if( (pH->htsize==0 && fts3Rehash(pH,8)) + || (pH->count>=pH->htsize && fts3Rehash(pH, pH->htsize*2)) + ){ + pH->count = 0; + return data; + } + assert( pH->htsize>0 ); + new_elem = (Fts3HashElem*)fts3HashMalloc( sizeof(Fts3HashElem) ); + if( new_elem==0 ) return data; + if( pH->copyKey && pKey!=0 ){ + new_elem->pKey = fts3HashMalloc( nKey ); + if( new_elem->pKey==0 ){ + fts3HashFree(new_elem); + return data; + } + memcpy((void*)new_elem->pKey, pKey, nKey); + }else{ + new_elem->pKey = (void*)pKey; + } + new_elem->nKey = nKey; + pH->count++; + assert( pH->htsize>0 ); + assert( (pH->htsize & (pH->htsize-1))==0 ); + h = hraw & (pH->htsize-1); + fts3HashInsertElement(pH, &pH->ht[h], new_elem); + new_elem->data = data; + return 0; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_hash.c *******************************************/ +/************** Begin file fts3_porter.c *************************************/ +/* +** 2006 September 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Implementation of the full-text-search tokenizer that implements +** a Porter stemmer. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_tokenizer.h" */ + +/* +** Class derived from sqlite3_tokenizer +*/ +typedef struct porter_tokenizer { + sqlite3_tokenizer base; /* Base class */ +} porter_tokenizer; + +/* +** Class derived from sqlite3_tokenizer_cursor +*/ +typedef struct porter_tokenizer_cursor { + sqlite3_tokenizer_cursor base; + const char *zInput; /* input we are tokenizing */ + int nInput; /* size of the input */ + int iOffset; /* current position in zInput */ + int iToken; /* index of next token to be returned */ + char *zToken; /* storage for current token */ + int nAllocated; /* space allocated to zToken buffer */ +} porter_tokenizer_cursor; + + +/* +** Create a new tokenizer instance. +*/ +static int porterCreate( + int argc, const char * const *argv, + sqlite3_tokenizer **ppTokenizer +){ + porter_tokenizer *t; + + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + + t = (porter_tokenizer *) sqlite3_malloc(sizeof(*t)); + if( t==NULL ) return SQLITE_NOMEM; + memset(t, 0, sizeof(*t)); + *ppTokenizer = &t->base; + return SQLITE_OK; +} + +/* +** Destroy a tokenizer +*/ +static int porterDestroy(sqlite3_tokenizer *pTokenizer){ + sqlite3_free(pTokenizer); + return SQLITE_OK; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is zInput[0..nInput-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int porterOpen( + sqlite3_tokenizer *pTokenizer, /* The tokenizer */ + const char *zInput, int nInput, /* String to be tokenized */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */ +){ + porter_tokenizer_cursor *c; + + UNUSED_PARAMETER(pTokenizer); + + c = (porter_tokenizer_cursor *) sqlite3_malloc(sizeof(*c)); + if( c==NULL ) return SQLITE_NOMEM; + + c->zInput = zInput; + if( zInput==0 ){ + c->nInput = 0; + }else if( nInput<0 ){ + c->nInput = (int)strlen(zInput); + }else{ + c->nInput = nInput; + } + c->iOffset = 0; /* start tokenizing at the beginning */ + c->iToken = 0; + c->zToken = NULL; /* no space allocated, yet. */ + c->nAllocated = 0; + + *ppCursor = &c->base; + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to +** porterOpen() above. +*/ +static int porterClose(sqlite3_tokenizer_cursor *pCursor){ + porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor; + sqlite3_free(c->zToken); + sqlite3_free(c); + return SQLITE_OK; +} +/* +** Vowel or consonant +*/ +static const char cType[] = { + 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 2, 1 +}; + +/* +** isConsonant() and isVowel() determine if their first character in +** the string they point to is a consonant or a vowel, according +** to Porter ruls. +** +** A consonate is any letter other than 'a', 'e', 'i', 'o', or 'u'. +** 'Y' is a consonant unless it follows another consonant, +** in which case it is a vowel. +** +** In these routine, the letters are in reverse order. So the 'y' rule +** is that 'y' is a consonant unless it is followed by another +** consonent. +*/ +static int isVowel(const char*); +static int isConsonant(const char *z){ + int j; + char x = *z; + if( x==0 ) return 0; + assert( x>='a' && x<='z' ); + j = cType[x-'a']; + if( j<2 ) return j; + return z[1]==0 || isVowel(z + 1); +} +static int isVowel(const char *z){ + int j; + char x = *z; + if( x==0 ) return 0; + assert( x>='a' && x<='z' ); + j = cType[x-'a']; + if( j<2 ) return 1-j; + return isConsonant(z + 1); +} + +/* +** Let any sequence of one or more vowels be represented by V and let +** C be sequence of one or more consonants. Then every word can be +** represented as: +** +** [C] (VC){m} [V] +** +** In prose: A word is an optional consonant followed by zero or +** vowel-consonant pairs followed by an optional vowel. "m" is the +** number of vowel consonant pairs. This routine computes the value +** of m for the first i bytes of a word. +** +** Return true if the m-value for z is 1 or more. In other words, +** return true if z contains at least one vowel that is followed +** by a consonant. +** +** In this routine z[] is in reverse order. So we are really looking +** for an instance of a consonant followed by a vowel. +*/ +static int m_gt_0(const char *z){ + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + return *z!=0; +} + +/* Like mgt0 above except we are looking for a value of m which is +** exactly 1 +*/ +static int m_eq_1(const char *z){ + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + if( *z==0 ) return 0; + while( isVowel(z) ){ z++; } + if( *z==0 ) return 1; + while( isConsonant(z) ){ z++; } + return *z==0; +} + +/* Like mgt0 above except we are looking for a value of m>1 instead +** or m>0 +*/ +static int m_gt_1(const char *z){ + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + if( *z==0 ) return 0; + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + return *z!=0; +} + +/* +** Return TRUE if there is a vowel anywhere within z[0..n-1] +*/ +static int hasVowel(const char *z){ + while( isConsonant(z) ){ z++; } + return *z!=0; +} + +/* +** Return TRUE if the word ends in a double consonant. +** +** The text is reversed here. So we are really looking at +** the first two characters of z[]. +*/ +static int doubleConsonant(const char *z){ + return isConsonant(z) && z[0]==z[1]; +} + +/* +** Return TRUE if the word ends with three letters which +** are consonant-vowel-consonent and where the final consonant +** is not 'w', 'x', or 'y'. +** +** The word is reversed here. So we are really checking the +** first three letters and the first one cannot be in [wxy]. +*/ +static int star_oh(const char *z){ + return + isConsonant(z) && + z[0]!='w' && z[0]!='x' && z[0]!='y' && + isVowel(z+1) && + isConsonant(z+2); +} + +/* +** If the word ends with zFrom and xCond() is true for the stem +** of the word that preceeds the zFrom ending, then change the +** ending to zTo. +** +** The input word *pz and zFrom are both in reverse order. zTo +** is in normal order. +** +** Return TRUE if zFrom matches. Return FALSE if zFrom does not +** match. Not that TRUE is returned even if xCond() fails and +** no substitution occurs. +*/ +static int stem( + char **pz, /* The word being stemmed (Reversed) */ + const char *zFrom, /* If the ending matches this... (Reversed) */ + const char *zTo, /* ... change the ending to this (not reversed) */ + int (*xCond)(const char*) /* Condition that must be true */ +){ + char *z = *pz; + while( *zFrom && *zFrom==*z ){ z++; zFrom++; } + if( *zFrom!=0 ) return 0; + if( xCond && !xCond(z) ) return 1; + while( *zTo ){ + *(--z) = *(zTo++); + } + *pz = z; + return 1; +} + +/* +** This is the fallback stemmer used when the porter stemmer is +** inappropriate. The input word is copied into the output with +** US-ASCII case folding. If the input word is too long (more +** than 20 bytes if it contains no digits or more than 6 bytes if +** it contains digits) then word is truncated to 20 or 6 bytes +** by taking 10 or 3 bytes from the beginning and end. +*/ +static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){ + int i, mx, j; + int hasDigit = 0; + for(i=0; i='A' && c<='Z' ){ + zOut[i] = c - 'A' + 'a'; + }else{ + if( c>='0' && c<='9' ) hasDigit = 1; + zOut[i] = c; + } + } + mx = hasDigit ? 3 : 10; + if( nIn>mx*2 ){ + for(j=mx, i=nIn-mx; i=(int)sizeof(zReverse)-7 ){ + /* The word is too big or too small for the porter stemmer. + ** Fallback to the copy stemmer */ + copy_stemmer(zIn, nIn, zOut, pnOut); + return; + } + for(i=0, j=sizeof(zReverse)-6; i='A' && c<='Z' ){ + zReverse[j] = c + 'a' - 'A'; + }else if( c>='a' && c<='z' ){ + zReverse[j] = c; + }else{ + /* The use of a character not in [a-zA-Z] means that we fallback + ** to the copy stemmer */ + copy_stemmer(zIn, nIn, zOut, pnOut); + return; + } + } + memset(&zReverse[sizeof(zReverse)-5], 0, 5); + z = &zReverse[j+1]; + + + /* Step 1a */ + if( z[0]=='s' ){ + if( + !stem(&z, "sess", "ss", 0) && + !stem(&z, "sei", "i", 0) && + !stem(&z, "ss", "ss", 0) + ){ + z++; + } + } + + /* Step 1b */ + z2 = z; + if( stem(&z, "dee", "ee", m_gt_0) ){ + /* Do nothing. The work was all in the test */ + }else if( + (stem(&z, "gni", "", hasVowel) || stem(&z, "de", "", hasVowel)) + && z!=z2 + ){ + if( stem(&z, "ta", "ate", 0) || + stem(&z, "lb", "ble", 0) || + stem(&z, "zi", "ize", 0) ){ + /* Do nothing. The work was all in the test */ + }else if( doubleConsonant(z) && (*z!='l' && *z!='s' && *z!='z') ){ + z++; + }else if( m_eq_1(z) && star_oh(z) ){ + *(--z) = 'e'; + } + } + + /* Step 1c */ + if( z[0]=='y' && hasVowel(z+1) ){ + z[0] = 'i'; + } + + /* Step 2 */ + switch( z[1] ){ + case 'a': + if( !stem(&z, "lanoita", "ate", m_gt_0) ){ + stem(&z, "lanoit", "tion", m_gt_0); + } + break; + case 'c': + if( !stem(&z, "icne", "ence", m_gt_0) ){ + stem(&z, "icna", "ance", m_gt_0); + } + break; + case 'e': + stem(&z, "rezi", "ize", m_gt_0); + break; + case 'g': + stem(&z, "igol", "log", m_gt_0); + break; + case 'l': + if( !stem(&z, "ilb", "ble", m_gt_0) + && !stem(&z, "illa", "al", m_gt_0) + && !stem(&z, "iltne", "ent", m_gt_0) + && !stem(&z, "ile", "e", m_gt_0) + ){ + stem(&z, "ilsuo", "ous", m_gt_0); + } + break; + case 'o': + if( !stem(&z, "noitazi", "ize", m_gt_0) + && !stem(&z, "noita", "ate", m_gt_0) + ){ + stem(&z, "rota", "ate", m_gt_0); + } + break; + case 's': + if( !stem(&z, "msila", "al", m_gt_0) + && !stem(&z, "ssenevi", "ive", m_gt_0) + && !stem(&z, "ssenluf", "ful", m_gt_0) + ){ + stem(&z, "ssensuo", "ous", m_gt_0); + } + break; + case 't': + if( !stem(&z, "itila", "al", m_gt_0) + && !stem(&z, "itivi", "ive", m_gt_0) + ){ + stem(&z, "itilib", "ble", m_gt_0); + } + break; + } + + /* Step 3 */ + switch( z[0] ){ + case 'e': + if( !stem(&z, "etaci", "ic", m_gt_0) + && !stem(&z, "evita", "", m_gt_0) + ){ + stem(&z, "ezila", "al", m_gt_0); + } + break; + case 'i': + stem(&z, "itici", "ic", m_gt_0); + break; + case 'l': + if( !stem(&z, "laci", "ic", m_gt_0) ){ + stem(&z, "luf", "", m_gt_0); + } + break; + case 's': + stem(&z, "ssen", "", m_gt_0); + break; + } + + /* Step 4 */ + switch( z[1] ){ + case 'a': + if( z[0]=='l' && m_gt_1(z+2) ){ + z += 2; + } + break; + case 'c': + if( z[0]=='e' && z[2]=='n' && (z[3]=='a' || z[3]=='e') && m_gt_1(z+4) ){ + z += 4; + } + break; + case 'e': + if( z[0]=='r' && m_gt_1(z+2) ){ + z += 2; + } + break; + case 'i': + if( z[0]=='c' && m_gt_1(z+2) ){ + z += 2; + } + break; + case 'l': + if( z[0]=='e' && z[2]=='b' && (z[3]=='a' || z[3]=='i') && m_gt_1(z+4) ){ + z += 4; + } + break; + case 'n': + if( z[0]=='t' ){ + if( z[2]=='a' ){ + if( m_gt_1(z+3) ){ + z += 3; + } + }else if( z[2]=='e' ){ + if( !stem(&z, "tneme", "", m_gt_1) + && !stem(&z, "tnem", "", m_gt_1) + ){ + stem(&z, "tne", "", m_gt_1); + } + } + } + break; + case 'o': + if( z[0]=='u' ){ + if( m_gt_1(z+2) ){ + z += 2; + } + }else if( z[3]=='s' || z[3]=='t' ){ + stem(&z, "noi", "", m_gt_1); + } + break; + case 's': + if( z[0]=='m' && z[2]=='i' && m_gt_1(z+3) ){ + z += 3; + } + break; + case 't': + if( !stem(&z, "eta", "", m_gt_1) ){ + stem(&z, "iti", "", m_gt_1); + } + break; + case 'u': + if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){ + z += 3; + } + break; + case 'v': + case 'z': + if( z[0]=='e' && z[2]=='i' && m_gt_1(z+3) ){ + z += 3; + } + break; + } + + /* Step 5a */ + if( z[0]=='e' ){ + if( m_gt_1(z+1) ){ + z++; + }else if( m_eq_1(z+1) && !star_oh(z+1) ){ + z++; + } + } + + /* Step 5b */ + if( m_gt_1(z) && z[0]=='l' && z[1]=='l' ){ + z++; + } + + /* z[] is now the stemmed word in reverse order. Flip it back + ** around into forward order and return. + */ + *pnOut = i = (int)strlen(z); + zOut[i] = 0; + while( *z ){ + zOut[--i] = *(z++); + } +} + +/* +** Characters that can be part of a token. We assume any character +** whose value is greater than 0x80 (any UTF character) can be +** part of a token. In other words, delimiters all must have +** values of 0x7f or lower. +*/ +static const char porterIdChar[] = { +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */ +}; +#define isDelim(C) (((ch=C)&0x80)==0 && (ch<0x30 || !porterIdChar[ch-0x30])) + +/* +** Extract the next token from a tokenization cursor. The cursor must +** have been opened by a prior call to porterOpen(). +*/ +static int porterNext( + sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by porterOpen */ + const char **pzToken, /* OUT: *pzToken is the token text */ + int *pnBytes, /* OUT: Number of bytes in token */ + int *piStartOffset, /* OUT: Starting offset of token */ + int *piEndOffset, /* OUT: Ending offset of token */ + int *piPosition /* OUT: Position integer of token */ +){ + porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor; + const char *z = c->zInput; + + while( c->iOffsetnInput ){ + int iStartOffset, ch; + + /* Scan past delimiter characters */ + while( c->iOffsetnInput && isDelim(z[c->iOffset]) ){ + c->iOffset++; + } + + /* Count non-delimiter characters. */ + iStartOffset = c->iOffset; + while( c->iOffsetnInput && !isDelim(z[c->iOffset]) ){ + c->iOffset++; + } + + if( c->iOffset>iStartOffset ){ + int n = c->iOffset-iStartOffset; + if( n>c->nAllocated ){ + char *pNew; + c->nAllocated = n+20; + pNew = sqlite3_realloc(c->zToken, c->nAllocated); + if( !pNew ) return SQLITE_NOMEM; + c->zToken = pNew; + } + porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes); + *pzToken = c->zToken; + *piStartOffset = iStartOffset; + *piEndOffset = c->iOffset; + *piPosition = c->iToken++; + return SQLITE_OK; + } + } + return SQLITE_DONE; +} + +/* +** The set of routines that implement the porter-stemmer tokenizer +*/ +static const sqlite3_tokenizer_module porterTokenizerModule = { + 0, + porterCreate, + porterDestroy, + porterOpen, + porterClose, + porterNext, + 0 +}; + +/* +** Allocate a new porter tokenizer. Return a pointer to the new +** tokenizer in *ppModule +*/ +SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule( + sqlite3_tokenizer_module const**ppModule +){ + *ppModule = &porterTokenizerModule; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_porter.c *****************************************/ +/************** Begin file fts3_tokenizer.c **********************************/ +/* +** 2007 June 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This is part of an SQLite module implementing full-text search. +** This particular file implements the generic tokenizer interface. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +/* +** Implementation of the SQL scalar function for accessing the underlying +** hash table. This function may be called as follows: +** +** SELECT (); +** SELECT (, ); +** +** where is the name passed as the second argument +** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer'). +** +** If the argument is specified, it must be a blob value +** containing a pointer to be stored as the hash data corresponding +** to the string . If is not specified, then +** the string must already exist in the has table. Otherwise, +** an error is returned. +** +** Whether or not the argument is specified, the value returned +** is a blob containing the pointer stored as the hash data corresponding +** to string (after the hash-table is updated, if applicable). +*/ +static void scalarFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Fts3Hash *pHash; + void *pPtr = 0; + const unsigned char *zName; + int nName; + + assert( argc==1 || argc==2 ); + + pHash = (Fts3Hash *)sqlite3_user_data(context); + + zName = sqlite3_value_text(argv[0]); + nName = sqlite3_value_bytes(argv[0])+1; + + if( argc==2 ){ + void *pOld; + int n = sqlite3_value_bytes(argv[1]); + if( zName==0 || n!=sizeof(pPtr) ){ + sqlite3_result_error(context, "argument type mismatch", -1); + return; + } + pPtr = *(void **)sqlite3_value_blob(argv[1]); + pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr); + if( pOld==pPtr ){ + sqlite3_result_error(context, "out of memory", -1); + return; + } + }else{ + if( zName ){ + pPtr = sqlite3Fts3HashFind(pHash, zName, nName); + } + if( !pPtr ){ + char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName); + sqlite3_result_error(context, zErr, -1); + sqlite3_free(zErr); + return; + } + } + + sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT); +} + +SQLITE_PRIVATE int sqlite3Fts3IsIdChar(char c){ + static const char isFtsIdChar[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */ + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */ + }; + return (c&0x80 || isFtsIdChar[(int)(c)]); +} + +SQLITE_PRIVATE const char *sqlite3Fts3NextToken(const char *zStr, int *pn){ + const char *z1; + const char *z2 = 0; + + /* Find the start of the next token. */ + z1 = zStr; + while( z2==0 ){ + char c = *z1; + switch( c ){ + case '\0': return 0; /* No more tokens here */ + case '\'': + case '"': + case '`': { + z2 = z1; + while( *++z2 && (*z2!=c || *++z2==c) ); + break; + } + case '[': + z2 = &z1[1]; + while( *z2 && z2[0]!=']' ) z2++; + if( *z2 ) z2++; + break; + + default: + if( sqlite3Fts3IsIdChar(*z1) ){ + z2 = &z1[1]; + while( sqlite3Fts3IsIdChar(*z2) ) z2++; + }else{ + z1++; + } + } + } + + *pn = (int)(z2-z1); + return z1; +} + +SQLITE_PRIVATE int sqlite3Fts3InitTokenizer( + Fts3Hash *pHash, /* Tokenizer hash table */ + const char *zArg, /* Tokenizer name */ + sqlite3_tokenizer **ppTok, /* OUT: Tokenizer (if applicable) */ + char **pzErr /* OUT: Set to malloced error message */ +){ + int rc; + char *z = (char *)zArg; + int n = 0; + char *zCopy; + char *zEnd; /* Pointer to nul-term of zCopy */ + sqlite3_tokenizer_module *m; + + zCopy = sqlite3_mprintf("%s", zArg); + if( !zCopy ) return SQLITE_NOMEM; + zEnd = &zCopy[strlen(zCopy)]; + + z = (char *)sqlite3Fts3NextToken(zCopy, &n); + if( z==0 ){ + assert( n==0 ); + z = zCopy; + } + z[n] = '\0'; + sqlite3Fts3Dequote(z); + + m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash,z,(int)strlen(z)+1); + if( !m ){ + sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", z); + rc = SQLITE_ERROR; + }else{ + char const **aArg = 0; + int iArg = 0; + z = &z[n+1]; + while( zxCreate(iArg, aArg, ppTok); + assert( rc!=SQLITE_OK || *ppTok ); + if( rc!=SQLITE_OK ){ + sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer"); + }else{ + (*ppTok)->pModule = m; + } + sqlite3_free((void *)aArg); + } + + sqlite3_free(zCopy); + return rc; +} + + +#ifdef SQLITE_TEST + +#include +/* #include */ + +/* +** Implementation of a special SQL scalar function for testing tokenizers +** designed to be used in concert with the Tcl testing framework. This +** function must be called with two or more arguments: +** +** SELECT (, ..., ); +** +** where is the name passed as the second argument +** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer') +** concatenated with the string '_test' (e.g. 'fts3_tokenizer_test'). +** +** The return value is a string that may be interpreted as a Tcl +** list. For each token in the , three elements are +** added to the returned list. The first is the token position, the +** second is the token text (folded, stemmed, etc.) and the third is the +** substring of associated with the token. For example, +** using the built-in "simple" tokenizer: +** +** SELECT fts_tokenizer_test('simple', 'I don't see how'); +** +** will return the string: +** +** "{0 i I 1 dont don't 2 see see 3 how how}" +** +*/ +static void testFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Fts3Hash *pHash; + sqlite3_tokenizer_module *p; + sqlite3_tokenizer *pTokenizer = 0; + sqlite3_tokenizer_cursor *pCsr = 0; + + const char *zErr = 0; + + const char *zName; + int nName; + const char *zInput; + int nInput; + + const char *azArg[64]; + + const char *zToken; + int nToken = 0; + int iStart = 0; + int iEnd = 0; + int iPos = 0; + int i; + + Tcl_Obj *pRet; + + if( argc<2 ){ + sqlite3_result_error(context, "insufficient arguments", -1); + return; + } + + nName = sqlite3_value_bytes(argv[0]); + zName = (const char *)sqlite3_value_text(argv[0]); + nInput = sqlite3_value_bytes(argv[argc-1]); + zInput = (const char *)sqlite3_value_text(argv[argc-1]); + + pHash = (Fts3Hash *)sqlite3_user_data(context); + p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1); + + if( !p ){ + char *zErr2 = sqlite3_mprintf("unknown tokenizer: %s", zName); + sqlite3_result_error(context, zErr2, -1); + sqlite3_free(zErr2); + return; + } + + pRet = Tcl_NewObj(); + Tcl_IncrRefCount(pRet); + + for(i=1; ixCreate(argc-2, azArg, &pTokenizer) ){ + zErr = "error in xCreate()"; + goto finish; + } + pTokenizer->pModule = p; + if( sqlite3Fts3OpenTokenizer(pTokenizer, 0, zInput, nInput, &pCsr) ){ + zErr = "error in xOpen()"; + goto finish; + } + + while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){ + Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iPos)); + Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken)); + zToken = &zInput[iStart]; + nToken = iEnd-iStart; + Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken)); + } + + if( SQLITE_OK!=p->xClose(pCsr) ){ + zErr = "error in xClose()"; + goto finish; + } + if( SQLITE_OK!=p->xDestroy(pTokenizer) ){ + zErr = "error in xDestroy()"; + goto finish; + } + +finish: + if( zErr ){ + sqlite3_result_error(context, zErr, -1); + }else{ + sqlite3_result_text(context, Tcl_GetString(pRet), -1, SQLITE_TRANSIENT); + } + Tcl_DecrRefCount(pRet); +} + +static +int registerTokenizer( + sqlite3 *db, + char *zName, + const sqlite3_tokenizer_module *p +){ + int rc; + sqlite3_stmt *pStmt; + const char zSql[] = "SELECT fts3_tokenizer(?, ?)"; + + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC); + sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC); + sqlite3_step(pStmt); + + return sqlite3_finalize(pStmt); +} + +static +int queryTokenizer( + sqlite3 *db, + char *zName, + const sqlite3_tokenizer_module **pp +){ + int rc; + sqlite3_stmt *pStmt; + const char zSql[] = "SELECT fts3_tokenizer(?)"; + + *pp = 0; + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC); + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB ){ + memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp)); + } + } + + return sqlite3_finalize(pStmt); +} + +SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule); + +/* +** Implementation of the scalar function fts3_tokenizer_internal_test(). +** This function is used for testing only, it is not included in the +** build unless SQLITE_TEST is defined. +** +** The purpose of this is to test that the fts3_tokenizer() function +** can be used as designed by the C-code in the queryTokenizer and +** registerTokenizer() functions above. These two functions are repeated +** in the README.tokenizer file as an example, so it is important to +** test them. +** +** To run the tests, evaluate the fts3_tokenizer_internal_test() scalar +** function with no arguments. An assert() will fail if a problem is +** detected. i.e.: +** +** SELECT fts3_tokenizer_internal_test(); +** +*/ +static void intTestFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int rc; + const sqlite3_tokenizer_module *p1; + const sqlite3_tokenizer_module *p2; + sqlite3 *db = (sqlite3 *)sqlite3_user_data(context); + + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + + /* Test the query function */ + sqlite3Fts3SimpleTokenizerModule(&p1); + rc = queryTokenizer(db, "simple", &p2); + assert( rc==SQLITE_OK ); + assert( p1==p2 ); + rc = queryTokenizer(db, "nosuchtokenizer", &p2); + assert( rc==SQLITE_ERROR ); + assert( p2==0 ); + assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") ); + + /* Test the storage function */ + rc = registerTokenizer(db, "nosuchtokenizer", p1); + assert( rc==SQLITE_OK ); + rc = queryTokenizer(db, "nosuchtokenizer", &p2); + assert( rc==SQLITE_OK ); + assert( p2==p1 ); + + sqlite3_result_text(context, "ok", -1, SQLITE_STATIC); +} + +#endif + +/* +** Set up SQL objects in database db used to access the contents of +** the hash table pointed to by argument pHash. The hash table must +** been initialized to use string keys, and to take a private copy +** of the key when a value is inserted. i.e. by a call similar to: +** +** sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1); +** +** This function adds a scalar function (see header comment above +** scalarFunc() in this file for details) and, if ENABLE_TABLE is +** defined at compilation time, a temporary virtual table (see header +** comment above struct HashTableVtab) to the database schema. Both +** provide read/write access to the contents of *pHash. +** +** The third argument to this function, zName, is used as the name +** of both the scalar and, if created, the virtual table. +*/ +SQLITE_PRIVATE int sqlite3Fts3InitHashTable( + sqlite3 *db, + Fts3Hash *pHash, + const char *zName +){ + int rc = SQLITE_OK; + void *p = (void *)pHash; + const int any = SQLITE_ANY; + +#ifdef SQLITE_TEST + char *zTest = 0; + char *zTest2 = 0; + void *pdb = (void *)db; + zTest = sqlite3_mprintf("%s_test", zName); + zTest2 = sqlite3_mprintf("%s_internal_test", zName); + if( !zTest || !zTest2 ){ + rc = SQLITE_NOMEM; + } +#endif + + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0); + } + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0); + } +#ifdef SQLITE_TEST + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zTest, -1, any, p, testFunc, 0, 0); + } + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0); + } +#endif + +#ifdef SQLITE_TEST + sqlite3_free(zTest); + sqlite3_free(zTest2); +#endif + + return rc; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_tokenizer.c **************************************/ +/************** Begin file fts3_tokenizer1.c *********************************/ +/* +** 2006 Oct 10 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** Implementation of the "simple" full-text-search tokenizer. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_tokenizer.h" */ + +typedef struct simple_tokenizer { + sqlite3_tokenizer base; + char delim[128]; /* flag ASCII delimiters */ +} simple_tokenizer; + +typedef struct simple_tokenizer_cursor { + sqlite3_tokenizer_cursor base; + const char *pInput; /* input we are tokenizing */ + int nBytes; /* size of the input */ + int iOffset; /* current position in pInput */ + int iToken; /* index of next token to be returned */ + char *pToken; /* storage for current token */ + int nTokenAllocated; /* space allocated to zToken buffer */ +} simple_tokenizer_cursor; + + +static int simpleDelim(simple_tokenizer *t, unsigned char c){ + return c<0x80 && t->delim[c]; +} +static int fts3_isalnum(int x){ + return (x>='0' && x<='9') || (x>='A' && x<='Z') || (x>='a' && x<='z'); +} + +/* +** Create a new tokenizer instance. +*/ +static int simpleCreate( + int argc, const char * const *argv, + sqlite3_tokenizer **ppTokenizer +){ + simple_tokenizer *t; + + t = (simple_tokenizer *) sqlite3_malloc(sizeof(*t)); + if( t==NULL ) return SQLITE_NOMEM; + memset(t, 0, sizeof(*t)); + + /* TODO(shess) Delimiters need to remain the same from run to run, + ** else we need to reindex. One solution would be a meta-table to + ** track such information in the database, then we'd only want this + ** information on the initial create. + */ + if( argc>1 ){ + int i, n = (int)strlen(argv[1]); + for(i=0; i=0x80 ){ + sqlite3_free(t); + return SQLITE_ERROR; + } + t->delim[ch] = 1; + } + } else { + /* Mark non-alphanumeric ASCII characters as delimiters */ + int i; + for(i=1; i<0x80; i++){ + t->delim[i] = !fts3_isalnum(i) ? -1 : 0; + } + } + + *ppTokenizer = &t->base; + return SQLITE_OK; +} + +/* +** Destroy a tokenizer +*/ +static int simpleDestroy(sqlite3_tokenizer *pTokenizer){ + sqlite3_free(pTokenizer); + return SQLITE_OK; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is pInput[0..nBytes-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int simpleOpen( + sqlite3_tokenizer *pTokenizer, /* The tokenizer */ + const char *pInput, int nBytes, /* String to be tokenized */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */ +){ + simple_tokenizer_cursor *c; + + UNUSED_PARAMETER(pTokenizer); + + c = (simple_tokenizer_cursor *) sqlite3_malloc(sizeof(*c)); + if( c==NULL ) return SQLITE_NOMEM; + + c->pInput = pInput; + if( pInput==0 ){ + c->nBytes = 0; + }else if( nBytes<0 ){ + c->nBytes = (int)strlen(pInput); + }else{ + c->nBytes = nBytes; + } + c->iOffset = 0; /* start tokenizing at the beginning */ + c->iToken = 0; + c->pToken = NULL; /* no space allocated, yet. */ + c->nTokenAllocated = 0; + + *ppCursor = &c->base; + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to +** simpleOpen() above. +*/ +static int simpleClose(sqlite3_tokenizer_cursor *pCursor){ + simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor; + sqlite3_free(c->pToken); + sqlite3_free(c); + return SQLITE_OK; +} + +/* +** Extract the next token from a tokenization cursor. The cursor must +** have been opened by a prior call to simpleOpen(). +*/ +static int simpleNext( + sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by simpleOpen */ + const char **ppToken, /* OUT: *ppToken is the token text */ + int *pnBytes, /* OUT: Number of bytes in token */ + int *piStartOffset, /* OUT: Starting offset of token */ + int *piEndOffset, /* OUT: Ending offset of token */ + int *piPosition /* OUT: Position integer of token */ +){ + simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor; + simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer; + unsigned char *p = (unsigned char *)c->pInput; + + while( c->iOffsetnBytes ){ + int iStartOffset; + + /* Scan past delimiter characters */ + while( c->iOffsetnBytes && simpleDelim(t, p[c->iOffset]) ){ + c->iOffset++; + } + + /* Count non-delimiter characters. */ + iStartOffset = c->iOffset; + while( c->iOffsetnBytes && !simpleDelim(t, p[c->iOffset]) ){ + c->iOffset++; + } + + if( c->iOffset>iStartOffset ){ + int i, n = c->iOffset-iStartOffset; + if( n>c->nTokenAllocated ){ + char *pNew; + c->nTokenAllocated = n+20; + pNew = sqlite3_realloc(c->pToken, c->nTokenAllocated); + if( !pNew ) return SQLITE_NOMEM; + c->pToken = pNew; + } + for(i=0; ipToken[i] = (char)((ch>='A' && ch<='Z') ? ch-'A'+'a' : ch); + } + *ppToken = c->pToken; + *pnBytes = n; + *piStartOffset = iStartOffset; + *piEndOffset = c->iOffset; + *piPosition = c->iToken++; + + return SQLITE_OK; + } + } + return SQLITE_DONE; +} + +/* +** The set of routines that implement the simple tokenizer +*/ +static const sqlite3_tokenizer_module simpleTokenizerModule = { + 0, + simpleCreate, + simpleDestroy, + simpleOpen, + simpleClose, + simpleNext, + 0, +}; + +/* +** Allocate a new simple tokenizer. Return a pointer to the new +** tokenizer in *ppModule +*/ +SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule( + sqlite3_tokenizer_module const**ppModule +){ + *ppModule = &simpleTokenizerModule; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_tokenizer1.c *************************************/ +/************** Begin file fts3_tokenize_vtab.c ******************************/ +/* +** 2013 Apr 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code for the "fts3tokenize" virtual table module. +** An fts3tokenize virtual table is created as follows: +** +** CREATE VIRTUAL TABLE USING fts3tokenize( +** , , ... +** ); +** +** The table created has the following schema: +** +** CREATE TABLE (input, token, start, end, position) +** +** When queried, the query must include a WHERE clause of type: +** +** input = +** +** The virtual table module tokenizes this , using the FTS3 +** tokenizer specified by the arguments to the CREATE VIRTUAL TABLE +** statement and returns one row for each token in the result. With +** fields set as follows: +** +** input: Always set to a copy of +** token: A token from the input. +** start: Byte offset of the token within the input . +** end: Byte offset of the byte immediately following the end of the +** token within the input string. +** pos: Token offset of token within input. +** +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +typedef struct Fts3tokTable Fts3tokTable; +typedef struct Fts3tokCursor Fts3tokCursor; + +/* +** Virtual table structure. +*/ +struct Fts3tokTable { + sqlite3_vtab base; /* Base class used by SQLite core */ + const sqlite3_tokenizer_module *pMod; + sqlite3_tokenizer *pTok; +}; + +/* +** Virtual table cursor structure. +*/ +struct Fts3tokCursor { + sqlite3_vtab_cursor base; /* Base class used by SQLite core */ + char *zInput; /* Input string */ + sqlite3_tokenizer_cursor *pCsr; /* Cursor to iterate through zInput */ + int iRowid; /* Current 'rowid' value */ + const char *zToken; /* Current 'token' value */ + int nToken; /* Size of zToken in bytes */ + int iStart; /* Current 'start' value */ + int iEnd; /* Current 'end' value */ + int iPos; /* Current 'pos' value */ +}; + +/* +** Query FTS for the tokenizer implementation named zName. +*/ +static int fts3tokQueryTokenizer( + Fts3Hash *pHash, + const char *zName, + const sqlite3_tokenizer_module **pp, + char **pzErr +){ + sqlite3_tokenizer_module *p; + int nName = (int)strlen(zName); + + p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1); + if( !p ){ + sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", zName); + return SQLITE_ERROR; + } + + *pp = p; + return SQLITE_OK; +} + +/* +** The second argument, argv[], is an array of pointers to nul-terminated +** strings. This function makes a copy of the array and strings into a +** single block of memory. It then dequotes any of the strings that appear +** to be quoted. +** +** If successful, output parameter *pazDequote is set to point at the +** array of dequoted strings and SQLITE_OK is returned. The caller is +** responsible for eventually calling sqlite3_free() to free the array +** in this case. Or, if an error occurs, an SQLite error code is returned. +** The final value of *pazDequote is undefined in this case. +*/ +static int fts3tokDequoteArray( + int argc, /* Number of elements in argv[] */ + const char * const *argv, /* Input array */ + char ***pazDequote /* Output array */ +){ + int rc = SQLITE_OK; /* Return code */ + if( argc==0 ){ + *pazDequote = 0; + }else{ + int i; + int nByte = 0; + char **azDequote; + + for(i=0; ixCreate((nDequote>1 ? nDequote-1 : 0), azArg, &pTok); + } + + if( rc==SQLITE_OK ){ + pTab = (Fts3tokTable *)sqlite3_malloc(sizeof(Fts3tokTable)); + if( pTab==0 ){ + rc = SQLITE_NOMEM; + } + } + + if( rc==SQLITE_OK ){ + memset(pTab, 0, sizeof(Fts3tokTable)); + pTab->pMod = pMod; + pTab->pTok = pTok; + *ppVtab = &pTab->base; + }else{ + if( pTok ){ + pMod->xDestroy(pTok); + } + } + + sqlite3_free(azDequote); + return rc; +} + +/* +** This function does the work for both the xDisconnect and xDestroy methods. +** These tables have no persistent representation of their own, so xDisconnect +** and xDestroy are identical operations. +*/ +static int fts3tokDisconnectMethod(sqlite3_vtab *pVtab){ + Fts3tokTable *pTab = (Fts3tokTable *)pVtab; + + pTab->pMod->xDestroy(pTab->pTok); + sqlite3_free(pTab); + return SQLITE_OK; +} + +/* +** xBestIndex - Analyze a WHERE and ORDER BY clause. +*/ +static int fts3tokBestIndexMethod( + sqlite3_vtab *pVTab, + sqlite3_index_info *pInfo +){ + int i; + UNUSED_PARAMETER(pVTab); + + for(i=0; inConstraint; i++){ + if( pInfo->aConstraint[i].usable + && pInfo->aConstraint[i].iColumn==0 + && pInfo->aConstraint[i].op==SQLITE_INDEX_CONSTRAINT_EQ + ){ + pInfo->idxNum = 1; + pInfo->aConstraintUsage[i].argvIndex = 1; + pInfo->aConstraintUsage[i].omit = 1; + pInfo->estimatedCost = 1; + return SQLITE_OK; + } + } + + pInfo->idxNum = 0; + assert( pInfo->estimatedCost>1000000.0 ); + + return SQLITE_OK; +} + +/* +** xOpen - Open a cursor. +*/ +static int fts3tokOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){ + Fts3tokCursor *pCsr; + UNUSED_PARAMETER(pVTab); + + pCsr = (Fts3tokCursor *)sqlite3_malloc(sizeof(Fts3tokCursor)); + if( pCsr==0 ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(Fts3tokCursor)); + + *ppCsr = (sqlite3_vtab_cursor *)pCsr; + return SQLITE_OK; +} + +/* +** Reset the tokenizer cursor passed as the only argument. As if it had +** just been returned by fts3tokOpenMethod(). +*/ +static void fts3tokResetCursor(Fts3tokCursor *pCsr){ + if( pCsr->pCsr ){ + Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab); + pTab->pMod->xClose(pCsr->pCsr); + pCsr->pCsr = 0; + } + sqlite3_free(pCsr->zInput); + pCsr->zInput = 0; + pCsr->zToken = 0; + pCsr->nToken = 0; + pCsr->iStart = 0; + pCsr->iEnd = 0; + pCsr->iPos = 0; + pCsr->iRowid = 0; +} + +/* +** xClose - Close a cursor. +*/ +static int fts3tokCloseMethod(sqlite3_vtab_cursor *pCursor){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + + fts3tokResetCursor(pCsr); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** xNext - Advance the cursor to the next row, if any. +*/ +static int fts3tokNextMethod(sqlite3_vtab_cursor *pCursor){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab); + int rc; /* Return code */ + + pCsr->iRowid++; + rc = pTab->pMod->xNext(pCsr->pCsr, + &pCsr->zToken, &pCsr->nToken, + &pCsr->iStart, &pCsr->iEnd, &pCsr->iPos + ); + + if( rc!=SQLITE_OK ){ + fts3tokResetCursor(pCsr); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + + return rc; +} + +/* +** xFilter - Initialize a cursor to point at the start of its data. +*/ +static int fts3tokFilterMethod( + sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */ + int idxNum, /* Strategy index */ + const char *idxStr, /* Unused */ + int nVal, /* Number of elements in apVal */ + sqlite3_value **apVal /* Arguments for the indexing scheme */ +){ + int rc = SQLITE_ERROR; + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab); + UNUSED_PARAMETER(idxStr); + UNUSED_PARAMETER(nVal); + + fts3tokResetCursor(pCsr); + if( idxNum==1 ){ + const char *zByte = (const char *)sqlite3_value_text(apVal[0]); + int nByte = sqlite3_value_bytes(apVal[0]); + pCsr->zInput = sqlite3_malloc(nByte+1); + if( pCsr->zInput==0 ){ + rc = SQLITE_NOMEM; + }else{ + memcpy(pCsr->zInput, zByte, nByte); + pCsr->zInput[nByte] = 0; + rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr); + if( rc==SQLITE_OK ){ + pCsr->pCsr->pTokenizer = pTab->pTok; + } + } + } + + if( rc!=SQLITE_OK ) return rc; + return fts3tokNextMethod(pCursor); +} + +/* +** xEof - Return true if the cursor is at EOF, or false otherwise. +*/ +static int fts3tokEofMethod(sqlite3_vtab_cursor *pCursor){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + return (pCsr->zToken==0); +} + +/* +** xColumn - Return a column value. +*/ +static int fts3tokColumnMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */ + int iCol /* Index of column to read value from */ +){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + + /* CREATE TABLE x(input, token, start, end, position) */ + switch( iCol ){ + case 0: + sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT); + break; + case 1: + sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT); + break; + case 2: + sqlite3_result_int(pCtx, pCsr->iStart); + break; + case 3: + sqlite3_result_int(pCtx, pCsr->iEnd); + break; + default: + assert( iCol==4 ); + sqlite3_result_int(pCtx, pCsr->iPos); + break; + } + return SQLITE_OK; +} + +/* +** xRowid - Return the current rowid for the cursor. +*/ +static int fts3tokRowidMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite_int64 *pRowid /* OUT: Rowid value */ +){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + *pRowid = (sqlite3_int64)pCsr->iRowid; + return SQLITE_OK; +} + +/* +** Register the fts3tok module with database connection db. Return SQLITE_OK +** if successful or an error code if sqlite3_create_module() fails. +*/ +SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3 *db, Fts3Hash *pHash){ + static const sqlite3_module fts3tok_module = { + 0, /* iVersion */ + fts3tokConnectMethod, /* xCreate */ + fts3tokConnectMethod, /* xConnect */ + fts3tokBestIndexMethod, /* xBestIndex */ + fts3tokDisconnectMethod, /* xDisconnect */ + fts3tokDisconnectMethod, /* xDestroy */ + fts3tokOpenMethod, /* xOpen */ + fts3tokCloseMethod, /* xClose */ + fts3tokFilterMethod, /* xFilter */ + fts3tokNextMethod, /* xNext */ + fts3tokEofMethod, /* xEof */ + fts3tokColumnMethod, /* xColumn */ + fts3tokRowidMethod, /* xRowid */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindFunction */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0 /* xRollbackTo */ + }; + int rc; /* Return code */ + + rc = sqlite3_create_module(db, "fts3tokenize", &fts3tok_module, (void*)pHash); + return rc; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_tokenize_vtab.c **********************************/ +/************** Begin file fts3_write.c **************************************/ +/* +** 2009 Oct 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file is part of the SQLite FTS3 extension module. Specifically, +** this file contains code to insert, update and delete rows from FTS3 +** tables. It also contains code to merge FTS3 b-tree segments. Some +** of the sub-routines used to merge segments are also used by the query +** code in fts3.c. +*/ + +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ + + +#define FTS_MAX_APPENDABLE_HEIGHT 16 + +/* +** When full-text index nodes are loaded from disk, the buffer that they +** are loaded into has the following number of bytes of padding at the end +** of it. i.e. if a full-text index node is 900 bytes in size, then a buffer +** of 920 bytes is allocated for it. +** +** This means that if we have a pointer into a buffer containing node data, +** it is always safe to read up to two varints from it without risking an +** overread, even if the node data is corrupted. +*/ +#define FTS3_NODE_PADDING (FTS3_VARINT_MAX*2) + +/* +** Under certain circumstances, b-tree nodes (doclists) can be loaded into +** memory incrementally instead of all at once. This can be a big performance +** win (reduced IO and CPU) if SQLite stops calling the virtual table xNext() +** method before retrieving all query results (as may happen, for example, +** if a query has a LIMIT clause). +** +** Incremental loading is used for b-tree nodes FTS3_NODE_CHUNK_THRESHOLD +** bytes and larger. Nodes are loaded in chunks of FTS3_NODE_CHUNKSIZE bytes. +** The code is written so that the hard lower-limit for each of these values +** is 1. Clearly such small values would be inefficient, but can be useful +** for testing purposes. +** +** If this module is built with SQLITE_TEST defined, these constants may +** be overridden at runtime for testing purposes. File fts3_test.c contains +** a Tcl interface to read and write the values. +*/ +#ifdef SQLITE_TEST +int test_fts3_node_chunksize = (4*1024); +int test_fts3_node_chunk_threshold = (4*1024)*4; +# define FTS3_NODE_CHUNKSIZE test_fts3_node_chunksize +# define FTS3_NODE_CHUNK_THRESHOLD test_fts3_node_chunk_threshold +#else +# define FTS3_NODE_CHUNKSIZE (4*1024) +# define FTS3_NODE_CHUNK_THRESHOLD (FTS3_NODE_CHUNKSIZE*4) +#endif + +/* +** The two values that may be meaningfully bound to the :1 parameter in +** statements SQL_REPLACE_STAT and SQL_SELECT_STAT. +*/ +#define FTS_STAT_DOCTOTAL 0 +#define FTS_STAT_INCRMERGEHINT 1 +#define FTS_STAT_AUTOINCRMERGE 2 + +/* +** If FTS_LOG_MERGES is defined, call sqlite3_log() to report each automatic +** and incremental merge operation that takes place. This is used for +** debugging FTS only, it should not usually be turned on in production +** systems. +*/ +#ifdef FTS3_LOG_MERGES +static void fts3LogMerge(int nMerge, sqlite3_int64 iAbsLevel){ + sqlite3_log(SQLITE_OK, "%d-way merge from level %d", nMerge, (int)iAbsLevel); +} +#else +#define fts3LogMerge(x, y) +#endif + + +typedef struct PendingList PendingList; +typedef struct SegmentNode SegmentNode; +typedef struct SegmentWriter SegmentWriter; + +/* +** An instance of the following data structure is used to build doclists +** incrementally. See function fts3PendingListAppend() for details. +*/ +struct PendingList { + int nData; + char *aData; + int nSpace; + sqlite3_int64 iLastDocid; + sqlite3_int64 iLastCol; + sqlite3_int64 iLastPos; +}; + + +/* +** Each cursor has a (possibly empty) linked list of the following objects. +*/ +struct Fts3DeferredToken { + Fts3PhraseToken *pToken; /* Pointer to corresponding expr token */ + int iCol; /* Column token must occur in */ + Fts3DeferredToken *pNext; /* Next in list of deferred tokens */ + PendingList *pList; /* Doclist is assembled here */ +}; + +/* +** An instance of this structure is used to iterate through the terms on +** a contiguous set of segment b-tree leaf nodes. Although the details of +** this structure are only manipulated by code in this file, opaque handles +** of type Fts3SegReader* are also used by code in fts3.c to iterate through +** terms when querying the full-text index. See functions: +** +** sqlite3Fts3SegReaderNew() +** sqlite3Fts3SegReaderFree() +** sqlite3Fts3SegReaderIterate() +** +** Methods used to manipulate Fts3SegReader structures: +** +** fts3SegReaderNext() +** fts3SegReaderFirstDocid() +** fts3SegReaderNextDocid() +*/ +struct Fts3SegReader { + int iIdx; /* Index within level, or 0x7FFFFFFF for PT */ + u8 bLookup; /* True for a lookup only */ + u8 rootOnly; /* True for a root-only reader */ + + sqlite3_int64 iStartBlock; /* Rowid of first leaf block to traverse */ + sqlite3_int64 iLeafEndBlock; /* Rowid of final leaf block to traverse */ + sqlite3_int64 iEndBlock; /* Rowid of final block in segment (or 0) */ + sqlite3_int64 iCurrentBlock; /* Current leaf block (or 0) */ + + char *aNode; /* Pointer to node data (or NULL) */ + int nNode; /* Size of buffer at aNode (or 0) */ + int nPopulate; /* If >0, bytes of buffer aNode[] loaded */ + sqlite3_blob *pBlob; /* If not NULL, blob handle to read node */ + + Fts3HashElem **ppNextElem; + + /* Variables set by fts3SegReaderNext(). These may be read directly + ** by the caller. They are valid from the time SegmentReaderNew() returns + ** until SegmentReaderNext() returns something other than SQLITE_OK + ** (i.e. SQLITE_DONE). + */ + int nTerm; /* Number of bytes in current term */ + char *zTerm; /* Pointer to current term */ + int nTermAlloc; /* Allocated size of zTerm buffer */ + char *aDoclist; /* Pointer to doclist of current entry */ + int nDoclist; /* Size of doclist in current entry */ + + /* The following variables are used by fts3SegReaderNextDocid() to iterate + ** through the current doclist (aDoclist/nDoclist). + */ + char *pOffsetList; + int nOffsetList; /* For descending pending seg-readers only */ + sqlite3_int64 iDocid; +}; + +#define fts3SegReaderIsPending(p) ((p)->ppNextElem!=0) +#define fts3SegReaderIsRootOnly(p) ((p)->rootOnly!=0) + +/* +** An instance of this structure is used to create a segment b-tree in the +** database. The internal details of this type are only accessed by the +** following functions: +** +** fts3SegWriterAdd() +** fts3SegWriterFlush() +** fts3SegWriterFree() +*/ +struct SegmentWriter { + SegmentNode *pTree; /* Pointer to interior tree structure */ + sqlite3_int64 iFirst; /* First slot in %_segments written */ + sqlite3_int64 iFree; /* Next free slot in %_segments */ + char *zTerm; /* Pointer to previous term buffer */ + int nTerm; /* Number of bytes in zTerm */ + int nMalloc; /* Size of malloc'd buffer at zMalloc */ + char *zMalloc; /* Malloc'd space (possibly) used for zTerm */ + int nSize; /* Size of allocation at aData */ + int nData; /* Bytes of data in aData */ + char *aData; /* Pointer to block from malloc() */ + i64 nLeafData; /* Number of bytes of leaf data written */ +}; + +/* +** Type SegmentNode is used by the following three functions to create +** the interior part of the segment b+-tree structures (everything except +** the leaf nodes). These functions and type are only ever used by code +** within the fts3SegWriterXXX() family of functions described above. +** +** fts3NodeAddTerm() +** fts3NodeWrite() +** fts3NodeFree() +** +** When a b+tree is written to the database (either as a result of a merge +** or the pending-terms table being flushed), leaves are written into the +** database file as soon as they are completely populated. The interior of +** the tree is assembled in memory and written out only once all leaves have +** been populated and stored. This is Ok, as the b+-tree fanout is usually +** very large, meaning that the interior of the tree consumes relatively +** little memory. +*/ +struct SegmentNode { + SegmentNode *pParent; /* Parent node (or NULL for root node) */ + SegmentNode *pRight; /* Pointer to right-sibling */ + SegmentNode *pLeftmost; /* Pointer to left-most node of this depth */ + int nEntry; /* Number of terms written to node so far */ + char *zTerm; /* Pointer to previous term buffer */ + int nTerm; /* Number of bytes in zTerm */ + int nMalloc; /* Size of malloc'd buffer at zMalloc */ + char *zMalloc; /* Malloc'd space (possibly) used for zTerm */ + int nData; /* Bytes of valid data so far */ + char *aData; /* Node data */ +}; + +/* +** Valid values for the second argument to fts3SqlStmt(). +*/ +#define SQL_DELETE_CONTENT 0 +#define SQL_IS_EMPTY 1 +#define SQL_DELETE_ALL_CONTENT 2 +#define SQL_DELETE_ALL_SEGMENTS 3 +#define SQL_DELETE_ALL_SEGDIR 4 +#define SQL_DELETE_ALL_DOCSIZE 5 +#define SQL_DELETE_ALL_STAT 6 +#define SQL_SELECT_CONTENT_BY_ROWID 7 +#define SQL_NEXT_SEGMENT_INDEX 8 +#define SQL_INSERT_SEGMENTS 9 +#define SQL_NEXT_SEGMENTS_ID 10 +#define SQL_INSERT_SEGDIR 11 +#define SQL_SELECT_LEVEL 12 +#define SQL_SELECT_LEVEL_RANGE 13 +#define SQL_SELECT_LEVEL_COUNT 14 +#define SQL_SELECT_SEGDIR_MAX_LEVEL 15 +#define SQL_DELETE_SEGDIR_LEVEL 16 +#define SQL_DELETE_SEGMENTS_RANGE 17 +#define SQL_CONTENT_INSERT 18 +#define SQL_DELETE_DOCSIZE 19 +#define SQL_REPLACE_DOCSIZE 20 +#define SQL_SELECT_DOCSIZE 21 +#define SQL_SELECT_STAT 22 +#define SQL_REPLACE_STAT 23 + +#define SQL_SELECT_ALL_PREFIX_LEVEL 24 +#define SQL_DELETE_ALL_TERMS_SEGDIR 25 +#define SQL_DELETE_SEGDIR_RANGE 26 +#define SQL_SELECT_ALL_LANGID 27 +#define SQL_FIND_MERGE_LEVEL 28 +#define SQL_MAX_LEAF_NODE_ESTIMATE 29 +#define SQL_DELETE_SEGDIR_ENTRY 30 +#define SQL_SHIFT_SEGDIR_ENTRY 31 +#define SQL_SELECT_SEGDIR 32 +#define SQL_CHOMP_SEGDIR 33 +#define SQL_SEGMENT_IS_APPENDABLE 34 +#define SQL_SELECT_INDEXES 35 +#define SQL_SELECT_MXLEVEL 36 + +#define SQL_SELECT_LEVEL_RANGE2 37 +#define SQL_UPDATE_LEVEL_IDX 38 +#define SQL_UPDATE_LEVEL 39 + +/* +** This function is used to obtain an SQLite prepared statement handle +** for the statement identified by the second argument. If successful, +** *pp is set to the requested statement handle and SQLITE_OK returned. +** Otherwise, an SQLite error code is returned and *pp is set to 0. +** +** If argument apVal is not NULL, then it must point to an array with +** at least as many entries as the requested statement has bound +** parameters. The values are bound to the statements parameters before +** returning. +*/ +static int fts3SqlStmt( + Fts3Table *p, /* Virtual table handle */ + int eStmt, /* One of the SQL_XXX constants above */ + sqlite3_stmt **pp, /* OUT: Statement handle */ + sqlite3_value **apVal /* Values to bind to statement */ +){ + const char *azSql[] = { +/* 0 */ "DELETE FROM %Q.'%q_content' WHERE rowid = ?", +/* 1 */ "SELECT NOT EXISTS(SELECT docid FROM %Q.'%q_content' WHERE rowid!=?)", +/* 2 */ "DELETE FROM %Q.'%q_content'", +/* 3 */ "DELETE FROM %Q.'%q_segments'", +/* 4 */ "DELETE FROM %Q.'%q_segdir'", +/* 5 */ "DELETE FROM %Q.'%q_docsize'", +/* 6 */ "DELETE FROM %Q.'%q_stat'", +/* 7 */ "SELECT %s WHERE rowid=?", +/* 8 */ "SELECT (SELECT max(idx) FROM %Q.'%q_segdir' WHERE level = ?) + 1", +/* 9 */ "REPLACE INTO %Q.'%q_segments'(blockid, block) VALUES(?, ?)", +/* 10 */ "SELECT coalesce((SELECT max(blockid) FROM %Q.'%q_segments') + 1, 1)", +/* 11 */ "REPLACE INTO %Q.'%q_segdir' VALUES(?,?,?,?,?,?)", + + /* Return segments in order from oldest to newest.*/ +/* 12 */ "SELECT idx, start_block, leaves_end_block, end_block, root " + "FROM %Q.'%q_segdir' WHERE level = ? ORDER BY idx ASC", +/* 13 */ "SELECT idx, start_block, leaves_end_block, end_block, root " + "FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?" + "ORDER BY level DESC, idx ASC", + +/* 14 */ "SELECT count(*) FROM %Q.'%q_segdir' WHERE level = ?", +/* 15 */ "SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?", + +/* 16 */ "DELETE FROM %Q.'%q_segdir' WHERE level = ?", +/* 17 */ "DELETE FROM %Q.'%q_segments' WHERE blockid BETWEEN ? AND ?", +/* 18 */ "INSERT INTO %Q.'%q_content' VALUES(%s)", +/* 19 */ "DELETE FROM %Q.'%q_docsize' WHERE docid = ?", +/* 20 */ "REPLACE INTO %Q.'%q_docsize' VALUES(?,?)", +/* 21 */ "SELECT size FROM %Q.'%q_docsize' WHERE docid=?", +/* 22 */ "SELECT value FROM %Q.'%q_stat' WHERE id=?", +/* 23 */ "REPLACE INTO %Q.'%q_stat' VALUES(?,?)", +/* 24 */ "", +/* 25 */ "", + +/* 26 */ "DELETE FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?", +/* 27 */ "SELECT ? UNION SELECT level / (1024 * ?) FROM %Q.'%q_segdir'", + +/* This statement is used to determine which level to read the input from +** when performing an incremental merge. It returns the absolute level number +** of the oldest level in the db that contains at least ? segments. Or, +** if no level in the FTS index contains more than ? segments, the statement +** returns zero rows. */ +/* 28 */ "SELECT level FROM %Q.'%q_segdir' GROUP BY level HAVING count(*)>=?" + " ORDER BY (level %% 1024) ASC LIMIT 1", + +/* Estimate the upper limit on the number of leaf nodes in a new segment +** created by merging the oldest :2 segments from absolute level :1. See +** function sqlite3Fts3Incrmerge() for details. */ +/* 29 */ "SELECT 2 * total(1 + leaves_end_block - start_block) " + " FROM %Q.'%q_segdir' WHERE level = ? AND idx < ?", + +/* SQL_DELETE_SEGDIR_ENTRY +** Delete the %_segdir entry on absolute level :1 with index :2. */ +/* 30 */ "DELETE FROM %Q.'%q_segdir' WHERE level = ? AND idx = ?", + +/* SQL_SHIFT_SEGDIR_ENTRY +** Modify the idx value for the segment with idx=:3 on absolute level :2 +** to :1. */ +/* 31 */ "UPDATE %Q.'%q_segdir' SET idx = ? WHERE level=? AND idx=?", + +/* SQL_SELECT_SEGDIR +** Read a single entry from the %_segdir table. The entry from absolute +** level :1 with index value :2. */ +/* 32 */ "SELECT idx, start_block, leaves_end_block, end_block, root " + "FROM %Q.'%q_segdir' WHERE level = ? AND idx = ?", + +/* SQL_CHOMP_SEGDIR +** Update the start_block (:1) and root (:2) fields of the %_segdir +** entry located on absolute level :3 with index :4. */ +/* 33 */ "UPDATE %Q.'%q_segdir' SET start_block = ?, root = ?" + "WHERE level = ? AND idx = ?", + +/* SQL_SEGMENT_IS_APPENDABLE +** Return a single row if the segment with end_block=? is appendable. Or +** no rows otherwise. */ +/* 34 */ "SELECT 1 FROM %Q.'%q_segments' WHERE blockid=? AND block IS NULL", + +/* SQL_SELECT_INDEXES +** Return the list of valid segment indexes for absolute level ? */ +/* 35 */ "SELECT idx FROM %Q.'%q_segdir' WHERE level=? ORDER BY 1 ASC", + +/* SQL_SELECT_MXLEVEL +** Return the largest relative level in the FTS index or indexes. */ +/* 36 */ "SELECT max( level %% 1024 ) FROM %Q.'%q_segdir'", + + /* Return segments in order from oldest to newest.*/ +/* 37 */ "SELECT level, idx, end_block " + "FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ? " + "ORDER BY level DESC, idx ASC", + + /* Update statements used while promoting segments */ +/* 38 */ "UPDATE OR FAIL %Q.'%q_segdir' SET level=-1,idx=? " + "WHERE level=? AND idx=?", +/* 39 */ "UPDATE OR FAIL %Q.'%q_segdir' SET level=? WHERE level=-1" + + }; + int rc = SQLITE_OK; + sqlite3_stmt *pStmt; + + assert( SizeofArray(azSql)==SizeofArray(p->aStmt) ); + assert( eStmt=0 ); + + pStmt = p->aStmt[eStmt]; + if( !pStmt ){ + char *zSql; + if( eStmt==SQL_CONTENT_INSERT ){ + zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist); + }else if( eStmt==SQL_SELECT_CONTENT_BY_ROWID ){ + zSql = sqlite3_mprintf(azSql[eStmt], p->zReadExprlist); + }else{ + zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName); + } + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, NULL); + sqlite3_free(zSql); + assert( rc==SQLITE_OK || pStmt==0 ); + p->aStmt[eStmt] = pStmt; + } + } + if( apVal ){ + int i; + int nParam = sqlite3_bind_parameter_count(pStmt); + for(i=0; rc==SQLITE_OK && inPendingData==0 ){ + sqlite3_stmt *pStmt; + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_null(pStmt, 1); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + } + } + + return rc; +} + +/* +** FTS maintains a separate indexes for each language-id (a 32-bit integer). +** Within each language id, a separate index is maintained to store the +** document terms, and each configured prefix size (configured the FTS +** "prefix=" option). And each index consists of multiple levels ("relative +** levels"). +** +** All three of these values (the language id, the specific index and the +** level within the index) are encoded in 64-bit integer values stored +** in the %_segdir table on disk. This function is used to convert three +** separate component values into the single 64-bit integer value that +** can be used to query the %_segdir table. +** +** Specifically, each language-id/index combination is allocated 1024 +** 64-bit integer level values ("absolute levels"). The main terms index +** for language-id 0 is allocate values 0-1023. The first prefix index +** (if any) for language-id 0 is allocated values 1024-2047. And so on. +** Language 1 indexes are allocated immediately following language 0. +** +** So, for a system with nPrefix prefix indexes configured, the block of +** absolute levels that corresponds to language-id iLangid and index +** iIndex starts at absolute level ((iLangid * (nPrefix+1) + iIndex) * 1024). +*/ +static sqlite3_int64 getAbsoluteLevel( + Fts3Table *p, /* FTS3 table handle */ + int iLangid, /* Language id */ + int iIndex, /* Index in p->aIndex[] */ + int iLevel /* Level of segments */ +){ + sqlite3_int64 iBase; /* First absolute level for iLangid/iIndex */ + assert( iLangid>=0 ); + assert( p->nIndex>0 ); + assert( iIndex>=0 && iIndexnIndex ); + + iBase = ((sqlite3_int64)iLangid * p->nIndex + iIndex) * FTS3_SEGDIR_MAXLEVEL; + return iBase + iLevel; +} + +/* +** Set *ppStmt to a statement handle that may be used to iterate through +** all rows in the %_segdir table, from oldest to newest. If successful, +** return SQLITE_OK. If an error occurs while preparing the statement, +** return an SQLite error code. +** +** There is only ever one instance of this SQL statement compiled for +** each FTS3 table. +** +** The statement returns the following columns from the %_segdir table: +** +** 0: idx +** 1: start_block +** 2: leaves_end_block +** 3: end_block +** 4: root +*/ +SQLITE_PRIVATE int sqlite3Fts3AllSegdirs( + Fts3Table *p, /* FTS3 table */ + int iLangid, /* Language being queried */ + int iIndex, /* Index for p->aIndex[] */ + int iLevel, /* Level to select (relative level) */ + sqlite3_stmt **ppStmt /* OUT: Compiled statement */ +){ + int rc; + sqlite3_stmt *pStmt = 0; + + assert( iLevel==FTS3_SEGCURSOR_ALL || iLevel>=0 ); + assert( iLevel=0 && iIndexnIndex ); + + if( iLevel<0 ){ + /* "SELECT * FROM %_segdir WHERE level BETWEEN ? AND ? ORDER BY ..." */ + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0)); + sqlite3_bind_int64(pStmt, 2, + getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1) + ); + } + }else{ + /* "SELECT * FROM %_segdir WHERE level = ? ORDER BY ..." */ + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex,iLevel)); + } + } + *ppStmt = pStmt; + return rc; +} + + +/* +** Append a single varint to a PendingList buffer. SQLITE_OK is returned +** if successful, or an SQLite error code otherwise. +** +** This function also serves to allocate the PendingList structure itself. +** For example, to create a new PendingList structure containing two +** varints: +** +** PendingList *p = 0; +** fts3PendingListAppendVarint(&p, 1); +** fts3PendingListAppendVarint(&p, 2); +*/ +static int fts3PendingListAppendVarint( + PendingList **pp, /* IN/OUT: Pointer to PendingList struct */ + sqlite3_int64 i /* Value to append to data */ +){ + PendingList *p = *pp; + + /* Allocate or grow the PendingList as required. */ + if( !p ){ + p = sqlite3_malloc(sizeof(*p) + 100); + if( !p ){ + return SQLITE_NOMEM; + } + p->nSpace = 100; + p->aData = (char *)&p[1]; + p->nData = 0; + } + else if( p->nData+FTS3_VARINT_MAX+1>p->nSpace ){ + int nNew = p->nSpace * 2; + p = sqlite3_realloc(p, sizeof(*p) + nNew); + if( !p ){ + sqlite3_free(*pp); + *pp = 0; + return SQLITE_NOMEM; + } + p->nSpace = nNew; + p->aData = (char *)&p[1]; + } + + /* Append the new serialized varint to the end of the list. */ + p->nData += sqlite3Fts3PutVarint(&p->aData[p->nData], i); + p->aData[p->nData] = '\0'; + *pp = p; + return SQLITE_OK; +} + +/* +** Add a docid/column/position entry to a PendingList structure. Non-zero +** is returned if the structure is sqlite3_realloced as part of adding +** the entry. Otherwise, zero. +** +** If an OOM error occurs, *pRc is set to SQLITE_NOMEM before returning. +** Zero is always returned in this case. Otherwise, if no OOM error occurs, +** it is set to SQLITE_OK. +*/ +static int fts3PendingListAppend( + PendingList **pp, /* IN/OUT: PendingList structure */ + sqlite3_int64 iDocid, /* Docid for entry to add */ + sqlite3_int64 iCol, /* Column for entry to add */ + sqlite3_int64 iPos, /* Position of term for entry to add */ + int *pRc /* OUT: Return code */ +){ + PendingList *p = *pp; + int rc = SQLITE_OK; + + assert( !p || p->iLastDocid<=iDocid ); + + if( !p || p->iLastDocid!=iDocid ){ + sqlite3_int64 iDelta = iDocid - (p ? p->iLastDocid : 0); + if( p ){ + assert( p->nDatanSpace ); + assert( p->aData[p->nData]==0 ); + p->nData++; + } + if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){ + goto pendinglistappend_out; + } + p->iLastCol = -1; + p->iLastPos = 0; + p->iLastDocid = iDocid; + } + if( iCol>0 && p->iLastCol!=iCol ){ + if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, 1)) + || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol)) + ){ + goto pendinglistappend_out; + } + p->iLastCol = iCol; + p->iLastPos = 0; + } + if( iCol>=0 ){ + assert( iPos>p->iLastPos || (iPos==0 && p->iLastPos==0) ); + rc = fts3PendingListAppendVarint(&p, 2+iPos-p->iLastPos); + if( rc==SQLITE_OK ){ + p->iLastPos = iPos; + } + } + + pendinglistappend_out: + *pRc = rc; + if( p!=*pp ){ + *pp = p; + return 1; + } + return 0; +} + +/* +** Free a PendingList object allocated by fts3PendingListAppend(). +*/ +static void fts3PendingListDelete(PendingList *pList){ + sqlite3_free(pList); +} + +/* +** Add an entry to one of the pending-terms hash tables. +*/ +static int fts3PendingTermsAddOne( + Fts3Table *p, + int iCol, + int iPos, + Fts3Hash *pHash, /* Pending terms hash table to add entry to */ + const char *zToken, + int nToken +){ + PendingList *pList; + int rc = SQLITE_OK; + + pList = (PendingList *)fts3HashFind(pHash, zToken, nToken); + if( pList ){ + p->nPendingData -= (pList->nData + nToken + sizeof(Fts3HashElem)); + } + if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){ + if( pList==fts3HashInsert(pHash, zToken, nToken, pList) ){ + /* Malloc failed while inserting the new entry. This can only + ** happen if there was no previous entry for this token. + */ + assert( 0==fts3HashFind(pHash, zToken, nToken) ); + sqlite3_free(pList); + rc = SQLITE_NOMEM; + } + } + if( rc==SQLITE_OK ){ + p->nPendingData += (pList->nData + nToken + sizeof(Fts3HashElem)); + } + return rc; +} + +/* +** Tokenize the nul-terminated string zText and add all tokens to the +** pending-terms hash-table. The docid used is that currently stored in +** p->iPrevDocid, and the column is specified by argument iCol. +** +** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code. +*/ +static int fts3PendingTermsAdd( + Fts3Table *p, /* Table into which text will be inserted */ + int iLangid, /* Language id to use */ + const char *zText, /* Text of document to be inserted */ + int iCol, /* Column into which text is being inserted */ + u32 *pnWord /* IN/OUT: Incr. by number tokens inserted */ +){ + int rc; + int iStart = 0; + int iEnd = 0; + int iPos = 0; + int nWord = 0; + + char const *zToken; + int nToken = 0; + + sqlite3_tokenizer *pTokenizer = p->pTokenizer; + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + sqlite3_tokenizer_cursor *pCsr; + int (*xNext)(sqlite3_tokenizer_cursor *pCursor, + const char**,int*,int*,int*,int*); + + assert( pTokenizer && pModule ); + + /* If the user has inserted a NULL value, this function may be called with + ** zText==0. In this case, add zero token entries to the hash table and + ** return early. */ + if( zText==0 ){ + *pnWord = 0; + return SQLITE_OK; + } + + rc = sqlite3Fts3OpenTokenizer(pTokenizer, iLangid, zText, -1, &pCsr); + if( rc!=SQLITE_OK ){ + return rc; + } + + xNext = pModule->xNext; + while( SQLITE_OK==rc + && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos)) + ){ + int i; + if( iPos>=nWord ) nWord = iPos+1; + + /* Positions cannot be negative; we use -1 as a terminator internally. + ** Tokens must have a non-zero length. + */ + if( iPos<0 || !zToken || nToken<=0 ){ + rc = SQLITE_ERROR; + break; + } + + /* Add the term to the terms index */ + rc = fts3PendingTermsAddOne( + p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken + ); + + /* Add the term to each of the prefix indexes that it is not too + ** short for. */ + for(i=1; rc==SQLITE_OK && inIndex; i++){ + struct Fts3Index *pIndex = &p->aIndex[i]; + if( nTokennPrefix ) continue; + rc = fts3PendingTermsAddOne( + p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix + ); + } + } + + pModule->xClose(pCsr); + *pnWord += nWord; + return (rc==SQLITE_DONE ? SQLITE_OK : rc); +} + +/* +** Calling this function indicates that subsequent calls to +** fts3PendingTermsAdd() are to add term/position-list pairs for the +** contents of the document with docid iDocid. +*/ +static int fts3PendingTermsDocid( + Fts3Table *p, /* Full-text table handle */ + int bDelete, /* True if this op is a delete */ + int iLangid, /* Language id of row being written */ + sqlite_int64 iDocid /* Docid of row being written */ +){ + assert( iLangid>=0 ); + assert( bDelete==1 || bDelete==0 ); + + /* TODO(shess) Explore whether partially flushing the buffer on + ** forced-flush would provide better performance. I suspect that if + ** we ordered the doclists by size and flushed the largest until the + ** buffer was half empty, that would let the less frequent terms + ** generate longer doclists. + */ + if( iDocidiPrevDocid + || (iDocid==p->iPrevDocid && p->bPrevDelete==0) + || p->iPrevLangid!=iLangid + || p->nPendingData>p->nMaxPendingData + ){ + int rc = sqlite3Fts3PendingTermsFlush(p); + if( rc!=SQLITE_OK ) return rc; + } + p->iPrevDocid = iDocid; + p->iPrevLangid = iLangid; + p->bPrevDelete = bDelete; + return SQLITE_OK; +} + +/* +** Discard the contents of the pending-terms hash tables. +*/ +SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *p){ + int i; + for(i=0; inIndex; i++){ + Fts3HashElem *pElem; + Fts3Hash *pHash = &p->aIndex[i].hPending; + for(pElem=fts3HashFirst(pHash); pElem; pElem=fts3HashNext(pElem)){ + PendingList *pList = (PendingList *)fts3HashData(pElem); + fts3PendingListDelete(pList); + } + fts3HashClear(pHash); + } + p->nPendingData = 0; +} + +/* +** This function is called by the xUpdate() method as part of an INSERT +** operation. It adds entries for each term in the new record to the +** pendingTerms hash table. +** +** Argument apVal is the same as the similarly named argument passed to +** fts3InsertData(). Parameter iDocid is the docid of the new row. +*/ +static int fts3InsertTerms( + Fts3Table *p, + int iLangid, + sqlite3_value **apVal, + u32 *aSz +){ + int i; /* Iterator variable */ + for(i=2; inColumn+2; i++){ + int iCol = i-2; + if( p->abNotindexed[iCol]==0 ){ + const char *zText = (const char *)sqlite3_value_text(apVal[i]); + int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]); + if( rc!=SQLITE_OK ){ + return rc; + } + aSz[p->nColumn] += sqlite3_value_bytes(apVal[i]); + } + } + return SQLITE_OK; +} + +/* +** This function is called by the xUpdate() method for an INSERT operation. +** The apVal parameter is passed a copy of the apVal argument passed by +** SQLite to the xUpdate() method. i.e: +** +** apVal[0] Not used for INSERT. +** apVal[1] rowid +** apVal[2] Left-most user-defined column +** ... +** apVal[p->nColumn+1] Right-most user-defined column +** apVal[p->nColumn+2] Hidden column with same name as table +** apVal[p->nColumn+3] Hidden "docid" column (alias for rowid) +** apVal[p->nColumn+4] Hidden languageid column +*/ +static int fts3InsertData( + Fts3Table *p, /* Full-text table */ + sqlite3_value **apVal, /* Array of values to insert */ + sqlite3_int64 *piDocid /* OUT: Docid for row just inserted */ +){ + int rc; /* Return code */ + sqlite3_stmt *pContentInsert; /* INSERT INTO %_content VALUES(...) */ + + if( p->zContentTbl ){ + sqlite3_value *pRowid = apVal[p->nColumn+3]; + if( sqlite3_value_type(pRowid)==SQLITE_NULL ){ + pRowid = apVal[1]; + } + if( sqlite3_value_type(pRowid)!=SQLITE_INTEGER ){ + return SQLITE_CONSTRAINT; + } + *piDocid = sqlite3_value_int64(pRowid); + return SQLITE_OK; + } + + /* Locate the statement handle used to insert data into the %_content + ** table. The SQL for this statement is: + ** + ** INSERT INTO %_content VALUES(?, ?, ?, ...) + ** + ** The statement features N '?' variables, where N is the number of user + ** defined columns in the FTS3 table, plus one for the docid field. + */ + rc = fts3SqlStmt(p, SQL_CONTENT_INSERT, &pContentInsert, &apVal[1]); + if( rc==SQLITE_OK && p->zLanguageid ){ + rc = sqlite3_bind_int( + pContentInsert, p->nColumn+2, + sqlite3_value_int(apVal[p->nColumn+4]) + ); + } + if( rc!=SQLITE_OK ) return rc; + + /* There is a quirk here. The users INSERT statement may have specified + ** a value for the "rowid" field, for the "docid" field, or for both. + ** Which is a problem, since "rowid" and "docid" are aliases for the + ** same value. For example: + ** + ** INSERT INTO fts3tbl(rowid, docid) VALUES(1, 2); + ** + ** In FTS3, this is an error. It is an error to specify non-NULL values + ** for both docid and some other rowid alias. + */ + if( SQLITE_NULL!=sqlite3_value_type(apVal[3+p->nColumn]) ){ + if( SQLITE_NULL==sqlite3_value_type(apVal[0]) + && SQLITE_NULL!=sqlite3_value_type(apVal[1]) + ){ + /* A rowid/docid conflict. */ + return SQLITE_ERROR; + } + rc = sqlite3_bind_value(pContentInsert, 1, apVal[3+p->nColumn]); + if( rc!=SQLITE_OK ) return rc; + } + + /* Execute the statement to insert the record. Set *piDocid to the + ** new docid value. + */ + sqlite3_step(pContentInsert); + rc = sqlite3_reset(pContentInsert); + + *piDocid = sqlite3_last_insert_rowid(p->db); + return rc; +} + + + +/* +** Remove all data from the FTS3 table. Clear the hash table containing +** pending terms. +*/ +static int fts3DeleteAll(Fts3Table *p, int bContent){ + int rc = SQLITE_OK; /* Return code */ + + /* Discard the contents of the pending-terms hash table. */ + sqlite3Fts3PendingTermsClear(p); + + /* Delete everything from the shadow tables. Except, leave %_content as + ** is if bContent is false. */ + assert( p->zContentTbl==0 || bContent==0 ); + if( bContent ) fts3SqlExec(&rc, p, SQL_DELETE_ALL_CONTENT, 0); + fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGMENTS, 0); + fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGDIR, 0); + if( p->bHasDocsize ){ + fts3SqlExec(&rc, p, SQL_DELETE_ALL_DOCSIZE, 0); + } + if( p->bHasStat ){ + fts3SqlExec(&rc, p, SQL_DELETE_ALL_STAT, 0); + } + return rc; +} + +/* +** +*/ +static int langidFromSelect(Fts3Table *p, sqlite3_stmt *pSelect){ + int iLangid = 0; + if( p->zLanguageid ) iLangid = sqlite3_column_int(pSelect, p->nColumn+1); + return iLangid; +} + +/* +** The first element in the apVal[] array is assumed to contain the docid +** (an integer) of a row about to be deleted. Remove all terms from the +** full-text index. +*/ +static void fts3DeleteTerms( + int *pRC, /* Result code */ + Fts3Table *p, /* The FTS table to delete from */ + sqlite3_value *pRowid, /* The docid to be deleted */ + u32 *aSz, /* Sizes of deleted document written here */ + int *pbFound /* OUT: Set to true if row really does exist */ +){ + int rc; + sqlite3_stmt *pSelect; + + assert( *pbFound==0 ); + if( *pRC ) return; + rc = fts3SqlStmt(p, SQL_SELECT_CONTENT_BY_ROWID, &pSelect, &pRowid); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pSelect) ){ + int i; + int iLangid = langidFromSelect(p, pSelect); + i64 iDocid = sqlite3_column_int64(pSelect, 0); + rc = fts3PendingTermsDocid(p, 1, iLangid, iDocid); + for(i=1; rc==SQLITE_OK && i<=p->nColumn; i++){ + int iCol = i-1; + if( p->abNotindexed[iCol]==0 ){ + const char *zText = (const char *)sqlite3_column_text(pSelect, i); + rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]); + aSz[p->nColumn] += sqlite3_column_bytes(pSelect, i); + } + } + if( rc!=SQLITE_OK ){ + sqlite3_reset(pSelect); + *pRC = rc; + return; + } + *pbFound = 1; + } + rc = sqlite3_reset(pSelect); + }else{ + sqlite3_reset(pSelect); + } + *pRC = rc; +} + +/* +** Forward declaration to account for the circular dependency between +** functions fts3SegmentMerge() and fts3AllocateSegdirIdx(). +*/ +static int fts3SegmentMerge(Fts3Table *, int, int, int); + +/* +** This function allocates a new level iLevel index in the segdir table. +** Usually, indexes are allocated within a level sequentially starting +** with 0, so the allocated index is one greater than the value returned +** by: +** +** SELECT max(idx) FROM %_segdir WHERE level = :iLevel +** +** However, if there are already FTS3_MERGE_COUNT indexes at the requested +** level, they are merged into a single level (iLevel+1) segment and the +** allocated index is 0. +** +** If successful, *piIdx is set to the allocated index slot and SQLITE_OK +** returned. Otherwise, an SQLite error code is returned. +*/ +static int fts3AllocateSegdirIdx( + Fts3Table *p, + int iLangid, /* Language id */ + int iIndex, /* Index for p->aIndex */ + int iLevel, + int *piIdx +){ + int rc; /* Return Code */ + sqlite3_stmt *pNextIdx; /* Query for next idx at level iLevel */ + int iNext = 0; /* Result of query pNextIdx */ + + assert( iLangid>=0 ); + assert( p->nIndex>=1 ); + + /* Set variable iNext to the next available segdir index at level iLevel. */ + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENT_INDEX, &pNextIdx, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64( + pNextIdx, 1, getAbsoluteLevel(p, iLangid, iIndex, iLevel) + ); + if( SQLITE_ROW==sqlite3_step(pNextIdx) ){ + iNext = sqlite3_column_int(pNextIdx, 0); + } + rc = sqlite3_reset(pNextIdx); + } + + if( rc==SQLITE_OK ){ + /* If iNext is FTS3_MERGE_COUNT, indicating that level iLevel is already + ** full, merge all segments in level iLevel into a single iLevel+1 + ** segment and allocate (newly freed) index 0 at level iLevel. Otherwise, + ** if iNext is less than FTS3_MERGE_COUNT, allocate index iNext. + */ + if( iNext>=FTS3_MERGE_COUNT ){ + fts3LogMerge(16, getAbsoluteLevel(p, iLangid, iIndex, iLevel)); + rc = fts3SegmentMerge(p, iLangid, iIndex, iLevel); + *piIdx = 0; + }else{ + *piIdx = iNext; + } + } + + return rc; +} + +/* +** The %_segments table is declared as follows: +** +** CREATE TABLE %_segments(blockid INTEGER PRIMARY KEY, block BLOB) +** +** This function reads data from a single row of the %_segments table. The +** specific row is identified by the iBlockid parameter. If paBlob is not +** NULL, then a buffer is allocated using sqlite3_malloc() and populated +** with the contents of the blob stored in the "block" column of the +** identified table row is. Whether or not paBlob is NULL, *pnBlob is set +** to the size of the blob in bytes before returning. +** +** If an error occurs, or the table does not contain the specified row, +** an SQLite error code is returned. Otherwise, SQLITE_OK is returned. If +** paBlob is non-NULL, then it is the responsibility of the caller to +** eventually free the returned buffer. +** +** This function may leave an open sqlite3_blob* handle in the +** Fts3Table.pSegments variable. This handle is reused by subsequent calls +** to this function. The handle may be closed by calling the +** sqlite3Fts3SegmentsClose() function. Reusing a blob handle is a handy +** performance improvement, but the blob handle should always be closed +** before control is returned to the user (to prevent a lock being held +** on the database file for longer than necessary). Thus, any virtual table +** method (xFilter etc.) that may directly or indirectly call this function +** must call sqlite3Fts3SegmentsClose() before returning. +*/ +SQLITE_PRIVATE int sqlite3Fts3ReadBlock( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iBlockid, /* Access the row with blockid=$iBlockid */ + char **paBlob, /* OUT: Blob data in malloc'd buffer */ + int *pnBlob, /* OUT: Size of blob data */ + int *pnLoad /* OUT: Bytes actually loaded */ +){ + int rc; /* Return code */ + + /* pnBlob must be non-NULL. paBlob may be NULL or non-NULL. */ + assert( pnBlob ); + + if( p->pSegments ){ + rc = sqlite3_blob_reopen(p->pSegments, iBlockid); + }else{ + if( 0==p->zSegmentsTbl ){ + p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName); + if( 0==p->zSegmentsTbl ) return SQLITE_NOMEM; + } + rc = sqlite3_blob_open( + p->db, p->zDb, p->zSegmentsTbl, "block", iBlockid, 0, &p->pSegments + ); + } + + if( rc==SQLITE_OK ){ + int nByte = sqlite3_blob_bytes(p->pSegments); + *pnBlob = nByte; + if( paBlob ){ + char *aByte = sqlite3_malloc(nByte + FTS3_NODE_PADDING); + if( !aByte ){ + rc = SQLITE_NOMEM; + }else{ + if( pnLoad && nByte>(FTS3_NODE_CHUNK_THRESHOLD) ){ + nByte = FTS3_NODE_CHUNKSIZE; + *pnLoad = nByte; + } + rc = sqlite3_blob_read(p->pSegments, aByte, nByte, 0); + memset(&aByte[nByte], 0, FTS3_NODE_PADDING); + if( rc!=SQLITE_OK ){ + sqlite3_free(aByte); + aByte = 0; + } + } + *paBlob = aByte; + } + } + + return rc; +} + +/* +** Close the blob handle at p->pSegments, if it is open. See comments above +** the sqlite3Fts3ReadBlock() function for details. +*/ +SQLITE_PRIVATE void sqlite3Fts3SegmentsClose(Fts3Table *p){ + sqlite3_blob_close(p->pSegments); + p->pSegments = 0; +} + +static int fts3SegReaderIncrRead(Fts3SegReader *pReader){ + int nRead; /* Number of bytes to read */ + int rc; /* Return code */ + + nRead = MIN(pReader->nNode - pReader->nPopulate, FTS3_NODE_CHUNKSIZE); + rc = sqlite3_blob_read( + pReader->pBlob, + &pReader->aNode[pReader->nPopulate], + nRead, + pReader->nPopulate + ); + + if( rc==SQLITE_OK ){ + pReader->nPopulate += nRead; + memset(&pReader->aNode[pReader->nPopulate], 0, FTS3_NODE_PADDING); + if( pReader->nPopulate==pReader->nNode ){ + sqlite3_blob_close(pReader->pBlob); + pReader->pBlob = 0; + pReader->nPopulate = 0; + } + } + return rc; +} + +static int fts3SegReaderRequire(Fts3SegReader *pReader, char *pFrom, int nByte){ + int rc = SQLITE_OK; + assert( !pReader->pBlob + || (pFrom>=pReader->aNode && pFrom<&pReader->aNode[pReader->nNode]) + ); + while( pReader->pBlob && rc==SQLITE_OK + && (pFrom - pReader->aNode + nByte)>pReader->nPopulate + ){ + rc = fts3SegReaderIncrRead(pReader); + } + return rc; +} + +/* +** Set an Fts3SegReader cursor to point at EOF. +*/ +static void fts3SegReaderSetEof(Fts3SegReader *pSeg){ + if( !fts3SegReaderIsRootOnly(pSeg) ){ + sqlite3_free(pSeg->aNode); + sqlite3_blob_close(pSeg->pBlob); + pSeg->pBlob = 0; + } + pSeg->aNode = 0; +} + +/* +** Move the iterator passed as the first argument to the next term in the +** segment. If successful, SQLITE_OK is returned. If there is no next term, +** SQLITE_DONE. Otherwise, an SQLite error code. +*/ +static int fts3SegReaderNext( + Fts3Table *p, + Fts3SegReader *pReader, + int bIncr +){ + int rc; /* Return code of various sub-routines */ + char *pNext; /* Cursor variable */ + int nPrefix; /* Number of bytes in term prefix */ + int nSuffix; /* Number of bytes in term suffix */ + + if( !pReader->aDoclist ){ + pNext = pReader->aNode; + }else{ + pNext = &pReader->aDoclist[pReader->nDoclist]; + } + + if( !pNext || pNext>=&pReader->aNode[pReader->nNode] ){ + + if( fts3SegReaderIsPending(pReader) ){ + Fts3HashElem *pElem = *(pReader->ppNextElem); + sqlite3_free(pReader->aNode); + pReader->aNode = 0; + if( pElem ){ + char *aCopy; + PendingList *pList = (PendingList *)fts3HashData(pElem); + int nCopy = pList->nData+1; + pReader->zTerm = (char *)fts3HashKey(pElem); + pReader->nTerm = fts3HashKeysize(pElem); + aCopy = (char*)sqlite3_malloc(nCopy); + if( !aCopy ) return SQLITE_NOMEM; + memcpy(aCopy, pList->aData, nCopy); + pReader->nNode = pReader->nDoclist = nCopy; + pReader->aNode = pReader->aDoclist = aCopy; + pReader->ppNextElem++; + assert( pReader->aNode ); + } + return SQLITE_OK; + } + + fts3SegReaderSetEof(pReader); + + /* If iCurrentBlock>=iLeafEndBlock, this is an EOF condition. All leaf + ** blocks have already been traversed. */ + assert( pReader->iCurrentBlock<=pReader->iLeafEndBlock ); + if( pReader->iCurrentBlock>=pReader->iLeafEndBlock ){ + return SQLITE_OK; + } + + rc = sqlite3Fts3ReadBlock( + p, ++pReader->iCurrentBlock, &pReader->aNode, &pReader->nNode, + (bIncr ? &pReader->nPopulate : 0) + ); + if( rc!=SQLITE_OK ) return rc; + assert( pReader->pBlob==0 ); + if( bIncr && pReader->nPopulatenNode ){ + pReader->pBlob = p->pSegments; + p->pSegments = 0; + } + pNext = pReader->aNode; + } + + assert( !fts3SegReaderIsPending(pReader) ); + + rc = fts3SegReaderRequire(pReader, pNext, FTS3_VARINT_MAX*2); + if( rc!=SQLITE_OK ) return rc; + + /* Because of the FTS3_NODE_PADDING bytes of padding, the following is + ** safe (no risk of overread) even if the node data is corrupted. */ + pNext += fts3GetVarint32(pNext, &nPrefix); + pNext += fts3GetVarint32(pNext, &nSuffix); + if( nPrefix<0 || nSuffix<=0 + || &pNext[nSuffix]>&pReader->aNode[pReader->nNode] + ){ + return FTS_CORRUPT_VTAB; + } + + if( nPrefix+nSuffix>pReader->nTermAlloc ){ + int nNew = (nPrefix+nSuffix)*2; + char *zNew = sqlite3_realloc(pReader->zTerm, nNew); + if( !zNew ){ + return SQLITE_NOMEM; + } + pReader->zTerm = zNew; + pReader->nTermAlloc = nNew; + } + + rc = fts3SegReaderRequire(pReader, pNext, nSuffix+FTS3_VARINT_MAX); + if( rc!=SQLITE_OK ) return rc; + + memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix); + pReader->nTerm = nPrefix+nSuffix; + pNext += nSuffix; + pNext += fts3GetVarint32(pNext, &pReader->nDoclist); + pReader->aDoclist = pNext; + pReader->pOffsetList = 0; + + /* Check that the doclist does not appear to extend past the end of the + ** b-tree node. And that the final byte of the doclist is 0x00. If either + ** of these statements is untrue, then the data structure is corrupt. + */ + if( &pReader->aDoclist[pReader->nDoclist]>&pReader->aNode[pReader->nNode] + || (pReader->nPopulate==0 && pReader->aDoclist[pReader->nDoclist-1]) + ){ + return FTS_CORRUPT_VTAB; + } + return SQLITE_OK; +} + +/* +** Set the SegReader to point to the first docid in the doclist associated +** with the current term. +*/ +static int fts3SegReaderFirstDocid(Fts3Table *pTab, Fts3SegReader *pReader){ + int rc = SQLITE_OK; + assert( pReader->aDoclist ); + assert( !pReader->pOffsetList ); + if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){ + u8 bEof = 0; + pReader->iDocid = 0; + pReader->nOffsetList = 0; + sqlite3Fts3DoclistPrev(0, + pReader->aDoclist, pReader->nDoclist, &pReader->pOffsetList, + &pReader->iDocid, &pReader->nOffsetList, &bEof + ); + }else{ + rc = fts3SegReaderRequire(pReader, pReader->aDoclist, FTS3_VARINT_MAX); + if( rc==SQLITE_OK ){ + int n = sqlite3Fts3GetVarint(pReader->aDoclist, &pReader->iDocid); + pReader->pOffsetList = &pReader->aDoclist[n]; + } + } + return rc; +} + +/* +** Advance the SegReader to point to the next docid in the doclist +** associated with the current term. +** +** If arguments ppOffsetList and pnOffsetList are not NULL, then +** *ppOffsetList is set to point to the first column-offset list +** in the doclist entry (i.e. immediately past the docid varint). +** *pnOffsetList is set to the length of the set of column-offset +** lists, not including the nul-terminator byte. For example: +*/ +static int fts3SegReaderNextDocid( + Fts3Table *pTab, + Fts3SegReader *pReader, /* Reader to advance to next docid */ + char **ppOffsetList, /* OUT: Pointer to current position-list */ + int *pnOffsetList /* OUT: Length of *ppOffsetList in bytes */ +){ + int rc = SQLITE_OK; + char *p = pReader->pOffsetList; + char c = 0; + + assert( p ); + + if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){ + /* A pending-terms seg-reader for an FTS4 table that uses order=desc. + ** Pending-terms doclists are always built up in ascending order, so + ** we have to iterate through them backwards here. */ + u8 bEof = 0; + if( ppOffsetList ){ + *ppOffsetList = pReader->pOffsetList; + *pnOffsetList = pReader->nOffsetList - 1; + } + sqlite3Fts3DoclistPrev(0, + pReader->aDoclist, pReader->nDoclist, &p, &pReader->iDocid, + &pReader->nOffsetList, &bEof + ); + if( bEof ){ + pReader->pOffsetList = 0; + }else{ + pReader->pOffsetList = p; + } + }else{ + char *pEnd = &pReader->aDoclist[pReader->nDoclist]; + + /* Pointer p currently points at the first byte of an offset list. The + ** following block advances it to point one byte past the end of + ** the same offset list. */ + while( 1 ){ + + /* The following line of code (and the "p++" below the while() loop) is + ** normally all that is required to move pointer p to the desired + ** position. The exception is if this node is being loaded from disk + ** incrementally and pointer "p" now points to the first byte past + ** the populated part of pReader->aNode[]. + */ + while( *p | c ) c = *p++ & 0x80; + assert( *p==0 ); + + if( pReader->pBlob==0 || p<&pReader->aNode[pReader->nPopulate] ) break; + rc = fts3SegReaderIncrRead(pReader); + if( rc!=SQLITE_OK ) return rc; + } + p++; + + /* If required, populate the output variables with a pointer to and the + ** size of the previous offset-list. + */ + if( ppOffsetList ){ + *ppOffsetList = pReader->pOffsetList; + *pnOffsetList = (int)(p - pReader->pOffsetList - 1); + } + + /* List may have been edited in place by fts3EvalNearTrim() */ + while( p=pEnd ){ + pReader->pOffsetList = 0; + }else{ + rc = fts3SegReaderRequire(pReader, p, FTS3_VARINT_MAX); + if( rc==SQLITE_OK ){ + sqlite3_int64 iDelta; + pReader->pOffsetList = p + sqlite3Fts3GetVarint(p, &iDelta); + if( pTab->bDescIdx ){ + pReader->iDocid -= iDelta; + }else{ + pReader->iDocid += iDelta; + } + } + } + } + + return SQLITE_OK; +} + + +SQLITE_PRIVATE int sqlite3Fts3MsrOvfl( + Fts3Cursor *pCsr, + Fts3MultiSegReader *pMsr, + int *pnOvfl +){ + Fts3Table *p = (Fts3Table*)pCsr->base.pVtab; + int nOvfl = 0; + int ii; + int rc = SQLITE_OK; + int pgsz = p->nPgsz; + + assert( p->bFts4 ); + assert( pgsz>0 ); + + for(ii=0; rc==SQLITE_OK && iinSegment; ii++){ + Fts3SegReader *pReader = pMsr->apSegment[ii]; + if( !fts3SegReaderIsPending(pReader) + && !fts3SegReaderIsRootOnly(pReader) + ){ + sqlite3_int64 jj; + for(jj=pReader->iStartBlock; jj<=pReader->iLeafEndBlock; jj++){ + int nBlob; + rc = sqlite3Fts3ReadBlock(p, jj, 0, &nBlob, 0); + if( rc!=SQLITE_OK ) break; + if( (nBlob+35)>pgsz ){ + nOvfl += (nBlob + 34)/pgsz; + } + } + } + } + *pnOvfl = nOvfl; + return rc; +} + +/* +** Free all allocations associated with the iterator passed as the +** second argument. +*/ +SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3SegReader *pReader){ + if( pReader ){ + if( !fts3SegReaderIsPending(pReader) ){ + sqlite3_free(pReader->zTerm); + } + if( !fts3SegReaderIsRootOnly(pReader) ){ + sqlite3_free(pReader->aNode); + } + sqlite3_blob_close(pReader->pBlob); + } + sqlite3_free(pReader); +} + +/* +** Allocate a new SegReader object. +*/ +SQLITE_PRIVATE int sqlite3Fts3SegReaderNew( + int iAge, /* Segment "age". */ + int bLookup, /* True for a lookup only */ + sqlite3_int64 iStartLeaf, /* First leaf to traverse */ + sqlite3_int64 iEndLeaf, /* Final leaf to traverse */ + sqlite3_int64 iEndBlock, /* Final block of segment */ + const char *zRoot, /* Buffer containing root node */ + int nRoot, /* Size of buffer containing root node */ + Fts3SegReader **ppReader /* OUT: Allocated Fts3SegReader */ +){ + Fts3SegReader *pReader; /* Newly allocated SegReader object */ + int nExtra = 0; /* Bytes to allocate segment root node */ + + assert( iStartLeaf<=iEndLeaf ); + if( iStartLeaf==0 ){ + nExtra = nRoot + FTS3_NODE_PADDING; + } + + pReader = (Fts3SegReader *)sqlite3_malloc(sizeof(Fts3SegReader) + nExtra); + if( !pReader ){ + return SQLITE_NOMEM; + } + memset(pReader, 0, sizeof(Fts3SegReader)); + pReader->iIdx = iAge; + pReader->bLookup = bLookup!=0; + pReader->iStartBlock = iStartLeaf; + pReader->iLeafEndBlock = iEndLeaf; + pReader->iEndBlock = iEndBlock; + + if( nExtra ){ + /* The entire segment is stored in the root node. */ + pReader->aNode = (char *)&pReader[1]; + pReader->rootOnly = 1; + pReader->nNode = nRoot; + memcpy(pReader->aNode, zRoot, nRoot); + memset(&pReader->aNode[nRoot], 0, FTS3_NODE_PADDING); + }else{ + pReader->iCurrentBlock = iStartLeaf-1; + } + *ppReader = pReader; + return SQLITE_OK; +} + +/* +** This is a comparison function used as a qsort() callback when sorting +** an array of pending terms by term. This occurs as part of flushing +** the contents of the pending-terms hash table to the database. +*/ +static int SQLITE_CDECL fts3CompareElemByTerm( + const void *lhs, + const void *rhs +){ + char *z1 = fts3HashKey(*(Fts3HashElem **)lhs); + char *z2 = fts3HashKey(*(Fts3HashElem **)rhs); + int n1 = fts3HashKeysize(*(Fts3HashElem **)lhs); + int n2 = fts3HashKeysize(*(Fts3HashElem **)rhs); + + int n = (n1aIndex */ + const char *zTerm, /* Term to search for */ + int nTerm, /* Size of buffer zTerm */ + int bPrefix, /* True for a prefix iterator */ + Fts3SegReader **ppReader /* OUT: SegReader for pending-terms */ +){ + Fts3SegReader *pReader = 0; /* Fts3SegReader object to return */ + Fts3HashElem *pE; /* Iterator variable */ + Fts3HashElem **aElem = 0; /* Array of term hash entries to scan */ + int nElem = 0; /* Size of array at aElem */ + int rc = SQLITE_OK; /* Return Code */ + Fts3Hash *pHash; + + pHash = &p->aIndex[iIndex].hPending; + if( bPrefix ){ + int nAlloc = 0; /* Size of allocated array at aElem */ + + for(pE=fts3HashFirst(pHash); pE; pE=fts3HashNext(pE)){ + char *zKey = (char *)fts3HashKey(pE); + int nKey = fts3HashKeysize(pE); + if( nTerm==0 || (nKey>=nTerm && 0==memcmp(zKey, zTerm, nTerm)) ){ + if( nElem==nAlloc ){ + Fts3HashElem **aElem2; + nAlloc += 16; + aElem2 = (Fts3HashElem **)sqlite3_realloc( + aElem, nAlloc*sizeof(Fts3HashElem *) + ); + if( !aElem2 ){ + rc = SQLITE_NOMEM; + nElem = 0; + break; + } + aElem = aElem2; + } + + aElem[nElem++] = pE; + } + } + + /* If more than one term matches the prefix, sort the Fts3HashElem + ** objects in term order using qsort(). This uses the same comparison + ** callback as is used when flushing terms to disk. + */ + if( nElem>1 ){ + qsort(aElem, nElem, sizeof(Fts3HashElem *), fts3CompareElemByTerm); + } + + }else{ + /* The query is a simple term lookup that matches at most one term in + ** the index. All that is required is a straight hash-lookup. + ** + ** Because the stack address of pE may be accessed via the aElem pointer + ** below, the "Fts3HashElem *pE" must be declared so that it is valid + ** within this entire function, not just this "else{...}" block. + */ + pE = fts3HashFindElem(pHash, zTerm, nTerm); + if( pE ){ + aElem = &pE; + nElem = 1; + } + } + + if( nElem>0 ){ + int nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *); + pReader = (Fts3SegReader *)sqlite3_malloc(nByte); + if( !pReader ){ + rc = SQLITE_NOMEM; + }else{ + memset(pReader, 0, nByte); + pReader->iIdx = 0x7FFFFFFF; + pReader->ppNextElem = (Fts3HashElem **)&pReader[1]; + memcpy(pReader->ppNextElem, aElem, nElem*sizeof(Fts3HashElem *)); + } + } + + if( bPrefix ){ + sqlite3_free(aElem); + } + *ppReader = pReader; + return rc; +} + +/* +** Compare the entries pointed to by two Fts3SegReader structures. +** Comparison is as follows: +** +** 1) EOF is greater than not EOF. +** +** 2) The current terms (if any) are compared using memcmp(). If one +** term is a prefix of another, the longer term is considered the +** larger. +** +** 3) By segment age. An older segment is considered larger. +*/ +static int fts3SegReaderCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){ + int rc; + if( pLhs->aNode && pRhs->aNode ){ + int rc2 = pLhs->nTerm - pRhs->nTerm; + if( rc2<0 ){ + rc = memcmp(pLhs->zTerm, pRhs->zTerm, pLhs->nTerm); + }else{ + rc = memcmp(pLhs->zTerm, pRhs->zTerm, pRhs->nTerm); + } + if( rc==0 ){ + rc = rc2; + } + }else{ + rc = (pLhs->aNode==0) - (pRhs->aNode==0); + } + if( rc==0 ){ + rc = pRhs->iIdx - pLhs->iIdx; + } + assert( rc!=0 ); + return rc; +} + +/* +** A different comparison function for SegReader structures. In this +** version, it is assumed that each SegReader points to an entry in +** a doclist for identical terms. Comparison is made as follows: +** +** 1) EOF (end of doclist in this case) is greater than not EOF. +** +** 2) By current docid. +** +** 3) By segment age. An older segment is considered larger. +*/ +static int fts3SegReaderDoclistCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){ + int rc = (pLhs->pOffsetList==0)-(pRhs->pOffsetList==0); + if( rc==0 ){ + if( pLhs->iDocid==pRhs->iDocid ){ + rc = pRhs->iIdx - pLhs->iIdx; + }else{ + rc = (pLhs->iDocid > pRhs->iDocid) ? 1 : -1; + } + } + assert( pLhs->aNode && pRhs->aNode ); + return rc; +} +static int fts3SegReaderDoclistCmpRev(Fts3SegReader *pLhs, Fts3SegReader *pRhs){ + int rc = (pLhs->pOffsetList==0)-(pRhs->pOffsetList==0); + if( rc==0 ){ + if( pLhs->iDocid==pRhs->iDocid ){ + rc = pRhs->iIdx - pLhs->iIdx; + }else{ + rc = (pLhs->iDocid < pRhs->iDocid) ? 1 : -1; + } + } + assert( pLhs->aNode && pRhs->aNode ); + return rc; +} + +/* +** Compare the term that the Fts3SegReader object passed as the first argument +** points to with the term specified by arguments zTerm and nTerm. +** +** If the pSeg iterator is already at EOF, return 0. Otherwise, return +** -ve if the pSeg term is less than zTerm/nTerm, 0 if the two terms are +** equal, or +ve if the pSeg term is greater than zTerm/nTerm. +*/ +static int fts3SegReaderTermCmp( + Fts3SegReader *pSeg, /* Segment reader object */ + const char *zTerm, /* Term to compare to */ + int nTerm /* Size of term zTerm in bytes */ +){ + int res = 0; + if( pSeg->aNode ){ + if( pSeg->nTerm>nTerm ){ + res = memcmp(pSeg->zTerm, zTerm, nTerm); + }else{ + res = memcmp(pSeg->zTerm, zTerm, pSeg->nTerm); + } + if( res==0 ){ + res = pSeg->nTerm-nTerm; + } + } + return res; +} + +/* +** Argument apSegment is an array of nSegment elements. It is known that +** the final (nSegment-nSuspect) members are already in sorted order +** (according to the comparison function provided). This function shuffles +** the array around until all entries are in sorted order. +*/ +static void fts3SegReaderSort( + Fts3SegReader **apSegment, /* Array to sort entries of */ + int nSegment, /* Size of apSegment array */ + int nSuspect, /* Unsorted entry count */ + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) /* Comparison function */ +){ + int i; /* Iterator variable */ + + assert( nSuspect<=nSegment ); + + if( nSuspect==nSegment ) nSuspect--; + for(i=nSuspect-1; i>=0; i--){ + int j; + for(j=i; j<(nSegment-1); j++){ + Fts3SegReader *pTmp; + if( xCmp(apSegment[j], apSegment[j+1])<0 ) break; + pTmp = apSegment[j+1]; + apSegment[j+1] = apSegment[j]; + apSegment[j] = pTmp; + } + } + +#ifndef NDEBUG + /* Check that the list really is sorted now. */ + for(i=0; i<(nSuspect-1); i++){ + assert( xCmp(apSegment[i], apSegment[i+1])<0 ); + } +#endif +} + +/* +** Insert a record into the %_segments table. +*/ +static int fts3WriteSegment( + Fts3Table *p, /* Virtual table handle */ + sqlite3_int64 iBlock, /* Block id for new block */ + char *z, /* Pointer to buffer containing block data */ + int n /* Size of buffer z in bytes */ +){ + sqlite3_stmt *pStmt; + int rc = fts3SqlStmt(p, SQL_INSERT_SEGMENTS, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, iBlock); + sqlite3_bind_blob(pStmt, 2, z, n, SQLITE_STATIC); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + } + return rc; +} + +/* +** Find the largest relative level number in the table. If successful, set +** *pnMax to this value and return SQLITE_OK. Otherwise, if an error occurs, +** set *pnMax to zero and return an SQLite error code. +*/ +SQLITE_PRIVATE int sqlite3Fts3MaxLevel(Fts3Table *p, int *pnMax){ + int rc; + int mxLevel = 0; + sqlite3_stmt *pStmt = 0; + + rc = fts3SqlStmt(p, SQL_SELECT_MXLEVEL, &pStmt, 0); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + mxLevel = sqlite3_column_int(pStmt, 0); + } + rc = sqlite3_reset(pStmt); + } + *pnMax = mxLevel; + return rc; +} + +/* +** Insert a record into the %_segdir table. +*/ +static int fts3WriteSegdir( + Fts3Table *p, /* Virtual table handle */ + sqlite3_int64 iLevel, /* Value for "level" field (absolute level) */ + int iIdx, /* Value for "idx" field */ + sqlite3_int64 iStartBlock, /* Value for "start_block" field */ + sqlite3_int64 iLeafEndBlock, /* Value for "leaves_end_block" field */ + sqlite3_int64 iEndBlock, /* Value for "end_block" field */ + sqlite3_int64 nLeafData, /* Bytes of leaf data in segment */ + char *zRoot, /* Blob value for "root" field */ + int nRoot /* Number of bytes in buffer zRoot */ +){ + sqlite3_stmt *pStmt; + int rc = fts3SqlStmt(p, SQL_INSERT_SEGDIR, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, iLevel); + sqlite3_bind_int(pStmt, 2, iIdx); + sqlite3_bind_int64(pStmt, 3, iStartBlock); + sqlite3_bind_int64(pStmt, 4, iLeafEndBlock); + if( nLeafData==0 ){ + sqlite3_bind_int64(pStmt, 5, iEndBlock); + }else{ + char *zEnd = sqlite3_mprintf("%lld %lld", iEndBlock, nLeafData); + if( !zEnd ) return SQLITE_NOMEM; + sqlite3_bind_text(pStmt, 5, zEnd, -1, sqlite3_free); + } + sqlite3_bind_blob(pStmt, 6, zRoot, nRoot, SQLITE_STATIC); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + } + return rc; +} + +/* +** Return the size of the common prefix (if any) shared by zPrev and +** zNext, in bytes. For example, +** +** fts3PrefixCompress("abc", 3, "abcdef", 6) // returns 3 +** fts3PrefixCompress("abX", 3, "abcdef", 6) // returns 2 +** fts3PrefixCompress("abX", 3, "Xbcdef", 6) // returns 0 +*/ +static int fts3PrefixCompress( + const char *zPrev, /* Buffer containing previous term */ + int nPrev, /* Size of buffer zPrev in bytes */ + const char *zNext, /* Buffer containing next term */ + int nNext /* Size of buffer zNext in bytes */ +){ + int n; + UNUSED_PARAMETER(nNext); + for(n=0; nnData; /* Current size of node in bytes */ + int nReq = nData; /* Required space after adding zTerm */ + int nPrefix; /* Number of bytes of prefix compression */ + int nSuffix; /* Suffix length */ + + nPrefix = fts3PrefixCompress(pTree->zTerm, pTree->nTerm, zTerm, nTerm); + nSuffix = nTerm-nPrefix; + + nReq += sqlite3Fts3VarintLen(nPrefix)+sqlite3Fts3VarintLen(nSuffix)+nSuffix; + if( nReq<=p->nNodeSize || !pTree->zTerm ){ + + if( nReq>p->nNodeSize ){ + /* An unusual case: this is the first term to be added to the node + ** and the static node buffer (p->nNodeSize bytes) is not large + ** enough. Use a separately malloced buffer instead This wastes + ** p->nNodeSize bytes, but since this scenario only comes about when + ** the database contain two terms that share a prefix of almost 2KB, + ** this is not expected to be a serious problem. + */ + assert( pTree->aData==(char *)&pTree[1] ); + pTree->aData = (char *)sqlite3_malloc(nReq); + if( !pTree->aData ){ + return SQLITE_NOMEM; + } + } + + if( pTree->zTerm ){ + /* There is no prefix-length field for first term in a node */ + nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nPrefix); + } + + nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nSuffix); + memcpy(&pTree->aData[nData], &zTerm[nPrefix], nSuffix); + pTree->nData = nData + nSuffix; + pTree->nEntry++; + + if( isCopyTerm ){ + if( pTree->nMalloczMalloc, nTerm*2); + if( !zNew ){ + return SQLITE_NOMEM; + } + pTree->nMalloc = nTerm*2; + pTree->zMalloc = zNew; + } + pTree->zTerm = pTree->zMalloc; + memcpy(pTree->zTerm, zTerm, nTerm); + pTree->nTerm = nTerm; + }else{ + pTree->zTerm = (char *)zTerm; + pTree->nTerm = nTerm; + } + return SQLITE_OK; + } + } + + /* If control flows to here, it was not possible to append zTerm to the + ** current node. Create a new node (a right-sibling of the current node). + ** If this is the first node in the tree, the term is added to it. + ** + ** Otherwise, the term is not added to the new node, it is left empty for + ** now. Instead, the term is inserted into the parent of pTree. If pTree + ** has no parent, one is created here. + */ + pNew = (SegmentNode *)sqlite3_malloc(sizeof(SegmentNode) + p->nNodeSize); + if( !pNew ){ + return SQLITE_NOMEM; + } + memset(pNew, 0, sizeof(SegmentNode)); + pNew->nData = 1 + FTS3_VARINT_MAX; + pNew->aData = (char *)&pNew[1]; + + if( pTree ){ + SegmentNode *pParent = pTree->pParent; + rc = fts3NodeAddTerm(p, &pParent, isCopyTerm, zTerm, nTerm); + if( pTree->pParent==0 ){ + pTree->pParent = pParent; + } + pTree->pRight = pNew; + pNew->pLeftmost = pTree->pLeftmost; + pNew->pParent = pParent; + pNew->zMalloc = pTree->zMalloc; + pNew->nMalloc = pTree->nMalloc; + pTree->zMalloc = 0; + }else{ + pNew->pLeftmost = pNew; + rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm); + } + + *ppTree = pNew; + return rc; +} + +/* +** Helper function for fts3NodeWrite(). +*/ +static int fts3TreeFinishNode( + SegmentNode *pTree, + int iHeight, + sqlite3_int64 iLeftChild +){ + int nStart; + assert( iHeight>=1 && iHeight<128 ); + nStart = FTS3_VARINT_MAX - sqlite3Fts3VarintLen(iLeftChild); + pTree->aData[nStart] = (char)iHeight; + sqlite3Fts3PutVarint(&pTree->aData[nStart+1], iLeftChild); + return nStart; +} + +/* +** Write the buffer for the segment node pTree and all of its peers to the +** database. Then call this function recursively to write the parent of +** pTree and its peers to the database. +** +** Except, if pTree is a root node, do not write it to the database. Instead, +** set output variables *paRoot and *pnRoot to contain the root node. +** +** If successful, SQLITE_OK is returned and output variable *piLast is +** set to the largest blockid written to the database (or zero if no +** blocks were written to the db). Otherwise, an SQLite error code is +** returned. +*/ +static int fts3NodeWrite( + Fts3Table *p, /* Virtual table handle */ + SegmentNode *pTree, /* SegmentNode handle */ + int iHeight, /* Height of this node in tree */ + sqlite3_int64 iLeaf, /* Block id of first leaf node */ + sqlite3_int64 iFree, /* Block id of next free slot in %_segments */ + sqlite3_int64 *piLast, /* OUT: Block id of last entry written */ + char **paRoot, /* OUT: Data for root node */ + int *pnRoot /* OUT: Size of root node in bytes */ +){ + int rc = SQLITE_OK; + + if( !pTree->pParent ){ + /* Root node of the tree. */ + int nStart = fts3TreeFinishNode(pTree, iHeight, iLeaf); + *piLast = iFree-1; + *pnRoot = pTree->nData - nStart; + *paRoot = &pTree->aData[nStart]; + }else{ + SegmentNode *pIter; + sqlite3_int64 iNextFree = iFree; + sqlite3_int64 iNextLeaf = iLeaf; + for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){ + int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf); + int nWrite = pIter->nData - nStart; + + rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite); + iNextFree++; + iNextLeaf += (pIter->nEntry+1); + } + if( rc==SQLITE_OK ){ + assert( iNextLeaf==iFree ); + rc = fts3NodeWrite( + p, pTree->pParent, iHeight+1, iFree, iNextFree, piLast, paRoot, pnRoot + ); + } + } + + return rc; +} + +/* +** Free all memory allocations associated with the tree pTree. +*/ +static void fts3NodeFree(SegmentNode *pTree){ + if( pTree ){ + SegmentNode *p = pTree->pLeftmost; + fts3NodeFree(p->pParent); + while( p ){ + SegmentNode *pRight = p->pRight; + if( p->aData!=(char *)&p[1] ){ + sqlite3_free(p->aData); + } + assert( pRight==0 || p->zMalloc==0 ); + sqlite3_free(p->zMalloc); + sqlite3_free(p); + p = pRight; + } + } +} + +/* +** Add a term to the segment being constructed by the SegmentWriter object +** *ppWriter. When adding the first term to a segment, *ppWriter should +** be passed NULL. This function will allocate a new SegmentWriter object +** and return it via the input/output variable *ppWriter in this case. +** +** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code. +*/ +static int fts3SegWriterAdd( + Fts3Table *p, /* Virtual table handle */ + SegmentWriter **ppWriter, /* IN/OUT: SegmentWriter handle */ + int isCopyTerm, /* True if buffer zTerm must be copied */ + const char *zTerm, /* Pointer to buffer containing term */ + int nTerm, /* Size of term in bytes */ + const char *aDoclist, /* Pointer to buffer containing doclist */ + int nDoclist /* Size of doclist in bytes */ +){ + int nPrefix; /* Size of term prefix in bytes */ + int nSuffix; /* Size of term suffix in bytes */ + int nReq; /* Number of bytes required on leaf page */ + int nData; + SegmentWriter *pWriter = *ppWriter; + + if( !pWriter ){ + int rc; + sqlite3_stmt *pStmt; + + /* Allocate the SegmentWriter structure */ + pWriter = (SegmentWriter *)sqlite3_malloc(sizeof(SegmentWriter)); + if( !pWriter ) return SQLITE_NOMEM; + memset(pWriter, 0, sizeof(SegmentWriter)); + *ppWriter = pWriter; + + /* Allocate a buffer in which to accumulate data */ + pWriter->aData = (char *)sqlite3_malloc(p->nNodeSize); + if( !pWriter->aData ) return SQLITE_NOMEM; + pWriter->nSize = p->nNodeSize; + + /* Find the next free blockid in the %_segments table */ + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + pWriter->iFree = sqlite3_column_int64(pStmt, 0); + pWriter->iFirst = pWriter->iFree; + } + rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ) return rc; + } + nData = pWriter->nData; + + nPrefix = fts3PrefixCompress(pWriter->zTerm, pWriter->nTerm, zTerm, nTerm); + nSuffix = nTerm-nPrefix; + + /* Figure out how many bytes are required by this new entry */ + nReq = sqlite3Fts3VarintLen(nPrefix) + /* varint containing prefix size */ + sqlite3Fts3VarintLen(nSuffix) + /* varint containing suffix size */ + nSuffix + /* Term suffix */ + sqlite3Fts3VarintLen(nDoclist) + /* Size of doclist */ + nDoclist; /* Doclist data */ + + if( nData>0 && nData+nReq>p->nNodeSize ){ + int rc; + + /* The current leaf node is full. Write it out to the database. */ + rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, nData); + if( rc!=SQLITE_OK ) return rc; + p->nLeafAdd++; + + /* Add the current term to the interior node tree. The term added to + ** the interior tree must: + ** + ** a) be greater than the largest term on the leaf node just written + ** to the database (still available in pWriter->zTerm), and + ** + ** b) be less than or equal to the term about to be added to the new + ** leaf node (zTerm/nTerm). + ** + ** In other words, it must be the prefix of zTerm 1 byte longer than + ** the common prefix (if any) of zTerm and pWriter->zTerm. + */ + assert( nPrefixpTree, isCopyTerm, zTerm, nPrefix+1); + if( rc!=SQLITE_OK ) return rc; + + nData = 0; + pWriter->nTerm = 0; + + nPrefix = 0; + nSuffix = nTerm; + nReq = 1 + /* varint containing prefix size */ + sqlite3Fts3VarintLen(nTerm) + /* varint containing suffix size */ + nTerm + /* Term suffix */ + sqlite3Fts3VarintLen(nDoclist) + /* Size of doclist */ + nDoclist; /* Doclist data */ + } + + /* Increase the total number of bytes written to account for the new entry. */ + pWriter->nLeafData += nReq; + + /* If the buffer currently allocated is too small for this entry, realloc + ** the buffer to make it large enough. + */ + if( nReq>pWriter->nSize ){ + char *aNew = sqlite3_realloc(pWriter->aData, nReq); + if( !aNew ) return SQLITE_NOMEM; + pWriter->aData = aNew; + pWriter->nSize = nReq; + } + assert( nData+nReq<=pWriter->nSize ); + + /* Append the prefix-compressed term and doclist to the buffer. */ + nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nPrefix); + nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nSuffix); + memcpy(&pWriter->aData[nData], &zTerm[nPrefix], nSuffix); + nData += nSuffix; + nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nDoclist); + memcpy(&pWriter->aData[nData], aDoclist, nDoclist); + pWriter->nData = nData + nDoclist; + + /* Save the current term so that it can be used to prefix-compress the next. + ** If the isCopyTerm parameter is true, then the buffer pointed to by + ** zTerm is transient, so take a copy of the term data. Otherwise, just + ** store a copy of the pointer. + */ + if( isCopyTerm ){ + if( nTerm>pWriter->nMalloc ){ + char *zNew = sqlite3_realloc(pWriter->zMalloc, nTerm*2); + if( !zNew ){ + return SQLITE_NOMEM; + } + pWriter->nMalloc = nTerm*2; + pWriter->zMalloc = zNew; + pWriter->zTerm = zNew; + } + assert( pWriter->zTerm==pWriter->zMalloc ); + memcpy(pWriter->zTerm, zTerm, nTerm); + }else{ + pWriter->zTerm = (char *)zTerm; + } + pWriter->nTerm = nTerm; + + return SQLITE_OK; +} + +/* +** Flush all data associated with the SegmentWriter object pWriter to the +** database. This function must be called after all terms have been added +** to the segment using fts3SegWriterAdd(). If successful, SQLITE_OK is +** returned. Otherwise, an SQLite error code. +*/ +static int fts3SegWriterFlush( + Fts3Table *p, /* Virtual table handle */ + SegmentWriter *pWriter, /* SegmentWriter to flush to the db */ + sqlite3_int64 iLevel, /* Value for 'level' column of %_segdir */ + int iIdx /* Value for 'idx' column of %_segdir */ +){ + int rc; /* Return code */ + if( pWriter->pTree ){ + sqlite3_int64 iLast = 0; /* Largest block id written to database */ + sqlite3_int64 iLastLeaf; /* Largest leaf block id written to db */ + char *zRoot = NULL; /* Pointer to buffer containing root node */ + int nRoot = 0; /* Size of buffer zRoot */ + + iLastLeaf = pWriter->iFree; + rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, pWriter->nData); + if( rc==SQLITE_OK ){ + rc = fts3NodeWrite(p, pWriter->pTree, 1, + pWriter->iFirst, pWriter->iFree, &iLast, &zRoot, &nRoot); + } + if( rc==SQLITE_OK ){ + rc = fts3WriteSegdir(p, iLevel, iIdx, + pWriter->iFirst, iLastLeaf, iLast, pWriter->nLeafData, zRoot, nRoot); + } + }else{ + /* The entire tree fits on the root node. Write it to the segdir table. */ + rc = fts3WriteSegdir(p, iLevel, iIdx, + 0, 0, 0, pWriter->nLeafData, pWriter->aData, pWriter->nData); + } + p->nLeafAdd++; + return rc; +} + +/* +** Release all memory held by the SegmentWriter object passed as the +** first argument. +*/ +static void fts3SegWriterFree(SegmentWriter *pWriter){ + if( pWriter ){ + sqlite3_free(pWriter->aData); + sqlite3_free(pWriter->zMalloc); + fts3NodeFree(pWriter->pTree); + sqlite3_free(pWriter); + } +} + +/* +** The first value in the apVal[] array is assumed to contain an integer. +** This function tests if there exist any documents with docid values that +** are different from that integer. i.e. if deleting the document with docid +** pRowid would mean the FTS3 table were empty. +** +** If successful, *pisEmpty is set to true if the table is empty except for +** document pRowid, or false otherwise, and SQLITE_OK is returned. If an +** error occurs, an SQLite error code is returned. +*/ +static int fts3IsEmpty(Fts3Table *p, sqlite3_value *pRowid, int *pisEmpty){ + sqlite3_stmt *pStmt; + int rc; + if( p->zContentTbl ){ + /* If using the content=xxx option, assume the table is never empty */ + *pisEmpty = 0; + rc = SQLITE_OK; + }else{ + rc = fts3SqlStmt(p, SQL_IS_EMPTY, &pStmt, &pRowid); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *pisEmpty = sqlite3_column_int(pStmt, 0); + } + rc = sqlite3_reset(pStmt); + } + } + return rc; +} + +/* +** Set *pnMax to the largest segment level in the database for the index +** iIndex. +** +** Segment levels are stored in the 'level' column of the %_segdir table. +** +** Return SQLITE_OK if successful, or an SQLite error code if not. +*/ +static int fts3SegmentMaxLevel( + Fts3Table *p, + int iLangid, + int iIndex, + sqlite3_int64 *pnMax +){ + sqlite3_stmt *pStmt; + int rc; + assert( iIndex>=0 && iIndexnIndex ); + + /* Set pStmt to the compiled version of: + ** + ** SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ? + ** + ** (1024 is actually the value of macro FTS3_SEGDIR_PREFIXLEVEL_STR). + */ + rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0)); + sqlite3_bind_int64(pStmt, 2, + getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1) + ); + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *pnMax = sqlite3_column_int64(pStmt, 0); + } + return sqlite3_reset(pStmt); +} + +/* +** iAbsLevel is an absolute level that may be assumed to exist within +** the database. This function checks if it is the largest level number +** within its index. Assuming no error occurs, *pbMax is set to 1 if +** iAbsLevel is indeed the largest level, or 0 otherwise, and SQLITE_OK +** is returned. If an error occurs, an error code is returned and the +** final value of *pbMax is undefined. +*/ +static int fts3SegmentIsMaxLevel(Fts3Table *p, i64 iAbsLevel, int *pbMax){ + + /* Set pStmt to the compiled version of: + ** + ** SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ? + ** + ** (1024 is actually the value of macro FTS3_SEGDIR_PREFIXLEVEL_STR). + */ + sqlite3_stmt *pStmt; + int rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + sqlite3_bind_int64(pStmt, 1, iAbsLevel+1); + sqlite3_bind_int64(pStmt, 2, + ((iAbsLevel/FTS3_SEGDIR_MAXLEVEL)+1) * FTS3_SEGDIR_MAXLEVEL + ); + + *pbMax = 0; + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *pbMax = sqlite3_column_type(pStmt, 0)==SQLITE_NULL; + } + return sqlite3_reset(pStmt); +} + +/* +** Delete all entries in the %_segments table associated with the segment +** opened with seg-reader pSeg. This function does not affect the contents +** of the %_segdir table. +*/ +static int fts3DeleteSegment( + Fts3Table *p, /* FTS table handle */ + Fts3SegReader *pSeg /* Segment to delete */ +){ + int rc = SQLITE_OK; /* Return code */ + if( pSeg->iStartBlock ){ + sqlite3_stmt *pDelete; /* SQL statement to delete rows */ + rc = fts3SqlStmt(p, SQL_DELETE_SEGMENTS_RANGE, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDelete, 1, pSeg->iStartBlock); + sqlite3_bind_int64(pDelete, 2, pSeg->iEndBlock); + sqlite3_step(pDelete); + rc = sqlite3_reset(pDelete); + } + } + return rc; +} + +/* +** This function is used after merging multiple segments into a single large +** segment to delete the old, now redundant, segment b-trees. Specifically, +** it: +** +** 1) Deletes all %_segments entries for the segments associated with +** each of the SegReader objects in the array passed as the third +** argument, and +** +** 2) deletes all %_segdir entries with level iLevel, or all %_segdir +** entries regardless of level if (iLevel<0). +** +** SQLITE_OK is returned if successful, otherwise an SQLite error code. +*/ +static int fts3DeleteSegdir( + Fts3Table *p, /* Virtual table handle */ + int iLangid, /* Language id */ + int iIndex, /* Index for p->aIndex */ + int iLevel, /* Level of %_segdir entries to delete */ + Fts3SegReader **apSegment, /* Array of SegReader objects */ + int nReader /* Size of array apSegment */ +){ + int rc = SQLITE_OK; /* Return Code */ + int i; /* Iterator variable */ + sqlite3_stmt *pDelete = 0; /* SQL statement to delete rows */ + + for(i=0; rc==SQLITE_OK && i=0 || iLevel==FTS3_SEGCURSOR_ALL ); + if( iLevel==FTS3_SEGCURSOR_ALL ){ + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_RANGE, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDelete, 1, getAbsoluteLevel(p, iLangid, iIndex, 0)); + sqlite3_bind_int64(pDelete, 2, + getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1) + ); + } + }else{ + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64( + pDelete, 1, getAbsoluteLevel(p, iLangid, iIndex, iLevel) + ); + } + } + + if( rc==SQLITE_OK ){ + sqlite3_step(pDelete); + rc = sqlite3_reset(pDelete); + } + + return rc; +} + +/* +** When this function is called, buffer *ppList (size *pnList bytes) contains +** a position list that may (or may not) feature multiple columns. This +** function adjusts the pointer *ppList and the length *pnList so that they +** identify the subset of the position list that corresponds to column iCol. +** +** If there are no entries in the input position list for column iCol, then +** *pnList is set to zero before returning. +** +** If parameter bZero is non-zero, then any part of the input list following +** the end of the output list is zeroed before returning. +*/ +static void fts3ColumnFilter( + int iCol, /* Column to filter on */ + int bZero, /* Zero out anything following *ppList */ + char **ppList, /* IN/OUT: Pointer to position list */ + int *pnList /* IN/OUT: Size of buffer *ppList in bytes */ +){ + char *pList = *ppList; + int nList = *pnList; + char *pEnd = &pList[nList]; + int iCurrent = 0; + char *p = pList; + + assert( iCol>=0 ); + while( 1 ){ + char c = 0; + while( ppMsr->nBuffer ){ + char *pNew; + pMsr->nBuffer = nList*2; + pNew = (char *)sqlite3_realloc(pMsr->aBuffer, pMsr->nBuffer); + if( !pNew ) return SQLITE_NOMEM; + pMsr->aBuffer = pNew; + } + + memcpy(pMsr->aBuffer, pList, nList); + return SQLITE_OK; +} + +SQLITE_PRIVATE int sqlite3Fts3MsrIncrNext( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */ + sqlite3_int64 *piDocid, /* OUT: Docid value */ + char **paPoslist, /* OUT: Pointer to position list */ + int *pnPoslist /* OUT: Size of position list in bytes */ +){ + int nMerge = pMsr->nAdvance; + Fts3SegReader **apSegment = pMsr->apSegment; + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = ( + p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp + ); + + if( nMerge==0 ){ + *paPoslist = 0; + return SQLITE_OK; + } + + while( 1 ){ + Fts3SegReader *pSeg; + pSeg = pMsr->apSegment[0]; + + if( pSeg->pOffsetList==0 ){ + *paPoslist = 0; + break; + }else{ + int rc; + char *pList; + int nList; + int j; + sqlite3_int64 iDocid = apSegment[0]->iDocid; + + rc = fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList); + j = 1; + while( rc==SQLITE_OK + && jpOffsetList + && apSegment[j]->iDocid==iDocid + ){ + rc = fts3SegReaderNextDocid(p, apSegment[j], 0, 0); + j++; + } + if( rc!=SQLITE_OK ) return rc; + fts3SegReaderSort(pMsr->apSegment, nMerge, j, xCmp); + + if( nList>0 && fts3SegReaderIsPending(apSegment[0]) ){ + rc = fts3MsrBufferData(pMsr, pList, nList+1); + if( rc!=SQLITE_OK ) return rc; + assert( (pMsr->aBuffer[nList] & 0xFE)==0x00 ); + pList = pMsr->aBuffer; + } + + if( pMsr->iColFilter>=0 ){ + fts3ColumnFilter(pMsr->iColFilter, 1, &pList, &nList); + } + + if( nList>0 ){ + *paPoslist = pList; + *piDocid = iDocid; + *pnPoslist = nList; + break; + } + } + } + + return SQLITE_OK; +} + +static int fts3SegReaderStart( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr, /* Cursor object */ + const char *zTerm, /* Term searched for (or NULL) */ + int nTerm /* Length of zTerm in bytes */ +){ + int i; + int nSeg = pCsr->nSegment; + + /* If the Fts3SegFilter defines a specific term (or term prefix) to search + ** for, then advance each segment iterator until it points to a term of + ** equal or greater value than the specified term. This prevents many + ** unnecessary merge/sort operations for the case where single segment + ** b-tree leaf nodes contain more than one term. + */ + for(i=0; pCsr->bRestart==0 && inSegment; i++){ + int res = 0; + Fts3SegReader *pSeg = pCsr->apSegment[i]; + do { + int rc = fts3SegReaderNext(p, pSeg, 0); + if( rc!=SQLITE_OK ) return rc; + }while( zTerm && (res = fts3SegReaderTermCmp(pSeg, zTerm, nTerm))<0 ); + + if( pSeg->bLookup && res!=0 ){ + fts3SegReaderSetEof(pSeg); + } + } + fts3SegReaderSort(pCsr->apSegment, nSeg, nSeg, fts3SegReaderCmp); + + return SQLITE_OK; +} + +SQLITE_PRIVATE int sqlite3Fts3SegReaderStart( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr, /* Cursor object */ + Fts3SegFilter *pFilter /* Restrictions on range of iteration */ +){ + pCsr->pFilter = pFilter; + return fts3SegReaderStart(p, pCsr, pFilter->zTerm, pFilter->nTerm); +} + +SQLITE_PRIVATE int sqlite3Fts3MsrIncrStart( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr, /* Cursor object */ + int iCol, /* Column to match on. */ + const char *zTerm, /* Term to iterate through a doclist for */ + int nTerm /* Number of bytes in zTerm */ +){ + int i; + int rc; + int nSegment = pCsr->nSegment; + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = ( + p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp + ); + + assert( pCsr->pFilter==0 ); + assert( zTerm && nTerm>0 ); + + /* Advance each segment iterator until it points to the term zTerm/nTerm. */ + rc = fts3SegReaderStart(p, pCsr, zTerm, nTerm); + if( rc!=SQLITE_OK ) return rc; + + /* Determine how many of the segments actually point to zTerm/nTerm. */ + for(i=0; iapSegment[i]; + if( !pSeg->aNode || fts3SegReaderTermCmp(pSeg, zTerm, nTerm) ){ + break; + } + } + pCsr->nAdvance = i; + + /* Advance each of the segments to point to the first docid. */ + for(i=0; inAdvance; i++){ + rc = fts3SegReaderFirstDocid(p, pCsr->apSegment[i]); + if( rc!=SQLITE_OK ) return rc; + } + fts3SegReaderSort(pCsr->apSegment, i, i, xCmp); + + assert( iCol<0 || iColnColumn ); + pCsr->iColFilter = iCol; + + return SQLITE_OK; +} + +/* +** This function is called on a MultiSegReader that has been started using +** sqlite3Fts3MsrIncrStart(). One or more calls to MsrIncrNext() may also +** have been made. Calling this function puts the MultiSegReader in such +** a state that if the next two calls are: +** +** sqlite3Fts3SegReaderStart() +** sqlite3Fts3SegReaderStep() +** +** then the entire doclist for the term is available in +** MultiSegReader.aDoclist/nDoclist. +*/ +SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr){ + int i; /* Used to iterate through segment-readers */ + + assert( pCsr->zTerm==0 ); + assert( pCsr->nTerm==0 ); + assert( pCsr->aDoclist==0 ); + assert( pCsr->nDoclist==0 ); + + pCsr->nAdvance = 0; + pCsr->bRestart = 1; + for(i=0; inSegment; i++){ + pCsr->apSegment[i]->pOffsetList = 0; + pCsr->apSegment[i]->nOffsetList = 0; + pCsr->apSegment[i]->iDocid = 0; + } + + return SQLITE_OK; +} + + +SQLITE_PRIVATE int sqlite3Fts3SegReaderStep( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr /* Cursor object */ +){ + int rc = SQLITE_OK; + + int isIgnoreEmpty = (pCsr->pFilter->flags & FTS3_SEGMENT_IGNORE_EMPTY); + int isRequirePos = (pCsr->pFilter->flags & FTS3_SEGMENT_REQUIRE_POS); + int isColFilter = (pCsr->pFilter->flags & FTS3_SEGMENT_COLUMN_FILTER); + int isPrefix = (pCsr->pFilter->flags & FTS3_SEGMENT_PREFIX); + int isScan = (pCsr->pFilter->flags & FTS3_SEGMENT_SCAN); + int isFirst = (pCsr->pFilter->flags & FTS3_SEGMENT_FIRST); + + Fts3SegReader **apSegment = pCsr->apSegment; + int nSegment = pCsr->nSegment; + Fts3SegFilter *pFilter = pCsr->pFilter; + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = ( + p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp + ); + + if( pCsr->nSegment==0 ) return SQLITE_OK; + + do { + int nMerge; + int i; + + /* Advance the first pCsr->nAdvance entries in the apSegment[] array + ** forward. Then sort the list in order of current term again. + */ + for(i=0; inAdvance; i++){ + Fts3SegReader *pSeg = apSegment[i]; + if( pSeg->bLookup ){ + fts3SegReaderSetEof(pSeg); + }else{ + rc = fts3SegReaderNext(p, pSeg, 0); + } + if( rc!=SQLITE_OK ) return rc; + } + fts3SegReaderSort(apSegment, nSegment, pCsr->nAdvance, fts3SegReaderCmp); + pCsr->nAdvance = 0; + + /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */ + assert( rc==SQLITE_OK ); + if( apSegment[0]->aNode==0 ) break; + + pCsr->nTerm = apSegment[0]->nTerm; + pCsr->zTerm = apSegment[0]->zTerm; + + /* If this is a prefix-search, and if the term that apSegment[0] points + ** to does not share a suffix with pFilter->zTerm/nTerm, then all + ** required callbacks have been made. In this case exit early. + ** + ** Similarly, if this is a search for an exact match, and the first term + ** of segment apSegment[0] is not a match, exit early. + */ + if( pFilter->zTerm && !isScan ){ + if( pCsr->nTermnTerm + || (!isPrefix && pCsr->nTerm>pFilter->nTerm) + || memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm) + ){ + break; + } + } + + nMerge = 1; + while( nMergeaNode + && apSegment[nMerge]->nTerm==pCsr->nTerm + && 0==memcmp(pCsr->zTerm, apSegment[nMerge]->zTerm, pCsr->nTerm) + ){ + nMerge++; + } + + assert( isIgnoreEmpty || (isRequirePos && !isColFilter) ); + if( nMerge==1 + && !isIgnoreEmpty + && !isFirst + && (p->bDescIdx==0 || fts3SegReaderIsPending(apSegment[0])==0) + ){ + pCsr->nDoclist = apSegment[0]->nDoclist; + if( fts3SegReaderIsPending(apSegment[0]) ){ + rc = fts3MsrBufferData(pCsr, apSegment[0]->aDoclist, pCsr->nDoclist); + pCsr->aDoclist = pCsr->aBuffer; + }else{ + pCsr->aDoclist = apSegment[0]->aDoclist; + } + if( rc==SQLITE_OK ) rc = SQLITE_ROW; + }else{ + int nDoclist = 0; /* Size of doclist */ + sqlite3_int64 iPrev = 0; /* Previous docid stored in doclist */ + + /* The current term of the first nMerge entries in the array + ** of Fts3SegReader objects is the same. The doclists must be merged + ** and a single term returned with the merged doclist. + */ + for(i=0; ipOffsetList ){ + int j; /* Number of segments that share a docid */ + char *pList = 0; + int nList = 0; + int nByte; + sqlite3_int64 iDocid = apSegment[0]->iDocid; + fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList); + j = 1; + while( jpOffsetList + && apSegment[j]->iDocid==iDocid + ){ + fts3SegReaderNextDocid(p, apSegment[j], 0, 0); + j++; + } + + if( isColFilter ){ + fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList); + } + + if( !isIgnoreEmpty || nList>0 ){ + + /* Calculate the 'docid' delta value to write into the merged + ** doclist. */ + sqlite3_int64 iDelta; + if( p->bDescIdx && nDoclist>0 ){ + iDelta = iPrev - iDocid; + }else{ + iDelta = iDocid - iPrev; + } + assert( iDelta>0 || (nDoclist==0 && iDelta==iDocid) ); + assert( nDoclist>0 || iDelta==iDocid ); + + nByte = sqlite3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0); + if( nDoclist+nByte>pCsr->nBuffer ){ + char *aNew; + pCsr->nBuffer = (nDoclist+nByte)*2; + aNew = sqlite3_realloc(pCsr->aBuffer, pCsr->nBuffer); + if( !aNew ){ + return SQLITE_NOMEM; + } + pCsr->aBuffer = aNew; + } + + if( isFirst ){ + char *a = &pCsr->aBuffer[nDoclist]; + int nWrite; + + nWrite = sqlite3Fts3FirstFilter(iDelta, pList, nList, a); + if( nWrite ){ + iPrev = iDocid; + nDoclist += nWrite; + } + }else{ + nDoclist += sqlite3Fts3PutVarint(&pCsr->aBuffer[nDoclist], iDelta); + iPrev = iDocid; + if( isRequirePos ){ + memcpy(&pCsr->aBuffer[nDoclist], pList, nList); + nDoclist += nList; + pCsr->aBuffer[nDoclist++] = '\0'; + } + } + } + + fts3SegReaderSort(apSegment, nMerge, j, xCmp); + } + if( nDoclist>0 ){ + pCsr->aDoclist = pCsr->aBuffer; + pCsr->nDoclist = nDoclist; + rc = SQLITE_ROW; + } + } + pCsr->nAdvance = nMerge; + }while( rc==SQLITE_OK ); + + return rc; +} + + +SQLITE_PRIVATE void sqlite3Fts3SegReaderFinish( + Fts3MultiSegReader *pCsr /* Cursor object */ +){ + if( pCsr ){ + int i; + for(i=0; inSegment; i++){ + sqlite3Fts3SegReaderFree(pCsr->apSegment[i]); + } + sqlite3_free(pCsr->apSegment); + sqlite3_free(pCsr->aBuffer); + + pCsr->nSegment = 0; + pCsr->apSegment = 0; + pCsr->aBuffer = 0; + } +} + +/* +** Decode the "end_block" field, selected by column iCol of the SELECT +** statement passed as the first argument. +** +** The "end_block" field may contain either an integer, or a text field +** containing the text representation of two non-negative integers separated +** by one or more space (0x20) characters. In the first case, set *piEndBlock +** to the integer value and *pnByte to zero before returning. In the second, +** set *piEndBlock to the first value and *pnByte to the second. +*/ +static void fts3ReadEndBlockField( + sqlite3_stmt *pStmt, + int iCol, + i64 *piEndBlock, + i64 *pnByte +){ + const unsigned char *zText = sqlite3_column_text(pStmt, iCol); + if( zText ){ + int i; + int iMul = 1; + i64 iVal = 0; + for(i=0; zText[i]>='0' && zText[i]<='9'; i++){ + iVal = iVal*10 + (zText[i] - '0'); + } + *piEndBlock = iVal; + while( zText[i]==' ' ) i++; + iVal = 0; + if( zText[i]=='-' ){ + i++; + iMul = -1; + } + for(/* no-op */; zText[i]>='0' && zText[i]<='9'; i++){ + iVal = iVal*10 + (zText[i] - '0'); + } + *pnByte = (iVal * (i64)iMul); + } +} + + +/* +** A segment of size nByte bytes has just been written to absolute level +** iAbsLevel. Promote any segments that should be promoted as a result. +*/ +static int fts3PromoteSegments( + Fts3Table *p, /* FTS table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level just updated */ + sqlite3_int64 nByte /* Size of new segment at iAbsLevel */ +){ + int rc = SQLITE_OK; + sqlite3_stmt *pRange; + + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE2, &pRange, 0); + + if( rc==SQLITE_OK ){ + int bOk = 0; + i64 iLast = (iAbsLevel/FTS3_SEGDIR_MAXLEVEL + 1) * FTS3_SEGDIR_MAXLEVEL - 1; + i64 nLimit = (nByte*3)/2; + + /* Loop through all entries in the %_segdir table corresponding to + ** segments in this index on levels greater than iAbsLevel. If there is + ** at least one such segment, and it is possible to determine that all + ** such segments are smaller than nLimit bytes in size, they will be + ** promoted to level iAbsLevel. */ + sqlite3_bind_int64(pRange, 1, iAbsLevel+1); + sqlite3_bind_int64(pRange, 2, iLast); + while( SQLITE_ROW==sqlite3_step(pRange) ){ + i64 nSize = 0, dummy; + fts3ReadEndBlockField(pRange, 2, &dummy, &nSize); + if( nSize<=0 || nSize>nLimit ){ + /* If nSize==0, then the %_segdir.end_block field does not not + ** contain a size value. This happens if it was written by an + ** old version of FTS. In this case it is not possible to determine + ** the size of the segment, and so segment promotion does not + ** take place. */ + bOk = 0; + break; + } + bOk = 1; + } + rc = sqlite3_reset(pRange); + + if( bOk ){ + int iIdx = 0; + sqlite3_stmt *pUpdate1 = 0; + sqlite3_stmt *pUpdate2 = 0; + + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_UPDATE_LEVEL_IDX, &pUpdate1, 0); + } + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_UPDATE_LEVEL, &pUpdate2, 0); + } + + if( rc==SQLITE_OK ){ + + /* Loop through all %_segdir entries for segments in this index with + ** levels equal to or greater than iAbsLevel. As each entry is visited, + ** updated it to set (level = -1) and (idx = N), where N is 0 for the + ** oldest segment in the range, 1 for the next oldest, and so on. + ** + ** In other words, move all segments being promoted to level -1, + ** setting the "idx" fields as appropriate to keep them in the same + ** order. The contents of level -1 (which is never used, except + ** transiently here), will be moved back to level iAbsLevel below. */ + sqlite3_bind_int64(pRange, 1, iAbsLevel); + while( SQLITE_ROW==sqlite3_step(pRange) ){ + sqlite3_bind_int(pUpdate1, 1, iIdx++); + sqlite3_bind_int(pUpdate1, 2, sqlite3_column_int(pRange, 0)); + sqlite3_bind_int(pUpdate1, 3, sqlite3_column_int(pRange, 1)); + sqlite3_step(pUpdate1); + rc = sqlite3_reset(pUpdate1); + if( rc!=SQLITE_OK ){ + sqlite3_reset(pRange); + break; + } + } + } + if( rc==SQLITE_OK ){ + rc = sqlite3_reset(pRange); + } + + /* Move level -1 to level iAbsLevel */ + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pUpdate2, 1, iAbsLevel); + sqlite3_step(pUpdate2); + rc = sqlite3_reset(pUpdate2); + } + } + } + + + return rc; +} + +/* +** Merge all level iLevel segments in the database into a single +** iLevel+1 segment. Or, if iLevel<0, merge all segments into a +** single segment with a level equal to the numerically largest level +** currently present in the database. +** +** If this function is called with iLevel<0, but there is only one +** segment in the database, SQLITE_DONE is returned immediately. +** Otherwise, if successful, SQLITE_OK is returned. If an error occurs, +** an SQLite error code is returned. +*/ +static int fts3SegmentMerge( + Fts3Table *p, + int iLangid, /* Language id to merge */ + int iIndex, /* Index in p->aIndex[] to merge */ + int iLevel /* Level to merge */ +){ + int rc; /* Return code */ + int iIdx = 0; /* Index of new segment */ + sqlite3_int64 iNewLevel = 0; /* Level/index to create new segment at */ + SegmentWriter *pWriter = 0; /* Used to write the new, merged, segment */ + Fts3SegFilter filter; /* Segment term filter condition */ + Fts3MultiSegReader csr; /* Cursor to iterate through level(s) */ + int bIgnoreEmpty = 0; /* True to ignore empty segments */ + i64 iMaxLevel = 0; /* Max level number for this index/langid */ + + assert( iLevel==FTS3_SEGCURSOR_ALL + || iLevel==FTS3_SEGCURSOR_PENDING + || iLevel>=0 + ); + assert( iLevel=0 && iIndexnIndex ); + + rc = sqlite3Fts3SegReaderCursor(p, iLangid, iIndex, iLevel, 0, 0, 1, 0, &csr); + if( rc!=SQLITE_OK || csr.nSegment==0 ) goto finished; + + if( iLevel!=FTS3_SEGCURSOR_PENDING ){ + rc = fts3SegmentMaxLevel(p, iLangid, iIndex, &iMaxLevel); + if( rc!=SQLITE_OK ) goto finished; + } + + if( iLevel==FTS3_SEGCURSOR_ALL ){ + /* This call is to merge all segments in the database to a single + ** segment. The level of the new segment is equal to the numerically + ** greatest segment level currently present in the database for this + ** index. The idx of the new segment is always 0. */ + if( csr.nSegment==1 ){ + rc = SQLITE_DONE; + goto finished; + } + iNewLevel = iMaxLevel; + bIgnoreEmpty = 1; + + }else{ + /* This call is to merge all segments at level iLevel. find the next + ** available segment index at level iLevel+1. The call to + ** fts3AllocateSegdirIdx() will merge the segments at level iLevel+1 to + ** a single iLevel+2 segment if necessary. */ + assert( FTS3_SEGCURSOR_PENDING==-1 ); + iNewLevel = getAbsoluteLevel(p, iLangid, iIndex, iLevel+1); + rc = fts3AllocateSegdirIdx(p, iLangid, iIndex, iLevel+1, &iIdx); + bIgnoreEmpty = (iLevel!=FTS3_SEGCURSOR_PENDING) && (iNewLevel>iMaxLevel); + } + if( rc!=SQLITE_OK ) goto finished; + + assert( csr.nSegment>0 ); + assert( iNewLevel>=getAbsoluteLevel(p, iLangid, iIndex, 0) ); + assert( iNewLevelnLeafData); + } + } + } + + finished: + fts3SegWriterFree(pWriter); + sqlite3Fts3SegReaderFinish(&csr); + return rc; +} + + +/* +** Flush the contents of pendingTerms to level 0 segments. +*/ +SQLITE_PRIVATE int sqlite3Fts3PendingTermsFlush(Fts3Table *p){ + int rc = SQLITE_OK; + int i; + + for(i=0; rc==SQLITE_OK && inIndex; i++){ + rc = fts3SegmentMerge(p, p->iPrevLangid, i, FTS3_SEGCURSOR_PENDING); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + sqlite3Fts3PendingTermsClear(p); + + /* Determine the auto-incr-merge setting if unknown. If enabled, + ** estimate the number of leaf blocks of content to be written + */ + if( rc==SQLITE_OK && p->bHasStat + && p->nAutoincrmerge==0xff && p->nLeafAdd>0 + ){ + sqlite3_stmt *pStmt = 0; + rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int(pStmt, 1, FTS_STAT_AUTOINCRMERGE); + rc = sqlite3_step(pStmt); + if( rc==SQLITE_ROW ){ + p->nAutoincrmerge = sqlite3_column_int(pStmt, 0); + if( p->nAutoincrmerge==1 ) p->nAutoincrmerge = 8; + }else if( rc==SQLITE_DONE ){ + p->nAutoincrmerge = 0; + } + rc = sqlite3_reset(pStmt); + } + } + return rc; +} + +/* +** Encode N integers as varints into a blob. +*/ +static void fts3EncodeIntArray( + int N, /* The number of integers to encode */ + u32 *a, /* The integer values */ + char *zBuf, /* Write the BLOB here */ + int *pNBuf /* Write number of bytes if zBuf[] used here */ +){ + int i, j; + for(i=j=0; iiPrevDocid. The sizes are encoded as +** a blob of varints. +*/ +static void fts3InsertDocsize( + int *pRC, /* Result code */ + Fts3Table *p, /* Table into which to insert */ + u32 *aSz /* Sizes of each column, in tokens */ +){ + char *pBlob; /* The BLOB encoding of the document size */ + int nBlob; /* Number of bytes in the BLOB */ + sqlite3_stmt *pStmt; /* Statement used to insert the encoding */ + int rc; /* Result code from subfunctions */ + + if( *pRC ) return; + pBlob = sqlite3_malloc( 10*p->nColumn ); + if( pBlob==0 ){ + *pRC = SQLITE_NOMEM; + return; + } + fts3EncodeIntArray(p->nColumn, aSz, pBlob, &nBlob); + rc = fts3SqlStmt(p, SQL_REPLACE_DOCSIZE, &pStmt, 0); + if( rc ){ + sqlite3_free(pBlob); + *pRC = rc; + return; + } + sqlite3_bind_int64(pStmt, 1, p->iPrevDocid); + sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, sqlite3_free); + sqlite3_step(pStmt); + *pRC = sqlite3_reset(pStmt); +} + +/* +** Record 0 of the %_stat table contains a blob consisting of N varints, +** where N is the number of user defined columns in the fts3 table plus +** two. If nCol is the number of user defined columns, then values of the +** varints are set as follows: +** +** Varint 0: Total number of rows in the table. +** +** Varint 1..nCol: For each column, the total number of tokens stored in +** the column for all rows of the table. +** +** Varint 1+nCol: The total size, in bytes, of all text values in all +** columns of all rows of the table. +** +*/ +static void fts3UpdateDocTotals( + int *pRC, /* The result code */ + Fts3Table *p, /* Table being updated */ + u32 *aSzIns, /* Size increases */ + u32 *aSzDel, /* Size decreases */ + int nChng /* Change in the number of documents */ +){ + char *pBlob; /* Storage for BLOB written into %_stat */ + int nBlob; /* Size of BLOB written into %_stat */ + u32 *a; /* Array of integers that becomes the BLOB */ + sqlite3_stmt *pStmt; /* Statement for reading and writing */ + int i; /* Loop counter */ + int rc; /* Result code from subfunctions */ + + const int nStat = p->nColumn+2; + + if( *pRC ) return; + a = sqlite3_malloc( (sizeof(u32)+10)*nStat ); + if( a==0 ){ + *pRC = SQLITE_NOMEM; + return; + } + pBlob = (char*)&a[nStat]; + rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0); + if( rc ){ + sqlite3_free(a); + *pRC = rc; + return; + } + sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL); + if( sqlite3_step(pStmt)==SQLITE_ROW ){ + fts3DecodeIntArray(nStat, a, + sqlite3_column_blob(pStmt, 0), + sqlite3_column_bytes(pStmt, 0)); + }else{ + memset(a, 0, sizeof(u32)*(nStat) ); + } + rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ){ + sqlite3_free(a); + *pRC = rc; + return; + } + if( nChng<0 && a[0]<(u32)(-nChng) ){ + a[0] = 0; + }else{ + a[0] += nChng; + } + for(i=0; inColumn+1; i++){ + u32 x = a[i+1]; + if( x+aSzIns[i] < aSzDel[i] ){ + x = 0; + }else{ + x = x + aSzIns[i] - aSzDel[i]; + } + a[i+1] = x; + } + fts3EncodeIntArray(nStat, a, pBlob, &nBlob); + rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0); + if( rc ){ + sqlite3_free(a); + *pRC = rc; + return; + } + sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL); + sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, SQLITE_STATIC); + sqlite3_step(pStmt); + *pRC = sqlite3_reset(pStmt); + sqlite3_free(a); +} + +/* +** Merge the entire database so that there is one segment for each +** iIndex/iLangid combination. +*/ +static int fts3DoOptimize(Fts3Table *p, int bReturnDone){ + int bSeenDone = 0; + int rc; + sqlite3_stmt *pAllLangid = 0; + + rc = fts3SqlStmt(p, SQL_SELECT_ALL_LANGID, &pAllLangid, 0); + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int(pAllLangid, 1, p->iPrevLangid); + sqlite3_bind_int(pAllLangid, 2, p->nIndex); + while( sqlite3_step(pAllLangid)==SQLITE_ROW ){ + int i; + int iLangid = sqlite3_column_int(pAllLangid, 0); + for(i=0; rc==SQLITE_OK && inIndex; i++){ + rc = fts3SegmentMerge(p, iLangid, i, FTS3_SEGCURSOR_ALL); + if( rc==SQLITE_DONE ){ + bSeenDone = 1; + rc = SQLITE_OK; + } + } + } + rc2 = sqlite3_reset(pAllLangid); + if( rc==SQLITE_OK ) rc = rc2; + } + + sqlite3Fts3SegmentsClose(p); + sqlite3Fts3PendingTermsClear(p); + + return (rc==SQLITE_OK && bReturnDone && bSeenDone) ? SQLITE_DONE : rc; +} + +/* +** This function is called when the user executes the following statement: +** +** INSERT INTO () VALUES('rebuild'); +** +** The entire FTS index is discarded and rebuilt. If the table is one +** created using the content=xxx option, then the new index is based on +** the current contents of the xxx table. Otherwise, it is rebuilt based +** on the contents of the %_content table. +*/ +static int fts3DoRebuild(Fts3Table *p){ + int rc; /* Return Code */ + + rc = fts3DeleteAll(p, 0); + if( rc==SQLITE_OK ){ + u32 *aSz = 0; + u32 *aSzIns = 0; + u32 *aSzDel = 0; + sqlite3_stmt *pStmt = 0; + int nEntry = 0; + + /* Compose and prepare an SQL statement to loop through the content table */ + char *zSql = sqlite3_mprintf("SELECT %s" , p->zReadExprlist); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + } + + if( rc==SQLITE_OK ){ + int nByte = sizeof(u32) * (p->nColumn+1)*3; + aSz = (u32 *)sqlite3_malloc(nByte); + if( aSz==0 ){ + rc = SQLITE_NOMEM; + }else{ + memset(aSz, 0, nByte); + aSzIns = &aSz[p->nColumn+1]; + aSzDel = &aSzIns[p->nColumn+1]; + } + } + + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + int iCol; + int iLangid = langidFromSelect(p, pStmt); + rc = fts3PendingTermsDocid(p, 0, iLangid, sqlite3_column_int64(pStmt, 0)); + memset(aSz, 0, sizeof(aSz[0]) * (p->nColumn+1)); + for(iCol=0; rc==SQLITE_OK && iColnColumn; iCol++){ + if( p->abNotindexed[iCol]==0 ){ + const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1); + rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]); + aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1); + } + } + if( p->bHasDocsize ){ + fts3InsertDocsize(&rc, p, aSz); + } + if( rc!=SQLITE_OK ){ + sqlite3_finalize(pStmt); + pStmt = 0; + }else{ + nEntry++; + for(iCol=0; iCol<=p->nColumn; iCol++){ + aSzIns[iCol] += aSz[iCol]; + } + } + } + if( p->bFts4 ){ + fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nEntry); + } + sqlite3_free(aSz); + + if( pStmt ){ + int rc2 = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + + return rc; +} + + +/* +** This function opens a cursor used to read the input data for an +** incremental merge operation. Specifically, it opens a cursor to scan +** the oldest nSeg segments (idx=0 through idx=(nSeg-1)) in absolute +** level iAbsLevel. +*/ +static int fts3IncrmergeCsr( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level to open */ + int nSeg, /* Number of segments to merge */ + Fts3MultiSegReader *pCsr /* Cursor object to populate */ +){ + int rc; /* Return Code */ + sqlite3_stmt *pStmt = 0; /* Statement used to read %_segdir entry */ + int nByte; /* Bytes allocated at pCsr->apSegment[] */ + + /* Allocate space for the Fts3MultiSegReader.aCsr[] array */ + memset(pCsr, 0, sizeof(*pCsr)); + nByte = sizeof(Fts3SegReader *) * nSeg; + pCsr->apSegment = (Fts3SegReader **)sqlite3_malloc(nByte); + + if( pCsr->apSegment==0 ){ + rc = SQLITE_NOMEM; + }else{ + memset(pCsr->apSegment, 0, nByte); + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0); + } + if( rc==SQLITE_OK ){ + int i; + int rc2; + sqlite3_bind_int64(pStmt, 1, iAbsLevel); + assert( pCsr->nSegment==0 ); + for(i=0; rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW && iapSegment[i] + ); + pCsr->nSegment++; + } + rc2 = sqlite3_reset(pStmt); + if( rc==SQLITE_OK ) rc = rc2; + } + + return rc; +} + +typedef struct IncrmergeWriter IncrmergeWriter; +typedef struct NodeWriter NodeWriter; +typedef struct Blob Blob; +typedef struct NodeReader NodeReader; + +/* +** An instance of the following structure is used as a dynamic buffer +** to build up nodes or other blobs of data in. +** +** The function blobGrowBuffer() is used to extend the allocation. +*/ +struct Blob { + char *a; /* Pointer to allocation */ + int n; /* Number of valid bytes of data in a[] */ + int nAlloc; /* Allocated size of a[] (nAlloc>=n) */ +}; + +/* +** This structure is used to build up buffers containing segment b-tree +** nodes (blocks). +*/ +struct NodeWriter { + sqlite3_int64 iBlock; /* Current block id */ + Blob key; /* Last key written to the current block */ + Blob block; /* Current block image */ +}; + +/* +** An object of this type contains the state required to create or append +** to an appendable b-tree segment. +*/ +struct IncrmergeWriter { + int nLeafEst; /* Space allocated for leaf blocks */ + int nWork; /* Number of leaf pages flushed */ + sqlite3_int64 iAbsLevel; /* Absolute level of input segments */ + int iIdx; /* Index of *output* segment in iAbsLevel+1 */ + sqlite3_int64 iStart; /* Block number of first allocated block */ + sqlite3_int64 iEnd; /* Block number of last allocated block */ + sqlite3_int64 nLeafData; /* Bytes of leaf page data so far */ + u8 bNoLeafData; /* If true, store 0 for segment size */ + NodeWriter aNodeWriter[FTS_MAX_APPENDABLE_HEIGHT]; +}; + +/* +** An object of the following type is used to read data from a single +** FTS segment node. See the following functions: +** +** nodeReaderInit() +** nodeReaderNext() +** nodeReaderRelease() +*/ +struct NodeReader { + const char *aNode; + int nNode; + int iOff; /* Current offset within aNode[] */ + + /* Output variables. Containing the current node entry. */ + sqlite3_int64 iChild; /* Pointer to child node */ + Blob term; /* Current term */ + const char *aDoclist; /* Pointer to doclist */ + int nDoclist; /* Size of doclist in bytes */ +}; + +/* +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, if the allocation at pBlob->a is not already at least nMin +** bytes in size, extend (realloc) it to be so. +** +** If an OOM error occurs, set *pRc to SQLITE_NOMEM and leave pBlob->a +** unmodified. Otherwise, if the allocation succeeds, update pBlob->nAlloc +** to reflect the new size of the pBlob->a[] buffer. +*/ +static void blobGrowBuffer(Blob *pBlob, int nMin, int *pRc){ + if( *pRc==SQLITE_OK && nMin>pBlob->nAlloc ){ + int nAlloc = nMin; + char *a = (char *)sqlite3_realloc(pBlob->a, nAlloc); + if( a ){ + pBlob->nAlloc = nAlloc; + pBlob->a = a; + }else{ + *pRc = SQLITE_NOMEM; + } + } +} + +/* +** Attempt to advance the node-reader object passed as the first argument to +** the next entry on the node. +** +** Return an error code if an error occurs (SQLITE_NOMEM is possible). +** Otherwise return SQLITE_OK. If there is no next entry on the node +** (e.g. because the current entry is the last) set NodeReader->aNode to +** NULL to indicate EOF. Otherwise, populate the NodeReader structure output +** variables for the new entry. +*/ +static int nodeReaderNext(NodeReader *p){ + int bFirst = (p->term.n==0); /* True for first term on the node */ + int nPrefix = 0; /* Bytes to copy from previous term */ + int nSuffix = 0; /* Bytes to append to the prefix */ + int rc = SQLITE_OK; /* Return code */ + + assert( p->aNode ); + if( p->iChild && bFirst==0 ) p->iChild++; + if( p->iOff>=p->nNode ){ + /* EOF */ + p->aNode = 0; + }else{ + if( bFirst==0 ){ + p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nPrefix); + } + p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nSuffix); + + blobGrowBuffer(&p->term, nPrefix+nSuffix, &rc); + if( rc==SQLITE_OK ){ + memcpy(&p->term.a[nPrefix], &p->aNode[p->iOff], nSuffix); + p->term.n = nPrefix+nSuffix; + p->iOff += nSuffix; + if( p->iChild==0 ){ + p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &p->nDoclist); + p->aDoclist = &p->aNode[p->iOff]; + p->iOff += p->nDoclist; + } + } + } + + assert( p->iOff<=p->nNode ); + + return rc; +} + +/* +** Release all dynamic resources held by node-reader object *p. +*/ +static void nodeReaderRelease(NodeReader *p){ + sqlite3_free(p->term.a); +} + +/* +** Initialize a node-reader object to read the node in buffer aNode/nNode. +** +** If successful, SQLITE_OK is returned and the NodeReader object set to +** point to the first entry on the node (if any). Otherwise, an SQLite +** error code is returned. +*/ +static int nodeReaderInit(NodeReader *p, const char *aNode, int nNode){ + memset(p, 0, sizeof(NodeReader)); + p->aNode = aNode; + p->nNode = nNode; + + /* Figure out if this is a leaf or an internal node. */ + if( p->aNode[0] ){ + /* An internal node. */ + p->iOff = 1 + sqlite3Fts3GetVarint(&p->aNode[1], &p->iChild); + }else{ + p->iOff = 1; + } + + return nodeReaderNext(p); +} + +/* +** This function is called while writing an FTS segment each time a leaf o +** node is finished and written to disk. The key (zTerm/nTerm) is guaranteed +** to be greater than the largest key on the node just written, but smaller +** than or equal to the first key that will be written to the next leaf +** node. +** +** The block id of the leaf node just written to disk may be found in +** (pWriter->aNodeWriter[0].iBlock) when this function is called. +*/ +static int fts3IncrmergePush( + Fts3Table *p, /* Fts3 table handle */ + IncrmergeWriter *pWriter, /* Writer object */ + const char *zTerm, /* Term to write to internal node */ + int nTerm /* Bytes at zTerm */ +){ + sqlite3_int64 iPtr = pWriter->aNodeWriter[0].iBlock; + int iLayer; + + assert( nTerm>0 ); + for(iLayer=1; ALWAYS(iLayeraNodeWriter[iLayer]; + int rc = SQLITE_OK; + int nPrefix; + int nSuffix; + int nSpace; + + /* Figure out how much space the key will consume if it is written to + ** the current node of layer iLayer. Due to the prefix compression, + ** the space required changes depending on which node the key is to + ** be added to. */ + nPrefix = fts3PrefixCompress(pNode->key.a, pNode->key.n, zTerm, nTerm); + nSuffix = nTerm - nPrefix; + nSpace = sqlite3Fts3VarintLen(nPrefix); + nSpace += sqlite3Fts3VarintLen(nSuffix) + nSuffix; + + if( pNode->key.n==0 || (pNode->block.n + nSpace)<=p->nNodeSize ){ + /* If the current node of layer iLayer contains zero keys, or if adding + ** the key to it will not cause it to grow to larger than nNodeSize + ** bytes in size, write the key here. */ + + Blob *pBlk = &pNode->block; + if( pBlk->n==0 ){ + blobGrowBuffer(pBlk, p->nNodeSize, &rc); + if( rc==SQLITE_OK ){ + pBlk->a[0] = (char)iLayer; + pBlk->n = 1 + sqlite3Fts3PutVarint(&pBlk->a[1], iPtr); + } + } + blobGrowBuffer(pBlk, pBlk->n + nSpace, &rc); + blobGrowBuffer(&pNode->key, nTerm, &rc); + + if( rc==SQLITE_OK ){ + if( pNode->key.n ){ + pBlk->n += sqlite3Fts3PutVarint(&pBlk->a[pBlk->n], nPrefix); + } + pBlk->n += sqlite3Fts3PutVarint(&pBlk->a[pBlk->n], nSuffix); + memcpy(&pBlk->a[pBlk->n], &zTerm[nPrefix], nSuffix); + pBlk->n += nSuffix; + + memcpy(pNode->key.a, zTerm, nTerm); + pNode->key.n = nTerm; + } + }else{ + /* Otherwise, flush the current node of layer iLayer to disk. + ** Then allocate a new, empty sibling node. The key will be written + ** into the parent of this node. */ + rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n); + + assert( pNode->block.nAlloc>=p->nNodeSize ); + pNode->block.a[0] = (char)iLayer; + pNode->block.n = 1 + sqlite3Fts3PutVarint(&pNode->block.a[1], iPtr+1); + + iNextPtr = pNode->iBlock; + pNode->iBlock++; + pNode->key.n = 0; + } + + if( rc!=SQLITE_OK || iNextPtr==0 ) return rc; + iPtr = iNextPtr; + } + + assert( 0 ); + return 0; +} + +/* +** Append a term and (optionally) doclist to the FTS segment node currently +** stored in blob *pNode. The node need not contain any terms, but the +** header must be written before this function is called. +** +** A node header is a single 0x00 byte for a leaf node, or a height varint +** followed by the left-hand-child varint for an internal node. +** +** The term to be appended is passed via arguments zTerm/nTerm. For a +** leaf node, the doclist is passed as aDoclist/nDoclist. For an internal +** node, both aDoclist and nDoclist must be passed 0. +** +** If the size of the value in blob pPrev is zero, then this is the first +** term written to the node. Otherwise, pPrev contains a copy of the +** previous term. Before this function returns, it is updated to contain a +** copy of zTerm/nTerm. +** +** It is assumed that the buffer associated with pNode is already large +** enough to accommodate the new entry. The buffer associated with pPrev +** is extended by this function if requrired. +** +** If an error (i.e. OOM condition) occurs, an SQLite error code is +** returned. Otherwise, SQLITE_OK. +*/ +static int fts3AppendToNode( + Blob *pNode, /* Current node image to append to */ + Blob *pPrev, /* Buffer containing previous term written */ + const char *zTerm, /* New term to write */ + int nTerm, /* Size of zTerm in bytes */ + const char *aDoclist, /* Doclist (or NULL) to write */ + int nDoclist /* Size of aDoclist in bytes */ +){ + int rc = SQLITE_OK; /* Return code */ + int bFirst = (pPrev->n==0); /* True if this is the first term written */ + int nPrefix; /* Size of term prefix in bytes */ + int nSuffix; /* Size of term suffix in bytes */ + + /* Node must have already been started. There must be a doclist for a + ** leaf node, and there must not be a doclist for an internal node. */ + assert( pNode->n>0 ); + assert( (pNode->a[0]=='\0')==(aDoclist!=0) ); + + blobGrowBuffer(pPrev, nTerm, &rc); + if( rc!=SQLITE_OK ) return rc; + + nPrefix = fts3PrefixCompress(pPrev->a, pPrev->n, zTerm, nTerm); + nSuffix = nTerm - nPrefix; + memcpy(pPrev->a, zTerm, nTerm); + pPrev->n = nTerm; + + if( bFirst==0 ){ + pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nPrefix); + } + pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nSuffix); + memcpy(&pNode->a[pNode->n], &zTerm[nPrefix], nSuffix); + pNode->n += nSuffix; + + if( aDoclist ){ + pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nDoclist); + memcpy(&pNode->a[pNode->n], aDoclist, nDoclist); + pNode->n += nDoclist; + } + + assert( pNode->n<=pNode->nAlloc ); + + return SQLITE_OK; +} + +/* +** Append the current term and doclist pointed to by cursor pCsr to the +** appendable b-tree segment opened for writing by pWriter. +** +** Return SQLITE_OK if successful, or an SQLite error code otherwise. +*/ +static int fts3IncrmergeAppend( + Fts3Table *p, /* Fts3 table handle */ + IncrmergeWriter *pWriter, /* Writer object */ + Fts3MultiSegReader *pCsr /* Cursor containing term and doclist */ +){ + const char *zTerm = pCsr->zTerm; + int nTerm = pCsr->nTerm; + const char *aDoclist = pCsr->aDoclist; + int nDoclist = pCsr->nDoclist; + int rc = SQLITE_OK; /* Return code */ + int nSpace; /* Total space in bytes required on leaf */ + int nPrefix; /* Size of prefix shared with previous term */ + int nSuffix; /* Size of suffix (nTerm - nPrefix) */ + NodeWriter *pLeaf; /* Object used to write leaf nodes */ + + pLeaf = &pWriter->aNodeWriter[0]; + nPrefix = fts3PrefixCompress(pLeaf->key.a, pLeaf->key.n, zTerm, nTerm); + nSuffix = nTerm - nPrefix; + + nSpace = sqlite3Fts3VarintLen(nPrefix); + nSpace += sqlite3Fts3VarintLen(nSuffix) + nSuffix; + nSpace += sqlite3Fts3VarintLen(nDoclist) + nDoclist; + + /* If the current block is not empty, and if adding this term/doclist + ** to the current block would make it larger than Fts3Table.nNodeSize + ** bytes, write this block out to the database. */ + if( pLeaf->block.n>0 && (pLeaf->block.n + nSpace)>p->nNodeSize ){ + rc = fts3WriteSegment(p, pLeaf->iBlock, pLeaf->block.a, pLeaf->block.n); + pWriter->nWork++; + + /* Add the current term to the parent node. The term added to the + ** parent must: + ** + ** a) be greater than the largest term on the leaf node just written + ** to the database (still available in pLeaf->key), and + ** + ** b) be less than or equal to the term about to be added to the new + ** leaf node (zTerm/nTerm). + ** + ** In other words, it must be the prefix of zTerm 1 byte longer than + ** the common prefix (if any) of zTerm and pWriter->zTerm. + */ + if( rc==SQLITE_OK ){ + rc = fts3IncrmergePush(p, pWriter, zTerm, nPrefix+1); + } + + /* Advance to the next output block */ + pLeaf->iBlock++; + pLeaf->key.n = 0; + pLeaf->block.n = 0; + + nSuffix = nTerm; + nSpace = 1; + nSpace += sqlite3Fts3VarintLen(nSuffix) + nSuffix; + nSpace += sqlite3Fts3VarintLen(nDoclist) + nDoclist; + } + + pWriter->nLeafData += nSpace; + blobGrowBuffer(&pLeaf->block, pLeaf->block.n + nSpace, &rc); + if( rc==SQLITE_OK ){ + if( pLeaf->block.n==0 ){ + pLeaf->block.n = 1; + pLeaf->block.a[0] = '\0'; + } + rc = fts3AppendToNode( + &pLeaf->block, &pLeaf->key, zTerm, nTerm, aDoclist, nDoclist + ); + } + + return rc; +} + +/* +** This function is called to release all dynamic resources held by the +** merge-writer object pWriter, and if no error has occurred, to flush +** all outstanding node buffers held by pWriter to disk. +** +** If *pRc is not SQLITE_OK when this function is called, then no attempt +** is made to write any data to disk. Instead, this function serves only +** to release outstanding resources. +** +** Otherwise, if *pRc is initially SQLITE_OK and an error occurs while +** flushing buffers to disk, *pRc is set to an SQLite error code before +** returning. +*/ +static void fts3IncrmergeRelease( + Fts3Table *p, /* FTS3 table handle */ + IncrmergeWriter *pWriter, /* Merge-writer object */ + int *pRc /* IN/OUT: Error code */ +){ + int i; /* Used to iterate through non-root layers */ + int iRoot; /* Index of root in pWriter->aNodeWriter */ + NodeWriter *pRoot; /* NodeWriter for root node */ + int rc = *pRc; /* Error code */ + + /* Set iRoot to the index in pWriter->aNodeWriter[] of the output segment + ** root node. If the segment fits entirely on a single leaf node, iRoot + ** will be set to 0. If the root node is the parent of the leaves, iRoot + ** will be 1. And so on. */ + for(iRoot=FTS_MAX_APPENDABLE_HEIGHT-1; iRoot>=0; iRoot--){ + NodeWriter *pNode = &pWriter->aNodeWriter[iRoot]; + if( pNode->block.n>0 ) break; + assert( *pRc || pNode->block.nAlloc==0 ); + assert( *pRc || pNode->key.nAlloc==0 ); + sqlite3_free(pNode->block.a); + sqlite3_free(pNode->key.a); + } + + /* Empty output segment. This is a no-op. */ + if( iRoot<0 ) return; + + /* The entire output segment fits on a single node. Normally, this means + ** the node would be stored as a blob in the "root" column of the %_segdir + ** table. However, this is not permitted in this case. The problem is that + ** space has already been reserved in the %_segments table, and so the + ** start_block and end_block fields of the %_segdir table must be populated. + ** And, by design or by accident, released versions of FTS cannot handle + ** segments that fit entirely on the root node with start_block!=0. + ** + ** Instead, create a synthetic root node that contains nothing but a + ** pointer to the single content node. So that the segment consists of a + ** single leaf and a single interior (root) node. + ** + ** Todo: Better might be to defer allocating space in the %_segments + ** table until we are sure it is needed. + */ + if( iRoot==0 ){ + Blob *pBlock = &pWriter->aNodeWriter[1].block; + blobGrowBuffer(pBlock, 1 + FTS3_VARINT_MAX, &rc); + if( rc==SQLITE_OK ){ + pBlock->a[0] = 0x01; + pBlock->n = 1 + sqlite3Fts3PutVarint( + &pBlock->a[1], pWriter->aNodeWriter[0].iBlock + ); + } + iRoot = 1; + } + pRoot = &pWriter->aNodeWriter[iRoot]; + + /* Flush all currently outstanding nodes to disk. */ + for(i=0; iaNodeWriter[i]; + if( pNode->block.n>0 && rc==SQLITE_OK ){ + rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n); + } + sqlite3_free(pNode->block.a); + sqlite3_free(pNode->key.a); + } + + /* Write the %_segdir record. */ + if( rc==SQLITE_OK ){ + rc = fts3WriteSegdir(p, + pWriter->iAbsLevel+1, /* level */ + pWriter->iIdx, /* idx */ + pWriter->iStart, /* start_block */ + pWriter->aNodeWriter[0].iBlock, /* leaves_end_block */ + pWriter->iEnd, /* end_block */ + (pWriter->bNoLeafData==0 ? pWriter->nLeafData : 0), /* end_block */ + pRoot->block.a, pRoot->block.n /* root */ + ); + } + sqlite3_free(pRoot->block.a); + sqlite3_free(pRoot->key.a); + + *pRc = rc; +} + +/* +** Compare the term in buffer zLhs (size in bytes nLhs) with that in +** zRhs (size in bytes nRhs) using memcmp. If one term is a prefix of +** the other, it is considered to be smaller than the other. +** +** Return -ve if zLhs is smaller than zRhs, 0 if it is equal, or +ve +** if it is greater. +*/ +static int fts3TermCmp( + const char *zLhs, int nLhs, /* LHS of comparison */ + const char *zRhs, int nRhs /* RHS of comparison */ +){ + int nCmp = MIN(nLhs, nRhs); + int res; + + res = memcmp(zLhs, zRhs, nCmp); + if( res==0 ) res = nLhs - nRhs; + + return res; +} + + +/* +** Query to see if the entry in the %_segments table with blockid iEnd is +** NULL. If no error occurs and the entry is NULL, set *pbRes 1 before +** returning. Otherwise, set *pbRes to 0. +** +** Or, if an error occurs while querying the database, return an SQLite +** error code. The final value of *pbRes is undefined in this case. +** +** This is used to test if a segment is an "appendable" segment. If it +** is, then a NULL entry has been inserted into the %_segments table +** with blockid %_segdir.end_block. +*/ +static int fts3IsAppendable(Fts3Table *p, sqlite3_int64 iEnd, int *pbRes){ + int bRes = 0; /* Result to set *pbRes to */ + sqlite3_stmt *pCheck = 0; /* Statement to query database with */ + int rc; /* Return code */ + + rc = fts3SqlStmt(p, SQL_SEGMENT_IS_APPENDABLE, &pCheck, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pCheck, 1, iEnd); + if( SQLITE_ROW==sqlite3_step(pCheck) ) bRes = 1; + rc = sqlite3_reset(pCheck); + } + + *pbRes = bRes; + return rc; +} + +/* +** This function is called when initializing an incremental-merge operation. +** It checks if the existing segment with index value iIdx at absolute level +** (iAbsLevel+1) can be appended to by the incremental merge. If it can, the +** merge-writer object *pWriter is initialized to write to it. +** +** An existing segment can be appended to by an incremental merge if: +** +** * It was initially created as an appendable segment (with all required +** space pre-allocated), and +** +** * The first key read from the input (arguments zKey and nKey) is +** greater than the largest key currently stored in the potential +** output segment. +*/ +static int fts3IncrmergeLoad( + Fts3Table *p, /* Fts3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level of input segments */ + int iIdx, /* Index of candidate output segment */ + const char *zKey, /* First key to write */ + int nKey, /* Number of bytes in nKey */ + IncrmergeWriter *pWriter /* Populate this object */ +){ + int rc; /* Return code */ + sqlite3_stmt *pSelect = 0; /* SELECT to read %_segdir entry */ + + rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR, &pSelect, 0); + if( rc==SQLITE_OK ){ + sqlite3_int64 iStart = 0; /* Value of %_segdir.start_block */ + sqlite3_int64 iLeafEnd = 0; /* Value of %_segdir.leaves_end_block */ + sqlite3_int64 iEnd = 0; /* Value of %_segdir.end_block */ + const char *aRoot = 0; /* Pointer to %_segdir.root buffer */ + int nRoot = 0; /* Size of aRoot[] in bytes */ + int rc2; /* Return code from sqlite3_reset() */ + int bAppendable = 0; /* Set to true if segment is appendable */ + + /* Read the %_segdir entry for index iIdx absolute level (iAbsLevel+1) */ + sqlite3_bind_int64(pSelect, 1, iAbsLevel+1); + sqlite3_bind_int(pSelect, 2, iIdx); + if( sqlite3_step(pSelect)==SQLITE_ROW ){ + iStart = sqlite3_column_int64(pSelect, 1); + iLeafEnd = sqlite3_column_int64(pSelect, 2); + fts3ReadEndBlockField(pSelect, 3, &iEnd, &pWriter->nLeafData); + if( pWriter->nLeafData<0 ){ + pWriter->nLeafData = pWriter->nLeafData * -1; + } + pWriter->bNoLeafData = (pWriter->nLeafData==0); + nRoot = sqlite3_column_bytes(pSelect, 4); + aRoot = sqlite3_column_blob(pSelect, 4); + }else{ + return sqlite3_reset(pSelect); + } + + /* Check for the zero-length marker in the %_segments table */ + rc = fts3IsAppendable(p, iEnd, &bAppendable); + + /* Check that zKey/nKey is larger than the largest key the candidate */ + if( rc==SQLITE_OK && bAppendable ){ + char *aLeaf = 0; + int nLeaf = 0; + + rc = sqlite3Fts3ReadBlock(p, iLeafEnd, &aLeaf, &nLeaf, 0); + if( rc==SQLITE_OK ){ + NodeReader reader; + for(rc = nodeReaderInit(&reader, aLeaf, nLeaf); + rc==SQLITE_OK && reader.aNode; + rc = nodeReaderNext(&reader) + ){ + assert( reader.aNode ); + } + if( fts3TermCmp(zKey, nKey, reader.term.a, reader.term.n)<=0 ){ + bAppendable = 0; + } + nodeReaderRelease(&reader); + } + sqlite3_free(aLeaf); + } + + if( rc==SQLITE_OK && bAppendable ){ + /* It is possible to append to this segment. Set up the IncrmergeWriter + ** object to do so. */ + int i; + int nHeight = (int)aRoot[0]; + NodeWriter *pNode; + + pWriter->nLeafEst = (int)((iEnd - iStart) + 1)/FTS_MAX_APPENDABLE_HEIGHT; + pWriter->iStart = iStart; + pWriter->iEnd = iEnd; + pWriter->iAbsLevel = iAbsLevel; + pWriter->iIdx = iIdx; + + for(i=nHeight+1; iaNodeWriter[i].iBlock = pWriter->iStart + i*pWriter->nLeafEst; + } + + pNode = &pWriter->aNodeWriter[nHeight]; + pNode->iBlock = pWriter->iStart + pWriter->nLeafEst*nHeight; + blobGrowBuffer(&pNode->block, MAX(nRoot, p->nNodeSize), &rc); + if( rc==SQLITE_OK ){ + memcpy(pNode->block.a, aRoot, nRoot); + pNode->block.n = nRoot; + } + + for(i=nHeight; i>=0 && rc==SQLITE_OK; i--){ + NodeReader reader; + pNode = &pWriter->aNodeWriter[i]; + + rc = nodeReaderInit(&reader, pNode->block.a, pNode->block.n); + while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader); + blobGrowBuffer(&pNode->key, reader.term.n, &rc); + if( rc==SQLITE_OK ){ + memcpy(pNode->key.a, reader.term.a, reader.term.n); + pNode->key.n = reader.term.n; + if( i>0 ){ + char *aBlock = 0; + int nBlock = 0; + pNode = &pWriter->aNodeWriter[i-1]; + pNode->iBlock = reader.iChild; + rc = sqlite3Fts3ReadBlock(p, reader.iChild, &aBlock, &nBlock, 0); + blobGrowBuffer(&pNode->block, MAX(nBlock, p->nNodeSize), &rc); + if( rc==SQLITE_OK ){ + memcpy(pNode->block.a, aBlock, nBlock); + pNode->block.n = nBlock; + } + sqlite3_free(aBlock); + } + } + nodeReaderRelease(&reader); + } + } + + rc2 = sqlite3_reset(pSelect); + if( rc==SQLITE_OK ) rc = rc2; + } + + return rc; +} + +/* +** Determine the largest segment index value that exists within absolute +** level iAbsLevel+1. If no error occurs, set *piIdx to this value plus +** one before returning SQLITE_OK. Or, if there are no segments at all +** within level iAbsLevel, set *piIdx to zero. +** +** If an error occurs, return an SQLite error code. The final value of +** *piIdx is undefined in this case. +*/ +static int fts3IncrmergeOutputIdx( + Fts3Table *p, /* FTS Table handle */ + sqlite3_int64 iAbsLevel, /* Absolute index of input segments */ + int *piIdx /* OUT: Next free index at iAbsLevel+1 */ +){ + int rc; + sqlite3_stmt *pOutputIdx = 0; /* SQL used to find output index */ + + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENT_INDEX, &pOutputIdx, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pOutputIdx, 1, iAbsLevel+1); + sqlite3_step(pOutputIdx); + *piIdx = sqlite3_column_int(pOutputIdx, 0); + rc = sqlite3_reset(pOutputIdx); + } + + return rc; +} + +/* +** Allocate an appendable output segment on absolute level iAbsLevel+1 +** with idx value iIdx. +** +** In the %_segdir table, a segment is defined by the values in three +** columns: +** +** start_block +** leaves_end_block +** end_block +** +** When an appendable segment is allocated, it is estimated that the +** maximum number of leaf blocks that may be required is the sum of the +** number of leaf blocks consumed by the input segments, plus the number +** of input segments, multiplied by two. This value is stored in stack +** variable nLeafEst. +** +** A total of 16*nLeafEst blocks are allocated when an appendable segment +** is created ((1 + end_block - start_block)==16*nLeafEst). The contiguous +** array of leaf nodes starts at the first block allocated. The array +** of interior nodes that are parents of the leaf nodes start at block +** (start_block + (1 + end_block - start_block) / 16). And so on. +** +** In the actual code below, the value "16" is replaced with the +** pre-processor macro FTS_MAX_APPENDABLE_HEIGHT. +*/ +static int fts3IncrmergeWriter( + Fts3Table *p, /* Fts3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level of input segments */ + int iIdx, /* Index of new output segment */ + Fts3MultiSegReader *pCsr, /* Cursor that data will be read from */ + IncrmergeWriter *pWriter /* Populate this object */ +){ + int rc; /* Return Code */ + int i; /* Iterator variable */ + int nLeafEst = 0; /* Blocks allocated for leaf nodes */ + sqlite3_stmt *pLeafEst = 0; /* SQL used to determine nLeafEst */ + sqlite3_stmt *pFirstBlock = 0; /* SQL used to determine first block */ + + /* Calculate nLeafEst. */ + rc = fts3SqlStmt(p, SQL_MAX_LEAF_NODE_ESTIMATE, &pLeafEst, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pLeafEst, 1, iAbsLevel); + sqlite3_bind_int64(pLeafEst, 2, pCsr->nSegment); + if( SQLITE_ROW==sqlite3_step(pLeafEst) ){ + nLeafEst = sqlite3_column_int(pLeafEst, 0); + } + rc = sqlite3_reset(pLeafEst); + } + if( rc!=SQLITE_OK ) return rc; + + /* Calculate the first block to use in the output segment */ + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pFirstBlock, 0); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pFirstBlock) ){ + pWriter->iStart = sqlite3_column_int64(pFirstBlock, 0); + pWriter->iEnd = pWriter->iStart - 1; + pWriter->iEnd += nLeafEst * FTS_MAX_APPENDABLE_HEIGHT; + } + rc = sqlite3_reset(pFirstBlock); + } + if( rc!=SQLITE_OK ) return rc; + + /* Insert the marker in the %_segments table to make sure nobody tries + ** to steal the space just allocated. This is also used to identify + ** appendable segments. */ + rc = fts3WriteSegment(p, pWriter->iEnd, 0, 0); + if( rc!=SQLITE_OK ) return rc; + + pWriter->iAbsLevel = iAbsLevel; + pWriter->nLeafEst = nLeafEst; + pWriter->iIdx = iIdx; + + /* Set up the array of NodeWriter objects */ + for(i=0; iaNodeWriter[i].iBlock = pWriter->iStart + i*pWriter->nLeafEst; + } + return SQLITE_OK; +} + +/* +** Remove an entry from the %_segdir table. This involves running the +** following two statements: +** +** DELETE FROM %_segdir WHERE level = :iAbsLevel AND idx = :iIdx +** UPDATE %_segdir SET idx = idx - 1 WHERE level = :iAbsLevel AND idx > :iIdx +** +** The DELETE statement removes the specific %_segdir level. The UPDATE +** statement ensures that the remaining segments have contiguously allocated +** idx values. +*/ +static int fts3RemoveSegdirEntry( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level to delete from */ + int iIdx /* Index of %_segdir entry to delete */ +){ + int rc; /* Return code */ + sqlite3_stmt *pDelete = 0; /* DELETE statement */ + + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_ENTRY, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDelete, 1, iAbsLevel); + sqlite3_bind_int(pDelete, 2, iIdx); + sqlite3_step(pDelete); + rc = sqlite3_reset(pDelete); + } + + return rc; +} + +/* +** One or more segments have just been removed from absolute level iAbsLevel. +** Update the 'idx' values of the remaining segments in the level so that +** the idx values are a contiguous sequence starting from 0. +*/ +static int fts3RepackSegdirLevel( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel /* Absolute level to repack */ +){ + int rc; /* Return code */ + int *aIdx = 0; /* Array of remaining idx values */ + int nIdx = 0; /* Valid entries in aIdx[] */ + int nAlloc = 0; /* Allocated size of aIdx[] */ + int i; /* Iterator variable */ + sqlite3_stmt *pSelect = 0; /* Select statement to read idx values */ + sqlite3_stmt *pUpdate = 0; /* Update statement to modify idx values */ + + rc = fts3SqlStmt(p, SQL_SELECT_INDEXES, &pSelect, 0); + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int64(pSelect, 1, iAbsLevel); + while( SQLITE_ROW==sqlite3_step(pSelect) ){ + if( nIdx>=nAlloc ){ + int *aNew; + nAlloc += 16; + aNew = sqlite3_realloc(aIdx, nAlloc*sizeof(int)); + if( !aNew ){ + rc = SQLITE_NOMEM; + break; + } + aIdx = aNew; + } + aIdx[nIdx++] = sqlite3_column_int(pSelect, 0); + } + rc2 = sqlite3_reset(pSelect); + if( rc==SQLITE_OK ) rc = rc2; + } + + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_SHIFT_SEGDIR_ENTRY, &pUpdate, 0); + } + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pUpdate, 2, iAbsLevel); + } + + assert( p->bIgnoreSavepoint==0 ); + p->bIgnoreSavepoint = 1; + for(i=0; rc==SQLITE_OK && ibIgnoreSavepoint = 0; + + sqlite3_free(aIdx); + return rc; +} + +static void fts3StartNode(Blob *pNode, int iHeight, sqlite3_int64 iChild){ + pNode->a[0] = (char)iHeight; + if( iChild ){ + assert( pNode->nAlloc>=1+sqlite3Fts3VarintLen(iChild) ); + pNode->n = 1 + sqlite3Fts3PutVarint(&pNode->a[1], iChild); + }else{ + assert( pNode->nAlloc>=1 ); + pNode->n = 1; + } +} + +/* +** The first two arguments are a pointer to and the size of a segment b-tree +** node. The node may be a leaf or an internal node. +** +** This function creates a new node image in blob object *pNew by copying +** all terms that are greater than or equal to zTerm/nTerm (for leaf nodes) +** or greater than zTerm/nTerm (for internal nodes) from aNode/nNode. +*/ +static int fts3TruncateNode( + const char *aNode, /* Current node image */ + int nNode, /* Size of aNode in bytes */ + Blob *pNew, /* OUT: Write new node image here */ + const char *zTerm, /* Omit all terms smaller than this */ + int nTerm, /* Size of zTerm in bytes */ + sqlite3_int64 *piBlock /* OUT: Block number in next layer down */ +){ + NodeReader reader; /* Reader object */ + Blob prev = {0, 0, 0}; /* Previous term written to new node */ + int rc = SQLITE_OK; /* Return code */ + int bLeaf = aNode[0]=='\0'; /* True for a leaf node */ + + /* Allocate required output space */ + blobGrowBuffer(pNew, nNode, &rc); + if( rc!=SQLITE_OK ) return rc; + pNew->n = 0; + + /* Populate new node buffer */ + for(rc = nodeReaderInit(&reader, aNode, nNode); + rc==SQLITE_OK && reader.aNode; + rc = nodeReaderNext(&reader) + ){ + if( pNew->n==0 ){ + int res = fts3TermCmp(reader.term.a, reader.term.n, zTerm, nTerm); + if( res<0 || (bLeaf==0 && res==0) ) continue; + fts3StartNode(pNew, (int)aNode[0], reader.iChild); + *piBlock = reader.iChild; + } + rc = fts3AppendToNode( + pNew, &prev, reader.term.a, reader.term.n, + reader.aDoclist, reader.nDoclist + ); + if( rc!=SQLITE_OK ) break; + } + if( pNew->n==0 ){ + fts3StartNode(pNew, (int)aNode[0], reader.iChild); + *piBlock = reader.iChild; + } + assert( pNew->n<=pNew->nAlloc ); + + nodeReaderRelease(&reader); + sqlite3_free(prev.a); + return rc; +} + +/* +** Remove all terms smaller than zTerm/nTerm from segment iIdx in absolute +** level iAbsLevel. This may involve deleting entries from the %_segments +** table, and modifying existing entries in both the %_segments and %_segdir +** tables. +** +** SQLITE_OK is returned if the segment is updated successfully. Or an +** SQLite error code otherwise. +*/ +static int fts3TruncateSegment( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level of segment to modify */ + int iIdx, /* Index within level of segment to modify */ + const char *zTerm, /* Remove terms smaller than this */ + int nTerm /* Number of bytes in buffer zTerm */ +){ + int rc = SQLITE_OK; /* Return code */ + Blob root = {0,0,0}; /* New root page image */ + Blob block = {0,0,0}; /* Buffer used for any other block */ + sqlite3_int64 iBlock = 0; /* Block id */ + sqlite3_int64 iNewStart = 0; /* New value for iStartBlock */ + sqlite3_int64 iOldStart = 0; /* Old value for iStartBlock */ + sqlite3_stmt *pFetch = 0; /* Statement used to fetch segdir */ + + rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR, &pFetch, 0); + if( rc==SQLITE_OK ){ + int rc2; /* sqlite3_reset() return code */ + sqlite3_bind_int64(pFetch, 1, iAbsLevel); + sqlite3_bind_int(pFetch, 2, iIdx); + if( SQLITE_ROW==sqlite3_step(pFetch) ){ + const char *aRoot = sqlite3_column_blob(pFetch, 4); + int nRoot = sqlite3_column_bytes(pFetch, 4); + iOldStart = sqlite3_column_int64(pFetch, 1); + rc = fts3TruncateNode(aRoot, nRoot, &root, zTerm, nTerm, &iBlock); + } + rc2 = sqlite3_reset(pFetch); + if( rc==SQLITE_OK ) rc = rc2; + } + + while( rc==SQLITE_OK && iBlock ){ + char *aBlock = 0; + int nBlock = 0; + iNewStart = iBlock; + + rc = sqlite3Fts3ReadBlock(p, iBlock, &aBlock, &nBlock, 0); + if( rc==SQLITE_OK ){ + rc = fts3TruncateNode(aBlock, nBlock, &block, zTerm, nTerm, &iBlock); + } + if( rc==SQLITE_OK ){ + rc = fts3WriteSegment(p, iNewStart, block.a, block.n); + } + sqlite3_free(aBlock); + } + + /* Variable iNewStart now contains the first valid leaf node. */ + if( rc==SQLITE_OK && iNewStart ){ + sqlite3_stmt *pDel = 0; + rc = fts3SqlStmt(p, SQL_DELETE_SEGMENTS_RANGE, &pDel, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDel, 1, iOldStart); + sqlite3_bind_int64(pDel, 2, iNewStart-1); + sqlite3_step(pDel); + rc = sqlite3_reset(pDel); + } + } + + if( rc==SQLITE_OK ){ + sqlite3_stmt *pChomp = 0; + rc = fts3SqlStmt(p, SQL_CHOMP_SEGDIR, &pChomp, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pChomp, 1, iNewStart); + sqlite3_bind_blob(pChomp, 2, root.a, root.n, SQLITE_STATIC); + sqlite3_bind_int64(pChomp, 3, iAbsLevel); + sqlite3_bind_int(pChomp, 4, iIdx); + sqlite3_step(pChomp); + rc = sqlite3_reset(pChomp); + } + } + + sqlite3_free(root.a); + sqlite3_free(block.a); + return rc; +} + +/* +** This function is called after an incrmental-merge operation has run to +** merge (or partially merge) two or more segments from absolute level +** iAbsLevel. +** +** Each input segment is either removed from the db completely (if all of +** its data was copied to the output segment by the incrmerge operation) +** or modified in place so that it no longer contains those entries that +** have been duplicated in the output segment. +*/ +static int fts3IncrmergeChomp( + Fts3Table *p, /* FTS table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level containing segments */ + Fts3MultiSegReader *pCsr, /* Chomp all segments opened by this cursor */ + int *pnRem /* Number of segments not deleted */ +){ + int i; + int nRem = 0; + int rc = SQLITE_OK; + + for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){ + Fts3SegReader *pSeg = 0; + int j; + + /* Find the Fts3SegReader object with Fts3SegReader.iIdx==i. It is hiding + ** somewhere in the pCsr->apSegment[] array. */ + for(j=0; ALWAYS(jnSegment); j++){ + pSeg = pCsr->apSegment[j]; + if( pSeg->iIdx==i ) break; + } + assert( jnSegment && pSeg->iIdx==i ); + + if( pSeg->aNode==0 ){ + /* Seg-reader is at EOF. Remove the entire input segment. */ + rc = fts3DeleteSegment(p, pSeg); + if( rc==SQLITE_OK ){ + rc = fts3RemoveSegdirEntry(p, iAbsLevel, pSeg->iIdx); + } + *pnRem = 0; + }else{ + /* The incremental merge did not copy all the data from this + ** segment to the upper level. The segment is modified in place + ** so that it contains no keys smaller than zTerm/nTerm. */ + const char *zTerm = pSeg->zTerm; + int nTerm = pSeg->nTerm; + rc = fts3TruncateSegment(p, iAbsLevel, pSeg->iIdx, zTerm, nTerm); + nRem++; + } + } + + if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){ + rc = fts3RepackSegdirLevel(p, iAbsLevel); + } + + *pnRem = nRem; + return rc; +} + +/* +** Store an incr-merge hint in the database. +*/ +static int fts3IncrmergeHintStore(Fts3Table *p, Blob *pHint){ + sqlite3_stmt *pReplace = 0; + int rc; /* Return code */ + + rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pReplace, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int(pReplace, 1, FTS_STAT_INCRMERGEHINT); + sqlite3_bind_blob(pReplace, 2, pHint->a, pHint->n, SQLITE_STATIC); + sqlite3_step(pReplace); + rc = sqlite3_reset(pReplace); + } + + return rc; +} + +/* +** Load an incr-merge hint from the database. The incr-merge hint, if one +** exists, is stored in the rowid==1 row of the %_stat table. +** +** If successful, populate blob *pHint with the value read from the %_stat +** table and return SQLITE_OK. Otherwise, if an error occurs, return an +** SQLite error code. +*/ +static int fts3IncrmergeHintLoad(Fts3Table *p, Blob *pHint){ + sqlite3_stmt *pSelect = 0; + int rc; + + pHint->n = 0; + rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pSelect, 0); + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int(pSelect, 1, FTS_STAT_INCRMERGEHINT); + if( SQLITE_ROW==sqlite3_step(pSelect) ){ + const char *aHint = sqlite3_column_blob(pSelect, 0); + int nHint = sqlite3_column_bytes(pSelect, 0); + if( aHint ){ + blobGrowBuffer(pHint, nHint, &rc); + if( rc==SQLITE_OK ){ + memcpy(pHint->a, aHint, nHint); + pHint->n = nHint; + } + } + } + rc2 = sqlite3_reset(pSelect); + if( rc==SQLITE_OK ) rc = rc2; + } + + return rc; +} + +/* +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, append an entry to the hint stored in blob *pHint. Each entry +** consists of two varints, the absolute level number of the input segments +** and the number of input segments. +** +** If successful, leave *pRc set to SQLITE_OK and return. If an error occurs, +** set *pRc to an SQLite error code before returning. +*/ +static void fts3IncrmergeHintPush( + Blob *pHint, /* Hint blob to append to */ + i64 iAbsLevel, /* First varint to store in hint */ + int nInput, /* Second varint to store in hint */ + int *pRc /* IN/OUT: Error code */ +){ + blobGrowBuffer(pHint, pHint->n + 2*FTS3_VARINT_MAX, pRc); + if( *pRc==SQLITE_OK ){ + pHint->n += sqlite3Fts3PutVarint(&pHint->a[pHint->n], iAbsLevel); + pHint->n += sqlite3Fts3PutVarint(&pHint->a[pHint->n], (i64)nInput); + } +} + +/* +** Read the last entry (most recently pushed) from the hint blob *pHint +** and then remove the entry. Write the two values read to *piAbsLevel and +** *pnInput before returning. +** +** If no error occurs, return SQLITE_OK. If the hint blob in *pHint does +** not contain at least two valid varints, return SQLITE_CORRUPT_VTAB. +*/ +static int fts3IncrmergeHintPop(Blob *pHint, i64 *piAbsLevel, int *pnInput){ + const int nHint = pHint->n; + int i; + + i = pHint->n-2; + while( i>0 && (pHint->a[i-1] & 0x80) ) i--; + while( i>0 && (pHint->a[i-1] & 0x80) ) i--; + + pHint->n = i; + i += sqlite3Fts3GetVarint(&pHint->a[i], piAbsLevel); + i += fts3GetVarint32(&pHint->a[i], pnInput); + if( i!=nHint ) return FTS_CORRUPT_VTAB; + + return SQLITE_OK; +} + + +/* +** Attempt an incremental merge that writes nMerge leaf blocks. +** +** Incremental merges happen nMin segments at a time. The segments +** to be merged are the nMin oldest segments (the ones with the smallest +** values for the _segdir.idx field) in the highest level that contains +** at least nMin segments. Multiple merges might occur in an attempt to +** write the quota of nMerge leaf blocks. +*/ +SQLITE_PRIVATE int sqlite3Fts3Incrmerge(Fts3Table *p, int nMerge, int nMin){ + int rc; /* Return code */ + int nRem = nMerge; /* Number of leaf pages yet to be written */ + Fts3MultiSegReader *pCsr; /* Cursor used to read input data */ + Fts3SegFilter *pFilter; /* Filter used with cursor pCsr */ + IncrmergeWriter *pWriter; /* Writer object */ + int nSeg = 0; /* Number of input segments */ + sqlite3_int64 iAbsLevel = 0; /* Absolute level number to work on */ + Blob hint = {0, 0, 0}; /* Hint read from %_stat table */ + int bDirtyHint = 0; /* True if blob 'hint' has been modified */ + + /* Allocate space for the cursor, filter and writer objects */ + const int nAlloc = sizeof(*pCsr) + sizeof(*pFilter) + sizeof(*pWriter); + pWriter = (IncrmergeWriter *)sqlite3_malloc(nAlloc); + if( !pWriter ) return SQLITE_NOMEM; + pFilter = (Fts3SegFilter *)&pWriter[1]; + pCsr = (Fts3MultiSegReader *)&pFilter[1]; + + rc = fts3IncrmergeHintLoad(p, &hint); + while( rc==SQLITE_OK && nRem>0 ){ + const i64 nMod = FTS3_SEGDIR_MAXLEVEL * p->nIndex; + sqlite3_stmt *pFindLevel = 0; /* SQL used to determine iAbsLevel */ + int bUseHint = 0; /* True if attempting to append */ + int iIdx = 0; /* Largest idx in level (iAbsLevel+1) */ + + /* Search the %_segdir table for the absolute level with the smallest + ** relative level number that contains at least nMin segments, if any. + ** If one is found, set iAbsLevel to the absolute level number and + ** nSeg to nMin. If no level with at least nMin segments can be found, + ** set nSeg to -1. + */ + rc = fts3SqlStmt(p, SQL_FIND_MERGE_LEVEL, &pFindLevel, 0); + sqlite3_bind_int(pFindLevel, 1, nMin); + if( sqlite3_step(pFindLevel)==SQLITE_ROW ){ + iAbsLevel = sqlite3_column_int64(pFindLevel, 0); + nSeg = nMin; + }else{ + nSeg = -1; + } + rc = sqlite3_reset(pFindLevel); + + /* If the hint read from the %_stat table is not empty, check if the + ** last entry in it specifies a relative level smaller than or equal + ** to the level identified by the block above (if any). If so, this + ** iteration of the loop will work on merging at the hinted level. + */ + if( rc==SQLITE_OK && hint.n ){ + int nHint = hint.n; + sqlite3_int64 iHintAbsLevel = 0; /* Hint level */ + int nHintSeg = 0; /* Hint number of segments */ + + rc = fts3IncrmergeHintPop(&hint, &iHintAbsLevel, &nHintSeg); + if( nSeg<0 || (iAbsLevel % nMod) >= (iHintAbsLevel % nMod) ){ + iAbsLevel = iHintAbsLevel; + nSeg = nHintSeg; + bUseHint = 1; + bDirtyHint = 1; + }else{ + /* This undoes the effect of the HintPop() above - so that no entry + ** is removed from the hint blob. */ + hint.n = nHint; + } + } + + /* If nSeg is less that zero, then there is no level with at least + ** nMin segments and no hint in the %_stat table. No work to do. + ** Exit early in this case. */ + if( nSeg<0 ) break; + + /* Open a cursor to iterate through the contents of the oldest nSeg + ** indexes of absolute level iAbsLevel. If this cursor is opened using + ** the 'hint' parameters, it is possible that there are less than nSeg + ** segments available in level iAbsLevel. In this case, no work is + ** done on iAbsLevel - fall through to the next iteration of the loop + ** to start work on some other level. */ + memset(pWriter, 0, nAlloc); + pFilter->flags = FTS3_SEGMENT_REQUIRE_POS; + + if( rc==SQLITE_OK ){ + rc = fts3IncrmergeOutputIdx(p, iAbsLevel, &iIdx); + assert( bUseHint==1 || bUseHint==0 ); + if( iIdx==0 || (bUseHint && iIdx==1) ){ + int bIgnore = 0; + rc = fts3SegmentIsMaxLevel(p, iAbsLevel+1, &bIgnore); + if( bIgnore ){ + pFilter->flags |= FTS3_SEGMENT_IGNORE_EMPTY; + } + } + } + + if( rc==SQLITE_OK ){ + rc = fts3IncrmergeCsr(p, iAbsLevel, nSeg, pCsr); + } + if( SQLITE_OK==rc && pCsr->nSegment==nSeg + && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter)) + && SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, pCsr)) + ){ + if( bUseHint && iIdx>0 ){ + const char *zKey = pCsr->zTerm; + int nKey = pCsr->nTerm; + rc = fts3IncrmergeLoad(p, iAbsLevel, iIdx-1, zKey, nKey, pWriter); + }else{ + rc = fts3IncrmergeWriter(p, iAbsLevel, iIdx, pCsr, pWriter); + } + + if( rc==SQLITE_OK && pWriter->nLeafEst ){ + fts3LogMerge(nSeg, iAbsLevel); + do { + rc = fts3IncrmergeAppend(p, pWriter, pCsr); + if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr); + if( pWriter->nWork>=nRem && rc==SQLITE_ROW ) rc = SQLITE_OK; + }while( rc==SQLITE_ROW ); + + /* Update or delete the input segments */ + if( rc==SQLITE_OK ){ + nRem -= (1 + pWriter->nWork); + rc = fts3IncrmergeChomp(p, iAbsLevel, pCsr, &nSeg); + if( nSeg!=0 ){ + bDirtyHint = 1; + fts3IncrmergeHintPush(&hint, iAbsLevel, nSeg, &rc); + } + } + } + + if( nSeg!=0 ){ + pWriter->nLeafData = pWriter->nLeafData * -1; + } + fts3IncrmergeRelease(p, pWriter, &rc); + if( nSeg==0 && pWriter->bNoLeafData==0 ){ + fts3PromoteSegments(p, iAbsLevel+1, pWriter->nLeafData); + } + } + + sqlite3Fts3SegReaderFinish(pCsr); + } + + /* Write the hint values into the %_stat table for the next incr-merger */ + if( bDirtyHint && rc==SQLITE_OK ){ + rc = fts3IncrmergeHintStore(p, &hint); + } + + sqlite3_free(pWriter); + sqlite3_free(hint.a); + return rc; +} + +/* +** Convert the text beginning at *pz into an integer and return +** its value. Advance *pz to point to the first character past +** the integer. +*/ +static int fts3Getint(const char **pz){ + const char *z = *pz; + int i = 0; + while( (*z)>='0' && (*z)<='9' ) i = 10*i + *(z++) - '0'; + *pz = z; + return i; +} + +/* +** Process statements of the form: +** +** INSERT INTO table(table) VALUES('merge=A,B'); +** +** A and B are integers that decode to be the number of leaf pages +** written for the merge, and the minimum number of segments on a level +** before it will be selected for a merge, respectively. +*/ +static int fts3DoIncrmerge( + Fts3Table *p, /* FTS3 table handle */ + const char *zParam /* Nul-terminated string containing "A,B" */ +){ + int rc; + int nMin = (FTS3_MERGE_COUNT / 2); + int nMerge = 0; + const char *z = zParam; + + /* Read the first integer value */ + nMerge = fts3Getint(&z); + + /* If the first integer value is followed by a ',', read the second + ** integer value. */ + if( z[0]==',' && z[1]!='\0' ){ + z++; + nMin = fts3Getint(&z); + } + + if( z[0]!='\0' || nMin<2 ){ + rc = SQLITE_ERROR; + }else{ + rc = SQLITE_OK; + if( !p->bHasStat ){ + assert( p->bFts4==0 ); + sqlite3Fts3CreateStatTable(&rc, p); + } + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3Incrmerge(p, nMerge, nMin); + } + sqlite3Fts3SegmentsClose(p); + } + return rc; +} + +/* +** Process statements of the form: +** +** INSERT INTO table(table) VALUES('automerge=X'); +** +** where X is an integer. X==0 means to turn automerge off. X!=0 means +** turn it on. The setting is persistent. +*/ +static int fts3DoAutoincrmerge( + Fts3Table *p, /* FTS3 table handle */ + const char *zParam /* Nul-terminated string containing boolean */ +){ + int rc = SQLITE_OK; + sqlite3_stmt *pStmt = 0; + p->nAutoincrmerge = fts3Getint(&zParam); + if( p->nAutoincrmerge==1 || p->nAutoincrmerge>FTS3_MERGE_COUNT ){ + p->nAutoincrmerge = 8; + } + if( !p->bHasStat ){ + assert( p->bFts4==0 ); + sqlite3Fts3CreateStatTable(&rc, p); + if( rc ) return rc; + } + rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0); + if( rc ) return rc; + sqlite3_bind_int(pStmt, 1, FTS_STAT_AUTOINCRMERGE); + sqlite3_bind_int(pStmt, 2, p->nAutoincrmerge); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + return rc; +} + +/* +** Return a 64-bit checksum for the FTS index entry specified by the +** arguments to this function. +*/ +static u64 fts3ChecksumEntry( + const char *zTerm, /* Pointer to buffer containing term */ + int nTerm, /* Size of zTerm in bytes */ + int iLangid, /* Language id for current row */ + int iIndex, /* Index (0..Fts3Table.nIndex-1) */ + i64 iDocid, /* Docid for current row. */ + int iCol, /* Column number */ + int iPos /* Position */ +){ + int i; + u64 ret = (u64)iDocid; + + ret += (ret<<3) + iLangid; + ret += (ret<<3) + iIndex; + ret += (ret<<3) + iCol; + ret += (ret<<3) + iPos; + for(i=0; inIndex-1) */ + int *pRc /* OUT: Return code */ +){ + Fts3SegFilter filter; + Fts3MultiSegReader csr; + int rc; + u64 cksum = 0; + + assert( *pRc==SQLITE_OK ); + + memset(&filter, 0, sizeof(filter)); + memset(&csr, 0, sizeof(csr)); + filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY; + filter.flags |= FTS3_SEGMENT_SCAN; + + rc = sqlite3Fts3SegReaderCursor( + p, iLangid, iIndex, FTS3_SEGCURSOR_ALL, 0, 0, 0, 1,&csr + ); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3SegReaderStart(p, &csr, &filter); + } + + if( rc==SQLITE_OK ){ + while( SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, &csr)) ){ + char *pCsr = csr.aDoclist; + char *pEnd = &pCsr[csr.nDoclist]; + + i64 iDocid = 0; + i64 iCol = 0; + i64 iPos = 0; + + pCsr += sqlite3Fts3GetVarint(pCsr, &iDocid); + while( pCsriPrevLangid); + sqlite3_bind_int(pAllLangid, 2, p->nIndex); + while( rc==SQLITE_OK && sqlite3_step(pAllLangid)==SQLITE_ROW ){ + int iLangid = sqlite3_column_int(pAllLangid, 0); + int i; + for(i=0; inIndex; i++){ + cksum1 = cksum1 ^ fts3ChecksumIndex(p, iLangid, i, &rc); + } + } + rc2 = sqlite3_reset(pAllLangid); + if( rc==SQLITE_OK ) rc = rc2; + } + + /* This block calculates the checksum according to the %_content table */ + if( rc==SQLITE_OK ){ + sqlite3_tokenizer_module const *pModule = p->pTokenizer->pModule; + sqlite3_stmt *pStmt = 0; + char *zSql; + + zSql = sqlite3_mprintf("SELECT %s" , p->zReadExprlist); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + } + + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + i64 iDocid = sqlite3_column_int64(pStmt, 0); + int iLang = langidFromSelect(p, pStmt); + int iCol; + + for(iCol=0; rc==SQLITE_OK && iColnColumn; iCol++){ + if( p->abNotindexed[iCol]==0 ){ + const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1); + int nText = sqlite3_column_bytes(pStmt, iCol+1); + sqlite3_tokenizer_cursor *pT = 0; + + rc = sqlite3Fts3OpenTokenizer(p->pTokenizer, iLang, zText, nText,&pT); + while( rc==SQLITE_OK ){ + char const *zToken; /* Buffer containing token */ + int nToken = 0; /* Number of bytes in token */ + int iDum1 = 0, iDum2 = 0; /* Dummy variables */ + int iPos = 0; /* Position of token in zText */ + + rc = pModule->xNext(pT, &zToken, &nToken, &iDum1, &iDum2, &iPos); + if( rc==SQLITE_OK ){ + int i; + cksum2 = cksum2 ^ fts3ChecksumEntry( + zToken, nToken, iLang, 0, iDocid, iCol, iPos + ); + for(i=1; inIndex; i++){ + if( p->aIndex[i].nPrefix<=nToken ){ + cksum2 = cksum2 ^ fts3ChecksumEntry( + zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos + ); + } + } + } + } + if( pT ) pModule->xClose(pT); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + } + } + + sqlite3_finalize(pStmt); + } + + *pbOk = (cksum1==cksum2); + return rc; +} + +/* +** Run the integrity-check. If no error occurs and the current contents of +** the FTS index are correct, return SQLITE_OK. Or, if the contents of the +** FTS index are incorrect, return SQLITE_CORRUPT_VTAB. +** +** Or, if an error (e.g. an OOM or IO error) occurs, return an SQLite +** error code. +** +** The integrity-check works as follows. For each token and indexed token +** prefix in the document set, a 64-bit checksum is calculated (by code +** in fts3ChecksumEntry()) based on the following: +** +** + The index number (0 for the main index, 1 for the first prefix +** index etc.), +** + The token (or token prefix) text itself, +** + The language-id of the row it appears in, +** + The docid of the row it appears in, +** + The column it appears in, and +** + The tokens position within that column. +** +** The checksums for all entries in the index are XORed together to create +** a single checksum for the entire index. +** +** The integrity-check code calculates the same checksum in two ways: +** +** 1. By scanning the contents of the FTS index, and +** 2. By scanning and tokenizing the content table. +** +** If the two checksums are identical, the integrity-check is deemed to have +** passed. +*/ +static int fts3DoIntegrityCheck( + Fts3Table *p /* FTS3 table handle */ +){ + int rc; + int bOk = 0; + rc = fts3IntegrityCheck(p, &bOk); + if( rc==SQLITE_OK && bOk==0 ) rc = FTS_CORRUPT_VTAB; + return rc; +} + +/* +** Handle a 'special' INSERT of the form: +** +** "INSERT INTO tbl(tbl) VALUES()" +** +** Argument pVal contains the result of . Currently the only +** meaningful value to insert is the text 'optimize'. +*/ +static int fts3SpecialInsert(Fts3Table *p, sqlite3_value *pVal){ + int rc; /* Return Code */ + const char *zVal = (const char *)sqlite3_value_text(pVal); + int nVal = sqlite3_value_bytes(pVal); + + if( !zVal ){ + return SQLITE_NOMEM; + }else if( nVal==8 && 0==sqlite3_strnicmp(zVal, "optimize", 8) ){ + rc = fts3DoOptimize(p, 0); + }else if( nVal==7 && 0==sqlite3_strnicmp(zVal, "rebuild", 7) ){ + rc = fts3DoRebuild(p); + }else if( nVal==15 && 0==sqlite3_strnicmp(zVal, "integrity-check", 15) ){ + rc = fts3DoIntegrityCheck(p); + }else if( nVal>6 && 0==sqlite3_strnicmp(zVal, "merge=", 6) ){ + rc = fts3DoIncrmerge(p, &zVal[6]); + }else if( nVal>10 && 0==sqlite3_strnicmp(zVal, "automerge=", 10) ){ + rc = fts3DoAutoincrmerge(p, &zVal[10]); +#ifdef SQLITE_TEST + }else if( nVal>9 && 0==sqlite3_strnicmp(zVal, "nodesize=", 9) ){ + p->nNodeSize = atoi(&zVal[9]); + rc = SQLITE_OK; + }else if( nVal>11 && 0==sqlite3_strnicmp(zVal, "maxpending=", 9) ){ + p->nMaxPendingData = atoi(&zVal[11]); + rc = SQLITE_OK; + }else if( nVal>21 && 0==sqlite3_strnicmp(zVal, "test-no-incr-doclist=", 21) ){ + p->bNoIncrDoclist = atoi(&zVal[21]); + rc = SQLITE_OK; +#endif + }else{ + rc = SQLITE_ERROR; + } + + return rc; +} + +#ifndef SQLITE_DISABLE_FTS4_DEFERRED +/* +** Delete all cached deferred doclists. Deferred doclists are cached +** (allocated) by the sqlite3Fts3CacheDeferredDoclists() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *pCsr){ + Fts3DeferredToken *pDef; + for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){ + fts3PendingListDelete(pDef->pList); + pDef->pList = 0; + } +} + +/* +** Free all entries in the pCsr->pDeffered list. Entries are added to +** this list using sqlite3Fts3DeferToken(). +*/ +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *pCsr){ + Fts3DeferredToken *pDef; + Fts3DeferredToken *pNext; + for(pDef=pCsr->pDeferred; pDef; pDef=pNext){ + pNext = pDef->pNext; + fts3PendingListDelete(pDef->pList); + sqlite3_free(pDef); + } + pCsr->pDeferred = 0; +} + +/* +** Generate deferred-doclists for all tokens in the pCsr->pDeferred list +** based on the row that pCsr currently points to. +** +** A deferred-doclist is like any other doclist with position information +** included, except that it only contains entries for a single row of the +** table, not for all rows. +*/ +SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *pCsr){ + int rc = SQLITE_OK; /* Return code */ + if( pCsr->pDeferred ){ + int i; /* Used to iterate through table columns */ + sqlite3_int64 iDocid; /* Docid of the row pCsr points to */ + Fts3DeferredToken *pDef; /* Used to iterate through deferred tokens */ + + Fts3Table *p = (Fts3Table *)pCsr->base.pVtab; + sqlite3_tokenizer *pT = p->pTokenizer; + sqlite3_tokenizer_module const *pModule = pT->pModule; + + assert( pCsr->isRequireSeek==0 ); + iDocid = sqlite3_column_int64(pCsr->pStmt, 0); + + for(i=0; inColumn && rc==SQLITE_OK; i++){ + if( p->abNotindexed[i]==0 ){ + const char *zText = (const char *)sqlite3_column_text(pCsr->pStmt, i+1); + sqlite3_tokenizer_cursor *pTC = 0; + + rc = sqlite3Fts3OpenTokenizer(pT, pCsr->iLangid, zText, -1, &pTC); + while( rc==SQLITE_OK ){ + char const *zToken; /* Buffer containing token */ + int nToken = 0; /* Number of bytes in token */ + int iDum1 = 0, iDum2 = 0; /* Dummy variables */ + int iPos = 0; /* Position of token in zText */ + + rc = pModule->xNext(pTC, &zToken, &nToken, &iDum1, &iDum2, &iPos); + for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){ + Fts3PhraseToken *pPT = pDef->pToken; + if( (pDef->iCol>=p->nColumn || pDef->iCol==i) + && (pPT->bFirst==0 || iPos==0) + && (pPT->n==nToken || (pPT->isPrefix && pPT->nz, pPT->n)) + ){ + fts3PendingListAppend(&pDef->pList, iDocid, i, iPos, &rc); + } + } + } + if( pTC ) pModule->xClose(pTC); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + } + + for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){ + if( pDef->pList ){ + rc = fts3PendingListAppendVarint(&pDef->pList, 0); + } + } + } + + return rc; +} + +SQLITE_PRIVATE int sqlite3Fts3DeferredTokenList( + Fts3DeferredToken *p, + char **ppData, + int *pnData +){ + char *pRet; + int nSkip; + sqlite3_int64 dummy; + + *ppData = 0; + *pnData = 0; + + if( p->pList==0 ){ + return SQLITE_OK; + } + + pRet = (char *)sqlite3_malloc(p->pList->nData); + if( !pRet ) return SQLITE_NOMEM; + + nSkip = sqlite3Fts3GetVarint(p->pList->aData, &dummy); + *pnData = p->pList->nData - nSkip; + *ppData = pRet; + + memcpy(pRet, &p->pList->aData[nSkip], *pnData); + return SQLITE_OK; +} + +/* +** Add an entry for token pToken to the pCsr->pDeferred list. +*/ +SQLITE_PRIVATE int sqlite3Fts3DeferToken( + Fts3Cursor *pCsr, /* Fts3 table cursor */ + Fts3PhraseToken *pToken, /* Token to defer */ + int iCol /* Column that token must appear in (or -1) */ +){ + Fts3DeferredToken *pDeferred; + pDeferred = sqlite3_malloc(sizeof(*pDeferred)); + if( !pDeferred ){ + return SQLITE_NOMEM; + } + memset(pDeferred, 0, sizeof(*pDeferred)); + pDeferred->pToken = pToken; + pDeferred->pNext = pCsr->pDeferred; + pDeferred->iCol = iCol; + pCsr->pDeferred = pDeferred; + + assert( pToken->pDeferred==0 ); + pToken->pDeferred = pDeferred; + + return SQLITE_OK; +} +#endif + +/* +** SQLite value pRowid contains the rowid of a row that may or may not be +** present in the FTS3 table. If it is, delete it and adjust the contents +** of subsiduary data structures accordingly. +*/ +static int fts3DeleteByRowid( + Fts3Table *p, + sqlite3_value *pRowid, + int *pnChng, /* IN/OUT: Decrement if row is deleted */ + u32 *aSzDel +){ + int rc = SQLITE_OK; /* Return code */ + int bFound = 0; /* True if *pRowid really is in the table */ + + fts3DeleteTerms(&rc, p, pRowid, aSzDel, &bFound); + if( bFound && rc==SQLITE_OK ){ + int isEmpty = 0; /* Deleting *pRowid leaves the table empty */ + rc = fts3IsEmpty(p, pRowid, &isEmpty); + if( rc==SQLITE_OK ){ + if( isEmpty ){ + /* Deleting this row means the whole table is empty. In this case + ** delete the contents of all three tables and throw away any + ** data in the pendingTerms hash table. */ + rc = fts3DeleteAll(p, 1); + *pnChng = 0; + memset(aSzDel, 0, sizeof(u32) * (p->nColumn+1) * 2); + }else{ + *pnChng = *pnChng - 1; + if( p->zContentTbl==0 ){ + fts3SqlExec(&rc, p, SQL_DELETE_CONTENT, &pRowid); + } + if( p->bHasDocsize ){ + fts3SqlExec(&rc, p, SQL_DELETE_DOCSIZE, &pRowid); + } + } + } + } + + return rc; +} + +/* +** This function does the work for the xUpdate method of FTS3 virtual +** tables. The schema of the virtual table being: +** +** CREATE TABLE
    ( +** , +**
    HIDDEN, +** docid HIDDEN, +** HIDDEN +** ); +** +** +*/ +SQLITE_PRIVATE int sqlite3Fts3UpdateMethod( + sqlite3_vtab *pVtab, /* FTS3 vtab object */ + int nArg, /* Size of argument array */ + sqlite3_value **apVal, /* Array of arguments */ + sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */ +){ + Fts3Table *p = (Fts3Table *)pVtab; + int rc = SQLITE_OK; /* Return Code */ + int isRemove = 0; /* True for an UPDATE or DELETE */ + u32 *aSzIns = 0; /* Sizes of inserted documents */ + u32 *aSzDel = 0; /* Sizes of deleted documents */ + int nChng = 0; /* Net change in number of documents */ + int bInsertDone = 0; + + /* At this point it must be known if the %_stat table exists or not. + ** So bHasStat may not be 2. */ + assert( p->bHasStat==0 || p->bHasStat==1 ); + + assert( p->pSegments==0 ); + assert( + nArg==1 /* DELETE operations */ + || nArg==(2 + p->nColumn + 3) /* INSERT or UPDATE operations */ + ); + + /* Check for a "special" INSERT operation. One of the form: + ** + ** INSERT INTO xyz(xyz) VALUES('command'); + */ + if( nArg>1 + && sqlite3_value_type(apVal[0])==SQLITE_NULL + && sqlite3_value_type(apVal[p->nColumn+2])!=SQLITE_NULL + ){ + rc = fts3SpecialInsert(p, apVal[p->nColumn+2]); + goto update_out; + } + + if( nArg>1 && sqlite3_value_int(apVal[2 + p->nColumn + 2])<0 ){ + rc = SQLITE_CONSTRAINT; + goto update_out; + } + + /* Allocate space to hold the change in document sizes */ + aSzDel = sqlite3_malloc( sizeof(aSzDel[0])*(p->nColumn+1)*2 ); + if( aSzDel==0 ){ + rc = SQLITE_NOMEM; + goto update_out; + } + aSzIns = &aSzDel[p->nColumn+1]; + memset(aSzDel, 0, sizeof(aSzDel[0])*(p->nColumn+1)*2); + + rc = fts3Writelock(p); + if( rc!=SQLITE_OK ) goto update_out; + + /* If this is an INSERT operation, or an UPDATE that modifies the rowid + ** value, then this operation requires constraint handling. + ** + ** If the on-conflict mode is REPLACE, this means that the existing row + ** should be deleted from the database before inserting the new row. Or, + ** if the on-conflict mode is other than REPLACE, then this method must + ** detect the conflict and return SQLITE_CONSTRAINT before beginning to + ** modify the database file. + */ + if( nArg>1 && p->zContentTbl==0 ){ + /* Find the value object that holds the new rowid value. */ + sqlite3_value *pNewRowid = apVal[3+p->nColumn]; + if( sqlite3_value_type(pNewRowid)==SQLITE_NULL ){ + pNewRowid = apVal[1]; + } + + if( sqlite3_value_type(pNewRowid)!=SQLITE_NULL && ( + sqlite3_value_type(apVal[0])==SQLITE_NULL + || sqlite3_value_int64(apVal[0])!=sqlite3_value_int64(pNewRowid) + )){ + /* The new rowid is not NULL (in this case the rowid will be + ** automatically assigned and there is no chance of a conflict), and + ** the statement is either an INSERT or an UPDATE that modifies the + ** rowid column. So if the conflict mode is REPLACE, then delete any + ** existing row with rowid=pNewRowid. + ** + ** Or, if the conflict mode is not REPLACE, insert the new record into + ** the %_content table. If we hit the duplicate rowid constraint (or any + ** other error) while doing so, return immediately. + ** + ** This branch may also run if pNewRowid contains a value that cannot + ** be losslessly converted to an integer. In this case, the eventual + ** call to fts3InsertData() (either just below or further on in this + ** function) will return SQLITE_MISMATCH. If fts3DeleteByRowid is + ** invoked, it will delete zero rows (since no row will have + ** docid=$pNewRowid if $pNewRowid is not an integer value). + */ + if( sqlite3_vtab_on_conflict(p->db)==SQLITE_REPLACE ){ + rc = fts3DeleteByRowid(p, pNewRowid, &nChng, aSzDel); + }else{ + rc = fts3InsertData(p, apVal, pRowid); + bInsertDone = 1; + } + } + } + if( rc!=SQLITE_OK ){ + goto update_out; + } + + /* If this is a DELETE or UPDATE operation, remove the old record. */ + if( sqlite3_value_type(apVal[0])!=SQLITE_NULL ){ + assert( sqlite3_value_type(apVal[0])==SQLITE_INTEGER ); + rc = fts3DeleteByRowid(p, apVal[0], &nChng, aSzDel); + isRemove = 1; + } + + /* If this is an INSERT or UPDATE operation, insert the new record. */ + if( nArg>1 && rc==SQLITE_OK ){ + int iLangid = sqlite3_value_int(apVal[2 + p->nColumn + 2]); + if( bInsertDone==0 ){ + rc = fts3InsertData(p, apVal, pRowid); + if( rc==SQLITE_CONSTRAINT && p->zContentTbl==0 ){ + rc = FTS_CORRUPT_VTAB; + } + } + if( rc==SQLITE_OK && (!isRemove || *pRowid!=p->iPrevDocid ) ){ + rc = fts3PendingTermsDocid(p, 0, iLangid, *pRowid); + } + if( rc==SQLITE_OK ){ + assert( p->iPrevDocid==*pRowid ); + rc = fts3InsertTerms(p, iLangid, apVal, aSzIns); + } + if( p->bHasDocsize ){ + fts3InsertDocsize(&rc, p, aSzIns); + } + nChng++; + } + + if( p->bFts4 ){ + fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nChng); + } + + update_out: + sqlite3_free(aSzDel); + sqlite3Fts3SegmentsClose(p); + return rc; +} + +/* +** Flush any data in the pending-terms hash table to disk. If successful, +** merge all segments in the database (including the new segment, if +** there was any data to flush) into a single segment. +*/ +SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *p){ + int rc; + rc = sqlite3_exec(p->db, "SAVEPOINT fts3", 0, 0, 0); + if( rc==SQLITE_OK ){ + rc = fts3DoOptimize(p, 1); + if( rc==SQLITE_OK || rc==SQLITE_DONE ){ + int rc2 = sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0); + if( rc2!=SQLITE_OK ) rc = rc2; + }else{ + sqlite3_exec(p->db, "ROLLBACK TO fts3", 0, 0, 0); + sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0); + } + } + sqlite3Fts3SegmentsClose(p); + return rc; +} + +#endif + +/************** End of fts3_write.c ******************************************/ +/************** Begin file fts3_snippet.c ************************************/ +/* +** 2009 Oct 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +*/ + +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +/* +** Characters that may appear in the second argument to matchinfo(). +*/ +#define FTS3_MATCHINFO_NPHRASE 'p' /* 1 value */ +#define FTS3_MATCHINFO_NCOL 'c' /* 1 value */ +#define FTS3_MATCHINFO_NDOC 'n' /* 1 value */ +#define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */ +#define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */ +#define FTS3_MATCHINFO_LCS 's' /* nCol values */ +#define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */ +#define FTS3_MATCHINFO_LHITS 'y' /* nCol*nPhrase values */ +#define FTS3_MATCHINFO_LHITS_BM 'b' /* nCol*nPhrase values */ + +/* +** The default value for the second argument to matchinfo(). +*/ +#define FTS3_MATCHINFO_DEFAULT "pcx" + + +/* +** Used as an fts3ExprIterate() context when loading phrase doclists to +** Fts3Expr.aDoclist[]/nDoclist. +*/ +typedef struct LoadDoclistCtx LoadDoclistCtx; +struct LoadDoclistCtx { + Fts3Cursor *pCsr; /* FTS3 Cursor */ + int nPhrase; /* Number of phrases seen so far */ + int nToken; /* Number of tokens seen so far */ +}; + +/* +** The following types are used as part of the implementation of the +** fts3BestSnippet() routine. +*/ +typedef struct SnippetIter SnippetIter; +typedef struct SnippetPhrase SnippetPhrase; +typedef struct SnippetFragment SnippetFragment; + +struct SnippetIter { + Fts3Cursor *pCsr; /* Cursor snippet is being generated from */ + int iCol; /* Extract snippet from this column */ + int nSnippet; /* Requested snippet length (in tokens) */ + int nPhrase; /* Number of phrases in query */ + SnippetPhrase *aPhrase; /* Array of size nPhrase */ + int iCurrent; /* First token of current snippet */ +}; + +struct SnippetPhrase { + int nToken; /* Number of tokens in phrase */ + char *pList; /* Pointer to start of phrase position list */ + int iHead; /* Next value in position list */ + char *pHead; /* Position list data following iHead */ + int iTail; /* Next value in trailing position list */ + char *pTail; /* Position list data following iTail */ +}; + +struct SnippetFragment { + int iCol; /* Column snippet is extracted from */ + int iPos; /* Index of first token in snippet */ + u64 covered; /* Mask of query phrases covered */ + u64 hlmask; /* Mask of snippet terms to highlight */ +}; + +/* +** This type is used as an fts3ExprIterate() context object while +** accumulating the data returned by the matchinfo() function. +*/ +typedef struct MatchInfo MatchInfo; +struct MatchInfo { + Fts3Cursor *pCursor; /* FTS3 Cursor */ + int nCol; /* Number of columns in table */ + int nPhrase; /* Number of matchable phrases in query */ + sqlite3_int64 nDoc; /* Number of docs in database */ + char flag; + u32 *aMatchinfo; /* Pre-allocated buffer */ +}; + +/* +** An instance of this structure is used to manage a pair of buffers, each +** (nElem * sizeof(u32)) bytes in size. See the MatchinfoBuffer code below +** for details. +*/ +struct MatchinfoBuffer { + u8 aRef[3]; + int nElem; + int bGlobal; /* Set if global data is loaded */ + char *zMatchinfo; + u32 aMatchinfo[1]; +}; + + +/* +** The snippet() and offsets() functions both return text values. An instance +** of the following structure is used to accumulate those values while the +** functions are running. See fts3StringAppend() for details. +*/ +typedef struct StrBuffer StrBuffer; +struct StrBuffer { + char *z; /* Pointer to buffer containing string */ + int n; /* Length of z in bytes (excl. nul-term) */ + int nAlloc; /* Allocated size of buffer z in bytes */ +}; + + +/************************************************************************* +** Start of MatchinfoBuffer code. +*/ + +/* +** Allocate a two-slot MatchinfoBuffer object. +*/ +static MatchinfoBuffer *fts3MIBufferNew(int nElem, const char *zMatchinfo){ + MatchinfoBuffer *pRet; + int nByte = sizeof(u32) * (2*nElem + 1) + sizeof(MatchinfoBuffer); + int nStr = (int)strlen(zMatchinfo); + + pRet = sqlite3_malloc(nByte + nStr+1); + if( pRet ){ + memset(pRet, 0, nByte); + pRet->aMatchinfo[0] = (u8*)(&pRet->aMatchinfo[1]) - (u8*)pRet; + pRet->aMatchinfo[1+nElem] = pRet->aMatchinfo[0] + sizeof(u32)*(nElem+1); + pRet->nElem = nElem; + pRet->zMatchinfo = ((char*)pRet) + nByte; + memcpy(pRet->zMatchinfo, zMatchinfo, nStr+1); + pRet->aRef[0] = 1; + } + + return pRet; +} + +static void fts3MIBufferFree(void *p){ + MatchinfoBuffer *pBuf = (MatchinfoBuffer*)((u8*)p - ((u32*)p)[-1]); + + assert( (u32*)p==&pBuf->aMatchinfo[1] + || (u32*)p==&pBuf->aMatchinfo[pBuf->nElem+2] + ); + if( (u32*)p==&pBuf->aMatchinfo[1] ){ + pBuf->aRef[1] = 0; + }else{ + pBuf->aRef[2] = 0; + } + + if( pBuf->aRef[0]==0 && pBuf->aRef[1]==0 && pBuf->aRef[2]==0 ){ + sqlite3_free(pBuf); + } +} + +static void (*fts3MIBufferAlloc(MatchinfoBuffer *p, u32 **paOut))(void*){ + void (*xRet)(void*) = 0; + u32 *aOut = 0; + + if( p->aRef[1]==0 ){ + p->aRef[1] = 1; + aOut = &p->aMatchinfo[1]; + xRet = fts3MIBufferFree; + } + else if( p->aRef[2]==0 ){ + p->aRef[2] = 1; + aOut = &p->aMatchinfo[p->nElem+2]; + xRet = fts3MIBufferFree; + }else{ + aOut = (u32*)sqlite3_malloc(p->nElem * sizeof(u32)); + if( aOut ){ + xRet = sqlite3_free; + if( p->bGlobal ) memcpy(aOut, &p->aMatchinfo[1], p->nElem*sizeof(u32)); + } + } + + *paOut = aOut; + return xRet; +} + +static void fts3MIBufferSetGlobal(MatchinfoBuffer *p){ + p->bGlobal = 1; + memcpy(&p->aMatchinfo[2+p->nElem], &p->aMatchinfo[1], p->nElem*sizeof(u32)); +} + +/* +** Free a MatchinfoBuffer object allocated using fts3MIBufferNew() +*/ +SQLITE_PRIVATE void sqlite3Fts3MIBufferFree(MatchinfoBuffer *p){ + if( p ){ + assert( p->aRef[0]==1 ); + p->aRef[0] = 0; + if( p->aRef[0]==0 && p->aRef[1]==0 && p->aRef[2]==0 ){ + sqlite3_free(p); + } + } +} + +/* +** End of MatchinfoBuffer code. +*************************************************************************/ + + +/* +** This function is used to help iterate through a position-list. A position +** list is a list of unique integers, sorted from smallest to largest. Each +** element of the list is represented by an FTS3 varint that takes the value +** of the difference between the current element and the previous one plus +** two. For example, to store the position-list: +** +** 4 9 113 +** +** the three varints: +** +** 6 7 106 +** +** are encoded. +** +** When this function is called, *pp points to the start of an element of +** the list. *piPos contains the value of the previous entry in the list. +** After it returns, *piPos contains the value of the next element of the +** list and *pp is advanced to the following varint. +*/ +static void fts3GetDeltaPosition(char **pp, int *piPos){ + int iVal; + *pp += fts3GetVarint32(*pp, &iVal); + *piPos += (iVal-2); +} + +/* +** Helper function for fts3ExprIterate() (see below). +*/ +static int fts3ExprIterate2( + Fts3Expr *pExpr, /* Expression to iterate phrases of */ + int *piPhrase, /* Pointer to phrase counter */ + int (*x)(Fts3Expr*,int,void*), /* Callback function to invoke for phrases */ + void *pCtx /* Second argument to pass to callback */ +){ + int rc; /* Return code */ + int eType = pExpr->eType; /* Type of expression node pExpr */ + + if( eType!=FTSQUERY_PHRASE ){ + assert( pExpr->pLeft && pExpr->pRight ); + rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx); + if( rc==SQLITE_OK && eType!=FTSQUERY_NOT ){ + rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx); + } + }else{ + rc = x(pExpr, *piPhrase, pCtx); + (*piPhrase)++; + } + return rc; +} + +/* +** Iterate through all phrase nodes in an FTS3 query, except those that +** are part of a sub-tree that is the right-hand-side of a NOT operator. +** For each phrase node found, the supplied callback function is invoked. +** +** If the callback function returns anything other than SQLITE_OK, +** the iteration is abandoned and the error code returned immediately. +** Otherwise, SQLITE_OK is returned after a callback has been made for +** all eligible phrase nodes. +*/ +static int fts3ExprIterate( + Fts3Expr *pExpr, /* Expression to iterate phrases of */ + int (*x)(Fts3Expr*,int,void*), /* Callback function to invoke for phrases */ + void *pCtx /* Second argument to pass to callback */ +){ + int iPhrase = 0; /* Variable used as the phrase counter */ + return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx); +} + + +/* +** This is an fts3ExprIterate() callback used while loading the doclists +** for each phrase into Fts3Expr.aDoclist[]/nDoclist. See also +** fts3ExprLoadDoclists(). +*/ +static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){ + int rc = SQLITE_OK; + Fts3Phrase *pPhrase = pExpr->pPhrase; + LoadDoclistCtx *p = (LoadDoclistCtx *)ctx; + + UNUSED_PARAMETER(iPhrase); + + p->nPhrase++; + p->nToken += pPhrase->nToken; + + return rc; +} + +/* +** Load the doclists for each phrase in the query associated with FTS3 cursor +** pCsr. +** +** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable +** phrases in the expression (all phrases except those directly or +** indirectly descended from the right-hand-side of a NOT operator). If +** pnToken is not NULL, then it is set to the number of tokens in all +** matchable phrases of the expression. +*/ +static int fts3ExprLoadDoclists( + Fts3Cursor *pCsr, /* Fts3 cursor for current query */ + int *pnPhrase, /* OUT: Number of phrases in query */ + int *pnToken /* OUT: Number of tokens in query */ +){ + int rc; /* Return Code */ + LoadDoclistCtx sCtx = {0,0,0}; /* Context for fts3ExprIterate() */ + sCtx.pCsr = pCsr; + rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx); + if( pnPhrase ) *pnPhrase = sCtx.nPhrase; + if( pnToken ) *pnToken = sCtx.nToken; + return rc; +} + +static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){ + (*(int *)ctx)++; + pExpr->iPhrase = iPhrase; + return SQLITE_OK; +} +static int fts3ExprPhraseCount(Fts3Expr *pExpr){ + int nPhrase = 0; + (void)fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase); + return nPhrase; +} + +/* +** Advance the position list iterator specified by the first two +** arguments so that it points to the first element with a value greater +** than or equal to parameter iNext. +*/ +static void fts3SnippetAdvance(char **ppIter, int *piIter, int iNext){ + char *pIter = *ppIter; + if( pIter ){ + int iIter = *piIter; + + while( iIteriCurrent<0 ){ + /* The SnippetIter object has just been initialized. The first snippet + ** candidate always starts at offset 0 (even if this candidate has a + ** score of 0.0). + */ + pIter->iCurrent = 0; + + /* Advance the 'head' iterator of each phrase to the first offset that + ** is greater than or equal to (iNext+nSnippet). + */ + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet); + } + }else{ + int iStart; + int iEnd = 0x7FFFFFFF; + + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + if( pPhrase->pHead && pPhrase->iHeadiHead; + } + } + if( iEnd==0x7FFFFFFF ){ + return 1; + } + + pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1; + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, iEnd+1); + fts3SnippetAdvance(&pPhrase->pTail, &pPhrase->iTail, iStart); + } + } + + return 0; +} + +/* +** Retrieve information about the current candidate snippet of snippet +** iterator pIter. +*/ +static void fts3SnippetDetails( + SnippetIter *pIter, /* Snippet iterator */ + u64 mCovered, /* Bitmask of phrases already covered */ + int *piToken, /* OUT: First token of proposed snippet */ + int *piScore, /* OUT: "Score" for this snippet */ + u64 *pmCover, /* OUT: Bitmask of phrases covered */ + u64 *pmHighlight /* OUT: Bitmask of terms to highlight */ +){ + int iStart = pIter->iCurrent; /* First token of snippet */ + int iScore = 0; /* Score of this snippet */ + int i; /* Loop counter */ + u64 mCover = 0; /* Mask of phrases covered by this snippet */ + u64 mHighlight = 0; /* Mask of tokens to highlight in snippet */ + + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + if( pPhrase->pTail ){ + char *pCsr = pPhrase->pTail; + int iCsr = pPhrase->iTail; + + while( iCsr<(iStart+pIter->nSnippet) ){ + int j; + u64 mPhrase = (u64)1 << i; + u64 mPos = (u64)1 << (iCsr - iStart); + assert( iCsr>=iStart ); + if( (mCover|mCovered)&mPhrase ){ + iScore++; + }else{ + iScore += 1000; + } + mCover |= mPhrase; + + for(j=0; jnToken; j++){ + mHighlight |= (mPos>>j); + } + + if( 0==(*pCsr & 0x0FE) ) break; + fts3GetDeltaPosition(&pCsr, &iCsr); + } + } + } + + /* Set the output variables before returning. */ + *piToken = iStart; + *piScore = iScore; + *pmCover = mCover; + *pmHighlight = mHighlight; +} + +/* +** This function is an fts3ExprIterate() callback used by fts3BestSnippet(). +** Each invocation populates an element of the SnippetIter.aPhrase[] array. +*/ +static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){ + SnippetIter *p = (SnippetIter *)ctx; + SnippetPhrase *pPhrase = &p->aPhrase[iPhrase]; + char *pCsr; + int rc; + + pPhrase->nToken = pExpr->pPhrase->nToken; + rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr); + assert( rc==SQLITE_OK || pCsr==0 ); + if( pCsr ){ + int iFirst = 0; + pPhrase->pList = pCsr; + fts3GetDeltaPosition(&pCsr, &iFirst); + assert( iFirst>=0 ); + pPhrase->pHead = pCsr; + pPhrase->pTail = pCsr; + pPhrase->iHead = iFirst; + pPhrase->iTail = iFirst; + }else{ + assert( rc!=SQLITE_OK || ( + pPhrase->pList==0 && pPhrase->pHead==0 && pPhrase->pTail==0 + )); + } + + return rc; +} + +/* +** Select the fragment of text consisting of nFragment contiguous tokens +** from column iCol that represent the "best" snippet. The best snippet +** is the snippet with the highest score, where scores are calculated +** by adding: +** +** (a) +1 point for each occurrence of a matchable phrase in the snippet. +** +** (b) +1000 points for the first occurrence of each matchable phrase in +** the snippet for which the corresponding mCovered bit is not set. +** +** The selected snippet parameters are stored in structure *pFragment before +** returning. The score of the selected snippet is stored in *piScore +** before returning. +*/ +static int fts3BestSnippet( + int nSnippet, /* Desired snippet length */ + Fts3Cursor *pCsr, /* Cursor to create snippet for */ + int iCol, /* Index of column to create snippet from */ + u64 mCovered, /* Mask of phrases already covered */ + u64 *pmSeen, /* IN/OUT: Mask of phrases seen */ + SnippetFragment *pFragment, /* OUT: Best snippet found */ + int *piScore /* OUT: Score of snippet pFragment */ +){ + int rc; /* Return Code */ + int nList; /* Number of phrases in expression */ + SnippetIter sIter; /* Iterates through snippet candidates */ + int nByte; /* Number of bytes of space to allocate */ + int iBestScore = -1; /* Best snippet score found so far */ + int i; /* Loop counter */ + + memset(&sIter, 0, sizeof(sIter)); + + /* Iterate through the phrases in the expression to count them. The same + ** callback makes sure the doclists are loaded for each phrase. + */ + rc = fts3ExprLoadDoclists(pCsr, &nList, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Now that it is known how many phrases there are, allocate and zero + ** the required space using malloc(). + */ + nByte = sizeof(SnippetPhrase) * nList; + sIter.aPhrase = (SnippetPhrase *)sqlite3_malloc(nByte); + if( !sIter.aPhrase ){ + return SQLITE_NOMEM; + } + memset(sIter.aPhrase, 0, nByte); + + /* Initialize the contents of the SnippetIter object. Then iterate through + ** the set of phrases in the expression to populate the aPhrase[] array. + */ + sIter.pCsr = pCsr; + sIter.iCol = iCol; + sIter.nSnippet = nSnippet; + sIter.nPhrase = nList; + sIter.iCurrent = -1; + rc = fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter); + if( rc==SQLITE_OK ){ + + /* Set the *pmSeen output variable. */ + for(i=0; iiCol = iCol; + while( !fts3SnippetNextCandidate(&sIter) ){ + int iPos; + int iScore; + u64 mCover; + u64 mHighlite; + fts3SnippetDetails(&sIter, mCovered, &iPos, &iScore, &mCover,&mHighlite); + assert( iScore>=0 ); + if( iScore>iBestScore ){ + pFragment->iPos = iPos; + pFragment->hlmask = mHighlite; + pFragment->covered = mCover; + iBestScore = iScore; + } + } + + *piScore = iBestScore; + } + sqlite3_free(sIter.aPhrase); + return rc; +} + + +/* +** Append a string to the string-buffer passed as the first argument. +** +** If nAppend is negative, then the length of the string zAppend is +** determined using strlen(). +*/ +static int fts3StringAppend( + StrBuffer *pStr, /* Buffer to append to */ + const char *zAppend, /* Pointer to data to append to buffer */ + int nAppend /* Size of zAppend in bytes (or -1) */ +){ + if( nAppend<0 ){ + nAppend = (int)strlen(zAppend); + } + + /* If there is insufficient space allocated at StrBuffer.z, use realloc() + ** to grow the buffer until so that it is big enough to accomadate the + ** appended data. + */ + if( pStr->n+nAppend+1>=pStr->nAlloc ){ + int nAlloc = pStr->nAlloc+nAppend+100; + char *zNew = sqlite3_realloc(pStr->z, nAlloc); + if( !zNew ){ + return SQLITE_NOMEM; + } + pStr->z = zNew; + pStr->nAlloc = nAlloc; + } + assert( pStr->z!=0 && (pStr->nAlloc >= pStr->n+nAppend+1) ); + + /* Append the data to the string buffer. */ + memcpy(&pStr->z[pStr->n], zAppend, nAppend); + pStr->n += nAppend; + pStr->z[pStr->n] = '\0'; + + return SQLITE_OK; +} + +/* +** The fts3BestSnippet() function often selects snippets that end with a +** query term. That is, the final term of the snippet is always a term +** that requires highlighting. For example, if 'X' is a highlighted term +** and '.' is a non-highlighted term, BestSnippet() may select: +** +** ........X.....X +** +** This function "shifts" the beginning of the snippet forward in the +** document so that there are approximately the same number of +** non-highlighted terms to the right of the final highlighted term as there +** are to the left of the first highlighted term. For example, to this: +** +** ....X.....X.... +** +** This is done as part of extracting the snippet text, not when selecting +** the snippet. Snippet selection is done based on doclists only, so there +** is no way for fts3BestSnippet() to know whether or not the document +** actually contains terms that follow the final highlighted term. +*/ +static int fts3SnippetShift( + Fts3Table *pTab, /* FTS3 table snippet comes from */ + int iLangid, /* Language id to use in tokenizing */ + int nSnippet, /* Number of tokens desired for snippet */ + const char *zDoc, /* Document text to extract snippet from */ + int nDoc, /* Size of buffer zDoc in bytes */ + int *piPos, /* IN/OUT: First token of snippet */ + u64 *pHlmask /* IN/OUT: Mask of tokens to highlight */ +){ + u64 hlmask = *pHlmask; /* Local copy of initial highlight-mask */ + + if( hlmask ){ + int nLeft; /* Tokens to the left of first highlight */ + int nRight; /* Tokens to the right of last highlight */ + int nDesired; /* Ideal number of tokens to shift forward */ + + for(nLeft=0; !(hlmask & ((u64)1 << nLeft)); nLeft++); + for(nRight=0; !(hlmask & ((u64)1 << (nSnippet-1-nRight))); nRight++); + nDesired = (nLeft-nRight)/2; + + /* Ideally, the start of the snippet should be pushed forward in the + ** document nDesired tokens. This block checks if there are actually + ** nDesired tokens to the right of the snippet. If so, *piPos and + ** *pHlMask are updated to shift the snippet nDesired tokens to the + ** right. Otherwise, the snippet is shifted by the number of tokens + ** available. + */ + if( nDesired>0 ){ + int nShift; /* Number of tokens to shift snippet by */ + int iCurrent = 0; /* Token counter */ + int rc; /* Return Code */ + sqlite3_tokenizer_module *pMod; + sqlite3_tokenizer_cursor *pC; + pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule; + + /* Open a cursor on zDoc/nDoc. Check if there are (nSnippet+nDesired) + ** or more tokens in zDoc/nDoc. + */ + rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC); + if( rc!=SQLITE_OK ){ + return rc; + } + while( rc==SQLITE_OK && iCurrent<(nSnippet+nDesired) ){ + const char *ZDUMMY; int DUMMY1 = 0, DUMMY2 = 0, DUMMY3 = 0; + rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent); + } + pMod->xClose(pC); + if( rc!=SQLITE_OK && rc!=SQLITE_DONE ){ return rc; } + + nShift = (rc==SQLITE_DONE)+iCurrent-nSnippet; + assert( nShift<=nDesired ); + if( nShift>0 ){ + *piPos += nShift; + *pHlmask = hlmask >> nShift; + } + } + } + return SQLITE_OK; +} + +/* +** Extract the snippet text for fragment pFragment from cursor pCsr and +** append it to string buffer pOut. +*/ +static int fts3SnippetText( + Fts3Cursor *pCsr, /* FTS3 Cursor */ + SnippetFragment *pFragment, /* Snippet to extract */ + int iFragment, /* Fragment number */ + int isLast, /* True for final fragment in snippet */ + int nSnippet, /* Number of tokens in extracted snippet */ + const char *zOpen, /* String inserted before highlighted term */ + const char *zClose, /* String inserted after highlighted term */ + const char *zEllipsis, /* String inserted between snippets */ + StrBuffer *pOut /* Write output here */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc; /* Return code */ + const char *zDoc; /* Document text to extract snippet from */ + int nDoc; /* Size of zDoc in bytes */ + int iCurrent = 0; /* Current token number of document */ + int iEnd = 0; /* Byte offset of end of current token */ + int isShiftDone = 0; /* True after snippet is shifted */ + int iPos = pFragment->iPos; /* First token of snippet */ + u64 hlmask = pFragment->hlmask; /* Highlight-mask for snippet */ + int iCol = pFragment->iCol+1; /* Query column to extract text from */ + sqlite3_tokenizer_module *pMod; /* Tokenizer module methods object */ + sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */ + + zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol); + if( zDoc==0 ){ + if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){ + return SQLITE_NOMEM; + } + return SQLITE_OK; + } + nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol); + + /* Open a token cursor on the document. */ + pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule; + rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC); + if( rc!=SQLITE_OK ){ + return rc; + } + + while( rc==SQLITE_OK ){ + const char *ZDUMMY; /* Dummy argument used with tokenizer */ + int DUMMY1 = -1; /* Dummy argument used with tokenizer */ + int iBegin = 0; /* Offset in zDoc of start of token */ + int iFin = 0; /* Offset in zDoc of end of token */ + int isHighlight = 0; /* True for highlighted terms */ + + /* Variable DUMMY1 is initialized to a negative value above. Elsewhere + ** in the FTS code the variable that the third argument to xNext points to + ** is initialized to zero before the first (*but not necessarily + ** subsequent*) call to xNext(). This is done for a particular application + ** that needs to know whether or not the tokenizer is being used for + ** snippet generation or for some other purpose. + ** + ** Extreme care is required when writing code to depend on this + ** initialization. It is not a documented part of the tokenizer interface. + ** If a tokenizer is used directly by any code outside of FTS, this + ** convention might not be respected. */ + rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + /* Special case - the last token of the snippet is also the last token + ** of the column. Append any punctuation that occurred between the end + ** of the previous token and the end of the document to the output. + ** Then break out of the loop. */ + rc = fts3StringAppend(pOut, &zDoc[iEnd], -1); + } + break; + } + if( iCurrentiLangid, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask + ); + isShiftDone = 1; + + /* Now that the shift has been done, check if the initial "..." are + ** required. They are required if (a) this is not the first fragment, + ** or (b) this fragment does not begin at position 0 of its column. + */ + if( rc==SQLITE_OK ){ + if( iPos>0 || iFragment>0 ){ + rc = fts3StringAppend(pOut, zEllipsis, -1); + }else if( iBegin ){ + rc = fts3StringAppend(pOut, zDoc, iBegin); + } + } + if( rc!=SQLITE_OK || iCurrent=(iPos+nSnippet) ){ + if( isLast ){ + rc = fts3StringAppend(pOut, zEllipsis, -1); + } + break; + } + + /* Set isHighlight to true if this term should be highlighted. */ + isHighlight = (hlmask & ((u64)1 << (iCurrent-iPos)))!=0; + + if( iCurrent>iPos ) rc = fts3StringAppend(pOut, &zDoc[iEnd], iBegin-iEnd); + if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1); + if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin); + if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1); + + iEnd = iFin; + } + + pMod->xClose(pC); + return rc; +} + + +/* +** This function is used to count the entries in a column-list (a +** delta-encoded list of term offsets within a single column of a single +** row). When this function is called, *ppCollist should point to the +** beginning of the first varint in the column-list (the varint that +** contains the position of the first matching term in the column data). +** Before returning, *ppCollist is set to point to the first byte after +** the last varint in the column-list (either the 0x00 signifying the end +** of the position-list, or the 0x01 that precedes the column number of +** the next column in the position-list). +** +** The number of elements in the column-list is returned. +*/ +static int fts3ColumnlistCount(char **ppCollist){ + char *pEnd = *ppCollist; + char c = 0; + int nEntry = 0; + + /* A column-list is terminated by either a 0x01 or 0x00. */ + while( 0xFE & (*pEnd | c) ){ + c = *pEnd++ & 0x80; + if( !c ) nEntry++; + } + + *ppCollist = pEnd; + return nEntry; +} + +/* +** This function gathers 'y' or 'b' data for a single phrase. +*/ +static void fts3ExprLHits( + Fts3Expr *pExpr, /* Phrase expression node */ + MatchInfo *p /* Matchinfo context */ +){ + Fts3Table *pTab = (Fts3Table *)p->pCursor->base.pVtab; + int iStart; + Fts3Phrase *pPhrase = pExpr->pPhrase; + char *pIter = pPhrase->doclist.pList; + int iCol = 0; + + assert( p->flag==FTS3_MATCHINFO_LHITS_BM || p->flag==FTS3_MATCHINFO_LHITS ); + if( p->flag==FTS3_MATCHINFO_LHITS ){ + iStart = pExpr->iPhrase * p->nCol; + }else{ + iStart = pExpr->iPhrase * ((p->nCol + 31) / 32); + } + + while( 1 ){ + int nHit = fts3ColumnlistCount(&pIter); + if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){ + if( p->flag==FTS3_MATCHINFO_LHITS ){ + p->aMatchinfo[iStart + iCol] = (u32)nHit; + }else if( nHit ){ + p->aMatchinfo[iStart + (iCol+1)/32] |= (1 << (iCol&0x1F)); + } + } + assert( *pIter==0x00 || *pIter==0x01 ); + if( *pIter!=0x01 ) break; + pIter++; + pIter += fts3GetVarint32(pIter, &iCol); + } +} + +/* +** Gather the results for matchinfo directives 'y' and 'b'. +*/ +static void fts3ExprLHitGather( + Fts3Expr *pExpr, + MatchInfo *p +){ + assert( (pExpr->pLeft==0)==(pExpr->pRight==0) ); + if( pExpr->bEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){ + if( pExpr->pLeft ){ + fts3ExprLHitGather(pExpr->pLeft, p); + fts3ExprLHitGather(pExpr->pRight, p); + }else{ + fts3ExprLHits(pExpr, p); + } + } +} + +/* +** fts3ExprIterate() callback used to collect the "global" matchinfo stats +** for a single query. +** +** fts3ExprIterate() callback to load the 'global' elements of a +** FTS3_MATCHINFO_HITS matchinfo array. The global stats are those elements +** of the matchinfo array that are constant for all rows returned by the +** current query. +** +** Argument pCtx is actually a pointer to a struct of type MatchInfo. This +** function populates Matchinfo.aMatchinfo[] as follows: +** +** for(iCol=0; iColpCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol] + ); +} + +/* +** fts3ExprIterate() callback used to collect the "local" part of the +** FTS3_MATCHINFO_HITS array. The local stats are those elements of the +** array that are different for each row returned by the query. +*/ +static int fts3ExprLocalHitsCb( + Fts3Expr *pExpr, /* Phrase expression node */ + int iPhrase, /* Phrase number */ + void *pCtx /* Pointer to MatchInfo structure */ +){ + int rc = SQLITE_OK; + MatchInfo *p = (MatchInfo *)pCtx; + int iStart = iPhrase * p->nCol * 3; + int i; + + for(i=0; inCol && rc==SQLITE_OK; i++){ + char *pCsr; + rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr); + if( pCsr ){ + p->aMatchinfo[iStart+i*3] = fts3ColumnlistCount(&pCsr); + }else{ + p->aMatchinfo[iStart+i*3] = 0; + } + } + + return rc; +} + +static int fts3MatchinfoCheck( + Fts3Table *pTab, + char cArg, + char **pzErr +){ + if( (cArg==FTS3_MATCHINFO_NPHRASE) + || (cArg==FTS3_MATCHINFO_NCOL) + || (cArg==FTS3_MATCHINFO_NDOC && pTab->bFts4) + || (cArg==FTS3_MATCHINFO_AVGLENGTH && pTab->bFts4) + || (cArg==FTS3_MATCHINFO_LENGTH && pTab->bHasDocsize) + || (cArg==FTS3_MATCHINFO_LCS) + || (cArg==FTS3_MATCHINFO_HITS) + || (cArg==FTS3_MATCHINFO_LHITS) + || (cArg==FTS3_MATCHINFO_LHITS_BM) + ){ + return SQLITE_OK; + } + sqlite3Fts3ErrMsg(pzErr, "unrecognized matchinfo request: %c", cArg); + return SQLITE_ERROR; +} + +static int fts3MatchinfoSize(MatchInfo *pInfo, char cArg){ + int nVal; /* Number of integers output by cArg */ + + switch( cArg ){ + case FTS3_MATCHINFO_NDOC: + case FTS3_MATCHINFO_NPHRASE: + case FTS3_MATCHINFO_NCOL: + nVal = 1; + break; + + case FTS3_MATCHINFO_AVGLENGTH: + case FTS3_MATCHINFO_LENGTH: + case FTS3_MATCHINFO_LCS: + nVal = pInfo->nCol; + break; + + case FTS3_MATCHINFO_LHITS: + nVal = pInfo->nCol * pInfo->nPhrase; + break; + + case FTS3_MATCHINFO_LHITS_BM: + nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32); + break; + + default: + assert( cArg==FTS3_MATCHINFO_HITS ); + nVal = pInfo->nCol * pInfo->nPhrase * 3; + break; + } + + return nVal; +} + +static int fts3MatchinfoSelectDoctotal( + Fts3Table *pTab, + sqlite3_stmt **ppStmt, + sqlite3_int64 *pnDoc, + const char **paLen +){ + sqlite3_stmt *pStmt; + const char *a; + sqlite3_int64 nDoc; + + if( !*ppStmt ){ + int rc = sqlite3Fts3SelectDoctotal(pTab, ppStmt); + if( rc!=SQLITE_OK ) return rc; + } + pStmt = *ppStmt; + assert( sqlite3_data_count(pStmt)==1 ); + + a = sqlite3_column_blob(pStmt, 0); + a += sqlite3Fts3GetVarint(a, &nDoc); + if( nDoc==0 ) return FTS_CORRUPT_VTAB; + *pnDoc = (u32)nDoc; + + if( paLen ) *paLen = a; + return SQLITE_OK; +} + +/* +** An instance of the following structure is used to store state while +** iterating through a multi-column position-list corresponding to the +** hits for a single phrase on a single row in order to calculate the +** values for a matchinfo() FTS3_MATCHINFO_LCS request. +*/ +typedef struct LcsIterator LcsIterator; +struct LcsIterator { + Fts3Expr *pExpr; /* Pointer to phrase expression */ + int iPosOffset; /* Tokens count up to end of this phrase */ + char *pRead; /* Cursor used to iterate through aDoclist */ + int iPos; /* Current position */ +}; + +/* +** If LcsIterator.iCol is set to the following value, the iterator has +** finished iterating through all offsets for all columns. +*/ +#define LCS_ITERATOR_FINISHED 0x7FFFFFFF; + +static int fts3MatchinfoLcsCb( + Fts3Expr *pExpr, /* Phrase expression node */ + int iPhrase, /* Phrase number (numbered from zero) */ + void *pCtx /* Pointer to MatchInfo structure */ +){ + LcsIterator *aIter = (LcsIterator *)pCtx; + aIter[iPhrase].pExpr = pExpr; + return SQLITE_OK; +} + +/* +** Advance the iterator passed as an argument to the next position. Return +** 1 if the iterator is at EOF or if it now points to the start of the +** position list for the next column. +*/ +static int fts3LcsIteratorAdvance(LcsIterator *pIter){ + char *pRead = pIter->pRead; + sqlite3_int64 iRead; + int rc = 0; + + pRead += sqlite3Fts3GetVarint(pRead, &iRead); + if( iRead==0 || iRead==1 ){ + pRead = 0; + rc = 1; + }else{ + pIter->iPos += (int)(iRead-2); + } + + pIter->pRead = pRead; + return rc; +} + +/* +** This function implements the FTS3_MATCHINFO_LCS matchinfo() flag. +** +** If the call is successful, the longest-common-substring lengths for each +** column are written into the first nCol elements of the pInfo->aMatchinfo[] +** array before returning. SQLITE_OK is returned in this case. +** +** Otherwise, if an error occurs, an SQLite error code is returned and the +** data written to the first nCol elements of pInfo->aMatchinfo[] is +** undefined. +*/ +static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){ + LcsIterator *aIter; + int i; + int iCol; + int nToken = 0; + + /* Allocate and populate the array of LcsIterator objects. The array + ** contains one element for each matchable phrase in the query. + **/ + aIter = sqlite3_malloc(sizeof(LcsIterator) * pCsr->nPhrase); + if( !aIter ) return SQLITE_NOMEM; + memset(aIter, 0, sizeof(LcsIterator) * pCsr->nPhrase); + (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter); + + for(i=0; inPhrase; i++){ + LcsIterator *pIter = &aIter[i]; + nToken -= pIter->pExpr->pPhrase->nToken; + pIter->iPosOffset = nToken; + } + + for(iCol=0; iColnCol; iCol++){ + int nLcs = 0; /* LCS value for this column */ + int nLive = 0; /* Number of iterators in aIter not at EOF */ + + for(i=0; inPhrase; i++){ + int rc; + LcsIterator *pIt = &aIter[i]; + rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead); + if( rc!=SQLITE_OK ) return rc; + if( pIt->pRead ){ + pIt->iPos = pIt->iPosOffset; + fts3LcsIteratorAdvance(&aIter[i]); + nLive++; + } + } + + while( nLive>0 ){ + LcsIterator *pAdv = 0; /* The iterator to advance by one position */ + int nThisLcs = 0; /* LCS for the current iterator positions */ + + for(i=0; inPhrase; i++){ + LcsIterator *pIter = &aIter[i]; + if( pIter->pRead==0 ){ + /* This iterator is already at EOF for this column. */ + nThisLcs = 0; + }else{ + if( pAdv==0 || pIter->iPosiPos ){ + pAdv = pIter; + } + if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){ + nThisLcs++; + }else{ + nThisLcs = 1; + } + if( nThisLcs>nLcs ) nLcs = nThisLcs; + } + } + if( fts3LcsIteratorAdvance(pAdv) ) nLive--; + } + + pInfo->aMatchinfo[iCol] = nLcs; + } + + sqlite3_free(aIter); + return SQLITE_OK; +} + +/* +** Populate the buffer pInfo->aMatchinfo[] with an array of integers to +** be returned by the matchinfo() function. Argument zArg contains the +** format string passed as the second argument to matchinfo (or the +** default value "pcx" if no second argument was specified). The format +** string has already been validated and the pInfo->aMatchinfo[] array +** is guaranteed to be large enough for the output. +** +** If bGlobal is true, then populate all fields of the matchinfo() output. +** If it is false, then assume that those fields that do not change between +** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS) +** have already been populated. +** +** Return SQLITE_OK if successful, or an SQLite error code if an error +** occurs. If a value other than SQLITE_OK is returned, the state the +** pInfo->aMatchinfo[] buffer is left in is undefined. +*/ +static int fts3MatchinfoValues( + Fts3Cursor *pCsr, /* FTS3 cursor object */ + int bGlobal, /* True to grab the global stats */ + MatchInfo *pInfo, /* Matchinfo context object */ + const char *zArg /* Matchinfo format string */ +){ + int rc = SQLITE_OK; + int i; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + sqlite3_stmt *pSelect = 0; + + for(i=0; rc==SQLITE_OK && zArg[i]; i++){ + pInfo->flag = zArg[i]; + switch( zArg[i] ){ + case FTS3_MATCHINFO_NPHRASE: + if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nPhrase; + break; + + case FTS3_MATCHINFO_NCOL: + if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol; + break; + + case FTS3_MATCHINFO_NDOC: + if( bGlobal ){ + sqlite3_int64 nDoc = 0; + rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, 0); + pInfo->aMatchinfo[0] = (u32)nDoc; + } + break; + + case FTS3_MATCHINFO_AVGLENGTH: + if( bGlobal ){ + sqlite3_int64 nDoc; /* Number of rows in table */ + const char *a; /* Aggregate column length array */ + + rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, &a); + if( rc==SQLITE_OK ){ + int iCol; + for(iCol=0; iColnCol; iCol++){ + u32 iVal; + sqlite3_int64 nToken; + a += sqlite3Fts3GetVarint(a, &nToken); + iVal = (u32)(((u32)(nToken&0xffffffff)+nDoc/2)/nDoc); + pInfo->aMatchinfo[iCol] = iVal; + } + } + } + break; + + case FTS3_MATCHINFO_LENGTH: { + sqlite3_stmt *pSelectDocsize = 0; + rc = sqlite3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize); + if( rc==SQLITE_OK ){ + int iCol; + const char *a = sqlite3_column_blob(pSelectDocsize, 0); + for(iCol=0; iColnCol; iCol++){ + sqlite3_int64 nToken; + a += sqlite3Fts3GetVarint(a, &nToken); + pInfo->aMatchinfo[iCol] = (u32)nToken; + } + } + sqlite3_reset(pSelectDocsize); + break; + } + + case FTS3_MATCHINFO_LCS: + rc = fts3ExprLoadDoclists(pCsr, 0, 0); + if( rc==SQLITE_OK ){ + rc = fts3MatchinfoLcs(pCsr, pInfo); + } + break; + + case FTS3_MATCHINFO_LHITS_BM: + case FTS3_MATCHINFO_LHITS: { + int nZero = fts3MatchinfoSize(pInfo, zArg[i]) * sizeof(u32); + memset(pInfo->aMatchinfo, 0, nZero); + fts3ExprLHitGather(pCsr->pExpr, pInfo); + break; + } + + default: { + Fts3Expr *pExpr; + assert( zArg[i]==FTS3_MATCHINFO_HITS ); + pExpr = pCsr->pExpr; + rc = fts3ExprLoadDoclists(pCsr, 0, 0); + if( rc!=SQLITE_OK ) break; + if( bGlobal ){ + if( pCsr->pDeferred ){ + rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &pInfo->nDoc, 0); + if( rc!=SQLITE_OK ) break; + } + rc = fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo); + sqlite3Fts3EvalTestDeferred(pCsr, &rc); + if( rc!=SQLITE_OK ) break; + } + (void)fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo); + break; + } + } + + pInfo->aMatchinfo += fts3MatchinfoSize(pInfo, zArg[i]); + } + + sqlite3_reset(pSelect); + return rc; +} + + +/* +** Populate pCsr->aMatchinfo[] with data for the current row. The +** 'matchinfo' data is an array of 32-bit unsigned integers (C type u32). +*/ +static void fts3GetMatchinfo( + sqlite3_context *pCtx, /* Return results here */ + Fts3Cursor *pCsr, /* FTS3 Cursor object */ + const char *zArg /* Second argument to matchinfo() function */ +){ + MatchInfo sInfo; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int bGlobal = 0; /* Collect 'global' stats as well as local */ + + u32 *aOut = 0; + void (*xDestroyOut)(void*) = 0; + + memset(&sInfo, 0, sizeof(MatchInfo)); + sInfo.pCursor = pCsr; + sInfo.nCol = pTab->nColumn; + + /* If there is cached matchinfo() data, but the format string for the + ** cache does not match the format string for this request, discard + ** the cached data. */ + if( pCsr->pMIBuffer && strcmp(pCsr->pMIBuffer->zMatchinfo, zArg) ){ + sqlite3Fts3MIBufferFree(pCsr->pMIBuffer); + pCsr->pMIBuffer = 0; + } + + /* If Fts3Cursor.pMIBuffer is NULL, then this is the first time the + ** matchinfo function has been called for this query. In this case + ** allocate the array used to accumulate the matchinfo data and + ** initialize those elements that are constant for every row. + */ + if( pCsr->pMIBuffer==0 ){ + int nMatchinfo = 0; /* Number of u32 elements in match-info */ + int i; /* Used to iterate through zArg */ + + /* Determine the number of phrases in the query */ + pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr); + sInfo.nPhrase = pCsr->nPhrase; + + /* Determine the number of integers in the buffer returned by this call. */ + for(i=0; zArg[i]; i++){ + char *zErr = 0; + if( fts3MatchinfoCheck(pTab, zArg[i], &zErr) ){ + sqlite3_result_error(pCtx, zErr, -1); + sqlite3_free(zErr); + return; + } + nMatchinfo += fts3MatchinfoSize(&sInfo, zArg[i]); + } + + /* Allocate space for Fts3Cursor.aMatchinfo[] and Fts3Cursor.zMatchinfo. */ + pCsr->pMIBuffer = fts3MIBufferNew(nMatchinfo, zArg); + if( !pCsr->pMIBuffer ) rc = SQLITE_NOMEM; + + pCsr->isMatchinfoNeeded = 1; + bGlobal = 1; + } + + if( rc==SQLITE_OK ){ + xDestroyOut = fts3MIBufferAlloc(pCsr->pMIBuffer, &aOut); + if( xDestroyOut==0 ){ + rc = SQLITE_NOMEM; + } + } + + if( rc==SQLITE_OK ){ + sInfo.aMatchinfo = aOut; + sInfo.nPhrase = pCsr->nPhrase; + rc = fts3MatchinfoValues(pCsr, bGlobal, &sInfo, zArg); + if( bGlobal ){ + fts3MIBufferSetGlobal(pCsr->pMIBuffer); + } + } + + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(pCtx, rc); + if( xDestroyOut ) xDestroyOut(aOut); + }else{ + int n = pCsr->pMIBuffer->nElem * sizeof(u32); + sqlite3_result_blob(pCtx, aOut, n, xDestroyOut); + } +} + +/* +** Implementation of snippet() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3Snippet( + sqlite3_context *pCtx, /* SQLite function call context */ + Fts3Cursor *pCsr, /* Cursor object */ + const char *zStart, /* Snippet start text - "" */ + const char *zEnd, /* Snippet end text - "" */ + const char *zEllipsis, /* Snippet ellipsis text - "..." */ + int iCol, /* Extract snippet from this column */ + int nToken /* Approximate number of tokens in snippet */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int i; + StrBuffer res = {0, 0, 0}; + + /* The returned text includes up to four fragments of text extracted from + ** the data in the current row. The first iteration of the for(...) loop + ** below attempts to locate a single fragment of text nToken tokens in + ** size that contains at least one instance of all phrases in the query + ** expression that appear in the current row. If such a fragment of text + ** cannot be found, the second iteration of the loop attempts to locate + ** a pair of fragments, and so on. + */ + int nSnippet = 0; /* Number of fragments in this snippet */ + SnippetFragment aSnippet[4]; /* Maximum of 4 fragments per snippet */ + int nFToken = -1; /* Number of tokens in each fragment */ + + if( !pCsr->pExpr ){ + sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC); + return; + } + + for(nSnippet=1; 1; nSnippet++){ + + int iSnip; /* Loop counter 0..nSnippet-1 */ + u64 mCovered = 0; /* Bitmask of phrases covered by snippet */ + u64 mSeen = 0; /* Bitmask of phrases seen by BestSnippet() */ + + if( nToken>=0 ){ + nFToken = (nToken+nSnippet-1) / nSnippet; + }else{ + nFToken = -1 * nToken; + } + + for(iSnip=0; iSnipnColumn; iRead++){ + SnippetFragment sF = {0, 0, 0, 0}; + int iS = 0; + if( iCol>=0 && iRead!=iCol ) continue; + + /* Find the best snippet of nFToken tokens in column iRead. */ + rc = fts3BestSnippet(nFToken, pCsr, iRead, mCovered, &mSeen, &sF, &iS); + if( rc!=SQLITE_OK ){ + goto snippet_out; + } + if( iS>iBestScore ){ + *pFragment = sF; + iBestScore = iS; + } + } + + mCovered |= pFragment->covered; + } + + /* If all query phrases seen by fts3BestSnippet() are present in at least + ** one of the nSnippet snippet fragments, break out of the loop. + */ + assert( (mCovered&mSeen)==mCovered ); + if( mSeen==mCovered || nSnippet==SizeofArray(aSnippet) ) break; + } + + assert( nFToken>0 ); + + for(i=0; ipCsr, pExpr, p->iCol, &pList); + nTerm = pExpr->pPhrase->nToken; + if( pList ){ + fts3GetDeltaPosition(&pList, &iPos); + assert( iPos>=0 ); + } + + for(iTerm=0; iTermaTerm[p->iTerm++]; + pT->iOff = nTerm-iTerm-1; + pT->pList = pList; + pT->iPos = iPos; + } + + return rc; +} + +/* +** Implementation of offsets() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3Offsets( + sqlite3_context *pCtx, /* SQLite function call context */ + Fts3Cursor *pCsr /* Cursor object */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + sqlite3_tokenizer_module const *pMod = pTab->pTokenizer->pModule; + int rc; /* Return Code */ + int nToken; /* Number of tokens in query */ + int iCol; /* Column currently being processed */ + StrBuffer res = {0, 0, 0}; /* Result string */ + TermOffsetCtx sCtx; /* Context for fts3ExprTermOffsetInit() */ + + if( !pCsr->pExpr ){ + sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC); + return; + } + + memset(&sCtx, 0, sizeof(sCtx)); + assert( pCsr->isRequireSeek==0 ); + + /* Count the number of terms in the query */ + rc = fts3ExprLoadDoclists(pCsr, 0, &nToken); + if( rc!=SQLITE_OK ) goto offsets_out; + + /* Allocate the array of TermOffset iterators. */ + sCtx.aTerm = (TermOffset *)sqlite3_malloc(sizeof(TermOffset)*nToken); + if( 0==sCtx.aTerm ){ + rc = SQLITE_NOMEM; + goto offsets_out; + } + sCtx.iDocid = pCsr->iPrevId; + sCtx.pCsr = pCsr; + + /* Loop through the table columns, appending offset information to + ** string-buffer res for each column. + */ + for(iCol=0; iColnColumn; iCol++){ + sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */ + const char *ZDUMMY; /* Dummy argument used with xNext() */ + int NDUMMY = 0; /* Dummy argument used with xNext() */ + int iStart = 0; + int iEnd = 0; + int iCurrent = 0; + const char *zDoc; + int nDoc; + + /* Initialize the contents of sCtx.aTerm[] for column iCol. There is + ** no way that this operation can fail, so the return code from + ** fts3ExprIterate() can be discarded. + */ + sCtx.iCol = iCol; + sCtx.iTerm = 0; + (void)fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx); + + /* Retreive the text stored in column iCol. If an SQL NULL is stored + ** in column iCol, jump immediately to the next iteration of the loop. + ** If an OOM occurs while retrieving the data (this can happen if SQLite + ** needs to transform the data from utf-16 to utf-8), return SQLITE_NOMEM + ** to the caller. + */ + zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1); + nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1); + if( zDoc==0 ){ + if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){ + continue; + } + rc = SQLITE_NOMEM; + goto offsets_out; + } + + /* Initialize a tokenizer iterator to iterate through column iCol. */ + rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, + zDoc, nDoc, &pC + ); + if( rc!=SQLITE_OK ) goto offsets_out; + + rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent); + while( rc==SQLITE_OK ){ + int i; /* Used to loop through terms */ + int iMinPos = 0x7FFFFFFF; /* Position of next token */ + TermOffset *pTerm = 0; /* TermOffset associated with next token */ + + for(i=0; ipList && (pT->iPos-pT->iOff)iPos-pT->iOff; + pTerm = pT; + } + } + + if( !pTerm ){ + /* All offsets for this column have been gathered. */ + rc = SQLITE_DONE; + }else{ + assert( iCurrent<=iMinPos ); + if( 0==(0xFE&*pTerm->pList) ){ + pTerm->pList = 0; + }else{ + fts3GetDeltaPosition(&pTerm->pList, &pTerm->iPos); + } + while( rc==SQLITE_OK && iCurrentxNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent); + } + if( rc==SQLITE_OK ){ + char aBuffer[64]; + sqlite3_snprintf(sizeof(aBuffer), aBuffer, + "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart + ); + rc = fts3StringAppend(&res, aBuffer, -1); + }else if( rc==SQLITE_DONE && pTab->zContentTbl==0 ){ + rc = FTS_CORRUPT_VTAB; + } + } + } + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + + pMod->xClose(pC); + if( rc!=SQLITE_OK ) goto offsets_out; + } + + offsets_out: + sqlite3_free(sCtx.aTerm); + assert( rc!=SQLITE_DONE ); + sqlite3Fts3SegmentsClose(pTab); + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(pCtx, rc); + sqlite3_free(res.z); + }else{ + sqlite3_result_text(pCtx, res.z, res.n-1, sqlite3_free); + } + return; +} + +/* +** Implementation of matchinfo() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3Matchinfo( + sqlite3_context *pContext, /* Function call context */ + Fts3Cursor *pCsr, /* FTS3 table cursor */ + const char *zArg /* Second arg to matchinfo() function */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + const char *zFormat; + + if( zArg ){ + zFormat = zArg; + }else{ + zFormat = FTS3_MATCHINFO_DEFAULT; + } + + if( !pCsr->pExpr ){ + sqlite3_result_blob(pContext, "", 0, SQLITE_STATIC); + return; + }else{ + /* Retrieve matchinfo() data. */ + fts3GetMatchinfo(pContext, pCsr, zFormat); + sqlite3Fts3SegmentsClose(pTab); + } +} + +#endif + +/************** End of fts3_snippet.c ****************************************/ +/************** Begin file fts3_unicode.c ************************************/ +/* +** 2012 May 24 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** Implementation of the "unicode" full-text-search tokenizer. +*/ + +#ifndef SQLITE_DISABLE_FTS3_UNICODE + +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_tokenizer.h" */ + +/* +** The following two macros - READ_UTF8 and WRITE_UTF8 - have been copied +** from the sqlite3 source file utf.c. If this file is compiled as part +** of the amalgamation, they are not required. +*/ +#ifndef SQLITE_AMALGAMATION + +static const unsigned char sqlite3Utf8Trans1[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00, +}; + +#define READ_UTF8(zIn, zTerm, c) \ + c = *(zIn++); \ + if( c>=0xc0 ){ \ + c = sqlite3Utf8Trans1[c-0xc0]; \ + while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \ + c = (c<<6) + (0x3f & *(zIn++)); \ + } \ + if( c<0x80 \ + || (c&0xFFFFF800)==0xD800 \ + || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ + } + +#define WRITE_UTF8(zOut, c) { \ + if( c<0x00080 ){ \ + *zOut++ = (u8)(c&0xFF); \ + } \ + else if( c<0x00800 ){ \ + *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ + else if( c<0x10000 ){ \ + *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + }else{ \ + *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \ + *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ +} + +#endif /* ifndef SQLITE_AMALGAMATION */ + +typedef struct unicode_tokenizer unicode_tokenizer; +typedef struct unicode_cursor unicode_cursor; + +struct unicode_tokenizer { + sqlite3_tokenizer base; + int bRemoveDiacritic; + int nException; + int *aiException; +}; + +struct unicode_cursor { + sqlite3_tokenizer_cursor base; + const unsigned char *aInput; /* Input text being tokenized */ + int nInput; /* Size of aInput[] in bytes */ + int iOff; /* Current offset within aInput[] */ + int iToken; /* Index of next token to be returned */ + char *zToken; /* storage for current token */ + int nAlloc; /* space allocated at zToken */ +}; + + +/* +** Destroy a tokenizer allocated by unicodeCreate(). +*/ +static int unicodeDestroy(sqlite3_tokenizer *pTokenizer){ + if( pTokenizer ){ + unicode_tokenizer *p = (unicode_tokenizer *)pTokenizer; + sqlite3_free(p->aiException); + sqlite3_free(p); + } + return SQLITE_OK; +} + +/* +** As part of a tokenchars= or separators= option, the CREATE VIRTUAL TABLE +** statement has specified that the tokenizer for this table shall consider +** all characters in string zIn/nIn to be separators (if bAlnum==0) or +** token characters (if bAlnum==1). +** +** For each codepoint in the zIn/nIn string, this function checks if the +** sqlite3FtsUnicodeIsalnum() function already returns the desired result. +** If so, no action is taken. Otherwise, the codepoint is added to the +** unicode_tokenizer.aiException[] array. For the purposes of tokenization, +** the return value of sqlite3FtsUnicodeIsalnum() is inverted for all +** codepoints in the aiException[] array. +** +** If a standalone diacritic mark (one that sqlite3FtsUnicodeIsdiacritic() +** identifies as a diacritic) occurs in the zIn/nIn string it is ignored. +** It is not possible to change the behavior of the tokenizer with respect +** to these codepoints. +*/ +static int unicodeAddExceptions( + unicode_tokenizer *p, /* Tokenizer to add exceptions to */ + int bAlnum, /* Replace Isalnum() return value with this */ + const char *zIn, /* Array of characters to make exceptions */ + int nIn /* Length of z in bytes */ +){ + const unsigned char *z = (const unsigned char *)zIn; + const unsigned char *zTerm = &z[nIn]; + int iCode; + int nEntry = 0; + + assert( bAlnum==0 || bAlnum==1 ); + + while( zaiException, (p->nException+nEntry)*sizeof(int)); + if( aNew==0 ) return SQLITE_NOMEM; + nNew = p->nException; + + z = (const unsigned char *)zIn; + while( zi; j--) aNew[j] = aNew[j-1]; + aNew[i] = iCode; + nNew++; + } + } + p->aiException = aNew; + p->nException = nNew; + } + + return SQLITE_OK; +} + +/* +** Return true if the p->aiException[] array contains the value iCode. +*/ +static int unicodeIsException(unicode_tokenizer *p, int iCode){ + if( p->nException>0 ){ + int *a = p->aiException; + int iLo = 0; + int iHi = p->nException-1; + + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + if( iCode==a[iTest] ){ + return 1; + }else if( iCode>a[iTest] ){ + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + } + + return 0; +} + +/* +** Return true if, for the purposes of tokenization, codepoint iCode is +** considered a token character (not a separator). +*/ +static int unicodeIsAlnum(unicode_tokenizer *p, int iCode){ + assert( (sqlite3FtsUnicodeIsalnum(iCode) & 0xFFFFFFFE)==0 ); + return sqlite3FtsUnicodeIsalnum(iCode) ^ unicodeIsException(p, iCode); +} + +/* +** Create a new tokenizer instance. +*/ +static int unicodeCreate( + int nArg, /* Size of array argv[] */ + const char * const *azArg, /* Tokenizer creation arguments */ + sqlite3_tokenizer **pp /* OUT: New tokenizer handle */ +){ + unicode_tokenizer *pNew; /* New tokenizer object */ + int i; + int rc = SQLITE_OK; + + pNew = (unicode_tokenizer *) sqlite3_malloc(sizeof(unicode_tokenizer)); + if( pNew==NULL ) return SQLITE_NOMEM; + memset(pNew, 0, sizeof(unicode_tokenizer)); + pNew->bRemoveDiacritic = 1; + + for(i=0; rc==SQLITE_OK && ibRemoveDiacritic = 1; + } + else if( n==19 && memcmp("remove_diacritics=0", z, 19)==0 ){ + pNew->bRemoveDiacritic = 0; + } + else if( n>=11 && memcmp("tokenchars=", z, 11)==0 ){ + rc = unicodeAddExceptions(pNew, 1, &z[11], n-11); + } + else if( n>=11 && memcmp("separators=", z, 11)==0 ){ + rc = unicodeAddExceptions(pNew, 0, &z[11], n-11); + } + else{ + /* Unrecognized argument */ + rc = SQLITE_ERROR; + } + } + + if( rc!=SQLITE_OK ){ + unicodeDestroy((sqlite3_tokenizer *)pNew); + pNew = 0; + } + *pp = (sqlite3_tokenizer *)pNew; + return rc; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is pInput[0..nBytes-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int unicodeOpen( + sqlite3_tokenizer *p, /* The tokenizer */ + const char *aInput, /* Input string */ + int nInput, /* Size of string aInput in bytes */ + sqlite3_tokenizer_cursor **pp /* OUT: New cursor object */ +){ + unicode_cursor *pCsr; + + pCsr = (unicode_cursor *)sqlite3_malloc(sizeof(unicode_cursor)); + if( pCsr==0 ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(unicode_cursor)); + + pCsr->aInput = (const unsigned char *)aInput; + if( aInput==0 ){ + pCsr->nInput = 0; + }else if( nInput<0 ){ + pCsr->nInput = (int)strlen(aInput); + }else{ + pCsr->nInput = nInput; + } + + *pp = &pCsr->base; + UNUSED_PARAMETER(p); + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to +** simpleOpen() above. +*/ +static int unicodeClose(sqlite3_tokenizer_cursor *pCursor){ + unicode_cursor *pCsr = (unicode_cursor *) pCursor; + sqlite3_free(pCsr->zToken); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** Extract the next token from a tokenization cursor. The cursor must +** have been opened by a prior call to simpleOpen(). +*/ +static int unicodeNext( + sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */ + const char **paToken, /* OUT: Token text */ + int *pnToken, /* OUT: Number of bytes at *paToken */ + int *piStart, /* OUT: Starting offset of token */ + int *piEnd, /* OUT: Ending offset of token */ + int *piPos /* OUT: Position integer of token */ +){ + unicode_cursor *pCsr = (unicode_cursor *)pC; + unicode_tokenizer *p = ((unicode_tokenizer *)pCsr->base.pTokenizer); + int iCode = 0; + char *zOut; + const unsigned char *z = &pCsr->aInput[pCsr->iOff]; + const unsigned char *zStart = z; + const unsigned char *zEnd; + const unsigned char *zTerm = &pCsr->aInput[pCsr->nInput]; + + /* Scan past any delimiter characters before the start of the next token. + ** Return SQLITE_DONE early if this takes us all the way to the end of + ** the input. */ + while( z=zTerm ) return SQLITE_DONE; + + zOut = pCsr->zToken; + do { + int iOut; + + /* Grow the output buffer if required. */ + if( (zOut-pCsr->zToken)>=(pCsr->nAlloc-4) ){ + char *zNew = sqlite3_realloc(pCsr->zToken, pCsr->nAlloc+64); + if( !zNew ) return SQLITE_NOMEM; + zOut = &zNew[zOut - pCsr->zToken]; + pCsr->zToken = zNew; + pCsr->nAlloc += 64; + } + + /* Write the folded case of the last character read to the output */ + zEnd = z; + iOut = sqlite3FtsUnicodeFold(iCode, p->bRemoveDiacritic); + if( iOut ){ + WRITE_UTF8(zOut, iOut); + } + + /* If the cursor is not at EOF, read the next character */ + if( z>=zTerm ) break; + READ_UTF8(z, zTerm, iCode); + }while( unicodeIsAlnum(p, iCode) + || sqlite3FtsUnicodeIsdiacritic(iCode) + ); + + /* Set the output variables and return. */ + pCsr->iOff = (int)(z - pCsr->aInput); + *paToken = pCsr->zToken; + *pnToken = (int)(zOut - pCsr->zToken); + *piStart = (int)(zStart - pCsr->aInput); + *piEnd = (int)(zEnd - pCsr->aInput); + *piPos = pCsr->iToken++; + return SQLITE_OK; +} + +/* +** Set *ppModule to a pointer to the sqlite3_tokenizer_module +** structure for the unicode tokenizer. +*/ +SQLITE_PRIVATE void sqlite3Fts3UnicodeTokenizer(sqlite3_tokenizer_module const **ppModule){ + static const sqlite3_tokenizer_module module = { + 0, + unicodeCreate, + unicodeDestroy, + unicodeOpen, + unicodeClose, + unicodeNext, + 0, + }; + *ppModule = &module; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ +#endif /* ifndef SQLITE_DISABLE_FTS3_UNICODE */ + +/************** End of fts3_unicode.c ****************************************/ +/************** Begin file fts3_unicode2.c ***********************************/ +/* +** 2012 May 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +*/ + +/* +** DO NOT EDIT THIS MACHINE GENERATED FILE. +*/ + +#ifndef SQLITE_DISABLE_FTS3_UNICODE +#if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4) + +/* #include */ + +/* +** Return true if the argument corresponds to a unicode codepoint +** classified as either a letter or a number. Otherwise false. +** +** The results are undefined if the value passed to this function +** is less than zero. +*/ +SQLITE_PRIVATE int sqlite3FtsUnicodeIsalnum(int c){ + /* Each unsigned integer in the following array corresponds to a contiguous + ** range of unicode codepoints that are not either letters or numbers (i.e. + ** codepoints for which this function should return 0). + ** + ** The most significant 22 bits in each 32-bit value contain the first + ** codepoint in the range. The least significant 10 bits are used to store + ** the size of the range (always at least 1). In other words, the value + ** ((C<<22) + N) represents a range of N codepoints starting with codepoint + ** C. It is not possible to represent a range larger than 1023 codepoints + ** using this format. + */ + static const unsigned int aEntry[] = { + 0x00000030, 0x0000E807, 0x00016C06, 0x0001EC2F, 0x0002AC07, + 0x0002D001, 0x0002D803, 0x0002EC01, 0x0002FC01, 0x00035C01, + 0x0003DC01, 0x000B0804, 0x000B480E, 0x000B9407, 0x000BB401, + 0x000BBC81, 0x000DD401, 0x000DF801, 0x000E1002, 0x000E1C01, + 0x000FD801, 0x00120808, 0x00156806, 0x00162402, 0x00163C01, + 0x00164437, 0x0017CC02, 0x00180005, 0x00181816, 0x00187802, + 0x00192C15, 0x0019A804, 0x0019C001, 0x001B5001, 0x001B580F, + 0x001B9C07, 0x001BF402, 0x001C000E, 0x001C3C01, 0x001C4401, + 0x001CC01B, 0x001E980B, 0x001FAC09, 0x001FD804, 0x00205804, + 0x00206C09, 0x00209403, 0x0020A405, 0x0020C00F, 0x00216403, + 0x00217801, 0x0023901B, 0x00240004, 0x0024E803, 0x0024F812, + 0x00254407, 0x00258804, 0x0025C001, 0x00260403, 0x0026F001, + 0x0026F807, 0x00271C02, 0x00272C03, 0x00275C01, 0x00278802, + 0x0027C802, 0x0027E802, 0x00280403, 0x0028F001, 0x0028F805, + 0x00291C02, 0x00292C03, 0x00294401, 0x0029C002, 0x0029D401, + 0x002A0403, 0x002AF001, 0x002AF808, 0x002B1C03, 0x002B2C03, + 0x002B8802, 0x002BC002, 0x002C0403, 0x002CF001, 0x002CF807, + 0x002D1C02, 0x002D2C03, 0x002D5802, 0x002D8802, 0x002DC001, + 0x002E0801, 0x002EF805, 0x002F1803, 0x002F2804, 0x002F5C01, + 0x002FCC08, 0x00300403, 0x0030F807, 0x00311803, 0x00312804, + 0x00315402, 0x00318802, 0x0031FC01, 0x00320802, 0x0032F001, + 0x0032F807, 0x00331803, 0x00332804, 0x00335402, 0x00338802, + 0x00340802, 0x0034F807, 0x00351803, 0x00352804, 0x00355C01, + 0x00358802, 0x0035E401, 0x00360802, 0x00372801, 0x00373C06, + 0x00375801, 0x00376008, 0x0037C803, 0x0038C401, 0x0038D007, + 0x0038FC01, 0x00391C09, 0x00396802, 0x003AC401, 0x003AD006, + 0x003AEC02, 0x003B2006, 0x003C041F, 0x003CD00C, 0x003DC417, + 0x003E340B, 0x003E6424, 0x003EF80F, 0x003F380D, 0x0040AC14, + 0x00412806, 0x00415804, 0x00417803, 0x00418803, 0x00419C07, + 0x0041C404, 0x0042080C, 0x00423C01, 0x00426806, 0x0043EC01, + 0x004D740C, 0x004E400A, 0x00500001, 0x0059B402, 0x005A0001, + 0x005A6C02, 0x005BAC03, 0x005C4803, 0x005CC805, 0x005D4802, + 0x005DC802, 0x005ED023, 0x005F6004, 0x005F7401, 0x0060000F, + 0x0062A401, 0x0064800C, 0x0064C00C, 0x00650001, 0x00651002, + 0x0066C011, 0x00672002, 0x00677822, 0x00685C05, 0x00687802, + 0x0069540A, 0x0069801D, 0x0069FC01, 0x006A8007, 0x006AA006, + 0x006C0005, 0x006CD011, 0x006D6823, 0x006E0003, 0x006E840D, + 0x006F980E, 0x006FF004, 0x00709014, 0x0070EC05, 0x0071F802, + 0x00730008, 0x00734019, 0x0073B401, 0x0073C803, 0x00770027, + 0x0077F004, 0x007EF401, 0x007EFC03, 0x007F3403, 0x007F7403, + 0x007FB403, 0x007FF402, 0x00800065, 0x0081A806, 0x0081E805, + 0x00822805, 0x0082801A, 0x00834021, 0x00840002, 0x00840C04, + 0x00842002, 0x00845001, 0x00845803, 0x00847806, 0x00849401, + 0x00849C01, 0x0084A401, 0x0084B801, 0x0084E802, 0x00850005, + 0x00852804, 0x00853C01, 0x00864264, 0x00900027, 0x0091000B, + 0x0092704E, 0x00940200, 0x009C0475, 0x009E53B9, 0x00AD400A, + 0x00B39406, 0x00B3BC03, 0x00B3E404, 0x00B3F802, 0x00B5C001, + 0x00B5FC01, 0x00B7804F, 0x00B8C00C, 0x00BA001A, 0x00BA6C59, + 0x00BC00D6, 0x00BFC00C, 0x00C00005, 0x00C02019, 0x00C0A807, + 0x00C0D802, 0x00C0F403, 0x00C26404, 0x00C28001, 0x00C3EC01, + 0x00C64002, 0x00C6580A, 0x00C70024, 0x00C8001F, 0x00C8A81E, + 0x00C94001, 0x00C98020, 0x00CA2827, 0x00CB003F, 0x00CC0100, + 0x01370040, 0x02924037, 0x0293F802, 0x02983403, 0x0299BC10, + 0x029A7C01, 0x029BC008, 0x029C0017, 0x029C8002, 0x029E2402, + 0x02A00801, 0x02A01801, 0x02A02C01, 0x02A08C09, 0x02A0D804, + 0x02A1D004, 0x02A20002, 0x02A2D011, 0x02A33802, 0x02A38012, + 0x02A3E003, 0x02A4980A, 0x02A51C0D, 0x02A57C01, 0x02A60004, + 0x02A6CC1B, 0x02A77802, 0x02A8A40E, 0x02A90C01, 0x02A93002, + 0x02A97004, 0x02A9DC03, 0x02A9EC01, 0x02AAC001, 0x02AAC803, + 0x02AADC02, 0x02AAF802, 0x02AB0401, 0x02AB7802, 0x02ABAC07, + 0x02ABD402, 0x02AF8C0B, 0x03600001, 0x036DFC02, 0x036FFC02, + 0x037FFC01, 0x03EC7801, 0x03ECA401, 0x03EEC810, 0x03F4F802, + 0x03F7F002, 0x03F8001A, 0x03F88007, 0x03F8C023, 0x03F95013, + 0x03F9A004, 0x03FBFC01, 0x03FC040F, 0x03FC6807, 0x03FCEC06, + 0x03FD6C0B, 0x03FF8007, 0x03FFA007, 0x03FFE405, 0x04040003, + 0x0404DC09, 0x0405E411, 0x0406400C, 0x0407402E, 0x040E7C01, + 0x040F4001, 0x04215C01, 0x04247C01, 0x0424FC01, 0x04280403, + 0x04281402, 0x04283004, 0x0428E003, 0x0428FC01, 0x04294009, + 0x0429FC01, 0x042CE407, 0x04400003, 0x0440E016, 0x04420003, + 0x0442C012, 0x04440003, 0x04449C0E, 0x04450004, 0x04460003, + 0x0446CC0E, 0x04471404, 0x045AAC0D, 0x0491C004, 0x05BD442E, + 0x05BE3C04, 0x074000F6, 0x07440027, 0x0744A4B5, 0x07480046, + 0x074C0057, 0x075B0401, 0x075B6C01, 0x075BEC01, 0x075C5401, + 0x075CD401, 0x075D3C01, 0x075DBC01, 0x075E2401, 0x075EA401, + 0x075F0C01, 0x07BBC002, 0x07C0002C, 0x07C0C064, 0x07C2800F, + 0x07C2C40E, 0x07C3040F, 0x07C3440F, 0x07C4401F, 0x07C4C03C, + 0x07C5C02B, 0x07C7981D, 0x07C8402B, 0x07C90009, 0x07C94002, + 0x07CC0021, 0x07CCC006, 0x07CCDC46, 0x07CE0014, 0x07CE8025, + 0x07CF1805, 0x07CF8011, 0x07D0003F, 0x07D10001, 0x07D108B6, + 0x07D3E404, 0x07D4003E, 0x07D50004, 0x07D54018, 0x07D7EC46, + 0x07D9140B, 0x07DA0046, 0x07DC0074, 0x38000401, 0x38008060, + 0x380400F0, + }; + static const unsigned int aAscii[4] = { + 0xFFFFFFFF, 0xFC00FFFF, 0xF8000001, 0xF8000001, + }; + + if( c<128 ){ + return ( (aAscii[c >> 5] & (1 << (c & 0x001F)))==0 ); + }else if( c<(1<<22) ){ + unsigned int key = (((unsigned int)c)<<10) | 0x000003FF; + int iRes = 0; + int iHi = sizeof(aEntry)/sizeof(aEntry[0]) - 1; + int iLo = 0; + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + if( key >= aEntry[iTest] ){ + iRes = iTest; + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + assert( aEntry[0]=aEntry[iRes] ); + return (((unsigned int)c) >= ((aEntry[iRes]>>10) + (aEntry[iRes]&0x3FF))); + } + return 1; +} + + +/* +** If the argument is a codepoint corresponding to a lowercase letter +** in the ASCII range with a diacritic added, return the codepoint +** of the ASCII letter only. For example, if passed 235 - "LATIN +** SMALL LETTER E WITH DIAERESIS" - return 65 ("LATIN SMALL LETTER +** E"). The resuls of passing a codepoint that corresponds to an +** uppercase letter are undefined. +*/ +static int remove_diacritic(int c){ + unsigned short aDia[] = { + 0, 1797, 1848, 1859, 1891, 1928, 1940, 1995, + 2024, 2040, 2060, 2110, 2168, 2206, 2264, 2286, + 2344, 2383, 2472, 2488, 2516, 2596, 2668, 2732, + 2782, 2842, 2894, 2954, 2984, 3000, 3028, 3336, + 3456, 3696, 3712, 3728, 3744, 3896, 3912, 3928, + 3968, 4008, 4040, 4106, 4138, 4170, 4202, 4234, + 4266, 4296, 4312, 4344, 4408, 4424, 4472, 4504, + 6148, 6198, 6264, 6280, 6360, 6429, 6505, 6529, + 61448, 61468, 61534, 61592, 61642, 61688, 61704, 61726, + 61784, 61800, 61836, 61880, 61914, 61948, 61998, 62122, + 62154, 62200, 62218, 62302, 62364, 62442, 62478, 62536, + 62554, 62584, 62604, 62640, 62648, 62656, 62664, 62730, + 62924, 63050, 63082, 63274, 63390, + }; + char aChar[] = { + '\0', 'a', 'c', 'e', 'i', 'n', 'o', 'u', 'y', 'y', 'a', 'c', + 'd', 'e', 'e', 'g', 'h', 'i', 'j', 'k', 'l', 'n', 'o', 'r', + 's', 't', 'u', 'u', 'w', 'y', 'z', 'o', 'u', 'a', 'i', 'o', + 'u', 'g', 'k', 'o', 'j', 'g', 'n', 'a', 'e', 'i', 'o', 'r', + 'u', 's', 't', 'h', 'a', 'e', 'o', 'y', '\0', '\0', '\0', '\0', + '\0', '\0', '\0', '\0', 'a', 'b', 'd', 'd', 'e', 'f', 'g', 'h', + 'h', 'i', 'k', 'l', 'l', 'm', 'n', 'p', 'r', 'r', 's', 't', + 'u', 'v', 'w', 'w', 'x', 'y', 'z', 'h', 't', 'w', 'y', 'a', + 'e', 'i', 'o', 'u', 'y', + }; + + unsigned int key = (((unsigned int)c)<<3) | 0x00000007; + int iRes = 0; + int iHi = sizeof(aDia)/sizeof(aDia[0]) - 1; + int iLo = 0; + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + if( key >= aDia[iTest] ){ + iRes = iTest; + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + assert( key>=aDia[iRes] ); + return ((c > (aDia[iRes]>>3) + (aDia[iRes]&0x07)) ? c : (int)aChar[iRes]); +} + + +/* +** Return true if the argument interpreted as a unicode codepoint +** is a diacritical modifier character. +*/ +SQLITE_PRIVATE int sqlite3FtsUnicodeIsdiacritic(int c){ + unsigned int mask0 = 0x08029FDF; + unsigned int mask1 = 0x000361F8; + if( c<768 || c>817 ) return 0; + return (c < 768+32) ? + (mask0 & (1 << (c-768))) : + (mask1 & (1 << (c-768-32))); +} + + +/* +** Interpret the argument as a unicode codepoint. If the codepoint +** is an upper case character that has a lower case equivalent, +** return the codepoint corresponding to the lower case version. +** Otherwise, return a copy of the argument. +** +** The results are undefined if the value passed to this function +** is less than zero. +*/ +SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int c, int bRemoveDiacritic){ + /* Each entry in the following array defines a rule for folding a range + ** of codepoints to lower case. The rule applies to a range of nRange + ** codepoints starting at codepoint iCode. + ** + ** If the least significant bit in flags is clear, then the rule applies + ** to all nRange codepoints (i.e. all nRange codepoints are upper case and + ** need to be folded). Or, if it is set, then the rule only applies to + ** every second codepoint in the range, starting with codepoint C. + ** + ** The 7 most significant bits in flags are an index into the aiOff[] + ** array. If a specific codepoint C does require folding, then its lower + ** case equivalent is ((C + aiOff[flags>>1]) & 0xFFFF). + ** + ** The contents of this array are generated by parsing the CaseFolding.txt + ** file distributed as part of the "Unicode Character Database". See + ** http://www.unicode.org for details. + */ + static const struct TableEntry { + unsigned short iCode; + unsigned char flags; + unsigned char nRange; + } aEntry[] = { + {65, 14, 26}, {181, 64, 1}, {192, 14, 23}, + {216, 14, 7}, {256, 1, 48}, {306, 1, 6}, + {313, 1, 16}, {330, 1, 46}, {376, 116, 1}, + {377, 1, 6}, {383, 104, 1}, {385, 50, 1}, + {386, 1, 4}, {390, 44, 1}, {391, 0, 1}, + {393, 42, 2}, {395, 0, 1}, {398, 32, 1}, + {399, 38, 1}, {400, 40, 1}, {401, 0, 1}, + {403, 42, 1}, {404, 46, 1}, {406, 52, 1}, + {407, 48, 1}, {408, 0, 1}, {412, 52, 1}, + {413, 54, 1}, {415, 56, 1}, {416, 1, 6}, + {422, 60, 1}, {423, 0, 1}, {425, 60, 1}, + {428, 0, 1}, {430, 60, 1}, {431, 0, 1}, + {433, 58, 2}, {435, 1, 4}, {439, 62, 1}, + {440, 0, 1}, {444, 0, 1}, {452, 2, 1}, + {453, 0, 1}, {455, 2, 1}, {456, 0, 1}, + {458, 2, 1}, {459, 1, 18}, {478, 1, 18}, + {497, 2, 1}, {498, 1, 4}, {502, 122, 1}, + {503, 134, 1}, {504, 1, 40}, {544, 110, 1}, + {546, 1, 18}, {570, 70, 1}, {571, 0, 1}, + {573, 108, 1}, {574, 68, 1}, {577, 0, 1}, + {579, 106, 1}, {580, 28, 1}, {581, 30, 1}, + {582, 1, 10}, {837, 36, 1}, {880, 1, 4}, + {886, 0, 1}, {902, 18, 1}, {904, 16, 3}, + {908, 26, 1}, {910, 24, 2}, {913, 14, 17}, + {931, 14, 9}, {962, 0, 1}, {975, 4, 1}, + {976, 140, 1}, {977, 142, 1}, {981, 146, 1}, + {982, 144, 1}, {984, 1, 24}, {1008, 136, 1}, + {1009, 138, 1}, {1012, 130, 1}, {1013, 128, 1}, + {1015, 0, 1}, {1017, 152, 1}, {1018, 0, 1}, + {1021, 110, 3}, {1024, 34, 16}, {1040, 14, 32}, + {1120, 1, 34}, {1162, 1, 54}, {1216, 6, 1}, + {1217, 1, 14}, {1232, 1, 88}, {1329, 22, 38}, + {4256, 66, 38}, {4295, 66, 1}, {4301, 66, 1}, + {7680, 1, 150}, {7835, 132, 1}, {7838, 96, 1}, + {7840, 1, 96}, {7944, 150, 8}, {7960, 150, 6}, + {7976, 150, 8}, {7992, 150, 8}, {8008, 150, 6}, + {8025, 151, 8}, {8040, 150, 8}, {8072, 150, 8}, + {8088, 150, 8}, {8104, 150, 8}, {8120, 150, 2}, + {8122, 126, 2}, {8124, 148, 1}, {8126, 100, 1}, + {8136, 124, 4}, {8140, 148, 1}, {8152, 150, 2}, + {8154, 120, 2}, {8168, 150, 2}, {8170, 118, 2}, + {8172, 152, 1}, {8184, 112, 2}, {8186, 114, 2}, + {8188, 148, 1}, {8486, 98, 1}, {8490, 92, 1}, + {8491, 94, 1}, {8498, 12, 1}, {8544, 8, 16}, + {8579, 0, 1}, {9398, 10, 26}, {11264, 22, 47}, + {11360, 0, 1}, {11362, 88, 1}, {11363, 102, 1}, + {11364, 90, 1}, {11367, 1, 6}, {11373, 84, 1}, + {11374, 86, 1}, {11375, 80, 1}, {11376, 82, 1}, + {11378, 0, 1}, {11381, 0, 1}, {11390, 78, 2}, + {11392, 1, 100}, {11499, 1, 4}, {11506, 0, 1}, + {42560, 1, 46}, {42624, 1, 24}, {42786, 1, 14}, + {42802, 1, 62}, {42873, 1, 4}, {42877, 76, 1}, + {42878, 1, 10}, {42891, 0, 1}, {42893, 74, 1}, + {42896, 1, 4}, {42912, 1, 10}, {42922, 72, 1}, + {65313, 14, 26}, + }; + static const unsigned short aiOff[] = { + 1, 2, 8, 15, 16, 26, 28, 32, + 37, 38, 40, 48, 63, 64, 69, 71, + 79, 80, 116, 202, 203, 205, 206, 207, + 209, 210, 211, 213, 214, 217, 218, 219, + 775, 7264, 10792, 10795, 23228, 23256, 30204, 54721, + 54753, 54754, 54756, 54787, 54793, 54809, 57153, 57274, + 57921, 58019, 58363, 61722, 65268, 65341, 65373, 65406, + 65408, 65410, 65415, 65424, 65436, 65439, 65450, 65462, + 65472, 65476, 65478, 65480, 65482, 65488, 65506, 65511, + 65514, 65521, 65527, 65528, 65529, + }; + + int ret = c; + + assert( c>=0 ); + assert( sizeof(unsigned short)==2 && sizeof(unsigned char)==1 ); + + if( c<128 ){ + if( c>='A' && c<='Z' ) ret = c + ('a' - 'A'); + }else if( c<65536 ){ + int iHi = sizeof(aEntry)/sizeof(aEntry[0]) - 1; + int iLo = 0; + int iRes = -1; + + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + int cmp = (c - aEntry[iTest].iCode); + if( cmp>=0 ){ + iRes = iTest; + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + assert( iRes<0 || c>=aEntry[iRes].iCode ); + + if( iRes>=0 ){ + const struct TableEntry *p = &aEntry[iRes]; + if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){ + ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF; + assert( ret>0 ); + } + } + + if( bRemoveDiacritic ) ret = remove_diacritic(ret); + } + + else if( c>=66560 && c<66600 ){ + ret = c + 40; + } + + return ret; +} +#endif /* defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4) */ +#endif /* !defined(SQLITE_DISABLE_FTS3_UNICODE) */ + +/************** End of fts3_unicode2.c ***************************************/ +/************** Begin file rtree.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code for implementations of the r-tree and r*-tree +** algorithms packaged as an SQLite virtual table module. +*/ + +/* +** Database Format of R-Tree Tables +** -------------------------------- +** +** The data structure for a single virtual r-tree table is stored in three +** native SQLite tables declared as follows. In each case, the '%' character +** in the table name is replaced with the user-supplied name of the r-tree +** table. +** +** CREATE TABLE %_node(nodeno INTEGER PRIMARY KEY, data BLOB) +** CREATE TABLE %_parent(nodeno INTEGER PRIMARY KEY, parentnode INTEGER) +** CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER) +** +** The data for each node of the r-tree structure is stored in the %_node +** table. For each node that is not the root node of the r-tree, there is +** an entry in the %_parent table associating the node with its parent. +** And for each row of data in the table, there is an entry in the %_rowid +** table that maps from the entries rowid to the id of the node that it +** is stored on. +** +** The root node of an r-tree always exists, even if the r-tree table is +** empty. The nodeno of the root node is always 1. All other nodes in the +** table must be the same size as the root node. The content of each node +** is formatted as follows: +** +** 1. If the node is the root node (node 1), then the first 2 bytes +** of the node contain the tree depth as a big-endian integer. +** For non-root nodes, the first 2 bytes are left unused. +** +** 2. The next 2 bytes contain the number of entries currently +** stored in the node. +** +** 3. The remainder of the node contains the node entries. Each entry +** consists of a single 8-byte integer followed by an even number +** of 4-byte coordinates. For leaf nodes the integer is the rowid +** of a record. For internal nodes it is the node number of a +** child page. +*/ + +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RTREE) + +#ifndef SQLITE_CORE +/* #include "sqlite3ext.h" */ + SQLITE_EXTENSION_INIT1 +#else +/* #include "sqlite3.h" */ +#endif + +/* #include */ +/* #include */ +/* #include */ + +#ifndef SQLITE_AMALGAMATION +#include "sqlite3rtree.h" +typedef sqlite3_int64 i64; +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned int u32; +#endif + +/* The following macro is used to suppress compiler warnings. +*/ +#ifndef UNUSED_PARAMETER +# define UNUSED_PARAMETER(x) (void)(x) +#endif + +typedef struct Rtree Rtree; +typedef struct RtreeCursor RtreeCursor; +typedef struct RtreeNode RtreeNode; +typedef struct RtreeCell RtreeCell; +typedef struct RtreeConstraint RtreeConstraint; +typedef struct RtreeMatchArg RtreeMatchArg; +typedef struct RtreeGeomCallback RtreeGeomCallback; +typedef union RtreeCoord RtreeCoord; +typedef struct RtreeSearchPoint RtreeSearchPoint; + +/* The rtree may have between 1 and RTREE_MAX_DIMENSIONS dimensions. */ +#define RTREE_MAX_DIMENSIONS 5 + +/* Size of hash table Rtree.aHash. This hash table is not expected to +** ever contain very many entries, so a fixed number of buckets is +** used. +*/ +#define HASHSIZE 97 + +/* The xBestIndex method of this virtual table requires an estimate of +** the number of rows in the virtual table to calculate the costs of +** various strategies. If possible, this estimate is loaded from the +** sqlite_stat1 table (with RTREE_MIN_ROWEST as a hard-coded minimum). +** Otherwise, if no sqlite_stat1 entry is available, use +** RTREE_DEFAULT_ROWEST. +*/ +#define RTREE_DEFAULT_ROWEST 1048576 +#define RTREE_MIN_ROWEST 100 + +/* +** An rtree virtual-table object. +*/ +struct Rtree { + sqlite3_vtab base; /* Base class. Must be first */ + sqlite3 *db; /* Host database connection */ + int iNodeSize; /* Size in bytes of each node in the node table */ + u8 nDim; /* Number of dimensions */ + u8 eCoordType; /* RTREE_COORD_REAL32 or RTREE_COORD_INT32 */ + u8 nBytesPerCell; /* Bytes consumed per cell */ + int iDepth; /* Current depth of the r-tree structure */ + char *zDb; /* Name of database containing r-tree table */ + char *zName; /* Name of r-tree table */ + int nBusy; /* Current number of users of this structure */ + i64 nRowEst; /* Estimated number of rows in this table */ + + /* List of nodes removed during a CondenseTree operation. List is + ** linked together via the pointer normally used for hash chains - + ** RtreeNode.pNext. RtreeNode.iNode stores the depth of the sub-tree + ** headed by the node (leaf nodes have RtreeNode.iNode==0). + */ + RtreeNode *pDeleted; + int iReinsertHeight; /* Height of sub-trees Reinsert() has run on */ + + /* Statements to read/write/delete a record from xxx_node */ + sqlite3_stmt *pReadNode; + sqlite3_stmt *pWriteNode; + sqlite3_stmt *pDeleteNode; + + /* Statements to read/write/delete a record from xxx_rowid */ + sqlite3_stmt *pReadRowid; + sqlite3_stmt *pWriteRowid; + sqlite3_stmt *pDeleteRowid; + + /* Statements to read/write/delete a record from xxx_parent */ + sqlite3_stmt *pReadParent; + sqlite3_stmt *pWriteParent; + sqlite3_stmt *pDeleteParent; + + RtreeNode *aHash[HASHSIZE]; /* Hash table of in-memory nodes. */ +}; + +/* Possible values for Rtree.eCoordType: */ +#define RTREE_COORD_REAL32 0 +#define RTREE_COORD_INT32 1 + +/* +** If SQLITE_RTREE_INT_ONLY is defined, then this virtual table will +** only deal with integer coordinates. No floating point operations +** will be done. +*/ +#ifdef SQLITE_RTREE_INT_ONLY + typedef sqlite3_int64 RtreeDValue; /* High accuracy coordinate */ + typedef int RtreeValue; /* Low accuracy coordinate */ +# define RTREE_ZERO 0 +#else + typedef double RtreeDValue; /* High accuracy coordinate */ + typedef float RtreeValue; /* Low accuracy coordinate */ +# define RTREE_ZERO 0.0 +#endif + +/* +** When doing a search of an r-tree, instances of the following structure +** record intermediate results from the tree walk. +** +** The id is always a node-id. For iLevel>=1 the id is the node-id of +** the node that the RtreeSearchPoint represents. When iLevel==0, however, +** the id is of the parent node and the cell that RtreeSearchPoint +** represents is the iCell-th entry in the parent node. +*/ +struct RtreeSearchPoint { + RtreeDValue rScore; /* The score for this node. Smallest goes first. */ + sqlite3_int64 id; /* Node ID */ + u8 iLevel; /* 0=entries. 1=leaf node. 2+ for higher */ + u8 eWithin; /* PARTLY_WITHIN or FULLY_WITHIN */ + u8 iCell; /* Cell index within the node */ +}; + +/* +** The minimum number of cells allowed for a node is a third of the +** maximum. In Gutman's notation: +** +** m = M/3 +** +** If an R*-tree "Reinsert" operation is required, the same number of +** cells are removed from the overfull node and reinserted into the tree. +*/ +#define RTREE_MINCELLS(p) ((((p)->iNodeSize-4)/(p)->nBytesPerCell)/3) +#define RTREE_REINSERT(p) RTREE_MINCELLS(p) +#define RTREE_MAXCELLS 51 + +/* +** The smallest possible node-size is (512-64)==448 bytes. And the largest +** supported cell size is 48 bytes (8 byte rowid + ten 4 byte coordinates). +** Therefore all non-root nodes must contain at least 3 entries. Since +** 2^40 is greater than 2^64, an r-tree structure always has a depth of +** 40 or less. +*/ +#define RTREE_MAX_DEPTH 40 + + +/* +** Number of entries in the cursor RtreeNode cache. The first entry is +** used to cache the RtreeNode for RtreeCursor.sPoint. The remaining +** entries cache the RtreeNode for the first elements of the priority queue. +*/ +#define RTREE_CACHE_SZ 5 + +/* +** An rtree cursor object. +*/ +struct RtreeCursor { + sqlite3_vtab_cursor base; /* Base class. Must be first */ + u8 atEOF; /* True if at end of search */ + u8 bPoint; /* True if sPoint is valid */ + int iStrategy; /* Copy of idxNum search parameter */ + int nConstraint; /* Number of entries in aConstraint */ + RtreeConstraint *aConstraint; /* Search constraints. */ + int nPointAlloc; /* Number of slots allocated for aPoint[] */ + int nPoint; /* Number of slots used in aPoint[] */ + int mxLevel; /* iLevel value for root of the tree */ + RtreeSearchPoint *aPoint; /* Priority queue for search points */ + RtreeSearchPoint sPoint; /* Cached next search point */ + RtreeNode *aNode[RTREE_CACHE_SZ]; /* Rtree node cache */ + u32 anQueue[RTREE_MAX_DEPTH+1]; /* Number of queued entries by iLevel */ +}; + +/* Return the Rtree of a RtreeCursor */ +#define RTREE_OF_CURSOR(X) ((Rtree*)((X)->base.pVtab)) + +/* +** A coordinate can be either a floating point number or a integer. All +** coordinates within a single R-Tree are always of the same time. +*/ +union RtreeCoord { + RtreeValue f; /* Floating point value */ + int i; /* Integer value */ + u32 u; /* Unsigned for byte-order conversions */ +}; + +/* +** The argument is an RtreeCoord. Return the value stored within the RtreeCoord +** formatted as a RtreeDValue (double or int64). This macro assumes that local +** variable pRtree points to the Rtree structure associated with the +** RtreeCoord. +*/ +#ifdef SQLITE_RTREE_INT_ONLY +# define DCOORD(coord) ((RtreeDValue)coord.i) +#else +# define DCOORD(coord) ( \ + (pRtree->eCoordType==RTREE_COORD_REAL32) ? \ + ((double)coord.f) : \ + ((double)coord.i) \ + ) +#endif + +/* +** A search constraint. +*/ +struct RtreeConstraint { + int iCoord; /* Index of constrained coordinate */ + int op; /* Constraining operation */ + union { + RtreeDValue rValue; /* Constraint value. */ + int (*xGeom)(sqlite3_rtree_geometry*,int,RtreeDValue*,int*); + int (*xQueryFunc)(sqlite3_rtree_query_info*); + } u; + sqlite3_rtree_query_info *pInfo; /* xGeom and xQueryFunc argument */ +}; + +/* Possible values for RtreeConstraint.op */ +#define RTREE_EQ 0x41 /* A */ +#define RTREE_LE 0x42 /* B */ +#define RTREE_LT 0x43 /* C */ +#define RTREE_GE 0x44 /* D */ +#define RTREE_GT 0x45 /* E */ +#define RTREE_MATCH 0x46 /* F: Old-style sqlite3_rtree_geometry_callback() */ +#define RTREE_QUERY 0x47 /* G: New-style sqlite3_rtree_query_callback() */ + + +/* +** An rtree structure node. +*/ +struct RtreeNode { + RtreeNode *pParent; /* Parent node */ + i64 iNode; /* The node number */ + int nRef; /* Number of references to this node */ + int isDirty; /* True if the node needs to be written to disk */ + u8 *zData; /* Content of the node, as should be on disk */ + RtreeNode *pNext; /* Next node in this hash collision chain */ +}; + +/* Return the number of cells in a node */ +#define NCELL(pNode) readInt16(&(pNode)->zData[2]) + +/* +** A single cell from a node, deserialized +*/ +struct RtreeCell { + i64 iRowid; /* Node or entry ID */ + RtreeCoord aCoord[RTREE_MAX_DIMENSIONS*2]; /* Bounding box coordinates */ +}; + + +/* +** This object becomes the sqlite3_user_data() for the SQL functions +** that are created by sqlite3_rtree_geometry_callback() and +** sqlite3_rtree_query_callback() and which appear on the right of MATCH +** operators in order to constrain a search. +** +** xGeom and xQueryFunc are the callback functions. Exactly one of +** xGeom and xQueryFunc fields is non-NULL, depending on whether the +** SQL function was created using sqlite3_rtree_geometry_callback() or +** sqlite3_rtree_query_callback(). +** +** This object is deleted automatically by the destructor mechanism in +** sqlite3_create_function_v2(). +*/ +struct RtreeGeomCallback { + int (*xGeom)(sqlite3_rtree_geometry*, int, RtreeDValue*, int*); + int (*xQueryFunc)(sqlite3_rtree_query_info*); + void (*xDestructor)(void*); + void *pContext; +}; + + +/* +** Value for the first field of every RtreeMatchArg object. The MATCH +** operator tests that the first field of a blob operand matches this +** value to avoid operating on invalid blobs (which could cause a segfault). +*/ +#define RTREE_GEOMETRY_MAGIC 0x891245AB + +/* +** An instance of this structure (in the form of a BLOB) is returned by +** the SQL functions that sqlite3_rtree_geometry_callback() and +** sqlite3_rtree_query_callback() create, and is read as the right-hand +** operand to the MATCH operator of an R-Tree. +*/ +struct RtreeMatchArg { + u32 magic; /* Always RTREE_GEOMETRY_MAGIC */ + RtreeGeomCallback cb; /* Info about the callback functions */ + int nParam; /* Number of parameters to the SQL function */ + sqlite3_value **apSqlParam; /* Original SQL parameter values */ + RtreeDValue aParam[1]; /* Values for parameters to the SQL function */ +}; + +#ifndef MAX +# define MAX(x,y) ((x) < (y) ? (y) : (x)) +#endif +#ifndef MIN +# define MIN(x,y) ((x) > (y) ? (y) : (x)) +#endif + +/* +** Functions to deserialize a 16 bit integer, 32 bit real number and +** 64 bit integer. The deserialized value is returned. +*/ +static int readInt16(u8 *p){ + return (p[0]<<8) + p[1]; +} +static void readCoord(u8 *p, RtreeCoord *pCoord){ + pCoord->u = ( + (((u32)p[0]) << 24) + + (((u32)p[1]) << 16) + + (((u32)p[2]) << 8) + + (((u32)p[3]) << 0) + ); +} +static i64 readInt64(u8 *p){ + return ( + (((i64)p[0]) << 56) + + (((i64)p[1]) << 48) + + (((i64)p[2]) << 40) + + (((i64)p[3]) << 32) + + (((i64)p[4]) << 24) + + (((i64)p[5]) << 16) + + (((i64)p[6]) << 8) + + (((i64)p[7]) << 0) + ); +} + +/* +** Functions to serialize a 16 bit integer, 32 bit real number and +** 64 bit integer. The value returned is the number of bytes written +** to the argument buffer (always 2, 4 and 8 respectively). +*/ +static int writeInt16(u8 *p, int i){ + p[0] = (i>> 8)&0xFF; + p[1] = (i>> 0)&0xFF; + return 2; +} +static int writeCoord(u8 *p, RtreeCoord *pCoord){ + u32 i; + assert( sizeof(RtreeCoord)==4 ); + assert( sizeof(u32)==4 ); + i = pCoord->u; + p[0] = (i>>24)&0xFF; + p[1] = (i>>16)&0xFF; + p[2] = (i>> 8)&0xFF; + p[3] = (i>> 0)&0xFF; + return 4; +} +static int writeInt64(u8 *p, i64 i){ + p[0] = (i>>56)&0xFF; + p[1] = (i>>48)&0xFF; + p[2] = (i>>40)&0xFF; + p[3] = (i>>32)&0xFF; + p[4] = (i>>24)&0xFF; + p[5] = (i>>16)&0xFF; + p[6] = (i>> 8)&0xFF; + p[7] = (i>> 0)&0xFF; + return 8; +} + +/* +** Increment the reference count of node p. +*/ +static void nodeReference(RtreeNode *p){ + if( p ){ + p->nRef++; + } +} + +/* +** Clear the content of node p (set all bytes to 0x00). +*/ +static void nodeZero(Rtree *pRtree, RtreeNode *p){ + memset(&p->zData[2], 0, pRtree->iNodeSize-2); + p->isDirty = 1; +} + +/* +** Given a node number iNode, return the corresponding key to use +** in the Rtree.aHash table. +*/ +static int nodeHash(i64 iNode){ + return iNode % HASHSIZE; +} + +/* +** Search the node hash table for node iNode. If found, return a pointer +** to it. Otherwise, return 0. +*/ +static RtreeNode *nodeHashLookup(Rtree *pRtree, i64 iNode){ + RtreeNode *p; + for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext); + return p; +} + +/* +** Add node pNode to the node hash table. +*/ +static void nodeHashInsert(Rtree *pRtree, RtreeNode *pNode){ + int iHash; + assert( pNode->pNext==0 ); + iHash = nodeHash(pNode->iNode); + pNode->pNext = pRtree->aHash[iHash]; + pRtree->aHash[iHash] = pNode; +} + +/* +** Remove node pNode from the node hash table. +*/ +static void nodeHashDelete(Rtree *pRtree, RtreeNode *pNode){ + RtreeNode **pp; + if( pNode->iNode!=0 ){ + pp = &pRtree->aHash[nodeHash(pNode->iNode)]; + for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); } + *pp = pNode->pNext; + pNode->pNext = 0; + } +} + +/* +** Allocate and return new r-tree node. Initially, (RtreeNode.iNode==0), +** indicating that node has not yet been assigned a node number. It is +** assigned a node number when nodeWrite() is called to write the +** node contents out to the database. +*/ +static RtreeNode *nodeNew(Rtree *pRtree, RtreeNode *pParent){ + RtreeNode *pNode; + pNode = (RtreeNode *)sqlite3_malloc(sizeof(RtreeNode) + pRtree->iNodeSize); + if( pNode ){ + memset(pNode, 0, sizeof(RtreeNode) + pRtree->iNodeSize); + pNode->zData = (u8 *)&pNode[1]; + pNode->nRef = 1; + pNode->pParent = pParent; + pNode->isDirty = 1; + nodeReference(pParent); + } + return pNode; +} + +/* +** Obtain a reference to an r-tree node. +*/ +static int nodeAcquire( + Rtree *pRtree, /* R-tree structure */ + i64 iNode, /* Node number to load */ + RtreeNode *pParent, /* Either the parent node or NULL */ + RtreeNode **ppNode /* OUT: Acquired node */ +){ + int rc; + int rc2 = SQLITE_OK; + RtreeNode *pNode; + + /* Check if the requested node is already in the hash table. If so, + ** increase its reference count and return it. + */ + if( (pNode = nodeHashLookup(pRtree, iNode)) ){ + assert( !pParent || !pNode->pParent || pNode->pParent==pParent ); + if( pParent && !pNode->pParent ){ + nodeReference(pParent); + pNode->pParent = pParent; + } + pNode->nRef++; + *ppNode = pNode; + return SQLITE_OK; + } + + sqlite3_bind_int64(pRtree->pReadNode, 1, iNode); + rc = sqlite3_step(pRtree->pReadNode); + if( rc==SQLITE_ROW ){ + const u8 *zBlob = sqlite3_column_blob(pRtree->pReadNode, 0); + if( pRtree->iNodeSize==sqlite3_column_bytes(pRtree->pReadNode, 0) ){ + pNode = (RtreeNode *)sqlite3_malloc(sizeof(RtreeNode)+pRtree->iNodeSize); + if( !pNode ){ + rc2 = SQLITE_NOMEM; + }else{ + pNode->pParent = pParent; + pNode->zData = (u8 *)&pNode[1]; + pNode->nRef = 1; + pNode->iNode = iNode; + pNode->isDirty = 0; + pNode->pNext = 0; + memcpy(pNode->zData, zBlob, pRtree->iNodeSize); + nodeReference(pParent); + } + } + } + rc = sqlite3_reset(pRtree->pReadNode); + if( rc==SQLITE_OK ) rc = rc2; + + /* If the root node was just loaded, set pRtree->iDepth to the height + ** of the r-tree structure. A height of zero means all data is stored on + ** the root node. A height of one means the children of the root node + ** are the leaves, and so on. If the depth as specified on the root node + ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt. + */ + if( pNode && iNode==1 ){ + pRtree->iDepth = readInt16(pNode->zData); + if( pRtree->iDepth>RTREE_MAX_DEPTH ){ + rc = SQLITE_CORRUPT_VTAB; + } + } + + /* If no error has occurred so far, check if the "number of entries" + ** field on the node is too large. If so, set the return code to + ** SQLITE_CORRUPT_VTAB. + */ + if( pNode && rc==SQLITE_OK ){ + if( NCELL(pNode)>((pRtree->iNodeSize-4)/pRtree->nBytesPerCell) ){ + rc = SQLITE_CORRUPT_VTAB; + } + } + + if( rc==SQLITE_OK ){ + if( pNode!=0 ){ + nodeHashInsert(pRtree, pNode); + }else{ + rc = SQLITE_CORRUPT_VTAB; + } + *ppNode = pNode; + }else{ + sqlite3_free(pNode); + *ppNode = 0; + } + + return rc; +} + +/* +** Overwrite cell iCell of node pNode with the contents of pCell. +*/ +static void nodeOverwriteCell( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node into which the cell is to be written */ + RtreeCell *pCell, /* The cell to write */ + int iCell /* Index into pNode into which pCell is written */ +){ + int ii; + u8 *p = &pNode->zData[4 + pRtree->nBytesPerCell*iCell]; + p += writeInt64(p, pCell->iRowid); + for(ii=0; ii<(pRtree->nDim*2); ii++){ + p += writeCoord(p, &pCell->aCoord[ii]); + } + pNode->isDirty = 1; +} + +/* +** Remove the cell with index iCell from node pNode. +*/ +static void nodeDeleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell){ + u8 *pDst = &pNode->zData[4 + pRtree->nBytesPerCell*iCell]; + u8 *pSrc = &pDst[pRtree->nBytesPerCell]; + int nByte = (NCELL(pNode) - iCell - 1) * pRtree->nBytesPerCell; + memmove(pDst, pSrc, nByte); + writeInt16(&pNode->zData[2], NCELL(pNode)-1); + pNode->isDirty = 1; +} + +/* +** Insert the contents of cell pCell into node pNode. If the insert +** is successful, return SQLITE_OK. +** +** If there is not enough free space in pNode, return SQLITE_FULL. +*/ +static int nodeInsertCell( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* Write new cell into this node */ + RtreeCell *pCell /* The cell to be inserted */ +){ + int nCell; /* Current number of cells in pNode */ + int nMaxCell; /* Maximum number of cells for pNode */ + + nMaxCell = (pRtree->iNodeSize-4)/pRtree->nBytesPerCell; + nCell = NCELL(pNode); + + assert( nCell<=nMaxCell ); + if( nCellzData[2], nCell+1); + pNode->isDirty = 1; + } + + return (nCell==nMaxCell); +} + +/* +** If the node is dirty, write it out to the database. +*/ +static int nodeWrite(Rtree *pRtree, RtreeNode *pNode){ + int rc = SQLITE_OK; + if( pNode->isDirty ){ + sqlite3_stmt *p = pRtree->pWriteNode; + if( pNode->iNode ){ + sqlite3_bind_int64(p, 1, pNode->iNode); + }else{ + sqlite3_bind_null(p, 1); + } + sqlite3_bind_blob(p, 2, pNode->zData, pRtree->iNodeSize, SQLITE_STATIC); + sqlite3_step(p); + pNode->isDirty = 0; + rc = sqlite3_reset(p); + if( pNode->iNode==0 && rc==SQLITE_OK ){ + pNode->iNode = sqlite3_last_insert_rowid(pRtree->db); + nodeHashInsert(pRtree, pNode); + } + } + return rc; +} + +/* +** Release a reference to a node. If the node is dirty and the reference +** count drops to zero, the node data is written to the database. +*/ +static int nodeRelease(Rtree *pRtree, RtreeNode *pNode){ + int rc = SQLITE_OK; + if( pNode ){ + assert( pNode->nRef>0 ); + pNode->nRef--; + if( pNode->nRef==0 ){ + if( pNode->iNode==1 ){ + pRtree->iDepth = -1; + } + if( pNode->pParent ){ + rc = nodeRelease(pRtree, pNode->pParent); + } + if( rc==SQLITE_OK ){ + rc = nodeWrite(pRtree, pNode); + } + nodeHashDelete(pRtree, pNode); + sqlite3_free(pNode); + } + } + return rc; +} + +/* +** Return the 64-bit integer value associated with cell iCell of +** node pNode. If pNode is a leaf node, this is a rowid. If it is +** an internal node, then the 64-bit integer is a child page number. +*/ +static i64 nodeGetRowid( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node from which to extract the ID */ + int iCell /* The cell index from which to extract the ID */ +){ + assert( iCellzData[4 + pRtree->nBytesPerCell*iCell]); +} + +/* +** Return coordinate iCoord from cell iCell in node pNode. +*/ +static void nodeGetCoord( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node from which to extract a coordinate */ + int iCell, /* The index of the cell within the node */ + int iCoord, /* Which coordinate to extract */ + RtreeCoord *pCoord /* OUT: Space to write result to */ +){ + readCoord(&pNode->zData[12 + pRtree->nBytesPerCell*iCell + 4*iCoord], pCoord); +} + +/* +** Deserialize cell iCell of node pNode. Populate the structure pointed +** to by pCell with the results. +*/ +static void nodeGetCell( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node containing the cell to be read */ + int iCell, /* Index of the cell within the node */ + RtreeCell *pCell /* OUT: Write the cell contents here */ +){ + u8 *pData; + RtreeCoord *pCoord; + int ii; + pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell); + pData = pNode->zData + (12 + pRtree->nBytesPerCell*iCell); + pCoord = pCell->aCoord; + for(ii=0; iinDim*2; ii++){ + readCoord(&pData[ii*4], &pCoord[ii]); + } +} + + +/* Forward declaration for the function that does the work of +** the virtual table module xCreate() and xConnect() methods. +*/ +static int rtreeInit( + sqlite3 *, void *, int, const char *const*, sqlite3_vtab **, char **, int +); + +/* +** Rtree virtual table module xCreate method. +*/ +static int rtreeCreate( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 1); +} + +/* +** Rtree virtual table module xConnect method. +*/ +static int rtreeConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 0); +} + +/* +** Increment the r-tree reference count. +*/ +static void rtreeReference(Rtree *pRtree){ + pRtree->nBusy++; +} + +/* +** Decrement the r-tree reference count. When the reference count reaches +** zero the structure is deleted. +*/ +static void rtreeRelease(Rtree *pRtree){ + pRtree->nBusy--; + if( pRtree->nBusy==0 ){ + sqlite3_finalize(pRtree->pReadNode); + sqlite3_finalize(pRtree->pWriteNode); + sqlite3_finalize(pRtree->pDeleteNode); + sqlite3_finalize(pRtree->pReadRowid); + sqlite3_finalize(pRtree->pWriteRowid); + sqlite3_finalize(pRtree->pDeleteRowid); + sqlite3_finalize(pRtree->pReadParent); + sqlite3_finalize(pRtree->pWriteParent); + sqlite3_finalize(pRtree->pDeleteParent); + sqlite3_free(pRtree); + } +} + +/* +** Rtree virtual table module xDisconnect method. +*/ +static int rtreeDisconnect(sqlite3_vtab *pVtab){ + rtreeRelease((Rtree *)pVtab); + return SQLITE_OK; +} + +/* +** Rtree virtual table module xDestroy method. +*/ +static int rtreeDestroy(sqlite3_vtab *pVtab){ + Rtree *pRtree = (Rtree *)pVtab; + int rc; + char *zCreate = sqlite3_mprintf( + "DROP TABLE '%q'.'%q_node';" + "DROP TABLE '%q'.'%q_rowid';" + "DROP TABLE '%q'.'%q_parent';", + pRtree->zDb, pRtree->zName, + pRtree->zDb, pRtree->zName, + pRtree->zDb, pRtree->zName + ); + if( !zCreate ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_exec(pRtree->db, zCreate, 0, 0, 0); + sqlite3_free(zCreate); + } + if( rc==SQLITE_OK ){ + rtreeRelease(pRtree); + } + + return rc; +} + +/* +** Rtree virtual table module xOpen method. +*/ +static int rtreeOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ + int rc = SQLITE_NOMEM; + RtreeCursor *pCsr; + + pCsr = (RtreeCursor *)sqlite3_malloc(sizeof(RtreeCursor)); + if( pCsr ){ + memset(pCsr, 0, sizeof(RtreeCursor)); + pCsr->base.pVtab = pVTab; + rc = SQLITE_OK; + } + *ppCursor = (sqlite3_vtab_cursor *)pCsr; + + return rc; +} + + +/* +** Free the RtreeCursor.aConstraint[] array and its contents. +*/ +static void freeCursorConstraints(RtreeCursor *pCsr){ + if( pCsr->aConstraint ){ + int i; /* Used to iterate through constraint array */ + for(i=0; inConstraint; i++){ + sqlite3_rtree_query_info *pInfo = pCsr->aConstraint[i].pInfo; + if( pInfo ){ + if( pInfo->xDelUser ) pInfo->xDelUser(pInfo->pUser); + sqlite3_free(pInfo); + } + } + sqlite3_free(pCsr->aConstraint); + pCsr->aConstraint = 0; + } +} + +/* +** Rtree virtual table module xClose method. +*/ +static int rtreeClose(sqlite3_vtab_cursor *cur){ + Rtree *pRtree = (Rtree *)(cur->pVtab); + int ii; + RtreeCursor *pCsr = (RtreeCursor *)cur; + freeCursorConstraints(pCsr); + sqlite3_free(pCsr->aPoint); + for(ii=0; iiaNode[ii]); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** Rtree virtual table module xEof method. +** +** Return non-zero if the cursor does not currently point to a valid +** record (i.e if the scan has finished), or zero otherwise. +*/ +static int rtreeEof(sqlite3_vtab_cursor *cur){ + RtreeCursor *pCsr = (RtreeCursor *)cur; + return pCsr->atEOF; +} + +/* +** Convert raw bits from the on-disk RTree record into a coordinate value. +** The on-disk format is big-endian and needs to be converted for little- +** endian platforms. The on-disk record stores integer coordinates if +** eInt is true and it stores 32-bit floating point records if eInt is +** false. a[] is the four bytes of the on-disk record to be decoded. +** Store the results in "r". +** +** There are three versions of this macro, one each for little-endian and +** big-endian processors and a third generic implementation. The endian- +** specific implementations are much faster and are preferred if the +** processor endianness is known at compile-time. The SQLITE_BYTEORDER +** macro is part of sqliteInt.h and hence the endian-specific +** implementation will only be used if this module is compiled as part +** of the amalgamation. +*/ +#if defined(SQLITE_BYTEORDER) && SQLITE_BYTEORDER==1234 +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + memcpy(&c.u,a,4); \ + c.u = ((c.u>>24)&0xff)|((c.u>>8)&0xff00)| \ + ((c.u&0xff)<<24)|((c.u&0xff00)<<8); \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#elif defined(SQLITE_BYTEORDER) && SQLITE_BYTEORDER==4321 +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + memcpy(&c.u,a,4); \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#else +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + c.u = ((u32)a[0]<<24) + ((u32)a[1]<<16) \ + +((u32)a[2]<<8) + a[3]; \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#endif + +/* +** Check the RTree node or entry given by pCellData and p against the MATCH +** constraint pConstraint. +*/ +static int rtreeCallbackConstraint( + RtreeConstraint *pConstraint, /* The constraint to test */ + int eInt, /* True if RTree holding integer coordinates */ + u8 *pCellData, /* Raw cell content */ + RtreeSearchPoint *pSearch, /* Container of this cell */ + sqlite3_rtree_dbl *prScore, /* OUT: score for the cell */ + int *peWithin /* OUT: visibility of the cell */ +){ + int i; /* Loop counter */ + sqlite3_rtree_query_info *pInfo = pConstraint->pInfo; /* Callback info */ + int nCoord = pInfo->nCoord; /* No. of coordinates */ + int rc; /* Callback return code */ + sqlite3_rtree_dbl aCoord[RTREE_MAX_DIMENSIONS*2]; /* Decoded coordinates */ + + assert( pConstraint->op==RTREE_MATCH || pConstraint->op==RTREE_QUERY ); + assert( nCoord==2 || nCoord==4 || nCoord==6 || nCoord==8 || nCoord==10 ); + + if( pConstraint->op==RTREE_QUERY && pSearch->iLevel==1 ){ + pInfo->iRowid = readInt64(pCellData); + } + pCellData += 8; + for(i=0; iop==RTREE_MATCH ){ + rc = pConstraint->u.xGeom((sqlite3_rtree_geometry*)pInfo, + nCoord, aCoord, &i); + if( i==0 ) *peWithin = NOT_WITHIN; + *prScore = RTREE_ZERO; + }else{ + pInfo->aCoord = aCoord; + pInfo->iLevel = pSearch->iLevel - 1; + pInfo->rScore = pInfo->rParentScore = pSearch->rScore; + pInfo->eWithin = pInfo->eParentWithin = pSearch->eWithin; + rc = pConstraint->u.xQueryFunc(pInfo); + if( pInfo->eWithin<*peWithin ) *peWithin = pInfo->eWithin; + if( pInfo->rScore<*prScore || *prScorerScore; + } + } + return rc; +} + +/* +** Check the internal RTree node given by pCellData against constraint p. +** If this constraint cannot be satisfied by any child within the node, +** set *peWithin to NOT_WITHIN. +*/ +static void rtreeNonleafConstraint( + RtreeConstraint *p, /* The constraint to test */ + int eInt, /* True if RTree holds integer coordinates */ + u8 *pCellData, /* Raw cell content as appears on disk */ + int *peWithin /* Adjust downward, as appropriate */ +){ + sqlite3_rtree_dbl val; /* Coordinate value convert to a double */ + + /* p->iCoord might point to either a lower or upper bound coordinate + ** in a coordinate pair. But make pCellData point to the lower bound. + */ + pCellData += 8 + 4*(p->iCoord&0xfe); + + assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE + || p->op==RTREE_GT || p->op==RTREE_EQ ); + switch( p->op ){ + case RTREE_LE: + case RTREE_LT: + case RTREE_EQ: + RTREE_DECODE_COORD(eInt, pCellData, val); + /* val now holds the lower bound of the coordinate pair */ + if( p->u.rValue>=val ) return; + if( p->op!=RTREE_EQ ) break; /* RTREE_LE and RTREE_LT end here */ + /* Fall through for the RTREE_EQ case */ + + default: /* RTREE_GT or RTREE_GE, or fallthrough of RTREE_EQ */ + pCellData += 4; + RTREE_DECODE_COORD(eInt, pCellData, val); + /* val now holds the upper bound of the coordinate pair */ + if( p->u.rValue<=val ) return; + } + *peWithin = NOT_WITHIN; +} + +/* +** Check the leaf RTree cell given by pCellData against constraint p. +** If this constraint is not satisfied, set *peWithin to NOT_WITHIN. +** If the constraint is satisfied, leave *peWithin unchanged. +** +** The constraint is of the form: xN op $val +** +** The op is given by p->op. The xN is p->iCoord-th coordinate in +** pCellData. $val is given by p->u.rValue. +*/ +static void rtreeLeafConstraint( + RtreeConstraint *p, /* The constraint to test */ + int eInt, /* True if RTree holds integer coordinates */ + u8 *pCellData, /* Raw cell content as appears on disk */ + int *peWithin /* Adjust downward, as appropriate */ +){ + RtreeDValue xN; /* Coordinate value converted to a double */ + + assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE + || p->op==RTREE_GT || p->op==RTREE_EQ ); + pCellData += 8 + p->iCoord*4; + RTREE_DECODE_COORD(eInt, pCellData, xN); + switch( p->op ){ + case RTREE_LE: if( xN <= p->u.rValue ) return; break; + case RTREE_LT: if( xN < p->u.rValue ) return; break; + case RTREE_GE: if( xN >= p->u.rValue ) return; break; + case RTREE_GT: if( xN > p->u.rValue ) return; break; + default: if( xN == p->u.rValue ) return; break; + } + *peWithin = NOT_WITHIN; +} + +/* +** One of the cells in node pNode is guaranteed to have a 64-bit +** integer value equal to iRowid. Return the index of this cell. +*/ +static int nodeRowidIndex( + Rtree *pRtree, + RtreeNode *pNode, + i64 iRowid, + int *piIndex +){ + int ii; + int nCell = NCELL(pNode); + assert( nCell<200 ); + for(ii=0; iipParent; + if( pParent ){ + return nodeRowidIndex(pRtree, pParent, pNode->iNode, piIndex); + } + *piIndex = -1; + return SQLITE_OK; +} + +/* +** Compare two search points. Return negative, zero, or positive if the first +** is less than, equal to, or greater than the second. +** +** The rScore is the primary key. Smaller rScore values come first. +** If the rScore is a tie, then use iLevel as the tie breaker with smaller +** iLevel values coming first. In this way, if rScore is the same for all +** SearchPoints, then iLevel becomes the deciding factor and the result +** is a depth-first search, which is the desired default behavior. +*/ +static int rtreeSearchPointCompare( + const RtreeSearchPoint *pA, + const RtreeSearchPoint *pB +){ + if( pA->rScorerScore ) return -1; + if( pA->rScore>pB->rScore ) return +1; + if( pA->iLeveliLevel ) return -1; + if( pA->iLevel>pB->iLevel ) return +1; + return 0; +} + +/* +** Interchange to search points in a cursor. +*/ +static void rtreeSearchPointSwap(RtreeCursor *p, int i, int j){ + RtreeSearchPoint t = p->aPoint[i]; + assert( iaPoint[i] = p->aPoint[j]; + p->aPoint[j] = t; + i++; j++; + if( i=RTREE_CACHE_SZ ){ + nodeRelease(RTREE_OF_CURSOR(p), p->aNode[i]); + p->aNode[i] = 0; + }else{ + RtreeNode *pTemp = p->aNode[i]; + p->aNode[i] = p->aNode[j]; + p->aNode[j] = pTemp; + } + } +} + +/* +** Return the search point with the lowest current score. +*/ +static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){ + return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0; +} + +/* +** Get the RtreeNode for the search point with the lowest score. +*/ +static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){ + sqlite3_int64 id; + int ii = 1 - pCur->bPoint; + assert( ii==0 || ii==1 ); + assert( pCur->bPoint || pCur->nPoint ); + if( pCur->aNode[ii]==0 ){ + assert( pRC!=0 ); + id = ii ? pCur->aPoint[0].id : pCur->sPoint.id; + *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]); + } + return pCur->aNode[ii]; +} + +/* +** Push a new element onto the priority queue +*/ +static RtreeSearchPoint *rtreeEnqueue( + RtreeCursor *pCur, /* The cursor */ + RtreeDValue rScore, /* Score for the new search point */ + u8 iLevel /* Level for the new search point */ +){ + int i, j; + RtreeSearchPoint *pNew; + if( pCur->nPoint>=pCur->nPointAlloc ){ + int nNew = pCur->nPointAlloc*2 + 8; + pNew = sqlite3_realloc(pCur->aPoint, nNew*sizeof(pCur->aPoint[0])); + if( pNew==0 ) return 0; + pCur->aPoint = pNew; + pCur->nPointAlloc = nNew; + } + i = pCur->nPoint++; + pNew = pCur->aPoint + i; + pNew->rScore = rScore; + pNew->iLevel = iLevel; + assert( iLevel<=RTREE_MAX_DEPTH ); + while( i>0 ){ + RtreeSearchPoint *pParent; + j = (i-1)/2; + pParent = pCur->aPoint + j; + if( rtreeSearchPointCompare(pNew, pParent)>=0 ) break; + rtreeSearchPointSwap(pCur, j, i); + i = j; + pNew = pParent; + } + return pNew; +} + +/* +** Allocate a new RtreeSearchPoint and return a pointer to it. Return +** NULL if malloc fails. +*/ +static RtreeSearchPoint *rtreeSearchPointNew( + RtreeCursor *pCur, /* The cursor */ + RtreeDValue rScore, /* Score for the new search point */ + u8 iLevel /* Level for the new search point */ +){ + RtreeSearchPoint *pNew, *pFirst; + pFirst = rtreeSearchPointFirst(pCur); + pCur->anQueue[iLevel]++; + if( pFirst==0 + || pFirst->rScore>rScore + || (pFirst->rScore==rScore && pFirst->iLevel>iLevel) + ){ + if( pCur->bPoint ){ + int ii; + pNew = rtreeEnqueue(pCur, rScore, iLevel); + if( pNew==0 ) return 0; + ii = (int)(pNew - pCur->aPoint) + 1; + if( iiaNode[ii]==0 ); + pCur->aNode[ii] = pCur->aNode[0]; + }else{ + nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]); + } + pCur->aNode[0] = 0; + *pNew = pCur->sPoint; + } + pCur->sPoint.rScore = rScore; + pCur->sPoint.iLevel = iLevel; + pCur->bPoint = 1; + return &pCur->sPoint; + }else{ + return rtreeEnqueue(pCur, rScore, iLevel); + } +} + +#if 0 +/* Tracing routines for the RtreeSearchPoint queue */ +static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){ + if( idx<0 ){ printf(" s"); }else{ printf("%2d", idx); } + printf(" %d.%05lld.%02d %g %d", + p->iLevel, p->id, p->iCell, p->rScore, p->eWithin + ); + idx++; + if( idxaNode[idx]); + }else{ + printf("\n"); + } +} +static void traceQueue(RtreeCursor *pCur, const char *zPrefix){ + int ii; + printf("=== %9s ", zPrefix); + if( pCur->bPoint ){ + tracePoint(&pCur->sPoint, -1, pCur); + } + for(ii=0; iinPoint; ii++){ + if( ii>0 || pCur->bPoint ) printf(" "); + tracePoint(&pCur->aPoint[ii], ii, pCur); + } +} +# define RTREE_QUEUE_TRACE(A,B) traceQueue(A,B) +#else +# define RTREE_QUEUE_TRACE(A,B) /* no-op */ +#endif + +/* Remove the search point with the lowest current score. +*/ +static void rtreeSearchPointPop(RtreeCursor *p){ + int i, j, k, n; + i = 1 - p->bPoint; + assert( i==0 || i==1 ); + if( p->aNode[i] ){ + nodeRelease(RTREE_OF_CURSOR(p), p->aNode[i]); + p->aNode[i] = 0; + } + if( p->bPoint ){ + p->anQueue[p->sPoint.iLevel]--; + p->bPoint = 0; + }else if( p->nPoint ){ + p->anQueue[p->aPoint[0].iLevel]--; + n = --p->nPoint; + p->aPoint[0] = p->aPoint[n]; + if( naNode[1] = p->aNode[n+1]; + p->aNode[n+1] = 0; + } + i = 0; + while( (j = i*2+1)aPoint[k], &p->aPoint[j])<0 ){ + if( rtreeSearchPointCompare(&p->aPoint[k], &p->aPoint[i])<0 ){ + rtreeSearchPointSwap(p, i, k); + i = k; + }else{ + break; + } + }else{ + if( rtreeSearchPointCompare(&p->aPoint[j], &p->aPoint[i])<0 ){ + rtreeSearchPointSwap(p, i, j); + i = j; + }else{ + break; + } + } + } + } +} + + +/* +** Continue the search on cursor pCur until the front of the queue +** contains an entry suitable for returning as a result-set row, +** or until the RtreeSearchPoint queue is empty, indicating that the +** query has completed. +*/ +static int rtreeStepToLeaf(RtreeCursor *pCur){ + RtreeSearchPoint *p; + Rtree *pRtree = RTREE_OF_CURSOR(pCur); + RtreeNode *pNode; + int eWithin; + int rc = SQLITE_OK; + int nCell; + int nConstraint = pCur->nConstraint; + int ii; + int eInt; + RtreeSearchPoint x; + + eInt = pRtree->eCoordType==RTREE_COORD_INT32; + while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){ + pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc); + if( rc ) return rc; + nCell = NCELL(pNode); + assert( nCell<200 ); + while( p->iCellzData + (4+pRtree->nBytesPerCell*p->iCell); + eWithin = FULLY_WITHIN; + for(ii=0; iiaConstraint + ii; + if( pConstraint->op>=RTREE_MATCH ){ + rc = rtreeCallbackConstraint(pConstraint, eInt, pCellData, p, + &rScore, &eWithin); + if( rc ) return rc; + }else if( p->iLevel==1 ){ + rtreeLeafConstraint(pConstraint, eInt, pCellData, &eWithin); + }else{ + rtreeNonleafConstraint(pConstraint, eInt, pCellData, &eWithin); + } + if( eWithin==NOT_WITHIN ) break; + } + p->iCell++; + if( eWithin==NOT_WITHIN ) continue; + x.iLevel = p->iLevel - 1; + if( x.iLevel ){ + x.id = readInt64(pCellData); + x.iCell = 0; + }else{ + x.id = p->id; + x.iCell = p->iCell - 1; + } + if( p->iCell>=nCell ){ + RTREE_QUEUE_TRACE(pCur, "POP-S:"); + rtreeSearchPointPop(pCur); + } + if( rScoreeWithin = eWithin; + p->id = x.id; + p->iCell = x.iCell; + RTREE_QUEUE_TRACE(pCur, "PUSH-S:"); + break; + } + if( p->iCell>=nCell ){ + RTREE_QUEUE_TRACE(pCur, "POP-Se:"); + rtreeSearchPointPop(pCur); + } + } + pCur->atEOF = p==0; + return SQLITE_OK; +} + +/* +** Rtree virtual table module xNext method. +*/ +static int rtreeNext(sqlite3_vtab_cursor *pVtabCursor){ + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + int rc = SQLITE_OK; + + /* Move to the next entry that matches the configured constraints. */ + RTREE_QUEUE_TRACE(pCsr, "POP-Nx:"); + rtreeSearchPointPop(pCsr); + rc = rtreeStepToLeaf(pCsr); + return rc; +} + +/* +** Rtree virtual table module xRowid method. +*/ +static int rtreeRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *pRowid){ + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr); + int rc = SQLITE_OK; + RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); + if( rc==SQLITE_OK && p ){ + *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell); + } + return rc; +} + +/* +** Rtree virtual table module xColumn method. +*/ +static int rtreeColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ + Rtree *pRtree = (Rtree *)cur->pVtab; + RtreeCursor *pCsr = (RtreeCursor *)cur; + RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr); + RtreeCoord c; + int rc = SQLITE_OK; + RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); + + if( rc ) return rc; + if( p==0 ) return SQLITE_OK; + if( i==0 ){ + sqlite3_result_int64(ctx, nodeGetRowid(pRtree, pNode, p->iCell)); + }else{ + if( rc ) return rc; + nodeGetCoord(pRtree, pNode, p->iCell, i-1, &c); +#ifndef SQLITE_RTREE_INT_ONLY + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + sqlite3_result_double(ctx, c.f); + }else +#endif + { + assert( pRtree->eCoordType==RTREE_COORD_INT32 ); + sqlite3_result_int(ctx, c.i); + } + } + return SQLITE_OK; +} + +/* +** Use nodeAcquire() to obtain the leaf node containing the record with +** rowid iRowid. If successful, set *ppLeaf to point to the node and +** return SQLITE_OK. If there is no such record in the table, set +** *ppLeaf to 0 and return SQLITE_OK. If an error occurs, set *ppLeaf +** to zero and return an SQLite error code. +*/ +static int findLeafNode( + Rtree *pRtree, /* RTree to search */ + i64 iRowid, /* The rowid searching for */ + RtreeNode **ppLeaf, /* Write the node here */ + sqlite3_int64 *piNode /* Write the node-id here */ +){ + int rc; + *ppLeaf = 0; + sqlite3_bind_int64(pRtree->pReadRowid, 1, iRowid); + if( sqlite3_step(pRtree->pReadRowid)==SQLITE_ROW ){ + i64 iNode = sqlite3_column_int64(pRtree->pReadRowid, 0); + if( piNode ) *piNode = iNode; + rc = nodeAcquire(pRtree, iNode, 0, ppLeaf); + sqlite3_reset(pRtree->pReadRowid); + }else{ + rc = sqlite3_reset(pRtree->pReadRowid); + } + return rc; +} + +/* +** This function is called to configure the RtreeConstraint object passed +** as the second argument for a MATCH constraint. The value passed as the +** first argument to this function is the right-hand operand to the MATCH +** operator. +*/ +static int deserializeGeometry(sqlite3_value *pValue, RtreeConstraint *pCons){ + RtreeMatchArg *pBlob; /* BLOB returned by geometry function */ + sqlite3_rtree_query_info *pInfo; /* Callback information */ + int nBlob; /* Size of the geometry function blob */ + int nExpected; /* Expected size of the BLOB */ + + /* Check that value is actually a blob. */ + if( sqlite3_value_type(pValue)!=SQLITE_BLOB ) return SQLITE_ERROR; + + /* Check that the blob is roughly the right size. */ + nBlob = sqlite3_value_bytes(pValue); + if( nBlob<(int)sizeof(RtreeMatchArg) ){ + return SQLITE_ERROR; + } + + pInfo = (sqlite3_rtree_query_info*)sqlite3_malloc( sizeof(*pInfo)+nBlob ); + if( !pInfo ) return SQLITE_NOMEM; + memset(pInfo, 0, sizeof(*pInfo)); + pBlob = (RtreeMatchArg*)&pInfo[1]; + + memcpy(pBlob, sqlite3_value_blob(pValue), nBlob); + nExpected = (int)(sizeof(RtreeMatchArg) + + pBlob->nParam*sizeof(sqlite3_value*) + + (pBlob->nParam-1)*sizeof(RtreeDValue)); + if( pBlob->magic!=RTREE_GEOMETRY_MAGIC || nBlob!=nExpected ){ + sqlite3_free(pInfo); + return SQLITE_ERROR; + } + pInfo->pContext = pBlob->cb.pContext; + pInfo->nParam = pBlob->nParam; + pInfo->aParam = pBlob->aParam; + pInfo->apSqlParam = pBlob->apSqlParam; + + if( pBlob->cb.xGeom ){ + pCons->u.xGeom = pBlob->cb.xGeom; + }else{ + pCons->op = RTREE_QUERY; + pCons->u.xQueryFunc = pBlob->cb.xQueryFunc; + } + pCons->pInfo = pInfo; + return SQLITE_OK; +} + +/* +** Rtree virtual table module xFilter method. +*/ +static int rtreeFilter( + sqlite3_vtab_cursor *pVtabCursor, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + Rtree *pRtree = (Rtree *)pVtabCursor->pVtab; + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + RtreeNode *pRoot = 0; + int ii; + int rc = SQLITE_OK; + int iCell = 0; + + rtreeReference(pRtree); + + /* Reset the cursor to the same state as rtreeOpen() leaves it in. */ + freeCursorConstraints(pCsr); + sqlite3_free(pCsr->aPoint); + memset(pCsr, 0, sizeof(RtreeCursor)); + pCsr->base.pVtab = (sqlite3_vtab*)pRtree; + + pCsr->iStrategy = idxNum; + if( idxNum==1 ){ + /* Special case - lookup by rowid. */ + RtreeNode *pLeaf; /* Leaf on which the required cell resides */ + RtreeSearchPoint *p; /* Search point for the the leaf */ + i64 iRowid = sqlite3_value_int64(argv[0]); + i64 iNode = 0; + rc = findLeafNode(pRtree, iRowid, &pLeaf, &iNode); + if( rc==SQLITE_OK && pLeaf!=0 ){ + p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0); + assert( p!=0 ); /* Always returns pCsr->sPoint */ + pCsr->aNode[0] = pLeaf; + p->id = iNode; + p->eWithin = PARTLY_WITHIN; + rc = nodeRowidIndex(pRtree, pLeaf, iRowid, &iCell); + p->iCell = iCell; + RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:"); + }else{ + pCsr->atEOF = 1; + } + }else{ + /* Normal case - r-tree scan. Set up the RtreeCursor.aConstraint array + ** with the configured constraints. + */ + rc = nodeAcquire(pRtree, 1, 0, &pRoot); + if( rc==SQLITE_OK && argc>0 ){ + pCsr->aConstraint = sqlite3_malloc(sizeof(RtreeConstraint)*argc); + pCsr->nConstraint = argc; + if( !pCsr->aConstraint ){ + rc = SQLITE_NOMEM; + }else{ + memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*argc); + memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1)); + assert( (idxStr==0 && argc==0) + || (idxStr && (int)strlen(idxStr)==argc*2) ); + for(ii=0; iiaConstraint[ii]; + p->op = idxStr[ii*2]; + p->iCoord = idxStr[ii*2+1]-'0'; + if( p->op>=RTREE_MATCH ){ + /* A MATCH operator. The right-hand-side must be a blob that + ** can be cast into an RtreeMatchArg object. One created using + ** an sqlite3_rtree_geometry_callback() SQL user function. + */ + rc = deserializeGeometry(argv[ii], p); + if( rc!=SQLITE_OK ){ + break; + } + p->pInfo->nCoord = pRtree->nDim*2; + p->pInfo->anQueue = pCsr->anQueue; + p->pInfo->mxLevel = pRtree->iDepth + 1; + }else{ +#ifdef SQLITE_RTREE_INT_ONLY + p->u.rValue = sqlite3_value_int64(argv[ii]); +#else + p->u.rValue = sqlite3_value_double(argv[ii]); +#endif + } + } + } + } + if( rc==SQLITE_OK ){ + RtreeSearchPoint *pNew; + pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, pRtree->iDepth+1); + if( pNew==0 ) return SQLITE_NOMEM; + pNew->id = 1; + pNew->iCell = 0; + pNew->eWithin = PARTLY_WITHIN; + assert( pCsr->bPoint==1 ); + pCsr->aNode[0] = pRoot; + pRoot = 0; + RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:"); + rc = rtreeStepToLeaf(pCsr); + } + } + + nodeRelease(pRtree, pRoot); + rtreeRelease(pRtree); + return rc; +} + +/* +** Set the pIdxInfo->estimatedRows variable to nRow. Unless this +** extension is currently being used by a version of SQLite too old to +** support estimatedRows. In that case this function is a no-op. +*/ +static void setEstimatedRows(sqlite3_index_info *pIdxInfo, i64 nRow){ +#if SQLITE_VERSION_NUMBER>=3008002 + if( sqlite3_libversion_number()>=3008002 ){ + pIdxInfo->estimatedRows = nRow; + } +#endif +} + +/* +** Rtree virtual table module xBestIndex method. There are three +** table scan strategies to choose from (in order from most to +** least desirable): +** +** idxNum idxStr Strategy +** ------------------------------------------------ +** 1 Unused Direct lookup by rowid. +** 2 See below R-tree query or full-table scan. +** ------------------------------------------------ +** +** If strategy 1 is used, then idxStr is not meaningful. If strategy +** 2 is used, idxStr is formatted to contain 2 bytes for each +** constraint used. The first two bytes of idxStr correspond to +** the constraint in sqlite3_index_info.aConstraintUsage[] with +** (argvIndex==1) etc. +** +** The first of each pair of bytes in idxStr identifies the constraint +** operator as follows: +** +** Operator Byte Value +** ---------------------- +** = 0x41 ('A') +** <= 0x42 ('B') +** < 0x43 ('C') +** >= 0x44 ('D') +** > 0x45 ('E') +** MATCH 0x46 ('F') +** ---------------------- +** +** The second of each pair of bytes identifies the coordinate column +** to which the constraint applies. The leftmost coordinate column +** is 'a', the second from the left 'b' etc. +*/ +static int rtreeBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ + Rtree *pRtree = (Rtree*)tab; + int rc = SQLITE_OK; + int ii; + int bMatch = 0; /* True if there exists a MATCH constraint */ + i64 nRow; /* Estimated rows returned by this scan */ + + int iIdx = 0; + char zIdxStr[RTREE_MAX_DIMENSIONS*8+1]; + memset(zIdxStr, 0, sizeof(zIdxStr)); + + /* Check if there exists a MATCH constraint - even an unusable one. If there + ** is, do not consider the lookup-by-rowid plan as using such a plan would + ** require the VDBE to evaluate the MATCH constraint, which is not currently + ** possible. */ + for(ii=0; iinConstraint; ii++){ + if( pIdxInfo->aConstraint[ii].op==SQLITE_INDEX_CONSTRAINT_MATCH ){ + bMatch = 1; + } + } + + assert( pIdxInfo->idxStr==0 ); + for(ii=0; iinConstraint && iIdx<(int)(sizeof(zIdxStr)-1); ii++){ + struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii]; + + if( bMatch==0 && p->usable + && p->iColumn==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ + ){ + /* We have an equality constraint on the rowid. Use strategy 1. */ + int jj; + for(jj=0; jjaConstraintUsage[jj].argvIndex = 0; + pIdxInfo->aConstraintUsage[jj].omit = 0; + } + pIdxInfo->idxNum = 1; + pIdxInfo->aConstraintUsage[ii].argvIndex = 1; + pIdxInfo->aConstraintUsage[jj].omit = 1; + + /* This strategy involves a two rowid lookups on an B-Tree structures + ** and then a linear search of an R-Tree node. This should be + ** considered almost as quick as a direct rowid lookup (for which + ** sqlite uses an internal cost of 0.0). It is expected to return + ** a single row. + */ + pIdxInfo->estimatedCost = 30.0; + setEstimatedRows(pIdxInfo, 1); + return SQLITE_OK; + } + + if( p->usable && (p->iColumn>0 || p->op==SQLITE_INDEX_CONSTRAINT_MATCH) ){ + u8 op; + switch( p->op ){ + case SQLITE_INDEX_CONSTRAINT_EQ: op = RTREE_EQ; break; + case SQLITE_INDEX_CONSTRAINT_GT: op = RTREE_GT; break; + case SQLITE_INDEX_CONSTRAINT_LE: op = RTREE_LE; break; + case SQLITE_INDEX_CONSTRAINT_LT: op = RTREE_LT; break; + case SQLITE_INDEX_CONSTRAINT_GE: op = RTREE_GE; break; + default: + assert( p->op==SQLITE_INDEX_CONSTRAINT_MATCH ); + op = RTREE_MATCH; + break; + } + zIdxStr[iIdx++] = op; + zIdxStr[iIdx++] = p->iColumn - 1 + '0'; + pIdxInfo->aConstraintUsage[ii].argvIndex = (iIdx/2); + pIdxInfo->aConstraintUsage[ii].omit = 1; + } + } + + pIdxInfo->idxNum = 2; + pIdxInfo->needToFreeIdxStr = 1; + if( iIdx>0 && 0==(pIdxInfo->idxStr = sqlite3_mprintf("%s", zIdxStr)) ){ + return SQLITE_NOMEM; + } + + nRow = pRtree->nRowEst / (iIdx + 1); + pIdxInfo->estimatedCost = (double)6.0 * (double)nRow; + setEstimatedRows(pIdxInfo, nRow); + + return rc; +} + +/* +** Return the N-dimensional volumn of the cell stored in *p. +*/ +static RtreeDValue cellArea(Rtree *pRtree, RtreeCell *p){ + RtreeDValue area = (RtreeDValue)1; + int ii; + for(ii=0; ii<(pRtree->nDim*2); ii+=2){ + area = (area * (DCOORD(p->aCoord[ii+1]) - DCOORD(p->aCoord[ii]))); + } + return area; +} + +/* +** Return the margin length of cell p. The margin length is the sum +** of the objects size in each dimension. +*/ +static RtreeDValue cellMargin(Rtree *pRtree, RtreeCell *p){ + RtreeDValue margin = (RtreeDValue)0; + int ii; + for(ii=0; ii<(pRtree->nDim*2); ii+=2){ + margin += (DCOORD(p->aCoord[ii+1]) - DCOORD(p->aCoord[ii])); + } + return margin; +} + +/* +** Store the union of cells p1 and p2 in p1. +*/ +static void cellUnion(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){ + int ii; + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + for(ii=0; ii<(pRtree->nDim*2); ii+=2){ + p1->aCoord[ii].f = MIN(p1->aCoord[ii].f, p2->aCoord[ii].f); + p1->aCoord[ii+1].f = MAX(p1->aCoord[ii+1].f, p2->aCoord[ii+1].f); + } + }else{ + for(ii=0; ii<(pRtree->nDim*2); ii+=2){ + p1->aCoord[ii].i = MIN(p1->aCoord[ii].i, p2->aCoord[ii].i); + p1->aCoord[ii+1].i = MAX(p1->aCoord[ii+1].i, p2->aCoord[ii+1].i); + } + } +} + +/* +** Return true if the area covered by p2 is a subset of the area covered +** by p1. False otherwise. +*/ +static int cellContains(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){ + int ii; + int isInt = (pRtree->eCoordType==RTREE_COORD_INT32); + for(ii=0; ii<(pRtree->nDim*2); ii+=2){ + RtreeCoord *a1 = &p1->aCoord[ii]; + RtreeCoord *a2 = &p2->aCoord[ii]; + if( (!isInt && (a2[0].fa1[1].f)) + || ( isInt && (a2[0].ia1[1].i)) + ){ + return 0; + } + } + return 1; +} + +/* +** Return the amount cell p would grow by if it were unioned with pCell. +*/ +static RtreeDValue cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){ + RtreeDValue area; + RtreeCell cell; + memcpy(&cell, p, sizeof(RtreeCell)); + area = cellArea(pRtree, &cell); + cellUnion(pRtree, &cell, pCell); + return (cellArea(pRtree, &cell)-area); +} + +static RtreeDValue cellOverlap( + Rtree *pRtree, + RtreeCell *p, + RtreeCell *aCell, + int nCell +){ + int ii; + RtreeDValue overlap = RTREE_ZERO; + for(ii=0; iinDim*2); jj+=2){ + RtreeDValue x1, x2; + x1 = MAX(DCOORD(p->aCoord[jj]), DCOORD(aCell[ii].aCoord[jj])); + x2 = MIN(DCOORD(p->aCoord[jj+1]), DCOORD(aCell[ii].aCoord[jj+1])); + if( x2iDepth-iHeight); ii++){ + int iCell; + sqlite3_int64 iBest = 0; + + RtreeDValue fMinGrowth = RTREE_ZERO; + RtreeDValue fMinArea = RTREE_ZERO; + + int nCell = NCELL(pNode); + RtreeCell cell; + RtreeNode *pChild; + + RtreeCell *aCell = 0; + + /* Select the child node which will be enlarged the least if pCell + ** is inserted into it. Resolve ties by choosing the entry with + ** the smallest area. + */ + for(iCell=0; iCellpParent ){ + RtreeNode *pParent = p->pParent; + RtreeCell cell; + int iCell; + + if( nodeParentIndex(pRtree, p, &iCell) ){ + return SQLITE_CORRUPT_VTAB; + } + + nodeGetCell(pRtree, pParent, iCell, &cell); + if( !cellContains(pRtree, &cell, pCell) ){ + cellUnion(pRtree, &cell, pCell); + nodeOverwriteCell(pRtree, pParent, &cell, iCell); + } + + p = pParent; + } + return SQLITE_OK; +} + +/* +** Write mapping (iRowid->iNode) to the _rowid table. +*/ +static int rowidWrite(Rtree *pRtree, sqlite3_int64 iRowid, sqlite3_int64 iNode){ + sqlite3_bind_int64(pRtree->pWriteRowid, 1, iRowid); + sqlite3_bind_int64(pRtree->pWriteRowid, 2, iNode); + sqlite3_step(pRtree->pWriteRowid); + return sqlite3_reset(pRtree->pWriteRowid); +} + +/* +** Write mapping (iNode->iPar) to the _parent table. +*/ +static int parentWrite(Rtree *pRtree, sqlite3_int64 iNode, sqlite3_int64 iPar){ + sqlite3_bind_int64(pRtree->pWriteParent, 1, iNode); + sqlite3_bind_int64(pRtree->pWriteParent, 2, iPar); + sqlite3_step(pRtree->pWriteParent); + return sqlite3_reset(pRtree->pWriteParent); +} + +static int rtreeInsertCell(Rtree *, RtreeNode *, RtreeCell *, int); + + +/* +** Arguments aIdx, aDistance and aSpare all point to arrays of size +** nIdx. The aIdx array contains the set of integers from 0 to +** (nIdx-1) in no particular order. This function sorts the values +** in aIdx according to the indexed values in aDistance. For +** example, assuming the inputs: +** +** aIdx = { 0, 1, 2, 3 } +** aDistance = { 5.0, 2.0, 7.0, 6.0 } +** +** this function sets the aIdx array to contain: +** +** aIdx = { 0, 1, 2, 3 } +** +** The aSpare array is used as temporary working space by the +** sorting algorithm. +*/ +static void SortByDistance( + int *aIdx, + int nIdx, + RtreeDValue *aDistance, + int *aSpare +){ + if( nIdx>1 ){ + int iLeft = 0; + int iRight = 0; + + int nLeft = nIdx/2; + int nRight = nIdx-nLeft; + int *aLeft = aIdx; + int *aRight = &aIdx[nLeft]; + + SortByDistance(aLeft, nLeft, aDistance, aSpare); + SortByDistance(aRight, nRight, aDistance, aSpare); + + memcpy(aSpare, aLeft, sizeof(int)*nLeft); + aLeft = aSpare; + + while( iLeft1 ){ + + int iLeft = 0; + int iRight = 0; + + int nLeft = nIdx/2; + int nRight = nIdx-nLeft; + int *aLeft = aIdx; + int *aRight = &aIdx[nLeft]; + + SortByDimension(pRtree, aLeft, nLeft, iDim, aCell, aSpare); + SortByDimension(pRtree, aRight, nRight, iDim, aCell, aSpare); + + memcpy(aSpare, aLeft, sizeof(int)*nLeft); + aLeft = aSpare; + while( iLeftnDim+1)*(sizeof(int*)+nCell*sizeof(int)); + + aaSorted = (int **)sqlite3_malloc(nByte); + if( !aaSorted ){ + return SQLITE_NOMEM; + } + + aSpare = &((int *)&aaSorted[pRtree->nDim])[pRtree->nDim*nCell]; + memset(aaSorted, 0, nByte); + for(ii=0; iinDim; ii++){ + int jj; + aaSorted[ii] = &((int *)&aaSorted[pRtree->nDim])[ii*nCell]; + for(jj=0; jjnDim; ii++){ + RtreeDValue margin = RTREE_ZERO; + RtreeDValue fBestOverlap = RTREE_ZERO; + RtreeDValue fBestArea = RTREE_ZERO; + int iBestLeft = 0; + int nLeft; + + for( + nLeft=RTREE_MINCELLS(pRtree); + nLeft<=(nCell-RTREE_MINCELLS(pRtree)); + nLeft++ + ){ + RtreeCell left; + RtreeCell right; + int kk; + RtreeDValue overlap; + RtreeDValue area; + + memcpy(&left, &aCell[aaSorted[ii][0]], sizeof(RtreeCell)); + memcpy(&right, &aCell[aaSorted[ii][nCell-1]], sizeof(RtreeCell)); + for(kk=1; kk<(nCell-1); kk++){ + if( kk0 ){ + RtreeNode *pChild = nodeHashLookup(pRtree, iRowid); + if( pChild ){ + nodeRelease(pRtree, pChild->pParent); + nodeReference(pNode); + pChild->pParent = pNode; + } + } + return xSetMapping(pRtree, iRowid, pNode->iNode); +} + +static int SplitNode( + Rtree *pRtree, + RtreeNode *pNode, + RtreeCell *pCell, + int iHeight +){ + int i; + int newCellIsRight = 0; + + int rc = SQLITE_OK; + int nCell = NCELL(pNode); + RtreeCell *aCell; + int *aiUsed; + + RtreeNode *pLeft = 0; + RtreeNode *pRight = 0; + + RtreeCell leftbbox; + RtreeCell rightbbox; + + /* Allocate an array and populate it with a copy of pCell and + ** all cells from node pLeft. Then zero the original node. + */ + aCell = sqlite3_malloc((sizeof(RtreeCell)+sizeof(int))*(nCell+1)); + if( !aCell ){ + rc = SQLITE_NOMEM; + goto splitnode_out; + } + aiUsed = (int *)&aCell[nCell+1]; + memset(aiUsed, 0, sizeof(int)*(nCell+1)); + for(i=0; iiNode==1 ){ + pRight = nodeNew(pRtree, pNode); + pLeft = nodeNew(pRtree, pNode); + pRtree->iDepth++; + pNode->isDirty = 1; + writeInt16(pNode->zData, pRtree->iDepth); + }else{ + pLeft = pNode; + pRight = nodeNew(pRtree, pLeft->pParent); + nodeReference(pLeft); + } + + if( !pLeft || !pRight ){ + rc = SQLITE_NOMEM; + goto splitnode_out; + } + + memset(pLeft->zData, 0, pRtree->iNodeSize); + memset(pRight->zData, 0, pRtree->iNodeSize); + + rc = splitNodeStartree(pRtree, aCell, nCell, pLeft, pRight, + &leftbbox, &rightbbox); + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + + /* Ensure both child nodes have node numbers assigned to them by calling + ** nodeWrite(). Node pRight always needs a node number, as it was created + ** by nodeNew() above. But node pLeft sometimes already has a node number. + ** In this case avoid the all to nodeWrite(). + */ + if( SQLITE_OK!=(rc = nodeWrite(pRtree, pRight)) + || (0==pLeft->iNode && SQLITE_OK!=(rc = nodeWrite(pRtree, pLeft))) + ){ + goto splitnode_out; + } + + rightbbox.iRowid = pRight->iNode; + leftbbox.iRowid = pLeft->iNode; + + if( pNode->iNode==1 ){ + rc = rtreeInsertCell(pRtree, pLeft->pParent, &leftbbox, iHeight+1); + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + }else{ + RtreeNode *pParent = pLeft->pParent; + int iCell; + rc = nodeParentIndex(pRtree, pLeft, &iCell); + if( rc==SQLITE_OK ){ + nodeOverwriteCell(pRtree, pParent, &leftbbox, iCell); + rc = AdjustTree(pRtree, pParent, &leftbbox); + } + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + } + if( (rc = rtreeInsertCell(pRtree, pRight->pParent, &rightbbox, iHeight+1)) ){ + goto splitnode_out; + } + + for(i=0; iiRowid ){ + newCellIsRight = 1; + } + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + } + if( pNode->iNode==1 ){ + for(i=0; iiRowid, pLeft, iHeight); + } + + if( rc==SQLITE_OK ){ + rc = nodeRelease(pRtree, pRight); + pRight = 0; + } + if( rc==SQLITE_OK ){ + rc = nodeRelease(pRtree, pLeft); + pLeft = 0; + } + +splitnode_out: + nodeRelease(pRtree, pRight); + nodeRelease(pRtree, pLeft); + sqlite3_free(aCell); + return rc; +} + +/* +** If node pLeaf is not the root of the r-tree and its pParent pointer is +** still NULL, load all ancestor nodes of pLeaf into memory and populate +** the pLeaf->pParent chain all the way up to the root node. +** +** This operation is required when a row is deleted (or updated - an update +** is implemented as a delete followed by an insert). SQLite provides the +** rowid of the row to delete, which can be used to find the leaf on which +** the entry resides (argument pLeaf). Once the leaf is located, this +** function is called to determine its ancestry. +*/ +static int fixLeafParent(Rtree *pRtree, RtreeNode *pLeaf){ + int rc = SQLITE_OK; + RtreeNode *pChild = pLeaf; + while( rc==SQLITE_OK && pChild->iNode!=1 && pChild->pParent==0 ){ + int rc2 = SQLITE_OK; /* sqlite3_reset() return code */ + sqlite3_bind_int64(pRtree->pReadParent, 1, pChild->iNode); + rc = sqlite3_step(pRtree->pReadParent); + if( rc==SQLITE_ROW ){ + RtreeNode *pTest; /* Used to test for reference loops */ + i64 iNode; /* Node number of parent node */ + + /* Before setting pChild->pParent, test that we are not creating a + ** loop of references (as we would if, say, pChild==pParent). We don't + ** want to do this as it leads to a memory leak when trying to delete + ** the referenced counted node structures. + */ + iNode = sqlite3_column_int64(pRtree->pReadParent, 0); + for(pTest=pLeaf; pTest && pTest->iNode!=iNode; pTest=pTest->pParent); + if( !pTest ){ + rc2 = nodeAcquire(pRtree, iNode, 0, &pChild->pParent); + } + } + rc = sqlite3_reset(pRtree->pReadParent); + if( rc==SQLITE_OK ) rc = rc2; + if( rc==SQLITE_OK && !pChild->pParent ) rc = SQLITE_CORRUPT_VTAB; + pChild = pChild->pParent; + } + return rc; +} + +static int deleteCell(Rtree *, RtreeNode *, int, int); + +static int removeNode(Rtree *pRtree, RtreeNode *pNode, int iHeight){ + int rc; + int rc2; + RtreeNode *pParent = 0; + int iCell; + + assert( pNode->nRef==1 ); + + /* Remove the entry in the parent cell. */ + rc = nodeParentIndex(pRtree, pNode, &iCell); + if( rc==SQLITE_OK ){ + pParent = pNode->pParent; + pNode->pParent = 0; + rc = deleteCell(pRtree, pParent, iCell, iHeight+1); + } + rc2 = nodeRelease(pRtree, pParent); + if( rc==SQLITE_OK ){ + rc = rc2; + } + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Remove the xxx_node entry. */ + sqlite3_bind_int64(pRtree->pDeleteNode, 1, pNode->iNode); + sqlite3_step(pRtree->pDeleteNode); + if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteNode)) ){ + return rc; + } + + /* Remove the xxx_parent entry. */ + sqlite3_bind_int64(pRtree->pDeleteParent, 1, pNode->iNode); + sqlite3_step(pRtree->pDeleteParent); + if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteParent)) ){ + return rc; + } + + /* Remove the node from the in-memory hash table and link it into + ** the Rtree.pDeleted list. Its contents will be re-inserted later on. + */ + nodeHashDelete(pRtree, pNode); + pNode->iNode = iHeight; + pNode->pNext = pRtree->pDeleted; + pNode->nRef++; + pRtree->pDeleted = pNode; + + return SQLITE_OK; +} + +static int fixBoundingBox(Rtree *pRtree, RtreeNode *pNode){ + RtreeNode *pParent = pNode->pParent; + int rc = SQLITE_OK; + if( pParent ){ + int ii; + int nCell = NCELL(pNode); + RtreeCell box; /* Bounding box for pNode */ + nodeGetCell(pRtree, pNode, 0, &box); + for(ii=1; iiiNode; + rc = nodeParentIndex(pRtree, pNode, &ii); + if( rc==SQLITE_OK ){ + nodeOverwriteCell(pRtree, pParent, &box, ii); + rc = fixBoundingBox(pRtree, pParent); + } + } + return rc; +} + +/* +** Delete the cell at index iCell of node pNode. After removing the +** cell, adjust the r-tree data structure if required. +*/ +static int deleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell, int iHeight){ + RtreeNode *pParent; + int rc; + + if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){ + return rc; + } + + /* Remove the cell from the node. This call just moves bytes around + ** the in-memory node image, so it cannot fail. + */ + nodeDeleteCell(pRtree, pNode, iCell); + + /* If the node is not the tree root and now has less than the minimum + ** number of cells, remove it from the tree. Otherwise, update the + ** cell in the parent node so that it tightly contains the updated + ** node. + */ + pParent = pNode->pParent; + assert( pParent || pNode->iNode==1 ); + if( pParent ){ + if( NCELL(pNode)nDim; iDim++){ + aCenterCoord[iDim] += DCOORD(aCell[ii].aCoord[iDim*2]); + aCenterCoord[iDim] += DCOORD(aCell[ii].aCoord[iDim*2+1]); + } + } + for(iDim=0; iDimnDim; iDim++){ + aCenterCoord[iDim] = (aCenterCoord[iDim]/(nCell*(RtreeDValue)2)); + } + + for(ii=0; iinDim; iDim++){ + RtreeDValue coord = (DCOORD(aCell[ii].aCoord[iDim*2+1]) - + DCOORD(aCell[ii].aCoord[iDim*2])); + aDistance[ii] += (coord-aCenterCoord[iDim])*(coord-aCenterCoord[iDim]); + } + } + + SortByDistance(aOrder, nCell, aDistance, aSpare); + nodeZero(pRtree, pNode); + + for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){ + RtreeCell *p = &aCell[aOrder[ii]]; + nodeInsertCell(pRtree, pNode, p); + if( p->iRowid==pCell->iRowid ){ + if( iHeight==0 ){ + rc = rowidWrite(pRtree, p->iRowid, pNode->iNode); + }else{ + rc = parentWrite(pRtree, p->iRowid, pNode->iNode); + } + } + } + if( rc==SQLITE_OK ){ + rc = fixBoundingBox(pRtree, pNode); + } + for(; rc==SQLITE_OK && iiiNode currently contains + ** the height of the sub-tree headed by the cell. + */ + RtreeNode *pInsert; + RtreeCell *p = &aCell[aOrder[ii]]; + rc = ChooseLeaf(pRtree, p, iHeight, &pInsert); + if( rc==SQLITE_OK ){ + int rc2; + rc = rtreeInsertCell(pRtree, pInsert, p, iHeight); + rc2 = nodeRelease(pRtree, pInsert); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + + sqlite3_free(aCell); + return rc; +} + +/* +** Insert cell pCell into node pNode. Node pNode is the head of a +** subtree iHeight high (leaf nodes have iHeight==0). +*/ +static int rtreeInsertCell( + Rtree *pRtree, + RtreeNode *pNode, + RtreeCell *pCell, + int iHeight +){ + int rc = SQLITE_OK; + if( iHeight>0 ){ + RtreeNode *pChild = nodeHashLookup(pRtree, pCell->iRowid); + if( pChild ){ + nodeRelease(pRtree, pChild->pParent); + nodeReference(pNode); + pChild->pParent = pNode; + } + } + if( nodeInsertCell(pRtree, pNode, pCell) ){ + if( iHeight<=pRtree->iReinsertHeight || pNode->iNode==1){ + rc = SplitNode(pRtree, pNode, pCell, iHeight); + }else{ + pRtree->iReinsertHeight = iHeight; + rc = Reinsert(pRtree, pNode, pCell, iHeight); + } + }else{ + rc = AdjustTree(pRtree, pNode, pCell); + if( rc==SQLITE_OK ){ + if( iHeight==0 ){ + rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode); + }else{ + rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode); + } + } + } + return rc; +} + +static int reinsertNodeContent(Rtree *pRtree, RtreeNode *pNode){ + int ii; + int rc = SQLITE_OK; + int nCell = NCELL(pNode); + + for(ii=0; rc==SQLITE_OK && iiiNode currently contains + ** the height of the sub-tree headed by the cell. + */ + rc = ChooseLeaf(pRtree, &cell, (int)pNode->iNode, &pInsert); + if( rc==SQLITE_OK ){ + int rc2; + rc = rtreeInsertCell(pRtree, pInsert, &cell, (int)pNode->iNode); + rc2 = nodeRelease(pRtree, pInsert); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + return rc; +} + +/* +** Select a currently unused rowid for a new r-tree record. +*/ +static int newRowid(Rtree *pRtree, i64 *piRowid){ + int rc; + sqlite3_bind_null(pRtree->pWriteRowid, 1); + sqlite3_bind_null(pRtree->pWriteRowid, 2); + sqlite3_step(pRtree->pWriteRowid); + rc = sqlite3_reset(pRtree->pWriteRowid); + *piRowid = sqlite3_last_insert_rowid(pRtree->db); + return rc; +} + +/* +** Remove the entry with rowid=iDelete from the r-tree structure. +*/ +static int rtreeDeleteRowid(Rtree *pRtree, sqlite3_int64 iDelete){ + int rc; /* Return code */ + RtreeNode *pLeaf = 0; /* Leaf node containing record iDelete */ + int iCell; /* Index of iDelete cell in pLeaf */ + RtreeNode *pRoot; /* Root node of rtree structure */ + + + /* Obtain a reference to the root node to initialize Rtree.iDepth */ + rc = nodeAcquire(pRtree, 1, 0, &pRoot); + + /* Obtain a reference to the leaf node that contains the entry + ** about to be deleted. + */ + if( rc==SQLITE_OK ){ + rc = findLeafNode(pRtree, iDelete, &pLeaf, 0); + } + + /* Delete the cell in question from the leaf node. */ + if( rc==SQLITE_OK ){ + int rc2; + rc = nodeRowidIndex(pRtree, pLeaf, iDelete, &iCell); + if( rc==SQLITE_OK ){ + rc = deleteCell(pRtree, pLeaf, iCell, 0); + } + rc2 = nodeRelease(pRtree, pLeaf); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + + /* Delete the corresponding entry in the _rowid table. */ + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pRtree->pDeleteRowid, 1, iDelete); + sqlite3_step(pRtree->pDeleteRowid); + rc = sqlite3_reset(pRtree->pDeleteRowid); + } + + /* Check if the root node now has exactly one child. If so, remove + ** it, schedule the contents of the child for reinsertion and + ** reduce the tree height by one. + ** + ** This is equivalent to copying the contents of the child into + ** the root node (the operation that Gutman's paper says to perform + ** in this scenario). + */ + if( rc==SQLITE_OK && pRtree->iDepth>0 && NCELL(pRoot)==1 ){ + int rc2; + RtreeNode *pChild; + i64 iChild = nodeGetRowid(pRtree, pRoot, 0); + rc = nodeAcquire(pRtree, iChild, pRoot, &pChild); + if( rc==SQLITE_OK ){ + rc = removeNode(pRtree, pChild, pRtree->iDepth-1); + } + rc2 = nodeRelease(pRtree, pChild); + if( rc==SQLITE_OK ) rc = rc2; + if( rc==SQLITE_OK ){ + pRtree->iDepth--; + writeInt16(pRoot->zData, pRtree->iDepth); + pRoot->isDirty = 1; + } + } + + /* Re-insert the contents of any underfull nodes removed from the tree. */ + for(pLeaf=pRtree->pDeleted; pLeaf; pLeaf=pRtree->pDeleted){ + if( rc==SQLITE_OK ){ + rc = reinsertNodeContent(pRtree, pLeaf); + } + pRtree->pDeleted = pLeaf->pNext; + sqlite3_free(pLeaf); + } + + /* Release the reference to the root node. */ + if( rc==SQLITE_OK ){ + rc = nodeRelease(pRtree, pRoot); + }else{ + nodeRelease(pRtree, pRoot); + } + + return rc; +} + +/* +** Rounding constants for float->double conversion. +*/ +#define RNDTOWARDS (1.0 - 1.0/8388608.0) /* Round towards zero */ +#define RNDAWAY (1.0 + 1.0/8388608.0) /* Round away from zero */ + +#if !defined(SQLITE_RTREE_INT_ONLY) +/* +** Convert an sqlite3_value into an RtreeValue (presumably a float) +** while taking care to round toward negative or positive, respectively. +*/ +static RtreeValue rtreeValueDown(sqlite3_value *v){ + double d = sqlite3_value_double(v); + float f = (float)d; + if( f>d ){ + f = (float)(d*(d<0 ? RNDAWAY : RNDTOWARDS)); + } + return f; +} +static RtreeValue rtreeValueUp(sqlite3_value *v){ + double d = sqlite3_value_double(v); + float f = (float)d; + if( f1 */ + int bHaveRowid = 0; /* Set to 1 after new rowid is determined */ + + rtreeReference(pRtree); + assert(nData>=1); + + cell.iRowid = 0; /* Used only to suppress a compiler warning */ + + /* Constraint handling. A write operation on an r-tree table may return + ** SQLITE_CONSTRAINT for two reasons: + ** + ** 1. A duplicate rowid value, or + ** 2. The supplied data violates the "x2>=x1" constraint. + ** + ** In the first case, if the conflict-handling mode is REPLACE, then + ** the conflicting row can be removed before proceeding. In the second + ** case, SQLITE_CONSTRAINT must be returned regardless of the + ** conflict-handling mode specified by the user. + */ + if( nData>1 ){ + int ii; + + /* Populate the cell.aCoord[] array. The first coordinate is azData[3]. + ** + ** NB: nData can only be less than nDim*2+3 if the rtree is mis-declared + ** with "column" that are interpreted as table constraints. + ** Example: CREATE VIRTUAL TABLE bad USING rtree(x,y,CHECK(y>5)); + ** This problem was discovered after years of use, so we silently ignore + ** these kinds of misdeclared tables to avoid breaking any legacy. + */ + assert( nData<=(pRtree->nDim*2 + 3) ); + +#ifndef SQLITE_RTREE_INT_ONLY + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + for(ii=0; iicell.aCoord[ii+1].f ){ + rc = SQLITE_CONSTRAINT; + goto constraint; + } + } + }else +#endif + { + for(ii=0; iicell.aCoord[ii+1].i ){ + rc = SQLITE_CONSTRAINT; + goto constraint; + } + } + } + + /* If a rowid value was supplied, check if it is already present in + ** the table. If so, the constraint has failed. */ + if( sqlite3_value_type(azData[2])!=SQLITE_NULL ){ + cell.iRowid = sqlite3_value_int64(azData[2]); + if( sqlite3_value_type(azData[0])==SQLITE_NULL + || sqlite3_value_int64(azData[0])!=cell.iRowid + ){ + int steprc; + sqlite3_bind_int64(pRtree->pReadRowid, 1, cell.iRowid); + steprc = sqlite3_step(pRtree->pReadRowid); + rc = sqlite3_reset(pRtree->pReadRowid); + if( SQLITE_ROW==steprc ){ + if( sqlite3_vtab_on_conflict(pRtree->db)==SQLITE_REPLACE ){ + rc = rtreeDeleteRowid(pRtree, cell.iRowid); + }else{ + rc = SQLITE_CONSTRAINT; + goto constraint; + } + } + } + bHaveRowid = 1; + } + } + + /* If azData[0] is not an SQL NULL value, it is the rowid of a + ** record to delete from the r-tree table. The following block does + ** just that. + */ + if( sqlite3_value_type(azData[0])!=SQLITE_NULL ){ + rc = rtreeDeleteRowid(pRtree, sqlite3_value_int64(azData[0])); + } + + /* If the azData[] array contains more than one element, elements + ** (azData[2]..azData[argc-1]) contain a new record to insert into + ** the r-tree structure. + */ + if( rc==SQLITE_OK && nData>1 ){ + /* Insert the new record into the r-tree */ + RtreeNode *pLeaf = 0; + + /* Figure out the rowid of the new row. */ + if( bHaveRowid==0 ){ + rc = newRowid(pRtree, &cell.iRowid); + } + *pRowid = cell.iRowid; + + if( rc==SQLITE_OK ){ + rc = ChooseLeaf(pRtree, &cell, 0, &pLeaf); + } + if( rc==SQLITE_OK ){ + int rc2; + pRtree->iReinsertHeight = -1; + rc = rtreeInsertCell(pRtree, pLeaf, &cell, 0); + rc2 = nodeRelease(pRtree, pLeaf); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + +constraint: + rtreeRelease(pRtree); + return rc; +} + +/* +** The xRename method for rtree module virtual tables. +*/ +static int rtreeRename(sqlite3_vtab *pVtab, const char *zNewName){ + Rtree *pRtree = (Rtree *)pVtab; + int rc = SQLITE_NOMEM; + char *zSql = sqlite3_mprintf( + "ALTER TABLE %Q.'%q_node' RENAME TO \"%w_node\";" + "ALTER TABLE %Q.'%q_parent' RENAME TO \"%w_parent\";" + "ALTER TABLE %Q.'%q_rowid' RENAME TO \"%w_rowid\";" + , pRtree->zDb, pRtree->zName, zNewName + , pRtree->zDb, pRtree->zName, zNewName + , pRtree->zDb, pRtree->zName, zNewName + ); + if( zSql ){ + rc = sqlite3_exec(pRtree->db, zSql, 0, 0, 0); + sqlite3_free(zSql); + } + return rc; +} + +/* +** This function populates the pRtree->nRowEst variable with an estimate +** of the number of rows in the virtual table. If possible, this is based +** on sqlite_stat1 data. Otherwise, use RTREE_DEFAULT_ROWEST. +*/ +static int rtreeQueryStat1(sqlite3 *db, Rtree *pRtree){ + const char *zFmt = "SELECT stat FROM %Q.sqlite_stat1 WHERE tbl = '%q_rowid'"; + char *zSql; + sqlite3_stmt *p; + int rc; + i64 nRow = 0; + + zSql = sqlite3_mprintf(zFmt, pRtree->zDb, pRtree->zName); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(db, zSql, -1, &p, 0); + if( rc==SQLITE_OK ){ + if( sqlite3_step(p)==SQLITE_ROW ) nRow = sqlite3_column_int64(p, 0); + rc = sqlite3_finalize(p); + }else if( rc!=SQLITE_NOMEM ){ + rc = SQLITE_OK; + } + + if( rc==SQLITE_OK ){ + if( nRow==0 ){ + pRtree->nRowEst = RTREE_DEFAULT_ROWEST; + }else{ + pRtree->nRowEst = MAX(nRow, RTREE_MIN_ROWEST); + } + } + sqlite3_free(zSql); + } + + return rc; +} + +static sqlite3_module rtreeModule = { + 0, /* iVersion */ + rtreeCreate, /* xCreate - create a table */ + rtreeConnect, /* xConnect - connect to an existing table */ + rtreeBestIndex, /* xBestIndex - Determine search strategy */ + rtreeDisconnect, /* xDisconnect - Disconnect from a table */ + rtreeDestroy, /* xDestroy - Drop a table */ + rtreeOpen, /* xOpen - open a cursor */ + rtreeClose, /* xClose - close a cursor */ + rtreeFilter, /* xFilter - configure scan constraints */ + rtreeNext, /* xNext - advance a cursor */ + rtreeEof, /* xEof */ + rtreeColumn, /* xColumn - read data */ + rtreeRowid, /* xRowid - read data */ + rtreeUpdate, /* xUpdate - write data */ + 0, /* xBegin - begin transaction */ + 0, /* xSync - sync transaction */ + 0, /* xCommit - commit transaction */ + 0, /* xRollback - rollback transaction */ + 0, /* xFindFunction - function overloading */ + rtreeRename, /* xRename - rename the table */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0 /* xRollbackTo */ +}; + +static int rtreeSqlInit( + Rtree *pRtree, + sqlite3 *db, + const char *zDb, + const char *zPrefix, + int isCreate +){ + int rc = SQLITE_OK; + + #define N_STATEMENT 9 + static const char *azSql[N_STATEMENT] = { + /* Read and write the xxx_node table */ + "SELECT data FROM '%q'.'%q_node' WHERE nodeno = :1", + "INSERT OR REPLACE INTO '%q'.'%q_node' VALUES(:1, :2)", + "DELETE FROM '%q'.'%q_node' WHERE nodeno = :1", + + /* Read and write the xxx_rowid table */ + "SELECT nodeno FROM '%q'.'%q_rowid' WHERE rowid = :1", + "INSERT OR REPLACE INTO '%q'.'%q_rowid' VALUES(:1, :2)", + "DELETE FROM '%q'.'%q_rowid' WHERE rowid = :1", + + /* Read and write the xxx_parent table */ + "SELECT parentnode FROM '%q'.'%q_parent' WHERE nodeno = :1", + "INSERT OR REPLACE INTO '%q'.'%q_parent' VALUES(:1, :2)", + "DELETE FROM '%q'.'%q_parent' WHERE nodeno = :1" + }; + sqlite3_stmt **appStmt[N_STATEMENT]; + int i; + + pRtree->db = db; + + if( isCreate ){ + char *zCreate = sqlite3_mprintf( +"CREATE TABLE \"%w\".\"%w_node\"(nodeno INTEGER PRIMARY KEY, data BLOB);" +"CREATE TABLE \"%w\".\"%w_rowid\"(rowid INTEGER PRIMARY KEY, nodeno INTEGER);" +"CREATE TABLE \"%w\".\"%w_parent\"(nodeno INTEGER PRIMARY KEY," + " parentnode INTEGER);" +"INSERT INTO '%q'.'%q_node' VALUES(1, zeroblob(%d))", + zDb, zPrefix, zDb, zPrefix, zDb, zPrefix, zDb, zPrefix, pRtree->iNodeSize + ); + if( !zCreate ){ + return SQLITE_NOMEM; + } + rc = sqlite3_exec(db, zCreate, 0, 0, 0); + sqlite3_free(zCreate); + if( rc!=SQLITE_OK ){ + return rc; + } + } + + appStmt[0] = &pRtree->pReadNode; + appStmt[1] = &pRtree->pWriteNode; + appStmt[2] = &pRtree->pDeleteNode; + appStmt[3] = &pRtree->pReadRowid; + appStmt[4] = &pRtree->pWriteRowid; + appStmt[5] = &pRtree->pDeleteRowid; + appStmt[6] = &pRtree->pReadParent; + appStmt[7] = &pRtree->pWriteParent; + appStmt[8] = &pRtree->pDeleteParent; + + rc = rtreeQueryStat1(db, pRtree); + for(i=0; iiNodeSize is populated and SQLITE_OK returned. +** Otherwise, an SQLite error code is returned. +** +** If this function is being called as part of an xConnect(), then the rtree +** table already exists. In this case the node-size is determined by inspecting +** the root node of the tree. +** +** Otherwise, for an xCreate(), use 64 bytes less than the database page-size. +** This ensures that each node is stored on a single database page. If the +** database page-size is so large that more than RTREE_MAXCELLS entries +** would fit in a single node, use a smaller node-size. +*/ +static int getNodeSize( + sqlite3 *db, /* Database handle */ + Rtree *pRtree, /* Rtree handle */ + int isCreate, /* True for xCreate, false for xConnect */ + char **pzErr /* OUT: Error message, if any */ +){ + int rc; + char *zSql; + if( isCreate ){ + int iPageSize = 0; + zSql = sqlite3_mprintf("PRAGMA %Q.page_size", pRtree->zDb); + rc = getIntFromStmt(db, zSql, &iPageSize); + if( rc==SQLITE_OK ){ + pRtree->iNodeSize = iPageSize-64; + if( (4+pRtree->nBytesPerCell*RTREE_MAXCELLS)iNodeSize ){ + pRtree->iNodeSize = 4+pRtree->nBytesPerCell*RTREE_MAXCELLS; + } + }else{ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } + }else{ + zSql = sqlite3_mprintf( + "SELECT length(data) FROM '%q'.'%q_node' WHERE nodeno = 1", + pRtree->zDb, pRtree->zName + ); + rc = getIntFromStmt(db, zSql, &pRtree->iNodeSize); + if( rc!=SQLITE_OK ){ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } + } + + sqlite3_free(zSql); + return rc; +} + +/* +** This function is the implementation of both the xConnect and xCreate +** methods of the r-tree virtual table. +** +** argv[0] -> module name +** argv[1] -> database name +** argv[2] -> table name +** argv[...] -> column names... +*/ +static int rtreeInit( + sqlite3 *db, /* Database connection */ + void *pAux, /* One of the RTREE_COORD_* constants */ + int argc, const char *const*argv, /* Parameters to CREATE TABLE statement */ + sqlite3_vtab **ppVtab, /* OUT: New virtual table */ + char **pzErr, /* OUT: Error message, if any */ + int isCreate /* True for xCreate, false for xConnect */ +){ + int rc = SQLITE_OK; + Rtree *pRtree; + int nDb; /* Length of string argv[1] */ + int nName; /* Length of string argv[2] */ + int eCoordType = (pAux ? RTREE_COORD_INT32 : RTREE_COORD_REAL32); + + const char *aErrMsg[] = { + 0, /* 0 */ + "Wrong number of columns for an rtree table", /* 1 */ + "Too few columns for an rtree table", /* 2 */ + "Too many columns for an rtree table" /* 3 */ + }; + + int iErr = (argc<6) ? 2 : argc>(RTREE_MAX_DIMENSIONS*2+4) ? 3 : argc%2; + if( aErrMsg[iErr] ){ + *pzErr = sqlite3_mprintf("%s", aErrMsg[iErr]); + return SQLITE_ERROR; + } + + sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1); + + /* Allocate the sqlite3_vtab structure */ + nDb = (int)strlen(argv[1]); + nName = (int)strlen(argv[2]); + pRtree = (Rtree *)sqlite3_malloc(sizeof(Rtree)+nDb+nName+2); + if( !pRtree ){ + return SQLITE_NOMEM; + } + memset(pRtree, 0, sizeof(Rtree)+nDb+nName+2); + pRtree->nBusy = 1; + pRtree->base.pModule = &rtreeModule; + pRtree->zDb = (char *)&pRtree[1]; + pRtree->zName = &pRtree->zDb[nDb+1]; + pRtree->nDim = (argc-4)/2; + pRtree->nBytesPerCell = 8 + pRtree->nDim*4*2; + pRtree->eCoordType = eCoordType; + memcpy(pRtree->zDb, argv[1], nDb); + memcpy(pRtree->zName, argv[2], nName); + + /* Figure out the node size to use. */ + rc = getNodeSize(db, pRtree, isCreate, pzErr); + + /* Create/Connect to the underlying relational database schema. If + ** that is successful, call sqlite3_declare_vtab() to configure + ** the r-tree table schema. + */ + if( rc==SQLITE_OK ){ + if( (rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate)) ){ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + }else{ + char *zSql = sqlite3_mprintf("CREATE TABLE x(%s", argv[3]); + char *zTmp; + int ii; + for(ii=4; zSql && iinBusy==1 ); + rtreeRelease(pRtree); + } + return rc; +} + + +/* +** Implementation of a scalar function that decodes r-tree nodes to +** human readable strings. This can be used for debugging and analysis. +** +** The scalar function takes two arguments: (1) the number of dimensions +** to the rtree (between 1 and 5, inclusive) and (2) a blob of data containing +** an r-tree node. For a two-dimensional r-tree structure called "rt", to +** deserialize all nodes, a statement like: +** +** SELECT rtreenode(2, data) FROM rt_node; +** +** The human readable string takes the form of a Tcl list with one +** entry for each cell in the r-tree node. Each entry is itself a +** list, containing the 8-byte rowid/pageno followed by the +** *2 coordinates. +*/ +static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){ + char *zText = 0; + RtreeNode node; + Rtree tree; + int ii; + + UNUSED_PARAMETER(nArg); + memset(&node, 0, sizeof(RtreeNode)); + memset(&tree, 0, sizeof(Rtree)); + tree.nDim = sqlite3_value_int(apArg[0]); + tree.nBytesPerCell = 8 + 8 * tree.nDim; + node.zData = (u8 *)sqlite3_value_blob(apArg[1]); + + for(ii=0; iixDestructor ) pInfo->xDestructor(pInfo->pContext); + sqlite3_free(p); +} + +/* +** This routine frees the BLOB that is returned by geomCallback(). +*/ +static void rtreeMatchArgFree(void *pArg){ + int i; + RtreeMatchArg *p = (RtreeMatchArg*)pArg; + for(i=0; inParam; i++){ + sqlite3_value_free(p->apSqlParam[i]); + } + sqlite3_free(p); +} + +/* +** Each call to sqlite3_rtree_geometry_callback() or +** sqlite3_rtree_query_callback() creates an ordinary SQLite +** scalar function that is implemented by this routine. +** +** All this function does is construct an RtreeMatchArg object that +** contains the geometry-checking callback routines and a list of +** parameters to this function, then return that RtreeMatchArg object +** as a BLOB. +** +** The R-Tree MATCH operator will read the returned BLOB, deserialize +** the RtreeMatchArg object, and use the RtreeMatchArg object to figure +** out which elements of the R-Tree should be returned by the query. +*/ +static void geomCallback(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){ + RtreeGeomCallback *pGeomCtx = (RtreeGeomCallback *)sqlite3_user_data(ctx); + RtreeMatchArg *pBlob; + int nBlob; + int memErr = 0; + + nBlob = sizeof(RtreeMatchArg) + (nArg-1)*sizeof(RtreeDValue) + + nArg*sizeof(sqlite3_value*); + pBlob = (RtreeMatchArg *)sqlite3_malloc(nBlob); + if( !pBlob ){ + sqlite3_result_error_nomem(ctx); + }else{ + int i; + pBlob->magic = RTREE_GEOMETRY_MAGIC; + pBlob->cb = pGeomCtx[0]; + pBlob->apSqlParam = (sqlite3_value**)&pBlob->aParam[nArg]; + pBlob->nParam = nArg; + for(i=0; iapSqlParam[i] = sqlite3_value_dup(aArg[i]); + if( pBlob->apSqlParam[i]==0 ) memErr = 1; +#ifdef SQLITE_RTREE_INT_ONLY + pBlob->aParam[i] = sqlite3_value_int64(aArg[i]); +#else + pBlob->aParam[i] = sqlite3_value_double(aArg[i]); +#endif + } + if( memErr ){ + sqlite3_result_error_nomem(ctx); + rtreeMatchArgFree(pBlob); + }else{ + sqlite3_result_blob(ctx, pBlob, nBlob, rtreeMatchArgFree); + } + } +} + +/* +** Register a new geometry function for use with the r-tree MATCH operator. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_rtree_geometry_callback( + sqlite3 *db, /* Register SQL function on this connection */ + const char *zGeom, /* Name of the new SQL function */ + int (*xGeom)(sqlite3_rtree_geometry*,int,RtreeDValue*,int*), /* Callback */ + void *pContext /* Extra data associated with the callback */ +){ + RtreeGeomCallback *pGeomCtx; /* Context object for new user-function */ + + /* Allocate and populate the context object. */ + pGeomCtx = (RtreeGeomCallback *)sqlite3_malloc(sizeof(RtreeGeomCallback)); + if( !pGeomCtx ) return SQLITE_NOMEM; + pGeomCtx->xGeom = xGeom; + pGeomCtx->xQueryFunc = 0; + pGeomCtx->xDestructor = 0; + pGeomCtx->pContext = pContext; + return sqlite3_create_function_v2(db, zGeom, -1, SQLITE_ANY, + (void *)pGeomCtx, geomCallback, 0, 0, rtreeFreeCallback + ); +} + +/* +** Register a new 2nd-generation geometry function for use with the +** r-tree MATCH operator. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3_rtree_query_callback( + sqlite3 *db, /* Register SQL function on this connection */ + const char *zQueryFunc, /* Name of new SQL function */ + int (*xQueryFunc)(sqlite3_rtree_query_info*), /* Callback */ + void *pContext, /* Extra data passed into the callback */ + void (*xDestructor)(void*) /* Destructor for the extra data */ +){ + RtreeGeomCallback *pGeomCtx; /* Context object for new user-function */ + + /* Allocate and populate the context object. */ + pGeomCtx = (RtreeGeomCallback *)sqlite3_malloc(sizeof(RtreeGeomCallback)); + if( !pGeomCtx ) return SQLITE_NOMEM; + pGeomCtx->xGeom = 0; + pGeomCtx->xQueryFunc = xQueryFunc; + pGeomCtx->xDestructor = xDestructor; + pGeomCtx->pContext = pContext; + return sqlite3_create_function_v2(db, zQueryFunc, -1, SQLITE_ANY, + (void *)pGeomCtx, geomCallback, 0, 0, rtreeFreeCallback + ); +} + +#if !SQLITE_CORE +#ifdef _WIN32 +__declspec(dllexport) +#endif +SQLITE_API int SQLITE_STDCALL sqlite3_rtree_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + SQLITE_EXTENSION_INIT2(pApi) + return sqlite3RtreeInit(db); +} +#endif + +#endif + +/************** End of rtree.c ***********************************************/ +/************** Begin file icu.c *********************************************/ +/* +** 2007 May 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** $Id: icu.c,v 1.7 2007/12/13 21:54:11 drh Exp $ +** +** This file implements an integration between the ICU library +** ("International Components for Unicode", an open-source library +** for handling unicode data) and SQLite. The integration uses +** ICU to provide the following to SQLite: +** +** * An implementation of the SQL regexp() function (and hence REGEXP +** operator) using the ICU uregex_XX() APIs. +** +** * Implementations of the SQL scalar upper() and lower() functions +** for case mapping. +** +** * Integration of ICU and SQLite collation sequences. +** +** * An implementation of the LIKE operator that uses ICU to +** provide case-independent matching. +*/ + +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU) + +/* Include ICU headers */ +#include +#include +#include +#include + +/* #include */ + +#ifndef SQLITE_CORE +/* #include "sqlite3ext.h" */ + SQLITE_EXTENSION_INIT1 +#else +/* #include "sqlite3.h" */ +#endif + +/* +** Maximum length (in bytes) of the pattern in a LIKE or GLOB +** operator. +*/ +#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH +# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 +#endif + +/* +** Version of sqlite3_free() that is always a function, never a macro. +*/ +static void xFree(void *p){ + sqlite3_free(p); +} + +/* +** Compare two UTF-8 strings for equality where the first string is +** a "LIKE" expression. Return true (1) if they are the same and +** false (0) if they are different. +*/ +static int icuLikeCompare( + const uint8_t *zPattern, /* LIKE pattern */ + const uint8_t *zString, /* The UTF-8 string to compare against */ + const UChar32 uEsc /* The escape character */ +){ + static const int MATCH_ONE = (UChar32)'_'; + static const int MATCH_ALL = (UChar32)'%'; + + int iPattern = 0; /* Current byte index in zPattern */ + int iString = 0; /* Current byte index in zString */ + + int prevEscape = 0; /* True if the previous character was uEsc */ + + while( zPattern[iPattern]!=0 ){ + + /* Read (and consume) the next character from the input pattern. */ + UChar32 uPattern; + U8_NEXT_UNSAFE(zPattern, iPattern, uPattern); + + /* There are now 4 possibilities: + ** + ** 1. uPattern is an unescaped match-all character "%", + ** 2. uPattern is an unescaped match-one character "_", + ** 3. uPattern is an unescaped escape character, or + ** 4. uPattern is to be handled as an ordinary character + */ + if( !prevEscape && uPattern==MATCH_ALL ){ + /* Case 1. */ + uint8_t c; + + /* Skip any MATCH_ALL or MATCH_ONE characters that follow a + ** MATCH_ALL. For each MATCH_ONE, skip one character in the + ** test string. + */ + while( (c=zPattern[iPattern]) == MATCH_ALL || c == MATCH_ONE ){ + if( c==MATCH_ONE ){ + if( zString[iString]==0 ) return 0; + U8_FWD_1_UNSAFE(zString, iString); + } + iPattern++; + } + + if( zPattern[iPattern]==0 ) return 1; + + while( zString[iString] ){ + if( icuLikeCompare(&zPattern[iPattern], &zString[iString], uEsc) ){ + return 1; + } + U8_FWD_1_UNSAFE(zString, iString); + } + return 0; + + }else if( !prevEscape && uPattern==MATCH_ONE ){ + /* Case 2. */ + if( zString[iString]==0 ) return 0; + U8_FWD_1_UNSAFE(zString, iString); + + }else if( !prevEscape && uPattern==uEsc){ + /* Case 3. */ + prevEscape = 1; + + }else{ + /* Case 4. */ + UChar32 uString; + U8_NEXT_UNSAFE(zString, iString, uString); + uString = u_foldCase(uString, U_FOLD_CASE_DEFAULT); + uPattern = u_foldCase(uPattern, U_FOLD_CASE_DEFAULT); + if( uString!=uPattern ){ + return 0; + } + prevEscape = 0; + } + } + + return zString[iString]==0; +} + +/* +** Implementation of the like() SQL function. This function implements +** the build-in LIKE operator. The first argument to the function is the +** pattern and the second argument is the string. So, the SQL statements: +** +** A LIKE B +** +** is implemented as like(B, A). If there is an escape character E, +** +** A LIKE B ESCAPE E +** +** is mapped to like(B, A, E). +*/ +static void icuLikeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zA = sqlite3_value_text(argv[0]); + const unsigned char *zB = sqlite3_value_text(argv[1]); + UChar32 uEsc = 0; + + /* Limit the length of the LIKE or GLOB pattern to avoid problems + ** of deep recursion and N*N behavior in patternCompare(). + */ + if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){ + sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); + return; + } + + + if( argc==3 ){ + /* The escape character string must consist of a single UTF-8 character. + ** Otherwise, return an error. + */ + int nE= sqlite3_value_bytes(argv[2]); + const unsigned char *zE = sqlite3_value_text(argv[2]); + int i = 0; + if( zE==0 ) return; + U8_NEXT(zE, i, nE, uEsc); + if( i!=nE){ + sqlite3_result_error(context, + "ESCAPE expression must be a single character", -1); + return; + } + } + + if( zA && zB ){ + sqlite3_result_int(context, icuLikeCompare(zA, zB, uEsc)); + } +} + +/* +** This function is called when an ICU function called from within +** the implementation of an SQL scalar function returns an error. +** +** The scalar function context passed as the first argument is +** loaded with an error message based on the following two args. +*/ +static void icuFunctionError( + sqlite3_context *pCtx, /* SQLite scalar function context */ + const char *zName, /* Name of ICU function that failed */ + UErrorCode e /* Error code returned by ICU function */ +){ + char zBuf[128]; + sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e)); + zBuf[127] = '\0'; + sqlite3_result_error(pCtx, zBuf, -1); +} + +/* +** Function to delete compiled regexp objects. Registered as +** a destructor function with sqlite3_set_auxdata(). +*/ +static void icuRegexpDelete(void *p){ + URegularExpression *pExpr = (URegularExpression *)p; + uregex_close(pExpr); +} + +/* +** Implementation of SQLite REGEXP operator. This scalar function takes +** two arguments. The first is a regular expression pattern to compile +** the second is a string to match against that pattern. If either +** argument is an SQL NULL, then NULL Is returned. Otherwise, the result +** is 1 if the string matches the pattern, or 0 otherwise. +** +** SQLite maps the regexp() function to the regexp() operator such +** that the following two are equivalent: +** +** zString REGEXP zPattern +** regexp(zPattern, zString) +** +** Uses the following ICU regexp APIs: +** +** uregex_open() +** uregex_matches() +** uregex_close() +*/ +static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){ + UErrorCode status = U_ZERO_ERROR; + URegularExpression *pExpr; + UBool res; + const UChar *zString = sqlite3_value_text16(apArg[1]); + + (void)nArg; /* Unused parameter */ + + /* If the left hand side of the regexp operator is NULL, + ** then the result is also NULL. + */ + if( !zString ){ + return; + } + + pExpr = sqlite3_get_auxdata(p, 0); + if( !pExpr ){ + const UChar *zPattern = sqlite3_value_text16(apArg[0]); + if( !zPattern ){ + return; + } + pExpr = uregex_open(zPattern, -1, 0, 0, &status); + + if( U_SUCCESS(status) ){ + sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete); + }else{ + assert(!pExpr); + icuFunctionError(p, "uregex_open", status); + return; + } + } + + /* Configure the text that the regular expression operates on. */ + uregex_setText(pExpr, zString, -1, &status); + if( !U_SUCCESS(status) ){ + icuFunctionError(p, "uregex_setText", status); + return; + } + + /* Attempt the match */ + res = uregex_matches(pExpr, 0, &status); + if( !U_SUCCESS(status) ){ + icuFunctionError(p, "uregex_matches", status); + return; + } + + /* Set the text that the regular expression operates on to a NULL + ** pointer. This is not really necessary, but it is tidier than + ** leaving the regular expression object configured with an invalid + ** pointer after this function returns. + */ + uregex_setText(pExpr, 0, 0, &status); + + /* Return 1 or 0. */ + sqlite3_result_int(p, res ? 1 : 0); +} + +/* +** Implementations of scalar functions for case mapping - upper() and +** lower(). Function upper() converts its input to upper-case (ABC). +** Function lower() converts to lower-case (abc). +** +** ICU provides two types of case mapping, "general" case mapping and +** "language specific". Refer to ICU documentation for the differences +** between the two. +** +** To utilise "general" case mapping, the upper() or lower() scalar +** functions are invoked with one argument: +** +** upper('ABC') -> 'abc' +** lower('abc') -> 'ABC' +** +** To access ICU "language specific" case mapping, upper() or lower() +** should be invoked with two arguments. The second argument is the name +** of the locale to use. Passing an empty string ("") or SQL NULL value +** as the second argument is the same as invoking the 1 argument version +** of upper() or lower(). +** +** lower('I', 'en_us') -> 'i' +** lower('I', 'tr_tr') -> 'ı' (small dotless i) +** +** http://www.icu-project.org/userguide/posix.html#case_mappings +*/ +static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){ + const UChar *zInput; + UChar *zOutput; + int nInput; + int nOutput; + + UErrorCode status = U_ZERO_ERROR; + const char *zLocale = 0; + + assert(nArg==1 || nArg==2); + if( nArg==2 ){ + zLocale = (const char *)sqlite3_value_text(apArg[1]); + } + + zInput = sqlite3_value_text16(apArg[0]); + if( !zInput ){ + return; + } + nInput = sqlite3_value_bytes16(apArg[0]); + + nOutput = nInput * 2 + 2; + zOutput = sqlite3_malloc(nOutput); + if( !zOutput ){ + return; + } + + if( sqlite3_user_data(p) ){ + u_strToUpper(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status); + }else{ + u_strToLower(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status); + } + + if( !U_SUCCESS(status) ){ + icuFunctionError(p, "u_strToLower()/u_strToUpper", status); + return; + } + + sqlite3_result_text16(p, zOutput, -1, xFree); +} + +/* +** Collation sequence destructor function. The pCtx argument points to +** a UCollator structure previously allocated using ucol_open(). +*/ +static void icuCollationDel(void *pCtx){ + UCollator *p = (UCollator *)pCtx; + ucol_close(p); +} + +/* +** Collation sequence comparison function. The pCtx argument points to +** a UCollator structure previously allocated using ucol_open(). +*/ +static int icuCollationColl( + void *pCtx, + int nLeft, + const void *zLeft, + int nRight, + const void *zRight +){ + UCollationResult res; + UCollator *p = (UCollator *)pCtx; + res = ucol_strcoll(p, (UChar *)zLeft, nLeft/2, (UChar *)zRight, nRight/2); + switch( res ){ + case UCOL_LESS: return -1; + case UCOL_GREATER: return +1; + case UCOL_EQUAL: return 0; + } + assert(!"Unexpected return value from ucol_strcoll()"); + return 0; +} + +/* +** Implementation of the scalar function icu_load_collation(). +** +** This scalar function is used to add ICU collation based collation +** types to an SQLite database connection. It is intended to be called +** as follows: +** +** SELECT icu_load_collation(, ); +** +** Where is a string containing an ICU locale identifier (i.e. +** "en_AU", "tr_TR" etc.) and is the name of the +** collation sequence to create. +*/ +static void icuLoadCollation( + sqlite3_context *p, + int nArg, + sqlite3_value **apArg +){ + sqlite3 *db = (sqlite3 *)sqlite3_user_data(p); + UErrorCode status = U_ZERO_ERROR; + const char *zLocale; /* Locale identifier - (eg. "jp_JP") */ + const char *zName; /* SQL Collation sequence name (eg. "japanese") */ + UCollator *pUCollator; /* ICU library collation object */ + int rc; /* Return code from sqlite3_create_collation_x() */ + + assert(nArg==2); + (void)nArg; /* Unused parameter */ + zLocale = (const char *)sqlite3_value_text(apArg[0]); + zName = (const char *)sqlite3_value_text(apArg[1]); + + if( !zLocale || !zName ){ + return; + } + + pUCollator = ucol_open(zLocale, &status); + if( !U_SUCCESS(status) ){ + icuFunctionError(p, "ucol_open", status); + return; + } + assert(p); + + rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator, + icuCollationColl, icuCollationDel + ); + if( rc!=SQLITE_OK ){ + ucol_close(pUCollator); + sqlite3_result_error(p, "Error registering collation function", -1); + } +} + +/* +** Register the ICU extension functions with database db. +*/ +SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db){ + struct IcuScalar { + const char *zName; /* Function name */ + int nArg; /* Number of arguments */ + int enc; /* Optimal text encoding */ + void *pContext; /* sqlite3_user_data() context */ + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + } scalars[] = { + {"regexp", 2, SQLITE_ANY, 0, icuRegexpFunc}, + + {"lower", 1, SQLITE_UTF16, 0, icuCaseFunc16}, + {"lower", 2, SQLITE_UTF16, 0, icuCaseFunc16}, + {"upper", 1, SQLITE_UTF16, (void*)1, icuCaseFunc16}, + {"upper", 2, SQLITE_UTF16, (void*)1, icuCaseFunc16}, + + {"lower", 1, SQLITE_UTF8, 0, icuCaseFunc16}, + {"lower", 2, SQLITE_UTF8, 0, icuCaseFunc16}, + {"upper", 1, SQLITE_UTF8, (void*)1, icuCaseFunc16}, + {"upper", 2, SQLITE_UTF8, (void*)1, icuCaseFunc16}, + + {"like", 2, SQLITE_UTF8, 0, icuLikeFunc}, + {"like", 3, SQLITE_UTF8, 0, icuLikeFunc}, + + {"icu_load_collation", 2, SQLITE_UTF8, (void*)db, icuLoadCollation}, + }; + + int rc = SQLITE_OK; + int i; + + for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){ + struct IcuScalar *p = &scalars[i]; + rc = sqlite3_create_function( + db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0 + ); + } + + return rc; +} + +#if !SQLITE_CORE +#ifdef _WIN32 +__declspec(dllexport) +#endif +SQLITE_API int SQLITE_STDCALL sqlite3_icu_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + SQLITE_EXTENSION_INIT2(pApi) + return sqlite3IcuInit(db); +} +#endif + +#endif + +/************** End of icu.c *************************************************/ +/************** Begin file fts3_icu.c ****************************************/ +/* +** 2007 June 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file implements a tokenizer for fts3 based on the ICU library. +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) +#ifdef SQLITE_ENABLE_ICU + +/* #include */ +/* #include */ +/* #include "fts3_tokenizer.h" */ + +#include +/* #include */ +/* #include */ +#include + +typedef struct IcuTokenizer IcuTokenizer; +typedef struct IcuCursor IcuCursor; + +struct IcuTokenizer { + sqlite3_tokenizer base; + char *zLocale; +}; + +struct IcuCursor { + sqlite3_tokenizer_cursor base; + + UBreakIterator *pIter; /* ICU break-iterator object */ + int nChar; /* Number of UChar elements in pInput */ + UChar *aChar; /* Copy of input using utf-16 encoding */ + int *aOffset; /* Offsets of each character in utf-8 input */ + + int nBuffer; + char *zBuffer; + + int iToken; +}; + +/* +** Create a new tokenizer instance. +*/ +static int icuCreate( + int argc, /* Number of entries in argv[] */ + const char * const *argv, /* Tokenizer creation arguments */ + sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */ +){ + IcuTokenizer *p; + int n = 0; + + if( argc>0 ){ + n = strlen(argv[0])+1; + } + p = (IcuTokenizer *)sqlite3_malloc(sizeof(IcuTokenizer)+n); + if( !p ){ + return SQLITE_NOMEM; + } + memset(p, 0, sizeof(IcuTokenizer)); + + if( n ){ + p->zLocale = (char *)&p[1]; + memcpy(p->zLocale, argv[0], n); + } + + *ppTokenizer = (sqlite3_tokenizer *)p; + + return SQLITE_OK; +} + +/* +** Destroy a tokenizer +*/ +static int icuDestroy(sqlite3_tokenizer *pTokenizer){ + IcuTokenizer *p = (IcuTokenizer *)pTokenizer; + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is pInput[0..nBytes-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int icuOpen( + sqlite3_tokenizer *pTokenizer, /* The tokenizer */ + const char *zInput, /* Input string */ + int nInput, /* Length of zInput in bytes */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */ +){ + IcuTokenizer *p = (IcuTokenizer *)pTokenizer; + IcuCursor *pCsr; + + const int32_t opt = U_FOLD_CASE_DEFAULT; + UErrorCode status = U_ZERO_ERROR; + int nChar; + + UChar32 c; + int iInput = 0; + int iOut = 0; + + *ppCursor = 0; + + if( zInput==0 ){ + nInput = 0; + zInput = ""; + }else if( nInput<0 ){ + nInput = strlen(zInput); + } + nChar = nInput+1; + pCsr = (IcuCursor *)sqlite3_malloc( + sizeof(IcuCursor) + /* IcuCursor */ + ((nChar+3)&~3) * sizeof(UChar) + /* IcuCursor.aChar[] */ + (nChar+1) * sizeof(int) /* IcuCursor.aOffset[] */ + ); + if( !pCsr ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(IcuCursor)); + pCsr->aChar = (UChar *)&pCsr[1]; + pCsr->aOffset = (int *)&pCsr->aChar[(nChar+3)&~3]; + + pCsr->aOffset[iOut] = iInput; + U8_NEXT(zInput, iInput, nInput, c); + while( c>0 ){ + int isError = 0; + c = u_foldCase(c, opt); + U16_APPEND(pCsr->aChar, iOut, nChar, c, isError); + if( isError ){ + sqlite3_free(pCsr); + return SQLITE_ERROR; + } + pCsr->aOffset[iOut] = iInput; + + if( iInputpIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status); + if( !U_SUCCESS(status) ){ + sqlite3_free(pCsr); + return SQLITE_ERROR; + } + pCsr->nChar = iOut; + + ubrk_first(pCsr->pIter); + *ppCursor = (sqlite3_tokenizer_cursor *)pCsr; + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to icuOpen(). +*/ +static int icuClose(sqlite3_tokenizer_cursor *pCursor){ + IcuCursor *pCsr = (IcuCursor *)pCursor; + ubrk_close(pCsr->pIter); + sqlite3_free(pCsr->zBuffer); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** Extract the next token from a tokenization cursor. +*/ +static int icuNext( + sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by simpleOpen */ + const char **ppToken, /* OUT: *ppToken is the token text */ + int *pnBytes, /* OUT: Number of bytes in token */ + int *piStartOffset, /* OUT: Starting offset of token */ + int *piEndOffset, /* OUT: Ending offset of token */ + int *piPosition /* OUT: Position integer of token */ +){ + IcuCursor *pCsr = (IcuCursor *)pCursor; + + int iStart = 0; + int iEnd = 0; + int nByte = 0; + + while( iStart==iEnd ){ + UChar32 c; + + iStart = ubrk_current(pCsr->pIter); + iEnd = ubrk_next(pCsr->pIter); + if( iEnd==UBRK_DONE ){ + return SQLITE_DONE; + } + + while( iStartaChar, iWhite, pCsr->nChar, c); + if( u_isspace(c) ){ + iStart = iWhite; + }else{ + break; + } + } + assert(iStart<=iEnd); + } + + do { + UErrorCode status = U_ZERO_ERROR; + if( nByte ){ + char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte); + if( !zNew ){ + return SQLITE_NOMEM; + } + pCsr->zBuffer = zNew; + pCsr->nBuffer = nByte; + } + + u_strToUTF8( + pCsr->zBuffer, pCsr->nBuffer, &nByte, /* Output vars */ + &pCsr->aChar[iStart], iEnd-iStart, /* Input vars */ + &status /* Output success/failure */ + ); + } while( nByte>pCsr->nBuffer ); + + *ppToken = pCsr->zBuffer; + *pnBytes = nByte; + *piStartOffset = pCsr->aOffset[iStart]; + *piEndOffset = pCsr->aOffset[iEnd]; + *piPosition = pCsr->iToken++; + + return SQLITE_OK; +} + +/* +** The set of routines that implement the simple tokenizer +*/ +static const sqlite3_tokenizer_module icuTokenizerModule = { + 0, /* iVersion */ + icuCreate, /* xCreate */ + icuDestroy, /* xCreate */ + icuOpen, /* xOpen */ + icuClose, /* xClose */ + icuNext, /* xNext */ + 0, /* xLanguageid */ +}; + +/* +** Set *ppModule to point at the implementation of the ICU tokenizer. +*/ +SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule( + sqlite3_tokenizer_module const**ppModule +){ + *ppModule = &icuTokenizerModule; +} + +#endif /* defined(SQLITE_ENABLE_ICU) */ +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_icu.c ********************************************/ +/************** Begin file sqlite3rbu.c **************************************/ +/* +** 2014 August 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** +** OVERVIEW +** +** The RBU extension requires that the RBU update be packaged as an +** SQLite database. The tables it expects to find are described in +** sqlite3rbu.h. Essentially, for each table xyz in the target database +** that the user wishes to write to, a corresponding data_xyz table is +** created in the RBU database and populated with one row for each row to +** update, insert or delete from the target table. +** +** The update proceeds in three stages: +** +** 1) The database is updated. The modified database pages are written +** to a *-oal file. A *-oal file is just like a *-wal file, except +** that it is named "-oal" instead of "-wal". +** Because regular SQLite clients do not look for file named +** "-oal", they go on using the original database in +** rollback mode while the *-oal file is being generated. +** +** During this stage RBU does not update the database by writing +** directly to the target tables. Instead it creates "imposter" +** tables using the SQLITE_TESTCTRL_IMPOSTER interface that it uses +** to update each b-tree individually. All updates required by each +** b-tree are completed before moving on to the next, and all +** updates are done in sorted key order. +** +** 2) The "-oal" file is moved to the equivalent "-wal" +** location using a call to rename(2). Before doing this the RBU +** module takes an EXCLUSIVE lock on the database file, ensuring +** that there are no other active readers. +** +** Once the EXCLUSIVE lock is released, any other database readers +** detect the new *-wal file and read the database in wal mode. At +** this point they see the new version of the database - including +** the updates made as part of the RBU update. +** +** 3) The new *-wal file is checkpointed. This proceeds in the same way +** as a regular database checkpoint, except that a single frame is +** checkpointed each time sqlite3rbu_step() is called. If the RBU +** handle is closed before the entire *-wal file is checkpointed, +** the checkpoint progress is saved in the RBU database and the +** checkpoint can be resumed by another RBU client at some point in +** the future. +** +** POTENTIAL PROBLEMS +** +** The rename() call might not be portable. And RBU is not currently +** syncing the directory after renaming the file. +** +** When state is saved, any commit to the *-oal file and the commit to +** the RBU update database are not atomic. So if the power fails at the +** wrong moment they might get out of sync. As the main database will be +** committed before the RBU update database this will likely either just +** pass unnoticed, or result in SQLITE_CONSTRAINT errors (due to UNIQUE +** constraint violations). +** +** If some client does modify the target database mid RBU update, or some +** other error occurs, the RBU extension will keep throwing errors. It's +** not really clear how to get out of this state. The system could just +** by delete the RBU update database and *-oal file and have the device +** download the update again and start over. +** +** At present, for an UPDATE, both the new.* and old.* records are +** collected in the rbu_xyz table. And for both UPDATEs and DELETEs all +** fields are collected. This means we're probably writing a lot more +** data to disk when saving the state of an ongoing update to the RBU +** update database than is strictly necessary. +** +*/ + +/* #include */ +/* #include */ +/* #include */ + +/* #include "sqlite3.h" */ + +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU) +/************** Include sqlite3rbu.h in the middle of sqlite3rbu.c ***********/ +/************** Begin file sqlite3rbu.h **************************************/ +/* +** 2014 August 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the public interface for the RBU extension. +*/ + +/* +** SUMMARY +** +** Writing a transaction containing a large number of operations on +** b-tree indexes that are collectively larger than the available cache +** memory can be very inefficient. +** +** The problem is that in order to update a b-tree, the leaf page (at least) +** containing the entry being inserted or deleted must be modified. If the +** working set of leaves is larger than the available cache memory, then a +** single leaf that is modified more than once as part of the transaction +** may be loaded from or written to the persistent media multiple times. +** Additionally, because the index updates are likely to be applied in +** random order, access to pages within the database is also likely to be in +** random order, which is itself quite inefficient. +** +** One way to improve the situation is to sort the operations on each index +** by index key before applying them to the b-tree. This leads to an IO +** pattern that resembles a single linear scan through the index b-tree, +** and all but guarantees each modified leaf page is loaded and stored +** exactly once. SQLite uses this trick to improve the performance of +** CREATE INDEX commands. This extension allows it to be used to improve +** the performance of large transactions on existing databases. +** +** Additionally, this extension allows the work involved in writing the +** large transaction to be broken down into sub-transactions performed +** sequentially by separate processes. This is useful if the system cannot +** guarantee that a single update process will run for long enough to apply +** the entire update, for example because the update is being applied on a +** mobile device that is frequently rebooted. Even after the writer process +** has committed one or more sub-transactions, other database clients continue +** to read from the original database snapshot. In other words, partially +** applied transactions are not visible to other clients. +** +** "RBU" stands for "Resumable Bulk Update". As in a large database update +** transmitted via a wireless network to a mobile device. A transaction +** applied using this extension is hence refered to as an "RBU update". +** +** +** LIMITATIONS +** +** An "RBU update" transaction is subject to the following limitations: +** +** * The transaction must consist of INSERT, UPDATE and DELETE operations +** only. +** +** * INSERT statements may not use any default values. +** +** * UPDATE and DELETE statements must identify their target rows by +** non-NULL PRIMARY KEY values. Rows with NULL values stored in PRIMARY +** KEY fields may not be updated or deleted. If the table being written +** has no PRIMARY KEY, affected rows must be identified by rowid. +** +** * UPDATE statements may not modify PRIMARY KEY columns. +** +** * No triggers will be fired. +** +** * No foreign key violations are detected or reported. +** +** * CHECK constraints are not enforced. +** +** * No constraint handling mode except for "OR ROLLBACK" is supported. +** +** +** PREPARATION +** +** An "RBU update" is stored as a separate SQLite database. A database +** containing an RBU update is an "RBU database". For each table in the +** target database to be updated, the RBU database should contain a table +** named "data_" containing the same set of columns as the +** target table, and one more - "rbu_control". The data_% table should +** have no PRIMARY KEY or UNIQUE constraints, but each column should have +** the same type as the corresponding column in the target database. +** The "rbu_control" column should have no type at all. For example, if +** the target database contains: +** +** CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c UNIQUE); +** +** Then the RBU database should contain: +** +** CREATE TABLE data_t1(a INTEGER, b TEXT, c, rbu_control); +** +** The order of the columns in the data_% table does not matter. +** +** Instead of a regular table, the RBU database may also contain virtual +** tables or view named using the data_ naming scheme. +** +** Instead of the plain data_ naming scheme, RBU database tables +** may also be named data_, where is any sequence +** of zero or more numeric characters (0-9). This can be significant because +** tables within the RBU database are always processed in order sorted by +** name. By judicious selection of the the portion of the names +** of the RBU tables the user can therefore control the order in which they +** are processed. This can be useful, for example, to ensure that "external +** content" FTS4 tables are updated before their underlying content tables. +** +** If the target database table is a virtual table or a table that has no +** PRIMARY KEY declaration, the data_% table must also contain a column +** named "rbu_rowid". This column is mapped to the tables implicit primary +** key column - "rowid". Virtual tables for which the "rowid" column does +** not function like a primary key value cannot be updated using RBU. For +** example, if the target db contains either of the following: +** +** CREATE VIRTUAL TABLE x1 USING fts3(a, b); +** CREATE TABLE x1(a, b) +** +** then the RBU database should contain: +** +** CREATE TABLE data_x1(a, b, rbu_rowid, rbu_control); +** +** All non-hidden columns (i.e. all columns matched by "SELECT *") of the +** target table must be present in the input table. For virtual tables, +** hidden columns are optional - they are updated by RBU if present in +** the input table, or not otherwise. For example, to write to an fts4 +** table with a hidden languageid column such as: +** +** CREATE VIRTUAL TABLE ft1 USING fts4(a, b, languageid='langid'); +** +** Either of the following input table schemas may be used: +** +** CREATE TABLE data_ft1(a, b, langid, rbu_rowid, rbu_control); +** CREATE TABLE data_ft1(a, b, rbu_rowid, rbu_control); +** +** For each row to INSERT into the target database as part of the RBU +** update, the corresponding data_% table should contain a single record +** with the "rbu_control" column set to contain integer value 0. The +** other columns should be set to the values that make up the new record +** to insert. +** +** If the target database table has an INTEGER PRIMARY KEY, it is not +** possible to insert a NULL value into the IPK column. Attempting to +** do so results in an SQLITE_MISMATCH error. +** +** For each row to DELETE from the target database as part of the RBU +** update, the corresponding data_% table should contain a single record +** with the "rbu_control" column set to contain integer value 1. The +** real primary key values of the row to delete should be stored in the +** corresponding columns of the data_% table. The values stored in the +** other columns are not used. +** +** For each row to UPDATE from the target database as part of the RBU +** update, the corresponding data_% table should contain a single record +** with the "rbu_control" column set to contain a value of type text. +** The real primary key values identifying the row to update should be +** stored in the corresponding columns of the data_% table row, as should +** the new values of all columns being update. The text value in the +** "rbu_control" column must contain the same number of characters as +** there are columns in the target database table, and must consist entirely +** of 'x' and '.' characters (or in some special cases 'd' - see below). For +** each column that is being updated, the corresponding character is set to +** 'x'. For those that remain as they are, the corresponding character of the +** rbu_control value should be set to '.'. For example, given the tables +** above, the update statement: +** +** UPDATE t1 SET c = 'usa' WHERE a = 4; +** +** is represented by the data_t1 row created by: +** +** INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..x'); +** +** Instead of an 'x' character, characters of the rbu_control value specified +** for UPDATEs may also be set to 'd'. In this case, instead of updating the +** target table with the value stored in the corresponding data_% column, the +** user-defined SQL function "rbu_delta()" is invoked and the result stored in +** the target table column. rbu_delta() is invoked with two arguments - the +** original value currently stored in the target table column and the +** value specified in the data_xxx table. +** +** For example, this row: +** +** INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..d'); +** +** is similar to an UPDATE statement such as: +** +** UPDATE t1 SET c = rbu_delta(c, 'usa') WHERE a = 4; +** +** Finally, if an 'f' character appears in place of a 'd' or 's' in an +** ota_control string, the contents of the data_xxx table column is assumed +** to be a "fossil delta" - a patch to be applied to a blob value in the +** format used by the fossil source-code management system. In this case +** the existing value within the target database table must be of type BLOB. +** It is replaced by the result of applying the specified fossil delta to +** itself. +** +** If the target database table is a virtual table or a table with no PRIMARY +** KEY, the rbu_control value should not include a character corresponding +** to the rbu_rowid value. For example, this: +** +** INSERT INTO data_ft1(a, b, rbu_rowid, rbu_control) +** VALUES(NULL, 'usa', 12, '.x'); +** +** causes a result similar to: +** +** UPDATE ft1 SET b = 'usa' WHERE rowid = 12; +** +** The data_xxx tables themselves should have no PRIMARY KEY declarations. +** However, RBU is more efficient if reading the rows in from each data_xxx +** table in "rowid" order is roughly the same as reading them sorted by +** the PRIMARY KEY of the corresponding target database table. In other +** words, rows should be sorted using the destination table PRIMARY KEY +** fields before they are inserted into the data_xxx tables. +** +** USAGE +** +** The API declared below allows an application to apply an RBU update +** stored on disk to an existing target database. Essentially, the +** application: +** +** 1) Opens an RBU handle using the sqlite3rbu_open() function. +** +** 2) Registers any required virtual table modules with the database +** handle returned by sqlite3rbu_db(). Also, if required, register +** the rbu_delta() implementation. +** +** 3) Calls the sqlite3rbu_step() function one or more times on +** the new handle. Each call to sqlite3rbu_step() performs a single +** b-tree operation, so thousands of calls may be required to apply +** a complete update. +** +** 4) Calls sqlite3rbu_close() to close the RBU update handle. If +** sqlite3rbu_step() has been called enough times to completely +** apply the update to the target database, then the RBU database +** is marked as fully applied. Otherwise, the state of the RBU +** update application is saved in the RBU database for later +** resumption. +** +** See comments below for more detail on APIs. +** +** If an update is only partially applied to the target database by the +** time sqlite3rbu_close() is called, various state information is saved +** within the RBU database. This allows subsequent processes to automatically +** resume the RBU update from where it left off. +** +** To remove all RBU extension state information, returning an RBU database +** to its original contents, it is sufficient to drop all tables that begin +** with the prefix "rbu_" +** +** DATABASE LOCKING +** +** An RBU update may not be applied to a database in WAL mode. Attempting +** to do so is an error (SQLITE_ERROR). +** +** While an RBU handle is open, a SHARED lock may be held on the target +** database file. This means it is possible for other clients to read the +** database, but not to write it. +** +** If an RBU update is started and then suspended before it is completed, +** then an external client writes to the database, then attempting to resume +** the suspended RBU update is also an error (SQLITE_BUSY). +*/ + +#ifndef _SQLITE3RBU_H +#define _SQLITE3RBU_H + +/* #include "sqlite3.h" ** Required for error code definitions ** */ + +#if 0 +extern "C" { +#endif + +typedef struct sqlite3rbu sqlite3rbu; + +/* +** Open an RBU handle. +** +** Argument zTarget is the path to the target database. Argument zRbu is +** the path to the RBU database. Each call to this function must be matched +** by a call to sqlite3rbu_close(). When opening the databases, RBU passes +** the SQLITE_CONFIG_URI flag to sqlite3_open_v2(). So if either zTarget +** or zRbu begin with "file:", it will be interpreted as an SQLite +** database URI, not a regular file name. +** +** If the zState argument is passed a NULL value, the RBU extension stores +** the current state of the update (how many rows have been updated, which +** indexes are yet to be updated etc.) within the RBU database itself. This +** can be convenient, as it means that the RBU application does not need to +** organize removing a separate state file after the update is concluded. +** Or, if zState is non-NULL, it must be a path to a database file in which +** the RBU extension can store the state of the update. +** +** When resuming an RBU update, the zState argument must be passed the same +** value as when the RBU update was started. +** +** Once the RBU update is finished, the RBU extension does not +** automatically remove any zState database file, even if it created it. +** +** By default, RBU uses the default VFS to access the files on disk. To +** use a VFS other than the default, an SQLite "file:" URI containing a +** "vfs=..." option may be passed as the zTarget option. +** +** IMPORTANT NOTE FOR ZIPVFS USERS: The RBU extension works with all of +** SQLite's built-in VFSs, including the multiplexor VFS. However it does +** not work out of the box with zipvfs. Refer to the comment describing +** the zipvfs_create_vfs() API below for details on using RBU with zipvfs. +*/ +SQLITE_API sqlite3rbu *SQLITE_STDCALL sqlite3rbu_open( + const char *zTarget, + const char *zRbu, + const char *zState +); + +/* +** Internally, each RBU connection uses a separate SQLite database +** connection to access the target and rbu update databases. This +** API allows the application direct access to these database handles. +** +** The first argument passed to this function must be a valid, open, RBU +** handle. The second argument should be passed zero to access the target +** database handle, or non-zero to access the rbu update database handle. +** Accessing the underlying database handles may be useful in the +** following scenarios: +** +** * If any target tables are virtual tables, it may be necessary to +** call sqlite3_create_module() on the target database handle to +** register the required virtual table implementations. +** +** * If the data_xxx tables in the RBU source database are virtual +** tables, the application may need to call sqlite3_create_module() on +** the rbu update db handle to any required virtual table +** implementations. +** +** * If the application uses the "rbu_delta()" feature described above, +** it must use sqlite3_create_function() or similar to register the +** rbu_delta() implementation with the target database handle. +** +** If an error has occurred, either while opening or stepping the RBU object, +** this function may return NULL. The error code and message may be collected +** when sqlite3rbu_close() is called. +*/ +SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3rbu_db(sqlite3rbu*, int bRbu); + +/* +** Do some work towards applying the RBU update to the target db. +** +** Return SQLITE_DONE if the update has been completely applied, or +** SQLITE_OK if no error occurs but there remains work to do to apply +** the RBU update. If an error does occur, some other error code is +** returned. +** +** Once a call to sqlite3rbu_step() has returned a value other than +** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops +** that immediately return the same value. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3rbu_step(sqlite3rbu *pRbu); + +/* +** Force RBU to save its state to disk. +** +** If a power failure or application crash occurs during an update, following +** system recovery RBU may resume the update from the point at which the state +** was last saved. In other words, from the most recent successful call to +** sqlite3rbu_close() or this function. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3rbu_savestate(sqlite3rbu *pRbu); + +/* +** Close an RBU handle. +** +** If the RBU update has been completely applied, mark the RBU database +** as fully applied. Otherwise, assuming no error has occurred, save the +** current state of the RBU update appliation to the RBU database. +** +** If an error has already occurred as part of an sqlite3rbu_step() +** or sqlite3rbu_open() call, or if one occurs within this function, an +** SQLite error code is returned. Additionally, *pzErrmsg may be set to +** point to a buffer containing a utf-8 formatted English language error +** message. It is the responsibility of the caller to eventually free any +** such buffer using sqlite3_free(). +** +** Otherwise, if no error occurs, this function returns SQLITE_OK if the +** update has been partially applied, or SQLITE_DONE if it has been +** completely applied. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3rbu_close(sqlite3rbu *pRbu, char **pzErrmsg); + +/* +** Return the total number of key-value operations (inserts, deletes or +** updates) that have been performed on the target database since the +** current RBU update was started. +*/ +SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3rbu_progress(sqlite3rbu *pRbu); + +/* +** Create an RBU VFS named zName that accesses the underlying file-system +** via existing VFS zParent. Or, if the zParent parameter is passed NULL, +** then the new RBU VFS uses the default system VFS to access the file-system. +** The new object is registered as a non-default VFS with SQLite before +** returning. +** +** Part of the RBU implementation uses a custom VFS object. Usually, this +** object is created and deleted automatically by RBU. +** +** The exception is for applications that also use zipvfs. In this case, +** the custom VFS must be explicitly created by the user before the RBU +** handle is opened. The RBU VFS should be installed so that the zipvfs +** VFS uses the RBU VFS, which in turn uses any other VFS layers in use +** (for example multiplexor) to access the file-system. For example, +** to assemble an RBU enabled VFS stack that uses both zipvfs and +** multiplexor (error checking omitted): +** +** // Create a VFS named "multiplex" (not the default). +** sqlite3_multiplex_initialize(0, 0); +** +** // Create an rbu VFS named "rbu" that uses multiplexor. If the +** // second argument were replaced with NULL, the "rbu" VFS would +** // access the file-system via the system default VFS, bypassing the +** // multiplexor. +** sqlite3rbu_create_vfs("rbu", "multiplex"); +** +** // Create a zipvfs VFS named "zipvfs" that uses rbu. +** zipvfs_create_vfs_v3("zipvfs", "rbu", 0, xCompressorAlgorithmDetector); +** +** // Make zipvfs the default VFS. +** sqlite3_vfs_register(sqlite3_vfs_find("zipvfs"), 1); +** +** Because the default VFS created above includes a RBU functionality, it +** may be used by RBU clients. Attempting to use RBU with a zipvfs VFS stack +** that does not include the RBU layer results in an error. +** +** The overhead of adding the "rbu" VFS to the system is negligible for +** non-RBU users. There is no harm in an application accessing the +** file-system via "rbu" all the time, even if it only uses RBU functionality +** occasionally. +*/ +SQLITE_API int SQLITE_STDCALL sqlite3rbu_create_vfs(const char *zName, const char *zParent); + +/* +** Deregister and destroy an RBU vfs created by an earlier call to +** sqlite3rbu_create_vfs(). +** +** VFS objects are not reference counted. If a VFS object is destroyed +** before all database handles that use it have been closed, the results +** are undefined. +*/ +SQLITE_API void SQLITE_STDCALL sqlite3rbu_destroy_vfs(const char *zName); + +#if 0 +} /* end of the 'extern "C"' block */ +#endif + +#endif /* _SQLITE3RBU_H */ + +/************** End of sqlite3rbu.h ******************************************/ +/************** Continuing where we left off in sqlite3rbu.c *****************/ + +#if defined(_WIN32_WCE) +/* #include "windows.h" */ +#endif + +/* Maximum number of prepared UPDATE statements held by this module */ +#define SQLITE_RBU_UPDATE_CACHESIZE 16 + +/* +** Swap two objects of type TYPE. +*/ +#if !defined(SQLITE_AMALGAMATION) +# define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;} +#endif + +/* +** The rbu_state table is used to save the state of a partially applied +** update so that it can be resumed later. The table consists of integer +** keys mapped to values as follows: +** +** RBU_STATE_STAGE: +** May be set to integer values 1, 2, 4 or 5. As follows: +** 1: the *-rbu file is currently under construction. +** 2: the *-rbu file has been constructed, but not yet moved +** to the *-wal path. +** 4: the checkpoint is underway. +** 5: the rbu update has been checkpointed. +** +** RBU_STATE_TBL: +** Only valid if STAGE==1. The target database name of the table +** currently being written. +** +** RBU_STATE_IDX: +** Only valid if STAGE==1. The target database name of the index +** currently being written, or NULL if the main table is currently being +** updated. +** +** RBU_STATE_ROW: +** Only valid if STAGE==1. Number of rows already processed for the current +** table/index. +** +** RBU_STATE_PROGRESS: +** Trbul number of sqlite3rbu_step() calls made so far as part of this +** rbu update. +** +** RBU_STATE_CKPT: +** Valid if STAGE==4. The 64-bit checksum associated with the wal-index +** header created by recovering the *-wal file. This is used to detect +** cases when another client appends frames to the *-wal file in the +** middle of an incremental checkpoint (an incremental checkpoint cannot +** be continued if this happens). +** +** RBU_STATE_COOKIE: +** Valid if STAGE==1. The current change-counter cookie value in the +** target db file. +** +** RBU_STATE_OALSZ: +** Valid if STAGE==1. The size in bytes of the *-oal file. +*/ +#define RBU_STATE_STAGE 1 +#define RBU_STATE_TBL 2 +#define RBU_STATE_IDX 3 +#define RBU_STATE_ROW 4 +#define RBU_STATE_PROGRESS 5 +#define RBU_STATE_CKPT 6 +#define RBU_STATE_COOKIE 7 +#define RBU_STATE_OALSZ 8 + +#define RBU_STAGE_OAL 1 +#define RBU_STAGE_MOVE 2 +#define RBU_STAGE_CAPTURE 3 +#define RBU_STAGE_CKPT 4 +#define RBU_STAGE_DONE 5 + + +#define RBU_CREATE_STATE \ + "CREATE TABLE IF NOT EXISTS %s.rbu_state(k INTEGER PRIMARY KEY, v)" + +typedef struct RbuFrame RbuFrame; +typedef struct RbuObjIter RbuObjIter; +typedef struct RbuState RbuState; +typedef struct rbu_vfs rbu_vfs; +typedef struct rbu_file rbu_file; +typedef struct RbuUpdateStmt RbuUpdateStmt; + +#if !defined(SQLITE_AMALGAMATION) +typedef unsigned int u32; +typedef unsigned char u8; +typedef sqlite3_int64 i64; +#endif + +/* +** These values must match the values defined in wal.c for the equivalent +** locks. These are not magic numbers as they are part of the SQLite file +** format. +*/ +#define WAL_LOCK_WRITE 0 +#define WAL_LOCK_CKPT 1 +#define WAL_LOCK_READ0 3 + +/* +** A structure to store values read from the rbu_state table in memory. +*/ +struct RbuState { + int eStage; + char *zTbl; + char *zIdx; + i64 iWalCksum; + int nRow; + i64 nProgress; + u32 iCookie; + i64 iOalSz; +}; + +struct RbuUpdateStmt { + char *zMask; /* Copy of update mask used with pUpdate */ + sqlite3_stmt *pUpdate; /* Last update statement (or NULL) */ + RbuUpdateStmt *pNext; +}; + +/* +** An iterator of this type is used to iterate through all objects in +** the target database that require updating. For each such table, the +** iterator visits, in order: +** +** * the table itself, +** * each index of the table (zero or more points to visit), and +** * a special "cleanup table" state. +** +** abIndexed: +** If the table has no indexes on it, abIndexed is set to NULL. Otherwise, +** it points to an array of flags nTblCol elements in size. The flag is +** set for each column that is either a part of the PK or a part of an +** index. Or clear otherwise. +** +*/ +struct RbuObjIter { + sqlite3_stmt *pTblIter; /* Iterate through tables */ + sqlite3_stmt *pIdxIter; /* Index iterator */ + int nTblCol; /* Size of azTblCol[] array */ + char **azTblCol; /* Array of unquoted target column names */ + char **azTblType; /* Array of target column types */ + int *aiSrcOrder; /* src table col -> target table col */ + u8 *abTblPk; /* Array of flags, set on target PK columns */ + u8 *abNotNull; /* Array of flags, set on NOT NULL columns */ + u8 *abIndexed; /* Array of flags, set on indexed & PK cols */ + int eType; /* Table type - an RBU_PK_XXX value */ + + /* Output variables. zTbl==0 implies EOF. */ + int bCleanup; /* True in "cleanup" state */ + const char *zTbl; /* Name of target db table */ + const char *zDataTbl; /* Name of rbu db table (or null) */ + const char *zIdx; /* Name of target db index (or null) */ + int iTnum; /* Root page of current object */ + int iPkTnum; /* If eType==EXTERNAL, root of PK index */ + int bUnique; /* Current index is unique */ + + /* Statements created by rbuObjIterPrepareAll() */ + int nCol; /* Number of columns in current object */ + sqlite3_stmt *pSelect; /* Source data */ + sqlite3_stmt *pInsert; /* Statement for INSERT operations */ + sqlite3_stmt *pDelete; /* Statement for DELETE ops */ + sqlite3_stmt *pTmpInsert; /* Insert into rbu_tmp_$zDataTbl */ + + /* Last UPDATE used (for PK b-tree updates only), or NULL. */ + RbuUpdateStmt *pRbuUpdate; +}; + +/* +** Values for RbuObjIter.eType +** +** 0: Table does not exist (error) +** 1: Table has an implicit rowid. +** 2: Table has an explicit IPK column. +** 3: Table has an external PK index. +** 4: Table is WITHOUT ROWID. +** 5: Table is a virtual table. +*/ +#define RBU_PK_NOTABLE 0 +#define RBU_PK_NONE 1 +#define RBU_PK_IPK 2 +#define RBU_PK_EXTERNAL 3 +#define RBU_PK_WITHOUT_ROWID 4 +#define RBU_PK_VTAB 5 + + +/* +** Within the RBU_STAGE_OAL stage, each call to sqlite3rbu_step() performs +** one of the following operations. +*/ +#define RBU_INSERT 1 /* Insert on a main table b-tree */ +#define RBU_DELETE 2 /* Delete a row from a main table b-tree */ +#define RBU_IDX_DELETE 3 /* Delete a row from an aux. index b-tree */ +#define RBU_IDX_INSERT 4 /* Insert on an aux. index b-tree */ +#define RBU_UPDATE 5 /* Update a row in a main table b-tree */ + + +/* +** A single step of an incremental checkpoint - frame iWalFrame of the wal +** file should be copied to page iDbPage of the database file. +*/ +struct RbuFrame { + u32 iDbPage; + u32 iWalFrame; +}; + +/* +** RBU handle. +*/ +struct sqlite3rbu { + int eStage; /* Value of RBU_STATE_STAGE field */ + sqlite3 *dbMain; /* target database handle */ + sqlite3 *dbRbu; /* rbu database handle */ + char *zTarget; /* Path to target db */ + char *zRbu; /* Path to rbu db */ + char *zState; /* Path to state db (or NULL if zRbu) */ + char zStateDb[5]; /* Db name for state ("stat" or "main") */ + int rc; /* Value returned by last rbu_step() call */ + char *zErrmsg; /* Error message if rc!=SQLITE_OK */ + int nStep; /* Rows processed for current object */ + int nProgress; /* Rows processed for all objects */ + RbuObjIter objiter; /* Iterator for skipping through tbl/idx */ + const char *zVfsName; /* Name of automatically created rbu vfs */ + rbu_file *pTargetFd; /* File handle open on target db */ + i64 iOalSz; + + /* The following state variables are used as part of the incremental + ** checkpoint stage (eStage==RBU_STAGE_CKPT). See comments surrounding + ** function rbuSetupCheckpoint() for details. */ + u32 iMaxFrame; /* Largest iWalFrame value in aFrame[] */ + u32 mLock; + int nFrame; /* Entries in aFrame[] array */ + int nFrameAlloc; /* Allocated size of aFrame[] array */ + RbuFrame *aFrame; + int pgsz; + u8 *aBuf; + i64 iWalCksum; +}; + +/* +** An rbu VFS is implemented using an instance of this structure. +*/ +struct rbu_vfs { + sqlite3_vfs base; /* rbu VFS shim methods */ + sqlite3_vfs *pRealVfs; /* Underlying VFS */ + sqlite3_mutex *mutex; /* Mutex to protect pMain */ + rbu_file *pMain; /* Linked list of main db files */ +}; + +/* +** Each file opened by an rbu VFS is represented by an instance of +** the following structure. +*/ +struct rbu_file { + sqlite3_file base; /* sqlite3_file methods */ + sqlite3_file *pReal; /* Underlying file handle */ + rbu_vfs *pRbuVfs; /* Pointer to the rbu_vfs object */ + sqlite3rbu *pRbu; /* Pointer to rbu object (rbu target only) */ + + int openFlags; /* Flags this file was opened with */ + u32 iCookie; /* Cookie value for main db files */ + u8 iWriteVer; /* "write-version" value for main db files */ + + int nShm; /* Number of entries in apShm[] array */ + char **apShm; /* Array of mmap'd *-shm regions */ + char *zDel; /* Delete this when closing file */ + + const char *zWal; /* Wal filename for this main db file */ + rbu_file *pWalFd; /* Wal file descriptor for this main db */ + rbu_file *pMainNext; /* Next MAIN_DB file */ +}; + + +/************************************************************************* +** The following three functions, found below: +** +** rbuDeltaGetInt() +** rbuDeltaChecksum() +** rbuDeltaApply() +** +** are lifted from the fossil source code (http://fossil-scm.org). They +** are used to implement the scalar SQL function rbu_fossil_delta(). +*/ + +/* +** Read bytes from *pz and convert them into a positive integer. When +** finished, leave *pz pointing to the first character past the end of +** the integer. The *pLen parameter holds the length of the string +** in *pz and is decremented once for each character in the integer. +*/ +static unsigned int rbuDeltaGetInt(const char **pz, int *pLen){ + static const signed char zValue[] = { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, 36, + -1, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, -1, -1, -1, 63, -1, + }; + unsigned int v = 0; + int c; + unsigned char *z = (unsigned char*)*pz; + unsigned char *zStart = z; + while( (c = zValue[0x7f&*(z++)])>=0 ){ + v = (v<<6) + c; + } + z--; + *pLen -= z - zStart; + *pz = (char*)z; + return v; +} + +/* +** Compute a 32-bit checksum on the N-byte buffer. Return the result. +*/ +static unsigned int rbuDeltaChecksum(const char *zIn, size_t N){ + const unsigned char *z = (const unsigned char *)zIn; + unsigned sum0 = 0; + unsigned sum1 = 0; + unsigned sum2 = 0; + unsigned sum3 = 0; + while(N >= 16){ + sum0 += ((unsigned)z[0] + z[4] + z[8] + z[12]); + sum1 += ((unsigned)z[1] + z[5] + z[9] + z[13]); + sum2 += ((unsigned)z[2] + z[6] + z[10]+ z[14]); + sum3 += ((unsigned)z[3] + z[7] + z[11]+ z[15]); + z += 16; + N -= 16; + } + while(N >= 4){ + sum0 += z[0]; + sum1 += z[1]; + sum2 += z[2]; + sum3 += z[3]; + z += 4; + N -= 4; + } + sum3 += (sum2 << 8) + (sum1 << 16) + (sum0 << 24); + switch(N){ + case 3: sum3 += (z[2] << 8); + case 2: sum3 += (z[1] << 16); + case 1: sum3 += (z[0] << 24); + default: ; + } + return sum3; +} + +/* +** Apply a delta. +** +** The output buffer should be big enough to hold the whole output +** file and a NUL terminator at the end. The delta_output_size() +** routine will determine this size for you. +** +** The delta string should be null-terminated. But the delta string +** may contain embedded NUL characters (if the input and output are +** binary files) so we also have to pass in the length of the delta in +** the lenDelta parameter. +** +** This function returns the size of the output file in bytes (excluding +** the final NUL terminator character). Except, if the delta string is +** malformed or intended for use with a source file other than zSrc, +** then this routine returns -1. +** +** Refer to the delta_create() documentation above for a description +** of the delta file format. +*/ +static int rbuDeltaApply( + const char *zSrc, /* The source or pattern file */ + int lenSrc, /* Length of the source file */ + const char *zDelta, /* Delta to apply to the pattern */ + int lenDelta, /* Length of the delta */ + char *zOut /* Write the output into this preallocated buffer */ +){ + unsigned int limit; + unsigned int total = 0; +#ifndef FOSSIL_OMIT_DELTA_CKSUM_TEST + char *zOrigOut = zOut; +#endif + + limit = rbuDeltaGetInt(&zDelta, &lenDelta); + if( *zDelta!='\n' ){ + /* ERROR: size integer not terminated by "\n" */ + return -1; + } + zDelta++; lenDelta--; + while( *zDelta && lenDelta>0 ){ + unsigned int cnt, ofst; + cnt = rbuDeltaGetInt(&zDelta, &lenDelta); + switch( zDelta[0] ){ + case '@': { + zDelta++; lenDelta--; + ofst = rbuDeltaGetInt(&zDelta, &lenDelta); + if( lenDelta>0 && zDelta[0]!=',' ){ + /* ERROR: copy command not terminated by ',' */ + return -1; + } + zDelta++; lenDelta--; + total += cnt; + if( total>limit ){ + /* ERROR: copy exceeds output file size */ + return -1; + } + if( (int)(ofst+cnt) > lenSrc ){ + /* ERROR: copy extends past end of input */ + return -1; + } + memcpy(zOut, &zSrc[ofst], cnt); + zOut += cnt; + break; + } + case ':': { + zDelta++; lenDelta--; + total += cnt; + if( total>limit ){ + /* ERROR: insert command gives an output larger than predicted */ + return -1; + } + if( (int)cnt>lenDelta ){ + /* ERROR: insert count exceeds size of delta */ + return -1; + } + memcpy(zOut, zDelta, cnt); + zOut += cnt; + zDelta += cnt; + lenDelta -= cnt; + break; + } + case ';': { + zDelta++; lenDelta--; + zOut[0] = 0; +#ifndef FOSSIL_OMIT_DELTA_CKSUM_TEST + if( cnt!=rbuDeltaChecksum(zOrigOut, total) ){ + /* ERROR: bad checksum */ + return -1; + } +#endif + if( total!=limit ){ + /* ERROR: generated size does not match predicted size */ + return -1; + } + return total; + } + default: { + /* ERROR: unknown delta operator */ + return -1; + } + } + } + /* ERROR: unterminated delta */ + return -1; +} + +static int rbuDeltaOutputSize(const char *zDelta, int lenDelta){ + int size; + size = rbuDeltaGetInt(&zDelta, &lenDelta); + if( *zDelta!='\n' ){ + /* ERROR: size integer not terminated by "\n" */ + return -1; + } + return size; +} + +/* +** End of code taken from fossil. +*************************************************************************/ + +/* +** Implementation of SQL scalar function rbu_fossil_delta(). +** +** This function applies a fossil delta patch to a blob. Exactly two +** arguments must be passed to this function. The first is the blob to +** patch and the second the patch to apply. If no error occurs, this +** function returns the patched blob. +*/ +static void rbuFossilDeltaFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *aDelta; + int nDelta; + const char *aOrig; + int nOrig; + + int nOut; + int nOut2; + char *aOut; + + assert( argc==2 ); + + nOrig = sqlite3_value_bytes(argv[0]); + aOrig = (const char*)sqlite3_value_blob(argv[0]); + nDelta = sqlite3_value_bytes(argv[1]); + aDelta = (const char*)sqlite3_value_blob(argv[1]); + + /* Figure out the size of the output */ + nOut = rbuDeltaOutputSize(aDelta, nDelta); + if( nOut<0 ){ + sqlite3_result_error(context, "corrupt fossil delta", -1); + return; + } + + aOut = sqlite3_malloc(nOut+1); + if( aOut==0 ){ + sqlite3_result_error_nomem(context); + }else{ + nOut2 = rbuDeltaApply(aOrig, nOrig, aDelta, nDelta, aOut); + if( nOut2!=nOut ){ + sqlite3_result_error(context, "corrupt fossil delta", -1); + }else{ + sqlite3_result_blob(context, aOut, nOut, sqlite3_free); + } + } +} + + +/* +** Prepare the SQL statement in buffer zSql against database handle db. +** If successful, set *ppStmt to point to the new statement and return +** SQLITE_OK. +** +** Otherwise, if an error does occur, set *ppStmt to NULL and return +** an SQLite error code. Additionally, set output variable *pzErrmsg to +** point to a buffer containing an error message. It is the responsibility +** of the caller to (eventually) free this buffer using sqlite3_free(). +*/ +static int prepareAndCollectError( + sqlite3 *db, + sqlite3_stmt **ppStmt, + char **pzErrmsg, + const char *zSql +){ + int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0); + if( rc!=SQLITE_OK ){ + *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + *ppStmt = 0; + } + return rc; +} + +/* +** Reset the SQL statement passed as the first argument. Return a copy +** of the value returned by sqlite3_reset(). +** +** If an error has occurred, then set *pzErrmsg to point to a buffer +** containing an error message. It is the responsibility of the caller +** to eventually free this buffer using sqlite3_free(). +*/ +static int resetAndCollectError(sqlite3_stmt *pStmt, char **pzErrmsg){ + int rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ){ + *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(sqlite3_db_handle(pStmt))); + } + return rc; +} + +/* +** Unless it is NULL, argument zSql points to a buffer allocated using +** sqlite3_malloc containing an SQL statement. This function prepares the SQL +** statement against database db and frees the buffer. If statement +** compilation is successful, *ppStmt is set to point to the new statement +** handle and SQLITE_OK is returned. +** +** Otherwise, if an error occurs, *ppStmt is set to NULL and an error code +** returned. In this case, *pzErrmsg may also be set to point to an error +** message. It is the responsibility of the caller to free this error message +** buffer using sqlite3_free(). +** +** If argument zSql is NULL, this function assumes that an OOM has occurred. +** In this case SQLITE_NOMEM is returned and *ppStmt set to NULL. +*/ +static int prepareFreeAndCollectError( + sqlite3 *db, + sqlite3_stmt **ppStmt, + char **pzErrmsg, + char *zSql +){ + int rc; + assert( *pzErrmsg==0 ); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + *ppStmt = 0; + }else{ + rc = prepareAndCollectError(db, ppStmt, pzErrmsg, zSql); + sqlite3_free(zSql); + } + return rc; +} + +/* +** Free the RbuObjIter.azTblCol[] and RbuObjIter.abTblPk[] arrays allocated +** by an earlier call to rbuObjIterCacheTableInfo(). +*/ +static void rbuObjIterFreeCols(RbuObjIter *pIter){ + int i; + for(i=0; inTblCol; i++){ + sqlite3_free(pIter->azTblCol[i]); + sqlite3_free(pIter->azTblType[i]); + } + sqlite3_free(pIter->azTblCol); + pIter->azTblCol = 0; + pIter->azTblType = 0; + pIter->aiSrcOrder = 0; + pIter->abTblPk = 0; + pIter->abNotNull = 0; + pIter->nTblCol = 0; + pIter->eType = 0; /* Invalid value */ +} + +/* +** Finalize all statements and free all allocations that are specific to +** the current object (table/index pair). +*/ +static void rbuObjIterClearStatements(RbuObjIter *pIter){ + RbuUpdateStmt *pUp; + + sqlite3_finalize(pIter->pSelect); + sqlite3_finalize(pIter->pInsert); + sqlite3_finalize(pIter->pDelete); + sqlite3_finalize(pIter->pTmpInsert); + pUp = pIter->pRbuUpdate; + while( pUp ){ + RbuUpdateStmt *pTmp = pUp->pNext; + sqlite3_finalize(pUp->pUpdate); + sqlite3_free(pUp); + pUp = pTmp; + } + + pIter->pSelect = 0; + pIter->pInsert = 0; + pIter->pDelete = 0; + pIter->pRbuUpdate = 0; + pIter->pTmpInsert = 0; + pIter->nCol = 0; +} + +/* +** Clean up any resources allocated as part of the iterator object passed +** as the only argument. +*/ +static void rbuObjIterFinalize(RbuObjIter *pIter){ + rbuObjIterClearStatements(pIter); + sqlite3_finalize(pIter->pTblIter); + sqlite3_finalize(pIter->pIdxIter); + rbuObjIterFreeCols(pIter); + memset(pIter, 0, sizeof(RbuObjIter)); +} + +/* +** Advance the iterator to the next position. +** +** If no error occurs, SQLITE_OK is returned and the iterator is left +** pointing to the next entry. Otherwise, an error code and message is +** left in the RBU handle passed as the first argument. A copy of the +** error code is returned. +*/ +static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){ + int rc = p->rc; + if( rc==SQLITE_OK ){ + + /* Free any SQLite statements used while processing the previous object */ + rbuObjIterClearStatements(pIter); + if( pIter->zIdx==0 ){ + rc = sqlite3_exec(p->dbMain, + "DROP TRIGGER IF EXISTS temp.rbu_insert_tr;" + "DROP TRIGGER IF EXISTS temp.rbu_update1_tr;" + "DROP TRIGGER IF EXISTS temp.rbu_update2_tr;" + "DROP TRIGGER IF EXISTS temp.rbu_delete_tr;" + , 0, 0, &p->zErrmsg + ); + } + + if( rc==SQLITE_OK ){ + if( pIter->bCleanup ){ + rbuObjIterFreeCols(pIter); + pIter->bCleanup = 0; + rc = sqlite3_step(pIter->pTblIter); + if( rc!=SQLITE_ROW ){ + rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg); + pIter->zTbl = 0; + }else{ + pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0); + pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1); + rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM; + } + }else{ + if( pIter->zIdx==0 ){ + sqlite3_stmt *pIdx = pIter->pIdxIter; + rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC); + } + if( rc==SQLITE_OK ){ + rc = sqlite3_step(pIter->pIdxIter); + if( rc!=SQLITE_ROW ){ + rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg); + pIter->bCleanup = 1; + pIter->zIdx = 0; + }else{ + pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0); + pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1); + pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2); + rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM; + } + } + } + } + } + + if( rc!=SQLITE_OK ){ + rbuObjIterFinalize(pIter); + p->rc = rc; + } + return rc; +} + + +/* +** The implementation of the rbu_target_name() SQL function. This function +** accepts one argument - the name of a table in the RBU database. If the +** table name matches the pattern: +** +** data[0-9]_ +** +** where is any sequence of 1 or more characters, is returned. +** Otherwise, if the only argument does not match the above pattern, an SQL +** NULL is returned. +** +** "data_t1" -> "t1" +** "data0123_t2" -> "t2" +** "dataAB_t3" -> NULL +*/ +static void rbuTargetNameFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zIn; + assert( argc==1 ); + + zIn = (const char*)sqlite3_value_text(argv[0]); + if( zIn && strlen(zIn)>4 && memcmp("data", zIn, 4)==0 ){ + int i; + for(i=4; zIn[i]>='0' && zIn[i]<='9'; i++); + if( zIn[i]=='_' && zIn[i+1] ){ + sqlite3_result_text(context, &zIn[i+1], -1, SQLITE_STATIC); + } + } +} + +/* +** Initialize the iterator structure passed as the second argument. +** +** If no error occurs, SQLITE_OK is returned and the iterator is left +** pointing to the first entry. Otherwise, an error code and message is +** left in the RBU handle passed as the first argument. A copy of the +** error code is returned. +*/ +static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){ + int rc; + memset(pIter, 0, sizeof(RbuObjIter)); + + rc = prepareAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg, + "SELECT rbu_target_name(name) AS target, name FROM sqlite_master " + "WHERE type IN ('table', 'view') AND target IS NOT NULL " + "ORDER BY name" + ); + + if( rc==SQLITE_OK ){ + rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg, + "SELECT name, rootpage, sql IS NULL OR substr(8, 6)=='UNIQUE' " + " FROM main.sqlite_master " + " WHERE type='index' AND tbl_name = ?" + ); + } + + pIter->bCleanup = 1; + p->rc = rc; + return rbuObjIterNext(p, pIter); +} + +/* +** This is a wrapper around "sqlite3_mprintf(zFmt, ...)". If an OOM occurs, +** an error code is stored in the RBU handle passed as the first argument. +** +** If an error has already occurred (p->rc is already set to something other +** than SQLITE_OK), then this function returns NULL without modifying the +** stored error code. In this case it still calls sqlite3_free() on any +** printf() parameters associated with %z conversions. +*/ +static char *rbuMPrintf(sqlite3rbu *p, const char *zFmt, ...){ + char *zSql = 0; + va_list ap; + va_start(ap, zFmt); + zSql = sqlite3_vmprintf(zFmt, ap); + if( p->rc==SQLITE_OK ){ + if( zSql==0 ) p->rc = SQLITE_NOMEM; + }else{ + sqlite3_free(zSql); + zSql = 0; + } + va_end(ap); + return zSql; +} + +/* +** Argument zFmt is a sqlite3_mprintf() style format string. The trailing +** arguments are the usual subsitution values. This function performs +** the printf() style substitutions and executes the result as an SQL +** statement on the RBU handles database. +** +** If an error occurs, an error code and error message is stored in the +** RBU handle. If an error has already occurred when this function is +** called, it is a no-op. +*/ +static int rbuMPrintfExec(sqlite3rbu *p, sqlite3 *db, const char *zFmt, ...){ + va_list ap; + char *zSql; + va_start(ap, zFmt); + zSql = sqlite3_vmprintf(zFmt, ap); + if( p->rc==SQLITE_OK ){ + if( zSql==0 ){ + p->rc = SQLITE_NOMEM; + }else{ + p->rc = sqlite3_exec(db, zSql, 0, 0, &p->zErrmsg); + } + } + sqlite3_free(zSql); + va_end(ap); + return p->rc; +} + +/* +** Attempt to allocate and return a pointer to a zeroed block of nByte +** bytes. +** +** If an error (i.e. an OOM condition) occurs, return NULL and leave an +** error code in the rbu handle passed as the first argument. Or, if an +** error has already occurred when this function is called, return NULL +** immediately without attempting the allocation or modifying the stored +** error code. +*/ +static void *rbuMalloc(sqlite3rbu *p, int nByte){ + void *pRet = 0; + if( p->rc==SQLITE_OK ){ + assert( nByte>0 ); + pRet = sqlite3_malloc(nByte); + if( pRet==0 ){ + p->rc = SQLITE_NOMEM; + }else{ + memset(pRet, 0, nByte); + } + } + return pRet; +} + + +/* +** Allocate and zero the pIter->azTblCol[] and abTblPk[] arrays so that +** there is room for at least nCol elements. If an OOM occurs, store an +** error code in the RBU handle passed as the first argument. +*/ +static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){ + int nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol; + char **azNew; + + azNew = (char**)rbuMalloc(p, nByte); + if( azNew ){ + pIter->azTblCol = azNew; + pIter->azTblType = &azNew[nCol]; + pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol]; + pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol]; + pIter->abNotNull = (u8*)&pIter->abTblPk[nCol]; + pIter->abIndexed = (u8*)&pIter->abNotNull[nCol]; + } +} + +/* +** The first argument must be a nul-terminated string. This function +** returns a copy of the string in memory obtained from sqlite3_malloc(). +** It is the responsibility of the caller to eventually free this memory +** using sqlite3_free(). +** +** If an OOM condition is encountered when attempting to allocate memory, +** output variable (*pRc) is set to SQLITE_NOMEM before returning. Otherwise, +** if the allocation succeeds, (*pRc) is left unchanged. +*/ +static char *rbuStrndup(const char *zStr, int *pRc){ + char *zRet = 0; + + assert( *pRc==SQLITE_OK ); + if( zStr ){ + int nCopy = strlen(zStr) + 1; + zRet = (char*)sqlite3_malloc(nCopy); + if( zRet ){ + memcpy(zRet, zStr, nCopy); + }else{ + *pRc = SQLITE_NOMEM; + } + } + + return zRet; +} + +/* +** Finalize the statement passed as the second argument. +** +** If the sqlite3_finalize() call indicates that an error occurs, and the +** rbu handle error code is not already set, set the error code and error +** message accordingly. +*/ +static void rbuFinalize(sqlite3rbu *p, sqlite3_stmt *pStmt){ + sqlite3 *db = sqlite3_db_handle(pStmt); + int rc = sqlite3_finalize(pStmt); + if( p->rc==SQLITE_OK && rc!=SQLITE_OK ){ + p->rc = rc; + p->zErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } +} + +/* Determine the type of a table. +** +** peType is of type (int*), a pointer to an output parameter of type +** (int). This call sets the output parameter as follows, depending +** on the type of the table specified by parameters dbName and zTbl. +** +** RBU_PK_NOTABLE: No such table. +** RBU_PK_NONE: Table has an implicit rowid. +** RBU_PK_IPK: Table has an explicit IPK column. +** RBU_PK_EXTERNAL: Table has an external PK index. +** RBU_PK_WITHOUT_ROWID: Table is WITHOUT ROWID. +** RBU_PK_VTAB: Table is a virtual table. +** +** Argument *piPk is also of type (int*), and also points to an output +** parameter. Unless the table has an external primary key index +** (i.e. unless *peType is set to 3), then *piPk is set to zero. Or, +** if the table does have an external primary key index, then *piPk +** is set to the root page number of the primary key index before +** returning. +** +** ALGORITHM: +** +** if( no entry exists in sqlite_master ){ +** return RBU_PK_NOTABLE +** }else if( sql for the entry starts with "CREATE VIRTUAL" ){ +** return RBU_PK_VTAB +** }else if( "PRAGMA index_list()" for the table contains a "pk" index ){ +** if( the index that is the pk exists in sqlite_master ){ +** *piPK = rootpage of that index. +** return RBU_PK_EXTERNAL +** }else{ +** return RBU_PK_WITHOUT_ROWID +** } +** }else if( "PRAGMA table_info()" lists one or more "pk" columns ){ +** return RBU_PK_IPK +** }else{ +** return RBU_PK_NONE +** } +*/ +static void rbuTableType( + sqlite3rbu *p, + const char *zTab, + int *peType, + int *piTnum, + int *piPk +){ + /* + ** 0) SELECT count(*) FROM sqlite_master where name=%Q AND IsVirtual(%Q) + ** 1) PRAGMA index_list = ? + ** 2) SELECT count(*) FROM sqlite_master where name=%Q + ** 3) PRAGMA table_info = ? + */ + sqlite3_stmt *aStmt[4] = {0, 0, 0, 0}; + + *peType = RBU_PK_NOTABLE; + *piPk = 0; + + assert( p->rc==SQLITE_OK ); + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[0], &p->zErrmsg, + sqlite3_mprintf( + "SELECT (sql LIKE 'create virtual%%'), rootpage" + " FROM sqlite_master" + " WHERE name=%Q", zTab + )); + if( p->rc!=SQLITE_OK || sqlite3_step(aStmt[0])!=SQLITE_ROW ){ + /* Either an error, or no such table. */ + goto rbuTableType_end; + } + if( sqlite3_column_int(aStmt[0], 0) ){ + *peType = RBU_PK_VTAB; /* virtual table */ + goto rbuTableType_end; + } + *piTnum = sqlite3_column_int(aStmt[0], 1); + + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[1], &p->zErrmsg, + sqlite3_mprintf("PRAGMA index_list=%Q",zTab) + ); + if( p->rc ) goto rbuTableType_end; + while( sqlite3_step(aStmt[1])==SQLITE_ROW ){ + const u8 *zOrig = sqlite3_column_text(aStmt[1], 3); + const u8 *zIdx = sqlite3_column_text(aStmt[1], 1); + if( zOrig && zIdx && zOrig[0]=='p' ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[2], &p->zErrmsg, + sqlite3_mprintf( + "SELECT rootpage FROM sqlite_master WHERE name = %Q", zIdx + )); + if( p->rc==SQLITE_OK ){ + if( sqlite3_step(aStmt[2])==SQLITE_ROW ){ + *piPk = sqlite3_column_int(aStmt[2], 0); + *peType = RBU_PK_EXTERNAL; + }else{ + *peType = RBU_PK_WITHOUT_ROWID; + } + } + goto rbuTableType_end; + } + } + + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[3], &p->zErrmsg, + sqlite3_mprintf("PRAGMA table_info=%Q",zTab) + ); + if( p->rc==SQLITE_OK ){ + while( sqlite3_step(aStmt[3])==SQLITE_ROW ){ + if( sqlite3_column_int(aStmt[3],5)>0 ){ + *peType = RBU_PK_IPK; /* explicit IPK column */ + goto rbuTableType_end; + } + } + *peType = RBU_PK_NONE; + } + +rbuTableType_end: { + unsigned int i; + for(i=0; iabIndexed[] array. +*/ +static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){ + sqlite3_stmt *pList = 0; + int bIndex = 0; + + if( p->rc==SQLITE_OK ){ + memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol); + p->rc = prepareFreeAndCollectError(p->dbMain, &pList, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl) + ); + } + + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pList) ){ + const char *zIdx = (const char*)sqlite3_column_text(pList, 1); + sqlite3_stmt *pXInfo = 0; + if( zIdx==0 ) break; + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx) + ); + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int iCid = sqlite3_column_int(pXInfo, 1); + if( iCid>=0 ) pIter->abIndexed[iCid] = 1; + } + rbuFinalize(p, pXInfo); + bIndex = 1; + } + + rbuFinalize(p, pList); + if( bIndex==0 ) pIter->abIndexed = 0; +} + + +/* +** If they are not already populated, populate the pIter->azTblCol[], +** pIter->abTblPk[], pIter->nTblCol and pIter->bRowid variables according to +** the table (not index) that the iterator currently points to. +** +** Return SQLITE_OK if successful, or an SQLite error code otherwise. If +** an error does occur, an error code and error message are also left in +** the RBU handle. +*/ +static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){ + if( pIter->azTblCol==0 ){ + sqlite3_stmt *pStmt = 0; + int nCol = 0; + int i; /* for() loop iterator variable */ + int bRbuRowid = 0; /* If input table has column "rbu_rowid" */ + int iOrder = 0; + int iTnum = 0; + + /* Figure out the type of table this step will deal with. */ + assert( pIter->eType==0 ); + rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum); + if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl); + } + if( p->rc ) return p->rc; + if( pIter->zIdx==0 ) pIter->iTnum = iTnum; + + assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK + || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID + || pIter->eType==RBU_PK_VTAB + ); + + /* Populate the azTblCol[] and nTblCol variables based on the columns + ** of the input table. Ignore any input table columns that begin with + ** "rbu_". */ + p->rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg, + sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl) + ); + if( p->rc==SQLITE_OK ){ + nCol = sqlite3_column_count(pStmt); + rbuAllocateIterArrays(p, pIter, nCol); + } + for(i=0; p->rc==SQLITE_OK && irc); + pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol; + pIter->azTblCol[pIter->nTblCol++] = zCopy; + } + else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){ + bRbuRowid = 1; + } + } + sqlite3_finalize(pStmt); + pStmt = 0; + + if( p->rc==SQLITE_OK + && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE) + ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf( + "table %q %s rbu_rowid column", pIter->zDataTbl, + (bRbuRowid ? "may not have" : "requires") + ); + } + + /* Check that all non-HIDDEN columns in the destination table are also + ** present in the input table. Populate the abTblPk[], azTblType[] and + ** aiTblOrder[] arrays at the same time. */ + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pStmt, &p->zErrmsg, + sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl) + ); + } + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + const char *zName = (const char*)sqlite3_column_text(pStmt, 1); + if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */ + for(i=iOrder; inTblCol; i++){ + if( 0==strcmp(zName, pIter->azTblCol[i]) ) break; + } + if( i==pIter->nTblCol ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("column missing from %q: %s", + pIter->zDataTbl, zName + ); + }else{ + int iPk = sqlite3_column_int(pStmt, 5); + int bNotNull = sqlite3_column_int(pStmt, 3); + const char *zType = (const char*)sqlite3_column_text(pStmt, 2); + + if( i!=iOrder ){ + SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]); + SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]); + } + + pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc); + pIter->abTblPk[iOrder] = (iPk!=0); + pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0); + iOrder++; + } + } + + rbuFinalize(p, pStmt); + rbuObjIterCacheIndexedCols(p, pIter); + assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 ); + } + + return p->rc; +} + +/* +** This function constructs and returns a pointer to a nul-terminated +** string containing some SQL clause or list based on one or more of the +** column names currently stored in the pIter->azTblCol[] array. +*/ +static char *rbuObjIterGetCollist( + sqlite3rbu *p, /* RBU object */ + RbuObjIter *pIter /* Object iterator for column names */ +){ + char *zList = 0; + const char *zSep = ""; + int i; + for(i=0; inTblCol; i++){ + const char *z = pIter->azTblCol[i]; + zList = rbuMPrintf(p, "%z%s\"%w\"", zList, zSep, z); + zSep = ", "; + } + return zList; +} + +/* +** This function is used to create a SELECT list (the list of SQL +** expressions that follows a SELECT keyword) for a SELECT statement +** used to read from an data_xxx or rbu_tmp_xxx table while updating the +** index object currently indicated by the iterator object passed as the +** second argument. A "PRAGMA index_xinfo = " statement is used +** to obtain the required information. +** +** If the index is of the following form: +** +** CREATE INDEX i1 ON t1(c, b COLLATE nocase); +** +** and "t1" is a table with an explicit INTEGER PRIMARY KEY column +** "ipk", the returned string is: +** +** "`c` COLLATE 'BINARY', `b` COLLATE 'NOCASE', `ipk` COLLATE 'BINARY'" +** +** As well as the returned string, three other malloc'd strings are +** returned via output parameters. As follows: +** +** pzImposterCols: ... +** pzImposterPk: ... +** pzWhere: ... +*/ +static char *rbuObjIterGetIndexCols( + sqlite3rbu *p, /* RBU object */ + RbuObjIter *pIter, /* Object iterator for column names */ + char **pzImposterCols, /* OUT: Columns for imposter table */ + char **pzImposterPk, /* OUT: Imposter PK clause */ + char **pzWhere, /* OUT: WHERE clause */ + int *pnBind /* OUT: Trbul number of columns */ +){ + int rc = p->rc; /* Error code */ + int rc2; /* sqlite3_finalize() return code */ + char *zRet = 0; /* String to return */ + char *zImpCols = 0; /* String to return via *pzImposterCols */ + char *zImpPK = 0; /* String to return via *pzImposterPK */ + char *zWhere = 0; /* String to return via *pzWhere */ + int nBind = 0; /* Value to return via *pnBind */ + const char *zCom = ""; /* Set to ", " later on */ + const char *zAnd = ""; /* Set to " AND " later on */ + sqlite3_stmt *pXInfo = 0; /* PRAGMA index_xinfo = ? */ + + if( rc==SQLITE_OK ){ + assert( p->zErrmsg==0 ); + rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx) + ); + } + + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int iCid = sqlite3_column_int(pXInfo, 1); + int bDesc = sqlite3_column_int(pXInfo, 3); + const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4); + const char *zCol; + const char *zType; + + if( iCid<0 ){ + /* An integer primary key. If the table has an explicit IPK, use + ** its name. Otherwise, use "rbu_rowid". */ + if( pIter->eType==RBU_PK_IPK ){ + int i; + for(i=0; pIter->abTblPk[i]==0; i++); + assert( inTblCol ); + zCol = pIter->azTblCol[i]; + }else{ + zCol = "rbu_rowid"; + } + zType = "INTEGER"; + }else{ + zCol = pIter->azTblCol[iCid]; + zType = pIter->azTblType[iCid]; + } + + zRet = sqlite3_mprintf("%z%s\"%w\" COLLATE %Q", zRet, zCom, zCol, zCollate); + if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){ + const char *zOrder = (bDesc ? " DESC" : ""); + zImpPK = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\"%s", + zImpPK, zCom, nBind, zCol, zOrder + ); + } + zImpCols = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\" %s COLLATE %Q", + zImpCols, zCom, nBind, zCol, zType, zCollate + ); + zWhere = sqlite3_mprintf( + "%z%s\"rbu_imp_%d%w\" IS ?", zWhere, zAnd, nBind, zCol + ); + if( zRet==0 || zImpPK==0 || zImpCols==0 || zWhere==0 ) rc = SQLITE_NOMEM; + zCom = ", "; + zAnd = " AND "; + nBind++; + } + + rc2 = sqlite3_finalize(pXInfo); + if( rc==SQLITE_OK ) rc = rc2; + + if( rc!=SQLITE_OK ){ + sqlite3_free(zRet); + sqlite3_free(zImpCols); + sqlite3_free(zImpPK); + sqlite3_free(zWhere); + zRet = 0; + zImpCols = 0; + zImpPK = 0; + zWhere = 0; + p->rc = rc; + } + + *pzImposterCols = zImpCols; + *pzImposterPk = zImpPK; + *pzWhere = zWhere; + *pnBind = nBind; + return zRet; +} + +/* +** Assuming the current table columns are "a", "b" and "c", and the zObj +** paramter is passed "old", return a string of the form: +** +** "old.a, old.b, old.b" +** +** With the column names escaped. +** +** For tables with implicit rowids - RBU_PK_EXTERNAL and RBU_PK_NONE, append +** the text ", old._rowid_" to the returned value. +*/ +static char *rbuObjIterGetOldlist( + sqlite3rbu *p, + RbuObjIter *pIter, + const char *zObj +){ + char *zList = 0; + if( p->rc==SQLITE_OK && pIter->abIndexed ){ + const char *zS = ""; + int i; + for(i=0; inTblCol; i++){ + if( pIter->abIndexed[i] ){ + const char *zCol = pIter->azTblCol[i]; + zList = sqlite3_mprintf("%z%s%s.\"%w\"", zList, zS, zObj, zCol); + }else{ + zList = sqlite3_mprintf("%z%sNULL", zList, zS); + } + zS = ", "; + if( zList==0 ){ + p->rc = SQLITE_NOMEM; + break; + } + } + + /* For a table with implicit rowids, append "old._rowid_" to the list. */ + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + zList = rbuMPrintf(p, "%z, %s._rowid_", zList, zObj); + } + } + return zList; +} + +/* +** Return an expression that can be used in a WHERE clause to match the +** primary key of the current table. For example, if the table is: +** +** CREATE TABLE t1(a, b, c, PRIMARY KEY(b, c)); +** +** Return the string: +** +** "b = ?1 AND c = ?2" +*/ +static char *rbuObjIterGetWhere( + sqlite3rbu *p, + RbuObjIter *pIter +){ + char *zList = 0; + if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){ + zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1); + }else if( pIter->eType==RBU_PK_EXTERNAL ){ + const char *zSep = ""; + int i; + for(i=0; inTblCol; i++){ + if( pIter->abTblPk[i] ){ + zList = rbuMPrintf(p, "%z%sc%d=?%d", zList, zSep, i, i+1); + zSep = " AND "; + } + } + zList = rbuMPrintf(p, + "_rowid_ = (SELECT id FROM rbu_imposter2 WHERE %z)", zList + ); + + }else{ + const char *zSep = ""; + int i; + for(i=0; inTblCol; i++){ + if( pIter->abTblPk[i] ){ + const char *zCol = pIter->azTblCol[i]; + zList = rbuMPrintf(p, "%z%s\"%w\"=?%d", zList, zSep, zCol, i+1); + zSep = " AND "; + } + } + } + return zList; +} + +/* +** The SELECT statement iterating through the keys for the current object +** (p->objiter.pSelect) currently points to a valid row. However, there +** is something wrong with the rbu_control value in the rbu_control value +** stored in the (p->nCol+1)'th column. Set the error code and error message +** of the RBU handle to something reflecting this. +*/ +static void rbuBadControlError(sqlite3rbu *p){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("invalid rbu_control value"); +} + + +/* +** Return a nul-terminated string containing the comma separated list of +** assignments that should be included following the "SET" keyword of +** an UPDATE statement used to update the table object that the iterator +** passed as the second argument currently points to if the rbu_control +** column of the data_xxx table entry is set to zMask. +** +** The memory for the returned string is obtained from sqlite3_malloc(). +** It is the responsibility of the caller to eventually free it using +** sqlite3_free(). +** +** If an OOM error is encountered when allocating space for the new +** string, an error code is left in the rbu handle passed as the first +** argument and NULL is returned. Or, if an error has already occurred +** when this function is called, NULL is returned immediately, without +** attempting the allocation or modifying the stored error code. +*/ +static char *rbuObjIterGetSetlist( + sqlite3rbu *p, + RbuObjIter *pIter, + const char *zMask +){ + char *zList = 0; + if( p->rc==SQLITE_OK ){ + int i; + + if( (int)strlen(zMask)!=pIter->nTblCol ){ + rbuBadControlError(p); + }else{ + const char *zSep = ""; + for(i=0; inTblCol; i++){ + char c = zMask[pIter->aiSrcOrder[i]]; + if( c=='x' ){ + zList = rbuMPrintf(p, "%z%s\"%w\"=?%d", + zList, zSep, pIter->azTblCol[i], i+1 + ); + zSep = ", "; + } + else if( c=='d' ){ + zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_delta(\"%w\", ?%d)", + zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1 + ); + zSep = ", "; + } + else if( c=='f' ){ + zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_fossil_delta(\"%w\", ?%d)", + zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1 + ); + zSep = ", "; + } + } + } + } + return zList; +} + +/* +** Return a nul-terminated string consisting of nByte comma separated +** "?" expressions. For example, if nByte is 3, return a pointer to +** a buffer containing the string "?,?,?". +** +** The memory for the returned string is obtained from sqlite3_malloc(). +** It is the responsibility of the caller to eventually free it using +** sqlite3_free(). +** +** If an OOM error is encountered when allocating space for the new +** string, an error code is left in the rbu handle passed as the first +** argument and NULL is returned. Or, if an error has already occurred +** when this function is called, NULL is returned immediately, without +** attempting the allocation or modifying the stored error code. +*/ +static char *rbuObjIterGetBindlist(sqlite3rbu *p, int nBind){ + char *zRet = 0; + int nByte = nBind*2 + 1; + + zRet = (char*)rbuMalloc(p, nByte); + if( zRet ){ + int i; + for(i=0; izIdx==0 ); + if( p->rc==SQLITE_OK ){ + const char *zSep = "PRIMARY KEY("; + sqlite3_stmt *pXList = 0; /* PRAGMA index_list = (pIter->zTbl) */ + sqlite3_stmt *pXInfo = 0; /* PRAGMA index_xinfo = */ + + p->rc = prepareFreeAndCollectError(p->dbMain, &pXList, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl) + ); + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXList) ){ + const char *zOrig = (const char*)sqlite3_column_text(pXList,3); + if( zOrig && strcmp(zOrig, "pk")==0 ){ + const char *zIdx = (const char*)sqlite3_column_text(pXList,1); + if( zIdx ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx) + ); + } + break; + } + } + rbuFinalize(p, pXList); + + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + if( sqlite3_column_int(pXInfo, 5) ){ + /* int iCid = sqlite3_column_int(pXInfo, 0); */ + const char *zCol = (const char*)sqlite3_column_text(pXInfo, 2); + const char *zDesc = sqlite3_column_int(pXInfo, 3) ? " DESC" : ""; + z = rbuMPrintf(p, "%z%s\"%w\"%s", z, zSep, zCol, zDesc); + zSep = ", "; + } + } + z = rbuMPrintf(p, "%z)", z); + rbuFinalize(p, pXInfo); + } + return z; +} + +/* +** This function creates the second imposter table used when writing to +** a table b-tree where the table has an external primary key. If the +** iterator passed as the second argument does not currently point to +** a table (not index) with an external primary key, this function is a +** no-op. +** +** Assuming the iterator does point to a table with an external PK, this +** function creates a WITHOUT ROWID imposter table named "rbu_imposter2" +** used to access that PK index. For example, if the target table is +** declared as follows: +** +** CREATE TABLE t1(a, b TEXT, c REAL, PRIMARY KEY(b, c)); +** +** then the imposter table schema is: +** +** CREATE TABLE rbu_imposter2(c1 TEXT, c2 REAL, id INTEGER) WITHOUT ROWID; +** +*/ +static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){ + if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){ + int tnum = pIter->iPkTnum; /* Root page of PK index */ + sqlite3_stmt *pQuery = 0; /* SELECT name ... WHERE rootpage = $tnum */ + const char *zIdx = 0; /* Name of PK index */ + sqlite3_stmt *pXInfo = 0; /* PRAGMA main.index_xinfo = $zIdx */ + const char *zComma = ""; + char *zCols = 0; /* Used to build up list of table cols */ + char *zPk = 0; /* Used to build up table PK declaration */ + + /* Figure out the name of the primary key index for the current table. + ** This is needed for the argument to "PRAGMA index_xinfo". Set + ** zIdx to point to a nul-terminated string containing this name. */ + p->rc = prepareAndCollectError(p->dbMain, &pQuery, &p->zErrmsg, + "SELECT name FROM sqlite_master WHERE rootpage = ?" + ); + if( p->rc==SQLITE_OK ){ + sqlite3_bind_int(pQuery, 1, tnum); + if( SQLITE_ROW==sqlite3_step(pQuery) ){ + zIdx = (const char*)sqlite3_column_text(pQuery, 0); + } + } + if( zIdx ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx) + ); + } + rbuFinalize(p, pQuery); + + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int bKey = sqlite3_column_int(pXInfo, 5); + if( bKey ){ + int iCid = sqlite3_column_int(pXInfo, 1); + int bDesc = sqlite3_column_int(pXInfo, 3); + const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4); + zCols = rbuMPrintf(p, "%z%sc%d %s COLLATE %s", zCols, zComma, + iCid, pIter->azTblType[iCid], zCollate + ); + zPk = rbuMPrintf(p, "%z%sc%d%s", zPk, zComma, iCid, bDesc?" DESC":""); + zComma = ", "; + } + } + zCols = rbuMPrintf(p, "%z, id INTEGER", zCols); + rbuFinalize(p, pXInfo); + + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum); + rbuMPrintfExec(p, p->dbMain, + "CREATE TABLE rbu_imposter2(%z, PRIMARY KEY(%z)) WITHOUT ROWID", + zCols, zPk + ); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0); + } +} + +/* +** If an error has already occurred when this function is called, it +** immediately returns zero (without doing any work). Or, if an error +** occurs during the execution of this function, it sets the error code +** in the sqlite3rbu object indicated by the first argument and returns +** zero. +** +** The iterator passed as the second argument is guaranteed to point to +** a table (not an index) when this function is called. This function +** attempts to create any imposter table required to write to the main +** table b-tree of the table before returning. Non-zero is returned if +** an imposter table are created, or zero otherwise. +** +** An imposter table is required in all cases except RBU_PK_VTAB. Only +** virtual tables are written to directly. The imposter table has the +** same schema as the actual target table (less any UNIQUE constraints). +** More precisely, the "same schema" means the same columns, types, +** collation sequences. For tables that do not have an external PRIMARY +** KEY, it also means the same PRIMARY KEY declaration. +*/ +static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){ + if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){ + int tnum = pIter->iTnum; + const char *zComma = ""; + char *zSql = 0; + int iCol; + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1); + + for(iCol=0; p->rc==SQLITE_OK && iColnTblCol; iCol++){ + const char *zPk = ""; + const char *zCol = pIter->azTblCol[iCol]; + const char *zColl = 0; + + p->rc = sqlite3_table_column_metadata( + p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0 + ); + + if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){ + /* If the target table column is an "INTEGER PRIMARY KEY", add + ** "PRIMARY KEY" to the imposter table column declaration. */ + zPk = "PRIMARY KEY "; + } + zSql = rbuMPrintf(p, "%z%s\"%w\" %s %sCOLLATE %s%s", + zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl, + (pIter->abNotNull[iCol] ? " NOT NULL" : "") + ); + zComma = ", "; + } + + if( pIter->eType==RBU_PK_WITHOUT_ROWID ){ + char *zPk = rbuWithoutRowidPK(p, pIter); + if( zPk ){ + zSql = rbuMPrintf(p, "%z, %z", zSql, zPk); + } + } + + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum); + rbuMPrintfExec(p, p->dbMain, "CREATE TABLE \"rbu_imp_%w\"(%z)%s", + pIter->zTbl, zSql, + (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "") + ); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0); + } +} + +/* +** Prepare a statement used to insert rows into the "rbu_tmp_xxx" table. +** Specifically a statement of the form: +** +** INSERT INTO rbu_tmp_xxx VALUES(?, ?, ? ...); +** +** The number of bound variables is equal to the number of columns in +** the target table, plus one (for the rbu_control column), plus one more +** (for the rbu_rowid column) if the target table is an implicit IPK or +** virtual table. +*/ +static void rbuObjIterPrepareTmpInsert( + sqlite3rbu *p, + RbuObjIter *pIter, + const char *zCollist, + const char *zRbuRowid +){ + int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE); + char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid); + if( zBind ){ + assert( pIter->pTmpInsert==0 ); + p->rc = prepareFreeAndCollectError( + p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf( + "INSERT INTO %s.'rbu_tmp_%q'(rbu_control,%s%s) VALUES(%z)", + p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind + )); + } +} + +static void rbuTmpInsertFunc( + sqlite3_context *pCtx, + int nVal, + sqlite3_value **apVal +){ + sqlite3rbu *p = sqlite3_user_data(pCtx); + int rc = SQLITE_OK; + int i; + + for(i=0; rc==SQLITE_OK && iobjiter.pTmpInsert, i+1, apVal[i]); + } + if( rc==SQLITE_OK ){ + sqlite3_step(p->objiter.pTmpInsert); + rc = sqlite3_reset(p->objiter.pTmpInsert); + } + + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(pCtx, rc); + } +} + +/* +** Ensure that the SQLite statement handles required to update the +** target database object currently indicated by the iterator passed +** as the second argument are available. +*/ +static int rbuObjIterPrepareAll( + sqlite3rbu *p, + RbuObjIter *pIter, + int nOffset /* Add "LIMIT -1 OFFSET $nOffset" to SELECT */ +){ + assert( pIter->bCleanup==0 ); + if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){ + const int tnum = pIter->iTnum; + char *zCollist = 0; /* List of indexed columns */ + char **pz = &p->zErrmsg; + const char *zIdx = pIter->zIdx; + char *zLimit = 0; + + if( nOffset ){ + zLimit = sqlite3_mprintf(" LIMIT -1 OFFSET %d", nOffset); + if( !zLimit ) p->rc = SQLITE_NOMEM; + } + + if( zIdx ){ + const char *zTbl = pIter->zTbl; + char *zImposterCols = 0; /* Columns for imposter table */ + char *zImposterPK = 0; /* Primary key declaration for imposter */ + char *zWhere = 0; /* WHERE clause on PK columns */ + char *zBind = 0; + int nBind = 0; + + assert( pIter->eType!=RBU_PK_VTAB ); + zCollist = rbuObjIterGetIndexCols( + p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind + ); + zBind = rbuObjIterGetBindlist(p, nBind); + + /* Create the imposter table used to write to this index. */ + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1,tnum); + rbuMPrintfExec(p, p->dbMain, + "CREATE TABLE \"rbu_imp_%w\"( %s, PRIMARY KEY( %s ) ) WITHOUT ROWID", + zTbl, zImposterCols, zImposterPK + ); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0); + + /* Create the statement to insert index entries */ + pIter->nCol = nBind; + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError( + p->dbMain, &pIter->pInsert, &p->zErrmsg, + sqlite3_mprintf("INSERT INTO \"rbu_imp_%w\" VALUES(%s)", zTbl, zBind) + ); + } + + /* And to delete index entries */ + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError( + p->dbMain, &pIter->pDelete, &p->zErrmsg, + sqlite3_mprintf("DELETE FROM \"rbu_imp_%w\" WHERE %s", zTbl, zWhere) + ); + } + + /* Create the SELECT statement to read keys in sorted order */ + if( p->rc==SQLITE_OK ){ + char *zSql; + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + zSql = sqlite3_mprintf( + "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' ORDER BY %s%s", + zCollist, p->zStateDb, pIter->zDataTbl, + zCollist, zLimit + ); + }else{ + zSql = sqlite3_mprintf( + "SELECT %s, rbu_control FROM '%q' " + "WHERE typeof(rbu_control)='integer' AND rbu_control!=1 " + "UNION ALL " + "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' " + "ORDER BY %s%s", + zCollist, pIter->zDataTbl, + zCollist, p->zStateDb, pIter->zDataTbl, + zCollist, zLimit + ); + } + p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz, zSql); + } + + sqlite3_free(zImposterCols); + sqlite3_free(zImposterPK); + sqlite3_free(zWhere); + sqlite3_free(zBind); + }else{ + int bRbuRowid = (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE); + const char *zTbl = pIter->zTbl; /* Table this step applies to */ + const char *zWrite; /* Imposter table name */ + + char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid); + char *zWhere = rbuObjIterGetWhere(p, pIter); + char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old"); + char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new"); + + zCollist = rbuObjIterGetCollist(p, pIter); + pIter->nCol = pIter->nTblCol; + + /* Create the imposter table or tables (if required). */ + rbuCreateImposterTable(p, pIter); + rbuCreateImposterTable2(p, pIter); + zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_"); + + /* Create the INSERT statement to write to the target PK b-tree */ + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz, + sqlite3_mprintf( + "INSERT INTO \"%s%w\"(%s%s) VALUES(%s)", + zWrite, zTbl, zCollist, (bRbuRowid ? ", _rowid_" : ""), zBindings + ) + ); + } + + /* Create the DELETE statement to write to the target PK b-tree */ + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz, + sqlite3_mprintf( + "DELETE FROM \"%s%w\" WHERE %s", zWrite, zTbl, zWhere + ) + ); + } + + if( pIter->abIndexed ){ + const char *zRbuRowid = ""; + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + zRbuRowid = ", rbu_rowid"; + } + + /* Create the rbu_tmp_xxx table and the triggers to populate it. */ + rbuMPrintfExec(p, p->dbRbu, + "CREATE TABLE IF NOT EXISTS %s.'rbu_tmp_%q' AS " + "SELECT *%s FROM '%q' WHERE 0;" + , p->zStateDb, pIter->zDataTbl + , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "") + , pIter->zDataTbl + ); + + rbuMPrintfExec(p, p->dbMain, + "CREATE TEMP TRIGGER rbu_delete_tr BEFORE DELETE ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(2, %s);" + "END;" + + "CREATE TEMP TRIGGER rbu_update1_tr BEFORE UPDATE ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(2, %s);" + "END;" + + "CREATE TEMP TRIGGER rbu_update2_tr AFTER UPDATE ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(3, %s);" + "END;", + zWrite, zTbl, zOldlist, + zWrite, zTbl, zOldlist, + zWrite, zTbl, zNewlist + ); + + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + rbuMPrintfExec(p, p->dbMain, + "CREATE TEMP TRIGGER rbu_insert_tr AFTER INSERT ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(0, %s);" + "END;", + zWrite, zTbl, zNewlist + ); + } + + rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid); + } + + /* Create the SELECT statement to read keys from data_xxx */ + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz, + sqlite3_mprintf( + "SELECT %s, rbu_control%s FROM '%q'%s", + zCollist, (bRbuRowid ? ", rbu_rowid" : ""), + pIter->zDataTbl, zLimit + ) + ); + } + + sqlite3_free(zWhere); + sqlite3_free(zOldlist); + sqlite3_free(zNewlist); + sqlite3_free(zBindings); + } + sqlite3_free(zCollist); + sqlite3_free(zLimit); + } + + return p->rc; +} + +/* +** Set output variable *ppStmt to point to an UPDATE statement that may +** be used to update the imposter table for the main table b-tree of the +** table object that pIter currently points to, assuming that the +** rbu_control column of the data_xyz table contains zMask. +** +** If the zMask string does not specify any columns to update, then this +** is not an error. Output variable *ppStmt is set to NULL in this case. +*/ +static int rbuGetUpdateStmt( + sqlite3rbu *p, /* RBU handle */ + RbuObjIter *pIter, /* Object iterator */ + const char *zMask, /* rbu_control value ('x.x.') */ + sqlite3_stmt **ppStmt /* OUT: UPDATE statement handle */ +){ + RbuUpdateStmt **pp; + RbuUpdateStmt *pUp = 0; + int nUp = 0; + + /* In case an error occurs */ + *ppStmt = 0; + + /* Search for an existing statement. If one is found, shift it to the front + ** of the LRU queue and return immediately. Otherwise, leave nUp pointing + ** to the number of statements currently in the cache and pUp to the + ** last object in the list. */ + for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){ + pUp = *pp; + if( strcmp(pUp->zMask, zMask)==0 ){ + *pp = pUp->pNext; + pUp->pNext = pIter->pRbuUpdate; + pIter->pRbuUpdate = pUp; + *ppStmt = pUp->pUpdate; + return SQLITE_OK; + } + nUp++; + } + assert( pUp==0 || pUp->pNext==0 ); + + if( nUp>=SQLITE_RBU_UPDATE_CACHESIZE ){ + for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext)); + *pp = 0; + sqlite3_finalize(pUp->pUpdate); + pUp->pUpdate = 0; + }else{ + pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1); + } + + if( pUp ){ + char *zWhere = rbuObjIterGetWhere(p, pIter); + char *zSet = rbuObjIterGetSetlist(p, pIter, zMask); + char *zUpdate = 0; + + pUp->zMask = (char*)&pUp[1]; + memcpy(pUp->zMask, zMask, pIter->nTblCol); + pUp->pNext = pIter->pRbuUpdate; + pIter->pRbuUpdate = pUp; + + if( zSet ){ + const char *zPrefix = ""; + + if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_"; + zUpdate = sqlite3_mprintf("UPDATE \"%s%w\" SET %s WHERE %s", + zPrefix, pIter->zTbl, zSet, zWhere + ); + p->rc = prepareFreeAndCollectError( + p->dbMain, &pUp->pUpdate, &p->zErrmsg, zUpdate + ); + *ppStmt = pUp->pUpdate; + } + sqlite3_free(zWhere); + sqlite3_free(zSet); + } + + return p->rc; +} + +static sqlite3 *rbuOpenDbhandle(sqlite3rbu *p, const char *zName){ + sqlite3 *db = 0; + if( p->rc==SQLITE_OK ){ + const int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_URI; + p->rc = sqlite3_open_v2(zName, &db, flags, p->zVfsName); + if( p->rc ){ + p->zErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + sqlite3_close(db); + db = 0; + } + } + return db; +} + +/* +** Open the database handle and attach the RBU database as "rbu". If an +** error occurs, leave an error code and message in the RBU handle. +*/ +static void rbuOpenDatabase(sqlite3rbu *p){ + assert( p->rc==SQLITE_OK ); + assert( p->dbMain==0 && p->dbRbu==0 ); + + p->eStage = 0; + p->dbMain = rbuOpenDbhandle(p, p->zTarget); + p->dbRbu = rbuOpenDbhandle(p, p->zRbu); + + /* If using separate RBU and state databases, attach the state database to + ** the RBU db handle now. */ + if( p->zState ){ + rbuMPrintfExec(p, p->dbRbu, "ATTACH %Q AS stat", p->zState); + memcpy(p->zStateDb, "stat", 4); + }else{ + memcpy(p->zStateDb, "main", 4); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_create_function(p->dbMain, + "rbu_tmp_insert", -1, SQLITE_UTF8, (void*)p, rbuTmpInsertFunc, 0, 0 + ); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_create_function(p->dbMain, + "rbu_fossil_delta", 2, SQLITE_UTF8, 0, rbuFossilDeltaFunc, 0, 0 + ); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_create_function(p->dbRbu, + "rbu_target_name", 1, SQLITE_UTF8, (void*)p, rbuTargetNameFunc, 0, 0 + ); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p); + } + rbuMPrintfExec(p, p->dbMain, "SELECT * FROM sqlite_master"); + + /* Mark the database file just opened as an RBU target database. If + ** this call returns SQLITE_NOTFOUND, then the RBU vfs is not in use. + ** This is an error. */ + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p); + } + + if( p->rc==SQLITE_NOTFOUND ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("rbu vfs not found"); + } +} + +/* +** This routine is a copy of the sqlite3FileSuffix3() routine from the core. +** It is a no-op unless SQLITE_ENABLE_8_3_NAMES is defined. +** +** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database +** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and +** if filename in z[] has a suffix (a.k.a. "extension") that is longer than +** three characters, then shorten the suffix on z[] to be the last three +** characters of the original suffix. +** +** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always +** do the suffix shortening regardless of URI parameter. +** +** Examples: +** +** test.db-journal => test.nal +** test.db-wal => test.wal +** test.db-shm => test.shm +** test.db-mj7f3319fa => test.9fa +*/ +static void rbuFileSuffix3(const char *zBase, char *z){ +#ifdef SQLITE_ENABLE_8_3_NAMES +#if SQLITE_ENABLE_8_3_NAMES<2 + if( sqlite3_uri_boolean(zBase, "8_3_names", 0) ) +#endif + { + int i, sz; + sz = sqlite3Strlen30(z); + for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} + if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4); + } +#endif +} + +/* +** Return the current wal-index header checksum for the target database +** as a 64-bit integer. +** +** The checksum is store in the first page of xShmMap memory as an 8-byte +** blob starting at byte offset 40. +*/ +static i64 rbuShmChecksum(sqlite3rbu *p){ + i64 iRet = 0; + if( p->rc==SQLITE_OK ){ + sqlite3_file *pDb = p->pTargetFd->pReal; + u32 volatile *ptr; + p->rc = pDb->pMethods->xShmMap(pDb, 0, 32*1024, 0, (void volatile**)&ptr); + if( p->rc==SQLITE_OK ){ + iRet = ((i64)ptr[10] << 32) + ptr[11]; + } + } + return iRet; +} + +/* +** This function is called as part of initializing or reinitializing an +** incremental checkpoint. +** +** It populates the sqlite3rbu.aFrame[] array with the set of +** (wal frame -> db page) copy operations required to checkpoint the +** current wal file, and obtains the set of shm locks required to safely +** perform the copy operations directly on the file-system. +** +** If argument pState is not NULL, then the incremental checkpoint is +** being resumed. In this case, if the checksum of the wal-index-header +** following recovery is not the same as the checksum saved in the RbuState +** object, then the rbu handle is set to DONE state. This occurs if some +** other client appends a transaction to the wal file in the middle of +** an incremental checkpoint. +*/ +static void rbuSetupCheckpoint(sqlite3rbu *p, RbuState *pState){ + + /* If pState is NULL, then the wal file may not have been opened and + ** recovered. Running a read-statement here to ensure that doing so + ** does not interfere with the "capture" process below. */ + if( pState==0 ){ + p->eStage = 0; + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_exec(p->dbMain, "SELECT * FROM sqlite_master", 0, 0, 0); + } + } + + /* Assuming no error has occurred, run a "restart" checkpoint with the + ** sqlite3rbu.eStage variable set to CAPTURE. This turns on the following + ** special behaviour in the rbu VFS: + ** + ** * If the exclusive shm WRITER or READ0 lock cannot be obtained, + ** the checkpoint fails with SQLITE_BUSY (normally SQLite would + ** proceed with running a passive checkpoint instead of failing). + ** + ** * Attempts to read from the *-wal file or write to the database file + ** do not perform any IO. Instead, the frame/page combinations that + ** would be read/written are recorded in the sqlite3rbu.aFrame[] + ** array. + ** + ** * Calls to xShmLock(UNLOCK) to release the exclusive shm WRITER, + ** READ0 and CHECKPOINT locks taken as part of the checkpoint are + ** no-ops. These locks will not be released until the connection + ** is closed. + ** + ** * Attempting to xSync() the database file causes an SQLITE_INTERNAL + ** error. + ** + ** As a result, unless an error (i.e. OOM or SQLITE_BUSY) occurs, the + ** checkpoint below fails with SQLITE_INTERNAL, and leaves the aFrame[] + ** array populated with a set of (frame -> page) mappings. Because the + ** WRITER, CHECKPOINT and READ0 locks are still held, it is safe to copy + ** data from the wal file into the database file according to the + ** contents of aFrame[]. + */ + if( p->rc==SQLITE_OK ){ + int rc2; + p->eStage = RBU_STAGE_CAPTURE; + rc2 = sqlite3_exec(p->dbMain, "PRAGMA main.wal_checkpoint=restart", 0, 0,0); + if( rc2!=SQLITE_INTERNAL ) p->rc = rc2; + } + + if( p->rc==SQLITE_OK ){ + p->eStage = RBU_STAGE_CKPT; + p->nStep = (pState ? pState->nRow : 0); + p->aBuf = rbuMalloc(p, p->pgsz); + p->iWalCksum = rbuShmChecksum(p); + } + + if( p->rc==SQLITE_OK && pState && pState->iWalCksum!=p->iWalCksum ){ + p->rc = SQLITE_DONE; + p->eStage = RBU_STAGE_DONE; + } +} + +/* +** Called when iAmt bytes are read from offset iOff of the wal file while +** the rbu object is in capture mode. Record the frame number of the frame +** being read in the aFrame[] array. +*/ +static int rbuCaptureWalRead(sqlite3rbu *pRbu, i64 iOff, int iAmt){ + const u32 mReq = (1<mLock!=mReq ){ + pRbu->rc = SQLITE_BUSY; + return SQLITE_INTERNAL; + } + + pRbu->pgsz = iAmt; + if( pRbu->nFrame==pRbu->nFrameAlloc ){ + int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2; + RbuFrame *aNew; + aNew = (RbuFrame*)sqlite3_realloc(pRbu->aFrame, nNew * sizeof(RbuFrame)); + if( aNew==0 ) return SQLITE_NOMEM; + pRbu->aFrame = aNew; + pRbu->nFrameAlloc = nNew; + } + + iFrame = (u32)((iOff-32) / (i64)(iAmt+24)) + 1; + if( pRbu->iMaxFrame

    • #QN2OZ4?E+IyhVHrU* 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