From 670d8d5263cb9fa4bb557a01b1de97d54a1b1f2e Mon Sep 17 00:00:00 2001 From: Michael Heimpold Date: Wed, 25 Jul 2012 20:51:49 +0000 Subject: [PATCH] [packages] php5: add sqlite extension This extension was dropped with the release 5.4 of php and there is a reference to a pecl module in the changelog. However, the pecl module doesn't exist (yet) so this is a 'backport' of the latest sqlite extension of php's 5.3 branch. This is not tested completely. Signed-off-by: Michael Heimpold SVN-Revision: 32877 --- lang/php5/patches/090-restore-sqlite2.patch | 50845 ++++++++++++++++++ lang/php5/patches/091-fix-sqlite2.patch | 101 + 2 files changed, 50946 insertions(+) create mode 100644 lang/php5/patches/090-restore-sqlite2.patch create mode 100644 lang/php5/patches/091-fix-sqlite2.patch diff --git a/lang/php5/patches/090-restore-sqlite2.patch b/lang/php5/patches/090-restore-sqlite2.patch new file mode 100644 index 0000000000..27bcec5c6e --- /dev/null +++ b/lang/php5/patches/090-restore-sqlite2.patch @@ -0,0 +1,50845 @@ +--- /dev/null ++++ b/ext/sqlite/config.m4 +@@ -0,0 +1,157 @@ ++dnl $Id$ ++dnl config.m4 for extension sqlite ++dnl vim:et:ts=2:sw=2 ++ ++PHP_ARG_WITH(sqlite, for sqlite support, ++[ --without-sqlite=DIR Do not include sqlite support. DIR is the sqlite base ++ install directory [BUNDLED]], yes) ++ ++PHP_ARG_ENABLE(sqlite-utf8, whether to enable UTF-8 support in sqlite (default: ISO-8859-1), ++[ --enable-sqlite-utf8 SQLite: Enable UTF-8 support for SQLite], no, no) ++ ++ ++ ++dnl ++dnl PHP_PROG_LEMON ++dnl ++dnl Search for lemon binary and check its version ++dnl ++AC_DEFUN([PHP_PROG_LEMON],[ ++ # we only support certain lemon versions ++ lemon_version_list="1.0" ++ ++ AC_CHECK_PROG(LEMON, lemon, lemon) ++ if test "$LEMON"; then ++ AC_CACHE_CHECK([for lemon version], php_cv_lemon_version, [ ++ lemon_version=`$LEMON -x 2>/dev/null | $SED -e 's/^.* //'` ++ php_cv_lemon_version=invalid ++ for lemon_check_version in $lemon_version_list; do ++ if test "$lemon_version" = "$lemon_check_version"; then ++ php_cv_lemon_version="$lemon_check_version (ok)" ++ fi ++ done ++ ]) ++ else ++ lemon_version=none ++ fi ++ case $php_cv_lemon_version in ++ ""|invalid[)] ++ lemon_msg="lemon versions supported for regeneration of libsqlite parsers: $lemon_version_list (found: $lemon_version)." ++ AC_MSG_WARN([$lemon_msg]) ++ LEMON="exit 0;" ++ ;; ++ esac ++ PHP_SUBST(LEMON) ++]) ++ ++ ++if test "$PHP_SQLITE" != "no"; then ++ if test "$PHP_PDO" != "no"; then ++ PHP_CHECK_PDO_INCLUDES([], [AC_MSG_WARN([Cannot find php_pdo_driver.h.])]) ++ if test -n "$pdo_inc_path"; then ++ AC_DEFINE([PHP_SQLITE2_HAVE_PDO], [1], [Have PDO]) ++ pdo_inc_path="-I$pdo_inc_path" ++ fi ++ fi ++ ++ if test "$PHP_SQLITE" != "yes"; then ++ SEARCH_PATH="/usr/local /usr" ++ SEARCH_FOR="/include/sqlite.h" ++ if test -r $PHP_SQLITE/; then # path given as parameter ++ SQLITE_DIR=$PHP_SQLITE ++ else # search default path list ++ AC_MSG_CHECKING([for sqlite files in default path]) ++ for i in $SEARCH_PATH ; do ++ if test -r $i/$SEARCH_FOR; then ++ SQLITE_DIR=$i ++ AC_MSG_RESULT(found in $i) ++ fi ++ done ++ fi ++ ++ if test -z "$SQLITE_DIR"; then ++ AC_MSG_RESULT([not found]) ++ AC_MSG_ERROR([Please reinstall the sqlite distribution from http://www.sqlite.org]) ++ fi ++ ++ PHP_CHECK_LIBRARY(sqlite, sqlite_open, [ ++ PHP_ADD_LIBRARY_WITH_PATH(sqlite, $SQLITE_DIR/$PHP_LIBDIR, SQLITE_SHARED_LIBADD) ++ PHP_ADD_INCLUDE($SQLITE_DIR/include) ++ ],[ ++ AC_MSG_ERROR([wrong sqlite lib version or lib not found]) ++ ],[ ++ -L$SQLITE_DIR/$PHP_LIBDIR -lm ++ ]) ++ SQLITE_MODULE_TYPE=external ++ PHP_SQLITE_CFLAGS=$pdo_inc_path ++ sqlite_extra_sources="libsqlite/src/encode.c" ++ else ++ # use bundled library ++ PHP_PROG_LEMON ++ SQLITE_MODULE_TYPE=builtin ++ PHP_SQLITE_CFLAGS="-I@ext_srcdir@/libsqlite/src -I@ext_builddir@/libsqlite/src $pdo_inc_path" ++ sqlite_extra_sources="libsqlite/src/opcodes.c \ ++ libsqlite/src/parse.c libsqlite/src/encode.c \ ++ libsqlite/src/auth.c libsqlite/src/btree.c libsqlite/src/build.c \ ++ libsqlite/src/delete.c libsqlite/src/expr.c libsqlite/src/func.c \ ++ libsqlite/src/hash.c libsqlite/src/insert.c libsqlite/src/main.c \ ++ libsqlite/src/os.c libsqlite/src/pager.c \ ++ libsqlite/src/printf.c libsqlite/src/random.c \ ++ libsqlite/src/select.c libsqlite/src/table.c libsqlite/src/tokenize.c \ ++ libsqlite/src/update.c libsqlite/src/util.c libsqlite/src/vdbe.c \ ++ libsqlite/src/attach.c libsqlite/src/btree_rb.c libsqlite/src/pragma.c \ ++ libsqlite/src/vacuum.c libsqlite/src/copy.c \ ++ libsqlite/src/vdbeaux.c libsqlite/src/date.c \ ++ libsqlite/src/where.c libsqlite/src/trigger.c" ++ fi ++ dnl ++ dnl Common for both bundled/external ++ dnl ++ sqlite_sources="sqlite.c sess_sqlite.c pdo_sqlite2.c $sqlite_extra_sources" ++ PHP_NEW_EXTENSION(sqlite, $sqlite_sources, $ext_shared,,$PHP_SQLITE_CFLAGS) ++ PHP_ADD_EXTENSION_DEP(sqlite, spl, true) ++ PHP_ADD_EXTENSION_DEP(sqlite, pdo, true) ++ ++ PHP_ADD_MAKEFILE_FRAGMENT ++ PHP_SUBST(SQLITE_SHARED_LIBADD) ++ PHP_INSTALL_HEADERS([$ext_builddir/libsqlite/src/sqlite.h]) ++ ++ if test "$SQLITE_MODULE_TYPE" = "builtin"; then ++ PHP_ADD_BUILD_DIR($ext_builddir/libsqlite/src, 1) ++ AC_CHECK_SIZEOF(char *, 4) ++ AC_DEFINE(SQLITE_PTR_SZ, SIZEOF_CHAR_P, [Size of a pointer]) ++ dnl use latin 1 for SQLite older than 2.8.9; the utf-8 handling ++ dnl in funcs.c uses assert(), which is a bit silly and something ++ dnl we want to avoid. This assert() was removed in SQLite 2.8.9. ++ if test "$PHP_SQLITE_UTF8" = "yes"; then ++ SQLITE_ENCODING="UTF8" ++ AC_DEFINE(SQLITE_UTF8, 1, [ ]) ++ else ++ SQLITE_ENCODING="ISO8859" ++ fi ++ PHP_SUBST(SQLITE_ENCODING) ++ ++ SQLITE_VERSION=`cat $ext_srcdir/libsqlite/VERSION` ++ PHP_SUBST(SQLITE_VERSION) ++ ++ sed -e s/--VERS--/$SQLITE_VERSION/ -e s/--ENCODING--/$SQLITE_ENCODING/ $ext_srcdir/libsqlite/src/sqlite.h.in > $ext_builddir/libsqlite/src/sqlite.h ++ ++ if test "$ext_shared" = "no" || test "$ext_srcdir" != "$abs_srcdir"; then ++ echo '#include ' > $ext_builddir/libsqlite/src/config.h ++ else ++ echo "#include \"$abs_builddir/config.h\"" > $ext_builddir/libsqlite/src/config.h ++ fi ++ ++ cat >> $ext_builddir/libsqlite/src/config.h <explain ) return; ++ db = pParse->db; ++ if( db->file_format<4 ){ ++ sqliteErrorMsg(pParse, "cannot attach auxiliary databases to an " ++ "older format master database", 0); ++ pParse->rc = SQLITE_ERROR; ++ return; ++ } ++ if( db->nDb>=MAX_ATTACHED+2 ){ ++ sqliteErrorMsg(pParse, "too many attached databases - max %d", ++ MAX_ATTACHED); ++ pParse->rc = SQLITE_ERROR; ++ return; ++ } ++ ++ zFile = 0; ++ sqliteSetNString(&zFile, pFilename->z, pFilename->n, 0); ++ if( zFile==0 ) return; ++ sqliteDequote(zFile); ++#ifndef SQLITE_OMIT_AUTHORIZATION ++ if( sqliteAuthCheck(pParse, SQLITE_ATTACH, zFile, 0, 0)!=SQLITE_OK ){ ++ sqliteFree(zFile); ++ return; ++ } ++#endif /* SQLITE_OMIT_AUTHORIZATION */ ++ ++ zName = 0; ++ sqliteSetNString(&zName, pDbname->z, pDbname->n, 0); ++ if( zName==0 ) return; ++ sqliteDequote(zName); ++ for(i=0; inDb; i++){ ++ if( db->aDb[i].zName && sqliteStrICmp(db->aDb[i].zName, zName)==0 ){ ++ sqliteErrorMsg(pParse, "database %z is already in use", zName); ++ pParse->rc = SQLITE_ERROR; ++ sqliteFree(zFile); ++ return; ++ } ++ } ++ ++ if( db->aDb==db->aDbStatic ){ ++ aNew = sqliteMalloc( sizeof(db->aDb[0])*3 ); ++ if( aNew==0 ) return; ++ memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2); ++ }else{ ++ aNew = sqliteRealloc(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)); ++ sqliteHashInit(&aNew->tblHash, SQLITE_HASH_STRING, 0); ++ sqliteHashInit(&aNew->idxHash, SQLITE_HASH_STRING, 0); ++ sqliteHashInit(&aNew->trigHash, SQLITE_HASH_STRING, 0); ++ sqliteHashInit(&aNew->aFKey, SQLITE_HASH_STRING, 1); ++ aNew->zName = zName; ++ rc = sqliteBtreeFactory(db, zFile, 0, MAX_PAGES, &aNew->pBt); ++ if( rc ){ ++ sqliteErrorMsg(pParse, "unable to open database: %s", zFile); ++ } ++#if SQLITE_HAS_CODEC ++ { ++ extern int sqliteCodecAttach(sqlite*, int, void*, int); ++ char *zKey = 0; ++ int nKey; ++ if( pKey && pKey->z && pKey->n ){ ++ sqliteSetNString(&zKey, pKey->z, pKey->n, 0); ++ sqliteDequote(zKey); ++ nKey = strlen(zKey); ++ }else{ ++ zKey = 0; ++ nKey = 0; ++ } ++ sqliteCodecAttach(db, db->nDb-1, zKey, nKey); ++ } ++#endif ++ sqliteFree(zFile); ++ db->flags &= ~SQLITE_Initialized; ++ if( pParse->nErr ) return; ++ if( rc==SQLITE_OK ){ ++ rc = sqliteInit(pParse->db, &pParse->zErrMsg); ++ } ++ if( rc ){ ++ int i = db->nDb - 1; ++ assert( i>=2 ); ++ if( db->aDb[i].pBt ){ ++ sqliteBtreeClose(db->aDb[i].pBt); ++ db->aDb[i].pBt = 0; ++ } ++ sqliteResetInternalSchema(db, 0); ++ pParse->nErr++; ++ pParse->rc = SQLITE_ERROR; ++ } ++} ++ ++/* ++** This routine is called by the parser to process a DETACH statement: ++** ++** DETACH DATABASE dbname ++** ++** The pDbname argument is the name of the database in the DETACH statement. ++*/ ++void sqliteDetach(Parse *pParse, Token *pDbname){ ++ int i; ++ sqlite *db; ++ Vdbe *v; ++ Db *pDb; ++ ++ v = sqliteGetVdbe(pParse); ++ sqliteVdbeAddOp(v, OP_Halt, 0, 0); ++ if( pParse->explain ) return; ++ db = pParse->db; ++ for(i=0; inDb; i++){ ++ pDb = &db->aDb[i]; ++ if( pDb->pBt==0 || pDb->zName==0 ) continue; ++ if( strlen(pDb->zName)!=pDbname->n ) continue; ++ if( sqliteStrNICmp(pDb->zName, pDbname->z, pDbname->n)==0 ) break; ++ } ++ if( i>=db->nDb ){ ++ sqliteErrorMsg(pParse, "no such database: %T", pDbname); ++ return; ++ } ++ if( i<2 ){ ++ sqliteErrorMsg(pParse, "cannot detach database %T", pDbname); ++ return; ++ } ++#ifndef SQLITE_OMIT_AUTHORIZATION ++ if( sqliteAuthCheck(pParse,SQLITE_DETACH,db->aDb[i].zName,0,0)!=SQLITE_OK ){ ++ return; ++ } ++#endif /* SQLITE_OMIT_AUTHORIZATION */ ++ sqliteBtreeClose(pDb->pBt); ++ pDb->pBt = 0; ++ sqliteFree(pDb->zName); ++ sqliteResetInternalSchema(db, i); ++ if( pDb->pAux && pDb->xFreeAux ) pDb->xFreeAux(pDb->pAux); ++ db->nDb--; ++ if( inDb ){ ++ db->aDb[i] = db->aDb[db->nDb]; ++ memset(&db->aDb[db->nDb], 0, sizeof(db->aDb[0])); ++ sqliteResetInternalSchema(db, i); ++ } ++} ++ ++/* ++** Initialize a DbFixer structure. This routine must be called prior ++** to passing the structure to one of the sqliteFixAAAA() routines below. ++** ++** The return value indicates whether or not fixation is required. TRUE ++** means we do need to fix the database references, FALSE means we do not. ++*/ ++int sqliteFixInit( ++ DbFixer *pFix, /* The fixer to be initialized */ ++ Parse *pParse, /* Error messages will be written here */ ++ int iDb, /* This is the database that must must be used */ ++ const char *zType, /* "view", "trigger", or "index" */ ++ const Token *pName /* Name of the view, trigger, or index */ ++){ ++ sqlite *db; ++ ++ if( iDb<0 || iDb==1 ) return 0; ++ db = pParse->db; ++ assert( db->nDb>iDb ); ++ pFix->pParse = pParse; ++ pFix->zDb = db->aDb[iDb].zName; ++ pFix->zType = zType; ++ pFix->pName = pName; ++ return 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 sqliteFixInit(). ++** ++** 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. ++*/ ++int sqliteFixSrcList( ++ DbFixer *pFix, /* Context of the fixation */ ++ SrcList *pList /* The Source list to check and modify */ ++){ ++ int i; ++ const char *zDb; ++ ++ if( pList==0 ) return 0; ++ zDb = pFix->zDb; ++ for(i=0; inSrc; i++){ ++ if( pList->a[i].zDatabase==0 ){ ++ pList->a[i].zDatabase = sqliteStrDup(zDb); ++ }else if( sqliteStrICmp(pList->a[i].zDatabase,zDb)!=0 ){ ++ sqliteErrorMsg(pFix->pParse, ++ "%s %z cannot reference objects in database %s", ++ pFix->zType, sqliteStrNDup(pFix->pName->z, pFix->pName->n), ++ pList->a[i].zDatabase); ++ return 1; ++ } ++ if( sqliteFixSelect(pFix, pList->a[i].pSelect) ) return 1; ++ if( sqliteFixExpr(pFix, pList->a[i].pOn) ) return 1; ++ } ++ return 0; ++} ++int sqliteFixSelect( ++ DbFixer *pFix, /* Context of the fixation */ ++ Select *pSelect /* The SELECT statement to be fixed to one database */ ++){ ++ while( pSelect ){ ++ if( sqliteFixExprList(pFix, pSelect->pEList) ){ ++ return 1; ++ } ++ if( sqliteFixSrcList(pFix, pSelect->pSrc) ){ ++ return 1; ++ } ++ if( sqliteFixExpr(pFix, pSelect->pWhere) ){ ++ return 1; ++ } ++ if( sqliteFixExpr(pFix, pSelect->pHaving) ){ ++ return 1; ++ } ++ pSelect = pSelect->pPrior; ++ } ++ return 0; ++} ++int sqliteFixExpr( ++ DbFixer *pFix, /* Context of the fixation */ ++ Expr *pExpr /* The expression to be fixed to one database */ ++){ ++ while( pExpr ){ ++ if( sqliteFixSelect(pFix, pExpr->pSelect) ){ ++ return 1; ++ } ++ if( sqliteFixExprList(pFix, pExpr->pList) ){ ++ return 1; ++ } ++ if( sqliteFixExpr(pFix, pExpr->pRight) ){ ++ return 1; ++ } ++ pExpr = pExpr->pLeft; ++ } ++ return 0; ++} ++int sqliteFixExprList( ++ DbFixer *pFix, /* Context of the fixation */ ++ ExprList *pList /* The expression to be fixed to one database */ ++){ ++ int i; ++ if( pList==0 ) return 0; ++ for(i=0; inExpr; i++){ ++ if( sqliteFixExpr(pFix, pList->a[i].pExpr) ){ ++ return 1; ++ } ++ } ++ return 0; ++} ++int sqliteFixTriggerStep( ++ DbFixer *pFix, /* Context of the fixation */ ++ TriggerStep *pStep /* The trigger step be fixed to one database */ ++){ ++ while( pStep ){ ++ if( sqliteFixSelect(pFix, pStep->pSelect) ){ ++ return 1; ++ } ++ if( sqliteFixExpr(pFix, pStep->pWhere) ){ ++ return 1; ++ } ++ if( sqliteFixExprList(pFix, pStep->pExprList) ){ ++ return 1; ++ } ++ pStep = pStep->pNext; ++ } ++ return 0; ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/auth.c +@@ -0,0 +1,219 @@ ++/* ++** 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 sqlite_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 ++** ++** $Id$ ++*/ ++#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_COPY ++** 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 sqlite_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. ++*/ ++int sqlite_set_authorizer( ++ sqlite *db, ++ int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), ++ void *pArg ++){ ++ db->xAuth = xAuth; ++ db->pAuthArg = pArg; ++ 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, int rc){ ++ sqliteErrorMsg(pParse, "illegal return value (%d) from the " ++ "authorization function - should be SQLITE_OK, SQLITE_IGNORE, " ++ "or SQLITE_DENY", rc); ++ pParse->rc = SQLITE_MISUSE; ++} ++ ++/* ++** 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. ++*/ ++void sqliteAuthRead( ++ Parse *pParse, /* The parser context */ ++ Expr *pExpr, /* The expression to check authorization on */ ++ SrcList *pTabList /* All table that pExpr might refer to */ ++){ ++ sqlite *db = pParse->db; ++ int rc; ++ Table *pTab; /* The table being read */ ++ const char *zCol; /* Name of the column of the table */ ++ int iSrc; /* Index in pTabList->a[] of table being read */ ++ const char *zDBase; /* Name of database being accessed */ ++ TriggerStack *pStack; /* The stack of current triggers */ ++ ++ if( db->xAuth==0 ) return; ++ assert( pExpr->op==TK_COLUMN ); ++ for(iSrc=0; iSrcnSrc; iSrc++){ ++ if( pExpr->iTable==pTabList->a[iSrc].iCursor ) break; ++ } ++ if( iSrc>=0 && iSrcnSrc ){ ++ pTab = pTabList->a[iSrc].pTab; ++ }else if( (pStack = pParse->trigStack)!=0 ){ ++ /* This must be an attempt to read the NEW or OLD pseudo-tables ++ ** of a trigger. ++ */ ++ assert( pExpr->iTable==pStack->newIdx || pExpr->iTable==pStack->oldIdx ); ++ pTab = pStack->pTab; ++ }else{ ++ return; ++ } ++ if( pTab==0 ) return; ++ if( pExpr->iColumn>=0 ){ ++ assert( pExpr->iColumnnCol ); ++ zCol = pTab->aCol[pExpr->iColumn].zName; ++ }else if( pTab->iPKey>=0 ){ ++ assert( pTab->iPKeynCol ); ++ zCol = pTab->aCol[pTab->iPKey].zName; ++ }else{ ++ zCol = "ROWID"; ++ } ++ assert( pExpr->iDbnDb ); ++ zDBase = db->aDb[pExpr->iDb].zName; ++ rc = db->xAuth(db->pAuthArg, SQLITE_READ, pTab->zName, zCol, zDBase, ++ pParse->zAuthContext); ++ if( rc==SQLITE_IGNORE ){ ++ pExpr->op = TK_NULL; ++ }else if( rc==SQLITE_DENY ){ ++ if( db->nDb>2 || pExpr->iDb!=0 ){ ++ sqliteErrorMsg(pParse, "access to %s.%s.%s is prohibited", ++ zDBase, pTab->zName, zCol); ++ }else{ ++ sqliteErrorMsg(pParse, "access to %s.%s is prohibited", pTab->zName,zCol); ++ } ++ pParse->rc = SQLITE_AUTH; ++ }else if( rc!=SQLITE_OK ){ ++ sqliteAuthBadReturnCode(pParse, rc); ++ } ++} ++ ++/* ++** 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. ++*/ ++int sqliteAuthCheck( ++ Parse *pParse, ++ int code, ++ const char *zArg1, ++ const char *zArg2, ++ const char *zArg3 ++){ ++ sqlite *db = pParse->db; ++ int rc; ++ ++ if( db->init.busy || db->xAuth==0 ){ ++ return SQLITE_OK; ++ } ++ rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext); ++ if( rc==SQLITE_DENY ){ ++ sqliteErrorMsg(pParse, "not authorized"); ++ pParse->rc = SQLITE_AUTH; ++ }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){ ++ rc = SQLITE_DENY; ++ sqliteAuthBadReturnCode(pParse, rc); ++ } ++ 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. ++*/ ++void sqliteAuthContextPush( ++ Parse *pParse, ++ AuthContext *pContext, ++ const char *zContext ++){ ++ pContext->pParse = pParse; ++ if( pParse ){ ++ pContext->zAuthContext = pParse->zAuthContext; ++ pParse->zAuthContext = zContext; ++ } ++} ++ ++/* ++** Pop an authorization context that was previously pushed ++** by sqliteAuthContextPush ++*/ ++void sqliteAuthContextPop(AuthContext *pContext){ ++ if( pContext->pParse ){ ++ pContext->pParse->zAuthContext = pContext->zAuthContext; ++ pContext->pParse = 0; ++ } ++} ++ ++#endif /* SQLITE_OMIT_AUTHORIZATION */ +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/btree.c +@@ -0,0 +1,3584 @@ ++/* ++** 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. ++** ++************************************************************************* ++** $Id$ ++** ++** This file implements a 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) | Ptr(N+1) | ++** ---------------------------------------------------------------- ++** ++** 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+1) and its subpages have values greater than Key(N). 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". Up to ++** MX_LOCAL_PAYLOAD bytes of payload can be carried directly on the ++** database page. If the payload is larger than MX_LOCAL_PAYLOAD bytes ++** 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+1) pointer. ++** ++** The first page of the file contains a magic string used to verify that ++** the file really is a valid BTree database, a pointer to a list of unused ++** pages in the file, and some meta information. The root of the first ++** BTree begins on page 2 of the file. (Pages are numbered beginning with ++** 1, not 0.) Thus a minimum database contains 2 pages. ++*/ ++#include "sqliteInt.h" ++#include "pager.h" ++#include "btree.h" ++#include ++ ++/* Forward declarations */ ++static BtOps sqliteBtreeOps; ++static BtCursorOps sqliteBtreeCursorOps; ++ ++/* ++** Macros used for byteswapping. B is a pointer to the Btree ++** structure. This is needed to access the Btree.needSwab boolean ++** in order to tell if byte swapping is needed or not. ++** X is an unsigned integer. SWAB16 byte swaps a 16-bit integer. ++** SWAB32 byteswaps a 32-bit integer. ++*/ ++#define SWAB16(B,X) ((B)->needSwab? swab16((u16)X) : ((u16)X)) ++#define SWAB32(B,X) ((B)->needSwab? swab32(X) : (X)) ++#define SWAB_ADD(B,X,A) \ ++ if((B)->needSwab){ X=swab32(swab32(X)+A); }else{ X += (A); } ++ ++/* ++** The following global variable - available only if SQLITE_TEST is ++** defined - is used to determine whether new databases are created in ++** native byte order or in non-native byte order. Non-native byte order ++** databases are created for testing purposes only. Under normal operation, ++** only native byte-order databases should be created, but we should be ++** able to read or write existing databases regardless of the byteorder. ++*/ ++#ifdef SQLITE_TEST ++int btree_native_byte_order = 1; ++#else ++# define btree_native_byte_order 1 ++#endif ++ ++/* ++** Forward declarations of structures used only in this file. ++*/ ++typedef struct PageOne PageOne; ++typedef struct MemPage MemPage; ++typedef struct PageHdr PageHdr; ++typedef struct Cell Cell; ++typedef struct CellHdr CellHdr; ++typedef struct FreeBlk FreeBlk; ++typedef struct OverflowPage OverflowPage; ++typedef struct FreelistInfo FreelistInfo; ++ ++/* ++** All structures on a database page are aligned to 4-byte boundries. ++** This routine rounds up a number of bytes to the next multiple of 4. ++** ++** This might need to change for computer architectures that require ++** and 8-byte alignment boundry for structures. ++*/ ++#define ROUNDUP(X) ((X+3) & ~3) ++ ++/* ++** This is a magic string that appears at the beginning of every ++** SQLite database in order to identify the file as a real database. ++*/ ++static const char zMagicHeader[] = ++ "** This file contains an SQLite 2.1 database **"; ++#define MAGIC_SIZE (sizeof(zMagicHeader)) ++ ++/* ++** This is a magic integer also used to test the integrity of the database ++** file. This integer is used in addition to the string above so that ++** if the file is written on a little-endian architecture and read ++** on a big-endian architectures (or vice versa) we can detect the ++** problem. ++** ++** The number used was obtained at random and has no special ++** significance other than the fact that it represents a different ++** integer on little-endian and big-endian machines. ++*/ ++#define MAGIC 0xdae37528 ++ ++/* ++** The first page of the database file contains a magic header string ++** to identify the file as an SQLite database file. It also contains ++** a pointer to the first free page of the file. Page 2 contains the ++** root of the principle BTree. The file might contain other BTrees ++** rooted on pages above 2. ++** ++** The first page also contains SQLITE_N_BTREE_META integers that ++** can be used by higher-level routines. ++** ++** Remember that pages are numbered beginning with 1. (See pager.c ++** for additional information.) Page 0 does not exist and a page ++** number of 0 is used to mean "no such page". ++*/ ++struct PageOne { ++ char zMagic[MAGIC_SIZE]; /* String that identifies the file as a database */ ++ int iMagic; /* Integer to verify correct byte order */ ++ Pgno freeList; /* First free page in a list of all free pages */ ++ int nFree; /* Number of pages on the free list */ ++ int aMeta[SQLITE_N_BTREE_META-1]; /* User defined integers */ ++}; ++ ++/* ++** Each database page has a header that is an instance of this ++** structure. ++** ++** PageHdr.firstFree is 0 if there is no free space on this page. ++** Otherwise, PageHdr.firstFree is the index in MemPage.u.aDisk[] of a ++** FreeBlk structure that describes the first block of free space. ++** All free space is defined by a linked list of FreeBlk structures. ++** ++** Data is stored in a linked list of Cell structures. PageHdr.firstCell ++** is the index into MemPage.u.aDisk[] of the first cell on the page. The ++** Cells are kept in sorted order. ++** ++** A Cell contains all information about a database entry and a pointer ++** to a child page that contains other entries less than itself. In ++** other words, the i-th Cell contains both Ptr(i) and Key(i). The ++** right-most pointer of the page is contained in PageHdr.rightChild. ++*/ ++struct PageHdr { ++ Pgno rightChild; /* Child page that comes after all cells on this page */ ++ u16 firstCell; /* Index in MemPage.u.aDisk[] of the first cell */ ++ u16 firstFree; /* Index in MemPage.u.aDisk[] of the first free block */ ++}; ++ ++/* ++** Entries on a page of the database are called "Cells". Each Cell ++** has a header and data. This structure defines the header. The ++** key and data (collectively the "payload") follow this header on ++** the database page. ++** ++** A definition of the complete Cell structure is given below. The ++** header for the cell must be defined first in order to do some ++** of the sizing #defines that follow. ++*/ ++struct CellHdr { ++ Pgno leftChild; /* Child page that comes before this cell */ ++ u16 nKey; /* Number of bytes in the key */ ++ u16 iNext; /* Index in MemPage.u.aDisk[] of next cell in sorted order */ ++ u8 nKeyHi; /* Upper 8 bits of key size for keys larger than 64K bytes */ ++ u8 nDataHi; /* Upper 8 bits of data size when the size is more than 64K */ ++ u16 nData; /* Number of bytes of data */ ++}; ++ ++/* ++** The key and data size are split into a lower 16-bit segment and an ++** upper 8-bit segment in order to pack them together into a smaller ++** space. The following macros reassembly a key or data size back ++** into an integer. ++*/ ++#define NKEY(b,h) (SWAB16(b,h.nKey) + h.nKeyHi*65536) ++#define NDATA(b,h) (SWAB16(b,h.nData) + h.nDataHi*65536) ++ ++/* ++** The minimum size of a complete Cell. The Cell must contain a header ++** and at least 4 bytes of payload. ++*/ ++#define MIN_CELL_SIZE (sizeof(CellHdr)+4) ++ ++/* ++** The maximum number of database entries that can be held in a single ++** page of the database. ++*/ ++#define MX_CELL ((SQLITE_USABLE_SIZE-sizeof(PageHdr))/MIN_CELL_SIZE) ++ ++/* ++** The amount of usable space on a single page of the BTree. This is the ++** page size minus the overhead of the page header. ++*/ ++#define USABLE_SPACE (SQLITE_USABLE_SIZE - sizeof(PageHdr)) ++ ++/* ++** The maximum amount of payload (in bytes) that can be stored locally for ++** a database entry. If the entry contains more data than this, the ++** extra goes onto overflow pages. ++** ++** This number is chosen so that at least 4 cells will fit on every page. ++*/ ++#define MX_LOCAL_PAYLOAD ((USABLE_SPACE/4-(sizeof(CellHdr)+sizeof(Pgno)))&~3) ++ ++/* ++** Data on a database page is stored as a linked list of Cell structures. ++** Both the key and the data are stored in aPayload[]. The key always comes ++** first. The aPayload[] field grows as necessary to hold the key and data, ++** up to a maximum of MX_LOCAL_PAYLOAD bytes. If the size of the key and ++** data combined exceeds MX_LOCAL_PAYLOAD bytes, then Cell.ovfl is the ++** page number of the first overflow page. ++** ++** Though this structure is fixed in size, the Cell on the database ++** page varies in size. Every cell has a CellHdr and at least 4 bytes ++** of payload space. Additional payload bytes (up to the maximum of ++** MX_LOCAL_PAYLOAD) and the Cell.ovfl value are allocated only as ++** needed. ++*/ ++struct Cell { ++ CellHdr h; /* The cell header */ ++ char aPayload[MX_LOCAL_PAYLOAD]; /* Key and data */ ++ Pgno ovfl; /* The first overflow page */ ++}; ++ ++/* ++** Free space on a page is remembered using a linked list of the FreeBlk ++** structures. Space on a database page is allocated in increments of ++** at least 4 bytes and is always aligned to a 4-byte boundry. The ++** linked list of FreeBlks is always kept in order by address. ++*/ ++struct FreeBlk { ++ u16 iSize; /* Number of bytes in this block of free space */ ++ u16 iNext; /* Index in MemPage.u.aDisk[] of the next free block */ ++}; ++ ++/* ++** The number of bytes of payload that will fit on a single overflow page. ++*/ ++#define OVERFLOW_SIZE (SQLITE_USABLE_SIZE-sizeof(Pgno)) ++ ++/* ++** When the key and data for a single entry in the BTree will not fit in ++** the MX_LOCAL_PAYLOAD bytes of space available on the database page, ++** then all extra bytes are written to a linked list of overflow pages. ++** Each overflow page is an instance of the following structure. ++** ++** Unused pages in the database are also represented by instances of ++** the OverflowPage structure. The PageOne.freeList field is the ++** page number of the first page in a linked list of unused database ++** pages. ++*/ ++struct OverflowPage { ++ Pgno iNext; ++ char aPayload[OVERFLOW_SIZE]; ++}; ++ ++/* ++** The PageOne.freeList field points to a linked list of overflow pages ++** hold information about free pages. The aPayload section of each ++** overflow page contains an instance of the following structure. The ++** aFree[] array holds the page number of nFree unused pages in the disk ++** file. ++*/ ++struct FreelistInfo { ++ int nFree; ++ Pgno aFree[(OVERFLOW_SIZE-sizeof(int))/sizeof(Pgno)]; ++}; ++ ++/* ++** For every page in the database file, an instance of the following structure ++** is stored in memory. The u.aDisk[] array contains the raw bits read from ++** the disk. The rest is auxiliary information held in memory only. The ++** auxiliary info is only valid for regular database pages - it is not ++** used for overflow pages and pages on the freelist. ++** ++** Of particular interest in the auxiliary info is the apCell[] entry. Each ++** apCell[] entry is a pointer to a Cell structure in u.aDisk[]. The cells are ++** put in this array so that they can be accessed in constant time, rather ++** than in linear time which would be needed if we had to walk the linked ++** list on every access. ++** ++** Note that apCell[] contains enough space to hold up to two more Cells ++** than can possibly fit on one page. In the steady state, every apCell[] ++** points to memory inside u.aDisk[]. But in the middle of an insert ++** operation, some apCell[] entries may temporarily point to data space ++** outside of u.aDisk[]. This is a transient situation that is quickly ++** resolved. But while it is happening, it is possible for a database ++** page to hold as many as two more cells than it might otherwise hold. ++** The extra two entries in apCell[] are an allowance for this situation. ++** ++** 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. ++*/ ++struct MemPage { ++ union u_page_data { ++ char aDisk[SQLITE_PAGE_SIZE]; /* Page data stored on disk */ ++ PageHdr hdr; /* Overlay page header */ ++ } u; ++ u8 isInit; /* True if auxiliary data is initialized */ ++ u8 idxShift; /* True if apCell[] indices have changed */ ++ u8 isOverfull; /* Some apCell[] points outside u.aDisk[] */ ++ MemPage *pParent; /* The parent of this page. NULL for root */ ++ int idxParent; /* Index in pParent->apCell[] of this node */ ++ int nFree; /* Number of free bytes in u.aDisk[] */ ++ int nCell; /* Number of entries on this page */ ++ Cell *apCell[MX_CELL+2]; /* All data entires in sorted order */ ++}; ++ ++/* ++** 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)-sizeof(union u_page_data)) ++ ++/* ++** Everything we need to know about an open database ++*/ ++struct Btree { ++ BtOps *pOps; /* Function table */ ++ Pager *pPager; /* The page cache */ ++ BtCursor *pCursor; /* A list of all open cursors */ ++ PageOne *page1; /* First page of the database */ ++ u8 inTrans; /* True if a transaction is in progress */ ++ u8 inCkpt; /* True if there is a checkpoint on the transaction */ ++ u8 readOnly; /* True if the underlying file is readonly */ ++ u8 needSwab; /* Need to byte-swapping */ ++}; ++typedef Btree Bt; ++ ++/* ++** A cursor is a pointer to a particular entry in the BTree. ++** The entry is identified by its MemPage and the index in ++** MemPage.apCell[] of the entry. ++*/ ++struct BtCursor { ++ BtCursorOps *pOps; /* Function table */ ++ Btree *pBt; /* The Btree to which this cursor belongs */ ++ BtCursor *pNext, *pPrev; /* Forms a linked list of all cursors */ ++ BtCursor *pShared; /* Loop of cursors with the same root page */ ++ Pgno pgnoRoot; /* The root page of this tree */ ++ MemPage *pPage; /* Page that contains the entry */ ++ int idx; /* Index of the entry in pPage->apCell[] */ ++ u8 wrFlag; /* True if writable */ ++ u8 eSkip; /* Determines if next step operation is a no-op */ ++ u8 iMatch; /* compare result from last sqliteBtreeMoveto() */ ++}; ++ ++/* ++** Legal values for BtCursor.eSkip. ++*/ ++#define SKIP_NONE 0 /* Always step the cursor */ ++#define SKIP_NEXT 1 /* The next sqliteBtreeNext() is a no-op */ ++#define SKIP_PREV 2 /* The next sqliteBtreePrevious() is a no-op */ ++#define SKIP_INVALID 3 /* Calls to Next() and Previous() are invalid */ ++ ++/* Forward declarations */ ++static int fileBtreeCloseCursor(BtCursor *pCur); ++ ++/* ++** Routines for byte swapping. ++*/ ++u16 swab16(u16 x){ ++ return ((x & 0xff)<<8) | ((x>>8)&0xff); ++} ++u32 swab32(u32 x){ ++ return ((x & 0xff)<<24) | ((x & 0xff00)<<8) | ++ ((x>>8) & 0xff00) | ((x>>24)&0xff); ++} ++ ++/* ++** Compute the total number of bytes that a Cell needs on the main ++** database page. The number returned includes the Cell header, ++** local payload storage, and the pointer to overflow pages (if ++** applicable). Additional space allocated on overflow pages ++** is NOT included in the value returned from this routine. ++*/ ++static int cellSize(Btree *pBt, Cell *pCell){ ++ int n = NKEY(pBt, pCell->h) + NDATA(pBt, pCell->h); ++ if( n>MX_LOCAL_PAYLOAD ){ ++ n = MX_LOCAL_PAYLOAD + sizeof(Pgno); ++ }else{ ++ n = ROUNDUP(n); ++ } ++ n += sizeof(CellHdr); ++ return n; ++} ++ ++/* ++** Defragment the page given. All Cells are moved to the ++** beginning of the page and all free space is collected ++** into one big FreeBlk at the end of the page. ++*/ ++static void defragmentPage(Btree *pBt, MemPage *pPage){ ++ int pc, i, n; ++ FreeBlk *pFBlk; ++ char newPage[SQLITE_USABLE_SIZE]; ++ ++ assert( sqlitepager_iswriteable(pPage) ); ++ assert( pPage->isInit ); ++ pc = sizeof(PageHdr); ++ pPage->u.hdr.firstCell = SWAB16(pBt, pc); ++ memcpy(newPage, pPage->u.aDisk, pc); ++ for(i=0; inCell; i++){ ++ Cell *pCell = pPage->apCell[i]; ++ ++ /* This routine should never be called on an overfull page. The ++ ** following asserts verify that constraint. */ ++ assert( Addr(pCell) > Addr(pPage) ); ++ assert( Addr(pCell) < Addr(pPage) + SQLITE_USABLE_SIZE ); ++ ++ n = cellSize(pBt, pCell); ++ pCell->h.iNext = SWAB16(pBt, pc + n); ++ memcpy(&newPage[pc], pCell, n); ++ pPage->apCell[i] = (Cell*)&pPage->u.aDisk[pc]; ++ pc += n; ++ } ++ assert( pPage->nFree==SQLITE_USABLE_SIZE-pc ); ++ memcpy(pPage->u.aDisk, newPage, pc); ++ if( pPage->nCell>0 ){ ++ pPage->apCell[pPage->nCell-1]->h.iNext = 0; ++ } ++ pFBlk = (FreeBlk*)&pPage->u.aDisk[pc]; ++ pFBlk->iSize = SWAB16(pBt, SQLITE_USABLE_SIZE - pc); ++ pFBlk->iNext = 0; ++ pPage->u.hdr.firstFree = SWAB16(pBt, pc); ++ memset(&pFBlk[1], 0, SQLITE_USABLE_SIZE - pc - sizeof(FreeBlk)); ++} ++ ++/* ++** Allocate nByte bytes of space on a page. nByte must be a ++** multiple of 4. ++** ++** Return the index into pPage->u.aDisk[] of the first byte of ++** the new allocation. Or return 0 if there is not enough free ++** space on the page to satisfy the allocation request. ++** ++** If the page contains nBytes of free space but does not contain ++** nBytes of contiguous free space, then this routine automatically ++** calls defragementPage() to consolidate all free space before ++** allocating the new chunk. ++*/ ++static int allocateSpace(Btree *pBt, MemPage *pPage, int nByte){ ++ FreeBlk *p; ++ u16 *pIdx; ++ int start; ++ int iSize; ++#ifndef NDEBUG ++ int cnt = 0; ++#endif ++ ++ assert( sqlitepager_iswriteable(pPage) ); ++ assert( nByte==ROUNDUP(nByte) ); ++ assert( pPage->isInit ); ++ if( pPage->nFreeisOverfull ) return 0; ++ pIdx = &pPage->u.hdr.firstFree; ++ p = (FreeBlk*)&pPage->u.aDisk[SWAB16(pBt, *pIdx)]; ++ while( (iSize = SWAB16(pBt, p->iSize))iNext==0 ){ ++ defragmentPage(pBt, pPage); ++ pIdx = &pPage->u.hdr.firstFree; ++ }else{ ++ pIdx = &p->iNext; ++ } ++ p = (FreeBlk*)&pPage->u.aDisk[SWAB16(pBt, *pIdx)]; ++ } ++ if( iSize==nByte ){ ++ start = SWAB16(pBt, *pIdx); ++ *pIdx = p->iNext; ++ }else{ ++ FreeBlk *pNew; ++ start = SWAB16(pBt, *pIdx); ++ pNew = (FreeBlk*)&pPage->u.aDisk[start + nByte]; ++ pNew->iNext = p->iNext; ++ pNew->iSize = SWAB16(pBt, iSize - nByte); ++ *pIdx = SWAB16(pBt, start + nByte); ++ } ++ pPage->nFree -= nByte; ++ return start; ++} ++ ++/* ++** Return a section of the MemPage.u.aDisk[] to the freelist. ++** The first byte of the new free block is pPage->u.aDisk[start] ++** and the size of the block is "size" bytes. Size must be ++** a multiple of 4. ++** ++** Most of the effort here is involved in coalesing adjacent ++** free blocks into a single big free block. ++*/ ++static void freeSpace(Btree *pBt, MemPage *pPage, int start, int size){ ++ int end = start + size; ++ u16 *pIdx, idx; ++ FreeBlk *pFBlk; ++ FreeBlk *pNew; ++ FreeBlk *pNext; ++ int iSize; ++ ++ assert( sqlitepager_iswriteable(pPage) ); ++ assert( size == ROUNDUP(size) ); ++ assert( start == ROUNDUP(start) ); ++ assert( pPage->isInit ); ++ pIdx = &pPage->u.hdr.firstFree; ++ idx = SWAB16(pBt, *pIdx); ++ while( idx!=0 && idxu.aDisk[idx]; ++ iSize = SWAB16(pBt, pFBlk->iSize); ++ if( idx + iSize == start ){ ++ pFBlk->iSize = SWAB16(pBt, iSize + size); ++ if( idx + iSize + size == SWAB16(pBt, pFBlk->iNext) ){ ++ pNext = (FreeBlk*)&pPage->u.aDisk[idx + iSize + size]; ++ if( pBt->needSwab ){ ++ pFBlk->iSize = swab16((u16)swab16(pNext->iSize)+iSize+size); ++ }else{ ++ pFBlk->iSize += pNext->iSize; ++ } ++ pFBlk->iNext = pNext->iNext; ++ } ++ pPage->nFree += size; ++ return; ++ } ++ pIdx = &pFBlk->iNext; ++ idx = SWAB16(pBt, *pIdx); ++ } ++ pNew = (FreeBlk*)&pPage->u.aDisk[start]; ++ if( idx != end ){ ++ pNew->iSize = SWAB16(pBt, size); ++ pNew->iNext = SWAB16(pBt, idx); ++ }else{ ++ pNext = (FreeBlk*)&pPage->u.aDisk[idx]; ++ pNew->iSize = SWAB16(pBt, size + SWAB16(pBt, pNext->iSize)); ++ pNew->iNext = pNext->iNext; ++ } ++ *pIdx = SWAB16(pBt, start); ++ pPage->nFree += size; ++} ++ ++/* ++** Initialize the auxiliary information for a disk block. ++** ++** The pParent parameter must be a pointer to the MemPage which ++** is the parent of the page being initialized. The root of the ++** BTree (usually page 2) has no parent and so for that page, ++** pParent==NULL. ++** ++** 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 initPage(Bt *pBt, MemPage *pPage, Pgno pgnoThis, MemPage *pParent){ ++ int idx; /* An index into pPage->u.aDisk[] */ ++ Cell *pCell; /* A pointer to a Cell in pPage->u.aDisk[] */ ++ FreeBlk *pFBlk; /* A pointer to a free block in pPage->u.aDisk[] */ ++ int sz; /* The size of a Cell in bytes */ ++ int freeSpace; /* Amount of free space on the page */ ++ ++ if( pPage->pParent ){ ++ assert( pPage->pParent==pParent ); ++ return SQLITE_OK; ++ } ++ if( pParent ){ ++ pPage->pParent = pParent; ++ sqlitepager_ref(pParent); ++ } ++ if( pPage->isInit ) return SQLITE_OK; ++ pPage->isInit = 1; ++ pPage->nCell = 0; ++ freeSpace = USABLE_SPACE; ++ idx = SWAB16(pBt, pPage->u.hdr.firstCell); ++ while( idx!=0 ){ ++ if( idx>SQLITE_USABLE_SIZE-MIN_CELL_SIZE ) goto page_format_error; ++ if( idxu.aDisk[idx]; ++ sz = cellSize(pBt, pCell); ++ if( idx+sz > SQLITE_USABLE_SIZE ) goto page_format_error; ++ freeSpace -= sz; ++ pPage->apCell[pPage->nCell++] = pCell; ++ idx = SWAB16(pBt, pCell->h.iNext); ++ } ++ pPage->nFree = 0; ++ idx = SWAB16(pBt, pPage->u.hdr.firstFree); ++ while( idx!=0 ){ ++ int iNext; ++ if( idx>SQLITE_USABLE_SIZE-sizeof(FreeBlk) ) goto page_format_error; ++ if( idxu.aDisk[idx]; ++ pPage->nFree += SWAB16(pBt, pFBlk->iSize); ++ iNext = SWAB16(pBt, pFBlk->iNext); ++ if( iNext>0 && iNext <= idx ) goto page_format_error; ++ idx = iNext; ++ } ++ if( pPage->nCell==0 && pPage->nFree==0 ){ ++ /* As a special case, an uninitialized root page appears to be ++ ** an empty database */ ++ return SQLITE_OK; ++ } ++ if( pPage->nFree!=freeSpace ) goto page_format_error; ++ return SQLITE_OK; ++ ++page_format_error: ++ return SQLITE_CORRUPT; ++} ++ ++/* ++** Set up a raw page so that it looks like a database page holding ++** no entries. ++*/ ++static void zeroPage(Btree *pBt, MemPage *pPage){ ++ PageHdr *pHdr; ++ FreeBlk *pFBlk; ++ assert( sqlitepager_iswriteable(pPage) ); ++ memset(pPage, 0, SQLITE_USABLE_SIZE); ++ pHdr = &pPage->u.hdr; ++ pHdr->firstCell = 0; ++ pHdr->firstFree = SWAB16(pBt, sizeof(*pHdr)); ++ pFBlk = (FreeBlk*)&pHdr[1]; ++ pFBlk->iNext = 0; ++ pPage->nFree = SQLITE_USABLE_SIZE - sizeof(*pHdr); ++ pFBlk->iSize = SWAB16(pBt, pPage->nFree); ++ pPage->nCell = 0; ++ pPage->isOverfull = 0; ++} ++ ++/* ++** This routine is called when the reference count for a page ++** reaches zero. We need to unref the pParent pointer when that ++** happens. ++*/ ++static void pageDestructor(void *pData){ ++ MemPage *pPage = (MemPage*)pData; ++ if( pPage->pParent ){ ++ MemPage *pParent = pPage->pParent; ++ pPage->pParent = 0; ++ sqlitepager_unref(pParent); ++ } ++} ++ ++/* ++** Open a new database. ++** ++** Actually, this routine just sets up the internal data structures ++** for accessing the database. We do not open the database file ++** until the first page is loaded. ++** ++** zFilename is the name of the database file. If zFilename is NULL ++** a new database with a random name is created. This randomly named ++** database file will be deleted when sqliteBtreeClose() is called. ++*/ ++int sqliteBtreeOpen( ++ const char *zFilename, /* Name of the file containing the BTree database */ ++ int omitJournal, /* if TRUE then do not journal this file */ ++ int nCache, /* How many pages in the page cache */ ++ Btree **ppBtree /* Pointer to new Btree object written here */ ++){ ++ Btree *pBt; ++ int rc; ++ ++ /* ++ ** 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(u32)==4 ); ++ assert( sizeof(u16)==2 ); ++ assert( sizeof(Pgno)==4 ); ++ assert( sizeof(PageHdr)==8 ); ++ assert( sizeof(CellHdr)==12 ); ++ assert( sizeof(FreeBlk)==4 ); ++ assert( sizeof(OverflowPage)==SQLITE_USABLE_SIZE ); ++ assert( sizeof(FreelistInfo)==OVERFLOW_SIZE ); ++ assert( sizeof(ptr)==sizeof(char*) ); ++ assert( sizeof(uptr)==sizeof(ptr) ); ++ ++ pBt = sqliteMalloc( sizeof(*pBt) ); ++ if( pBt==0 ){ ++ *ppBtree = 0; ++ return SQLITE_NOMEM; ++ } ++ if( nCache<10 ) nCache = 10; ++ rc = sqlitepager_open(&pBt->pPager, zFilename, nCache, EXTRA_SIZE, ++ !omitJournal); ++ if( rc!=SQLITE_OK ){ ++ if( pBt->pPager ) sqlitepager_close(pBt->pPager); ++ sqliteFree(pBt); ++ *ppBtree = 0; ++ return rc; ++ } ++ sqlitepager_set_destructor(pBt->pPager, pageDestructor); ++ pBt->pCursor = 0; ++ pBt->page1 = 0; ++ pBt->readOnly = sqlitepager_isreadonly(pBt->pPager); ++ pBt->pOps = &sqliteBtreeOps; ++ *ppBtree = pBt; ++ return SQLITE_OK; ++} ++ ++/* ++** Close an open database and invalidate all cursors. ++*/ ++static int fileBtreeClose(Btree *pBt){ ++ while( pBt->pCursor ){ ++ fileBtreeCloseCursor(pBt->pCursor); ++ } ++ sqlitepager_close(pBt->pPager); ++ sqliteFree(pBt); ++ 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. ++*/ ++static int fileBtreeSetCacheSize(Btree *pBt, int mxPage){ ++ sqlitepager_set_cachesize(pBt->pPager, mxPage); ++ return SQLITE_OK; ++} ++ ++/* ++** 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. ++*/ ++static int fileBtreeSetSafetyLevel(Btree *pBt, int level){ ++ sqlitepager_set_safety_level(pBt->pPager, level); ++ return SQLITE_OK; ++} ++ ++/* ++** Get a reference to page1 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. SQLITE_PROTOCOL is returned ++** if there is a locking protocol violation. ++*/ ++static int lockBtree(Btree *pBt){ ++ int rc; ++ if( pBt->page1 ) return SQLITE_OK; ++ rc = sqlitepager_get(pBt->pPager, 1, (void**)&pBt->page1); ++ if( rc!=SQLITE_OK ) return rc; ++ ++ /* Do some checking to help insure the file we opened really is ++ ** a valid database file. ++ */ ++ if( sqlitepager_pagecount(pBt->pPager)>0 ){ ++ PageOne *pP1 = pBt->page1; ++ if( strcmp(pP1->zMagic,zMagicHeader)!=0 || ++ (pP1->iMagic!=MAGIC && swab32(pP1->iMagic)!=MAGIC) ){ ++ rc = SQLITE_NOTADB; ++ goto page1_init_failed; ++ } ++ pBt->needSwab = pP1->iMagic!=MAGIC; ++ } ++ return rc; ++ ++page1_init_failed: ++ sqlitepager_unref(pBt->page1); ++ pBt->page1 = 0; ++ return rc; ++} ++ ++/* ++** 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 are any outstanding cursors, this routine is a no-op. ++** ++** If there is a transaction in progress, this routine is a no-op. ++*/ ++static void unlockBtreeIfUnused(Btree *pBt){ ++ if( pBt->inTrans==0 && pBt->pCursor==0 && pBt->page1!=0 ){ ++ sqlitepager_unref(pBt->page1); ++ pBt->page1 = 0; ++ pBt->inTrans = 0; ++ pBt->inCkpt = 0; ++ } ++} ++ ++/* ++** Create a new database by initializing the first two pages of the ++** file. ++*/ ++static int newDatabase(Btree *pBt){ ++ MemPage *pRoot; ++ PageOne *pP1; ++ int rc; ++ if( sqlitepager_pagecount(pBt->pPager)>1 ) return SQLITE_OK; ++ pP1 = pBt->page1; ++ rc = sqlitepager_write(pBt->page1); ++ if( rc ) return rc; ++ rc = sqlitepager_get(pBt->pPager, 2, (void**)&pRoot); ++ if( rc ) return rc; ++ rc = sqlitepager_write(pRoot); ++ if( rc ){ ++ sqlitepager_unref(pRoot); ++ return rc; ++ } ++ strcpy(pP1->zMagic, zMagicHeader); ++ if( btree_native_byte_order ){ ++ pP1->iMagic = MAGIC; ++ pBt->needSwab = 0; ++ }else{ ++ pP1->iMagic = swab32(MAGIC); ++ pBt->needSwab = 1; ++ } ++ zeroPage(pBt, pRoot); ++ sqlitepager_unref(pRoot); ++ return SQLITE_OK; ++} ++ ++/* ++** Attempt to start a new transaction. ++** ++** A transaction must be started before attempting any changes ++** to the database. None of the following routines will work ++** unless a transaction is started first: ++** ++** sqliteBtreeCreateTable() ++** sqliteBtreeCreateIndex() ++** sqliteBtreeClearTable() ++** sqliteBtreeDropTable() ++** sqliteBtreeInsert() ++** sqliteBtreeDelete() ++** sqliteBtreeUpdateMeta() ++*/ ++static int fileBtreeBeginTrans(Btree *pBt){ ++ int rc; ++ if( pBt->inTrans ) return SQLITE_ERROR; ++ if( pBt->readOnly ) return SQLITE_READONLY; ++ if( pBt->page1==0 ){ ++ rc = lockBtree(pBt); ++ if( rc!=SQLITE_OK ){ ++ return rc; ++ } ++ } ++ rc = sqlitepager_begin(pBt->page1); ++ if( rc==SQLITE_OK ){ ++ rc = newDatabase(pBt); ++ } ++ if( rc==SQLITE_OK ){ ++ pBt->inTrans = 1; ++ pBt->inCkpt = 0; ++ }else{ ++ unlockBtreeIfUnused(pBt); ++ } ++ return rc; ++} ++ ++/* ++** Commit the transaction currently in progress. ++** ++** This will release the write lock on the database file. If there ++** are no active cursors, it also releases the read lock. ++*/ ++static int fileBtreeCommit(Btree *pBt){ ++ int rc; ++ rc = pBt->readOnly ? SQLITE_OK : sqlitepager_commit(pBt->pPager); ++ pBt->inTrans = 0; ++ pBt->inCkpt = 0; ++ unlockBtreeIfUnused(pBt); ++ return rc; ++} ++ ++/* ++** Rollback the transaction in progress. All cursors will be ++** invalided by this operation. Any attempt to use a cursor ++** that was open at the beginning of this operation 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. ++*/ ++static int fileBtreeRollback(Btree *pBt){ ++ int rc; ++ BtCursor *pCur; ++ if( pBt->inTrans==0 ) return SQLITE_OK; ++ pBt->inTrans = 0; ++ pBt->inCkpt = 0; ++ rc = pBt->readOnly ? SQLITE_OK : sqlitepager_rollback(pBt->pPager); ++ for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ ++ if( pCur->pPage && pCur->pPage->isInit==0 ){ ++ sqlitepager_unref(pCur->pPage); ++ pCur->pPage = 0; ++ } ++ } ++ unlockBtreeIfUnused(pBt); ++ return rc; ++} ++ ++/* ++** Set the checkpoint for the current transaction. The checkpoint serves ++** as a sub-transaction that can be rolled back independently of the ++** main transaction. You must start a transaction before starting a ++** checkpoint. The checkpoint is ended automatically if the transaction ++** commits or rolls back. ++** ++** Only one checkpoint may be active at a time. It is an error to try ++** to start a new checkpoint if another checkpoint is already active. ++*/ ++static int fileBtreeBeginCkpt(Btree *pBt){ ++ int rc; ++ if( !pBt->inTrans || pBt->inCkpt ){ ++ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; ++ } ++ rc = pBt->readOnly ? SQLITE_OK : sqlitepager_ckpt_begin(pBt->pPager); ++ pBt->inCkpt = 1; ++ return rc; ++} ++ ++ ++/* ++** Commit a checkpoint to transaction currently in progress. If no ++** checkpoint is active, this is a no-op. ++*/ ++static int fileBtreeCommitCkpt(Btree *pBt){ ++ int rc; ++ if( pBt->inCkpt && !pBt->readOnly ){ ++ rc = sqlitepager_ckpt_commit(pBt->pPager); ++ }else{ ++ rc = SQLITE_OK; ++ } ++ pBt->inCkpt = 0; ++ return rc; ++} ++ ++/* ++** Rollback the checkpoint to the current transaction. If there ++** is no active checkpoint or transaction, this routine is a no-op. ++** ++** All cursors will be invalided by this operation. Any attempt ++** to use a cursor that was open at the beginning of this operation ++** will result in an error. ++*/ ++static int fileBtreeRollbackCkpt(Btree *pBt){ ++ int rc; ++ BtCursor *pCur; ++ if( pBt->inCkpt==0 || pBt->readOnly ) return SQLITE_OK; ++ rc = sqlitepager_ckpt_rollback(pBt->pPager); ++ for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ ++ if( pCur->pPage && pCur->pPage->isInit==0 ){ ++ sqlitepager_unref(pCur->pPage); ++ pCur->pPage = 0; ++ } ++ } ++ pBt->inCkpt = 0; ++ return rc; ++} ++ ++/* ++** Create a new cursor for the BTree whose root is on the page ++** iTable. The act of acquiring a cursor gets a read lock on ++** the database file. ++** ++** 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: No other cursors may be open with wrFlag==0 on the same table ++** ++** 3: The database must be writable (not on read-only media) ++** ++** 4: There must be an active transaction. ++** ++** Condition 2 warrants further discussion. If any cursor is opened ++** on a table with wrFlag==0, that prevents all other cursors from ++** writing to that table. This is a kind of "read-lock". When a cursor ++** is opened with wrFlag==0 it is guaranteed that the table will not ++** change as long as the cursor is open. This allows the cursor to ++** do a sequential scan of the table without having to worry about ++** entries being inserted or deleted during the scan. Cursors should ++** be opened with wrFlag==0 only if this read-lock property is needed. ++** That is to say, cursors should be opened with wrFlag==0 only if they ++** intend to use the sqliteBtreeNext() system call. All other cursors ++** should be opened with wrFlag==1 even if they never really intend ++** to write. ++** ++** 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. ++*/ ++static ++int fileBtreeCursor(Btree *pBt, int iTable, int wrFlag, BtCursor **ppCur){ ++ int rc; ++ BtCursor *pCur, *pRing; ++ ++ if( pBt->readOnly && wrFlag ){ ++ *ppCur = 0; ++ return SQLITE_READONLY; ++ } ++ if( pBt->page1==0 ){ ++ rc = lockBtree(pBt); ++ if( rc!=SQLITE_OK ){ ++ *ppCur = 0; ++ return rc; ++ } ++ } ++ pCur = sqliteMalloc( sizeof(*pCur) ); ++ if( pCur==0 ){ ++ rc = SQLITE_NOMEM; ++ goto create_cursor_exception; ++ } ++ pCur->pgnoRoot = (Pgno)iTable; ++ rc = sqlitepager_get(pBt->pPager, pCur->pgnoRoot, (void**)&pCur->pPage); ++ if( rc!=SQLITE_OK ){ ++ goto create_cursor_exception; ++ } ++ rc = initPage(pBt, pCur->pPage, pCur->pgnoRoot, 0); ++ if( rc!=SQLITE_OK ){ ++ goto create_cursor_exception; ++ } ++ pCur->pOps = &sqliteBtreeCursorOps; ++ pCur->pBt = pBt; ++ pCur->wrFlag = wrFlag; ++ pCur->idx = 0; ++ pCur->eSkip = SKIP_INVALID; ++ pCur->pNext = pBt->pCursor; ++ if( pCur->pNext ){ ++ pCur->pNext->pPrev = pCur; ++ } ++ pCur->pPrev = 0; ++ pRing = pBt->pCursor; ++ while( pRing && pRing->pgnoRoot!=pCur->pgnoRoot ){ pRing = pRing->pNext; } ++ if( pRing ){ ++ pCur->pShared = pRing->pShared; ++ pRing->pShared = pCur; ++ }else{ ++ pCur->pShared = pCur; ++ } ++ pBt->pCursor = pCur; ++ *ppCur = pCur; ++ return SQLITE_OK; ++ ++create_cursor_exception: ++ *ppCur = 0; ++ if( pCur ){ ++ if( pCur->pPage ) sqlitepager_unref(pCur->pPage); ++ sqliteFree(pCur); ++ } ++ unlockBtreeIfUnused(pBt); ++ return rc; ++} ++ ++/* ++** Close a cursor. The read lock on the database file is released ++** when the last cursor is closed. ++*/ ++static int fileBtreeCloseCursor(BtCursor *pCur){ ++ Btree *pBt = pCur->pBt; ++ if( pCur->pPrev ){ ++ pCur->pPrev->pNext = pCur->pNext; ++ }else{ ++ pBt->pCursor = pCur->pNext; ++ } ++ if( pCur->pNext ){ ++ pCur->pNext->pPrev = pCur->pPrev; ++ } ++ if( pCur->pPage ){ ++ sqlitepager_unref(pCur->pPage); ++ } ++ if( pCur->pShared!=pCur ){ ++ BtCursor *pRing = pCur->pShared; ++ while( pRing->pShared!=pCur ){ pRing = pRing->pShared; } ++ pRing->pShared = pCur->pShared; ++ } ++ unlockBtreeIfUnused(pBt); ++ sqliteFree(pCur); ++ return SQLITE_OK; ++} ++ ++/* ++** Make a temporary cursor by filling in the fields of pTempCur. ++** The temporary cursor is not on the cursor list for the Btree. ++*/ ++static void getTempCursor(BtCursor *pCur, BtCursor *pTempCur){ ++ memcpy(pTempCur, pCur, sizeof(*pCur)); ++ pTempCur->pNext = 0; ++ pTempCur->pPrev = 0; ++ if( pTempCur->pPage ){ ++ sqlitepager_ref(pTempCur->pPage); ++ } ++} ++ ++/* ++** Delete a temporary cursor such as was made by the CreateTemporaryCursor() ++** function above. ++*/ ++static void releaseTempCursor(BtCursor *pCur){ ++ if( pCur->pPage ){ ++ sqlitepager_unref(pCur->pPage); ++ } ++} ++ ++/* ++** Set *pSize to the number of bytes of key in the entry the ++** cursor currently points to. Always return SQLITE_OK. ++** Failure is not possible. If the cursor is not currently ++** pointing to an entry (which can happen, for example, if ++** the database is empty) then *pSize is set to 0. ++*/ ++static int fileBtreeKeySize(BtCursor *pCur, int *pSize){ ++ Cell *pCell; ++ MemPage *pPage; ++ ++ pPage = pCur->pPage; ++ assert( pPage!=0 ); ++ if( pCur->idx >= pPage->nCell ){ ++ *pSize = 0; ++ }else{ ++ pCell = pPage->apCell[pCur->idx]; ++ *pSize = NKEY(pCur->pBt, pCell->h); ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** Read payload information from the entry that the pCur cursor is ++** pointing to. Begin reading the payload at "offset" and read ++** a total of "amt" bytes. Put the result in zBuf. ++** ++** This routine does not make a distinction between key and data. ++** It just reads bytes from the payload area. ++*/ ++static int getPayload(BtCursor *pCur, int offset, int amt, char *zBuf){ ++ char *aPayload; ++ Pgno nextPage; ++ int rc; ++ Btree *pBt = pCur->pBt; ++ assert( pCur!=0 && pCur->pPage!=0 ); ++ assert( pCur->idx>=0 && pCur->idxpPage->nCell ); ++ aPayload = pCur->pPage->apCell[pCur->idx]->aPayload; ++ if( offsetMX_LOCAL_PAYLOAD ){ ++ a = MX_LOCAL_PAYLOAD - offset; ++ } ++ memcpy(zBuf, &aPayload[offset], a); ++ if( a==amt ){ ++ return SQLITE_OK; ++ } ++ offset = 0; ++ zBuf += a; ++ amt -= a; ++ }else{ ++ offset -= MX_LOCAL_PAYLOAD; ++ } ++ if( amt>0 ){ ++ nextPage = SWAB32(pBt, pCur->pPage->apCell[pCur->idx]->ovfl); ++ } ++ while( amt>0 && nextPage ){ ++ OverflowPage *pOvfl; ++ rc = sqlitepager_get(pBt->pPager, nextPage, (void**)&pOvfl); ++ if( rc!=0 ){ ++ return rc; ++ } ++ nextPage = SWAB32(pBt, pOvfl->iNext); ++ if( offset OVERFLOW_SIZE ){ ++ a = OVERFLOW_SIZE - offset; ++ } ++ memcpy(zBuf, &pOvfl->aPayload[offset], a); ++ offset = 0; ++ amt -= a; ++ zBuf += a; ++ }else{ ++ offset -= OVERFLOW_SIZE; ++ } ++ sqlitepager_unref(pOvfl); ++ } ++ if( amt>0 ){ ++ return SQLITE_CORRUPT; ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** Read part of the key associated with cursor pCur. A maximum ++** of "amt" bytes will be transfered into zBuf[]. The transfer ++** begins at "offset". The number of bytes actually read is ++** returned. ++** ++** Change: It used to be that the amount returned will be smaller ++** than the amount requested if there are not enough bytes in the key ++** to satisfy the request. But now, it must be the case that there ++** is enough data available to satisfy the request. If not, an exception ++** is raised. The change was made in an effort to boost performance ++** by eliminating unneeded tests. ++*/ ++static int fileBtreeKey(BtCursor *pCur, int offset, int amt, char *zBuf){ ++ MemPage *pPage; ++ ++ assert( amt>=0 ); ++ assert( offset>=0 ); ++ assert( pCur->pPage!=0 ); ++ pPage = pCur->pPage; ++ if( pCur->idx >= pPage->nCell ){ ++ return 0; ++ } ++ assert( amt+offset <= NKEY(pCur->pBt, pPage->apCell[pCur->idx]->h) ); ++ getPayload(pCur, offset, amt, zBuf); ++ return amt; ++} ++ ++/* ++** Set *pSize to the number of bytes of data in the entry the ++** cursor currently points to. Always return SQLITE_OK. ++** Failure is not possible. If the cursor is not currently ++** pointing to an entry (which can happen, for example, if ++** the database is empty) then *pSize is set to 0. ++*/ ++static int fileBtreeDataSize(BtCursor *pCur, int *pSize){ ++ Cell *pCell; ++ MemPage *pPage; ++ ++ pPage = pCur->pPage; ++ assert( pPage!=0 ); ++ if( pCur->idx >= pPage->nCell ){ ++ *pSize = 0; ++ }else{ ++ pCell = pPage->apCell[pCur->idx]; ++ *pSize = NDATA(pCur->pBt, pCell->h); ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** Read part of the data associated with cursor pCur. A maximum ++** of "amt" bytes will be transfered into zBuf[]. The transfer ++** begins at "offset". The number of bytes actually read is ++** returned. The amount returned will be smaller than the ++** amount requested if there are not enough bytes in the data ++** to satisfy the request. ++*/ ++static int fileBtreeData(BtCursor *pCur, int offset, int amt, char *zBuf){ ++ Cell *pCell; ++ MemPage *pPage; ++ ++ assert( amt>=0 ); ++ assert( offset>=0 ); ++ assert( pCur->pPage!=0 ); ++ pPage = pCur->pPage; ++ if( pCur->idx >= pPage->nCell ){ ++ return 0; ++ } ++ pCell = pPage->apCell[pCur->idx]; ++ assert( amt+offset <= NDATA(pCur->pBt, pCell->h) ); ++ getPayload(pCur, offset + NKEY(pCur->pBt, pCell->h), amt, zBuf); ++ return amt; ++} ++ ++/* ++** Compare an external key against the key on the entry that pCur points to. ++** ++** The external key is pKey and is nKey bytes long. The last nIgnore bytes ++** of the key associated with pCur are ignored, as if they do not exist. ++** (The normal case is for nIgnore to be zero in which case the entire ++** internal key is used in the comparison.) ++** ++** The comparison result is written to *pRes as follows: ++** ++** *pRes<0 This means pCur0 This means pCur>pKey ++** ++** When one key is an exact prefix of the other, the shorter key is ++** considered less than the longer one. In order to be equal the ++** keys must be exactly the same length. (The length of the pCur key ++** is the actual key length minus nIgnore bytes.) ++*/ ++static int fileBtreeKeyCompare( ++ BtCursor *pCur, /* Pointer to entry to compare against */ ++ const void *pKey, /* Key to compare against entry that pCur points to */ ++ int nKey, /* Number of bytes in pKey */ ++ int nIgnore, /* Ignore this many bytes at the end of pCur */ ++ int *pResult /* Write the result here */ ++){ ++ Pgno nextPage; ++ int n, c, rc, nLocal; ++ Cell *pCell; ++ Btree *pBt = pCur->pBt; ++ const char *zKey = (const char*)pKey; ++ ++ assert( pCur->pPage ); ++ assert( pCur->idx>=0 && pCur->idxpPage->nCell ); ++ pCell = pCur->pPage->apCell[pCur->idx]; ++ nLocal = NKEY(pBt, pCell->h) - nIgnore; ++ if( nLocal<0 ) nLocal = 0; ++ n = nKeyMX_LOCAL_PAYLOAD ){ ++ n = MX_LOCAL_PAYLOAD; ++ } ++ c = memcmp(pCell->aPayload, zKey, n); ++ if( c!=0 ){ ++ *pResult = c; ++ return SQLITE_OK; ++ } ++ zKey += n; ++ nKey -= n; ++ nLocal -= n; ++ nextPage = SWAB32(pBt, pCell->ovfl); ++ while( nKey>0 && nLocal>0 ){ ++ OverflowPage *pOvfl; ++ if( nextPage==0 ){ ++ return SQLITE_CORRUPT; ++ } ++ rc = sqlitepager_get(pBt->pPager, nextPage, (void**)&pOvfl); ++ if( rc ){ ++ return rc; ++ } ++ nextPage = SWAB32(pBt, pOvfl->iNext); ++ n = nKeyOVERFLOW_SIZE ){ ++ n = OVERFLOW_SIZE; ++ } ++ c = memcmp(pOvfl->aPayload, zKey, n); ++ sqlitepager_unref(pOvfl); ++ if( c!=0 ){ ++ *pResult = c; ++ return SQLITE_OK; ++ } ++ nKey -= n; ++ nLocal -= n; ++ zKey += n; ++ } ++ if( c==0 ){ ++ c = nLocal - nKey; ++ } ++ *pResult = c; ++ return SQLITE_OK; ++} ++ ++/* ++** Move the cursor down to a new child page. The newPgno argument is the ++** page number of the child page in the byte order of the disk image. ++*/ ++static int moveToChild(BtCursor *pCur, int newPgno){ ++ int rc; ++ MemPage *pNewPage; ++ Btree *pBt = pCur->pBt; ++ ++ newPgno = SWAB32(pBt, newPgno); ++ rc = sqlitepager_get(pBt->pPager, newPgno, (void**)&pNewPage); ++ if( rc ) return rc; ++ rc = initPage(pBt, pNewPage, newPgno, pCur->pPage); ++ if( rc ) return rc; ++ assert( pCur->idx>=pCur->pPage->nCell ++ || pCur->pPage->apCell[pCur->idx]->h.leftChild==SWAB32(pBt,newPgno) ); ++ assert( pCur->idxpPage->nCell ++ || pCur->pPage->u.hdr.rightChild==SWAB32(pBt,newPgno) ); ++ pNewPage->idxParent = pCur->idx; ++ pCur->pPage->idxShift = 0; ++ sqlitepager_unref(pCur->pPage); ++ pCur->pPage = pNewPage; ++ pCur->idx = 0; ++ if( pNewPage->nCell<1 ){ ++ return SQLITE_CORRUPT; ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** 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){ ++ Pgno oldPgno; ++ MemPage *pParent; ++ MemPage *pPage; ++ int idxParent; ++ pPage = pCur->pPage; ++ assert( pPage!=0 ); ++ pParent = pPage->pParent; ++ assert( pParent!=0 ); ++ idxParent = pPage->idxParent; ++ sqlitepager_ref(pParent); ++ sqlitepager_unref(pPage); ++ pCur->pPage = pParent; ++ assert( pParent->idxShift==0 ); ++ if( pParent->idxShift==0 ){ ++ pCur->idx = idxParent; ++#ifndef NDEBUG ++ /* Verify that pCur->idx is the correct index to point back to the child ++ ** page we just came from ++ */ ++ oldPgno = SWAB32(pCur->pBt, sqlitepager_pagenumber(pPage)); ++ if( pCur->idxnCell ){ ++ assert( pParent->apCell[idxParent]->h.leftChild==oldPgno ); ++ }else{ ++ assert( pParent->u.hdr.rightChild==oldPgno ); ++ } ++#endif ++ }else{ ++ /* The MemPage.idxShift flag indicates that cell indices might have ++ ** changed since idxParent was set and hence idxParent might be out ++ ** of date. So recompute the parent cell index by scanning all cells ++ ** and locating the one that points to the child we just came from. ++ */ ++ int i; ++ pCur->idx = pParent->nCell; ++ oldPgno = SWAB32(pCur->pBt, sqlitepager_pagenumber(pPage)); ++ for(i=0; inCell; i++){ ++ if( pParent->apCell[i]->h.leftChild==oldPgno ){ ++ pCur->idx = i; ++ break; ++ } ++ } ++ } ++} ++ ++/* ++** Move the cursor to the root page ++*/ ++static int moveToRoot(BtCursor *pCur){ ++ MemPage *pNew; ++ int rc; ++ Btree *pBt = pCur->pBt; ++ ++ rc = sqlitepager_get(pBt->pPager, pCur->pgnoRoot, (void**)&pNew); ++ if( rc ) return rc; ++ rc = initPage(pBt, pNew, pCur->pgnoRoot, 0); ++ if( rc ) return rc; ++ sqlitepager_unref(pCur->pPage); ++ pCur->pPage = pNew; ++ pCur->idx = 0; ++ return SQLITE_OK; ++} ++ ++/* ++** Move the cursor down to the left-most leaf entry beneath the ++** entry to which it is currently pointing. ++*/ ++static int moveToLeftmost(BtCursor *pCur){ ++ Pgno pgno; ++ int rc; ++ ++ while( (pgno = pCur->pPage->apCell[pCur->idx]->h.leftChild)!=0 ){ ++ rc = moveToChild(pCur, pgno); ++ if( rc ) return rc; ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** 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*. ++*/ ++static int moveToRightmost(BtCursor *pCur){ ++ Pgno pgno; ++ int rc; ++ ++ while( (pgno = pCur->pPage->u.hdr.rightChild)!=0 ){ ++ pCur->idx = pCur->pPage->nCell; ++ rc = moveToChild(pCur, pgno); ++ if( rc ) return rc; ++ } ++ pCur->idx = pCur->pPage->nCell - 1; ++ 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. ++*/ ++static int fileBtreeFirst(BtCursor *pCur, int *pRes){ ++ int rc; ++ if( pCur->pPage==0 ) return SQLITE_ABORT; ++ rc = moveToRoot(pCur); ++ if( rc ) return rc; ++ if( pCur->pPage->nCell==0 ){ ++ *pRes = 1; ++ return SQLITE_OK; ++ } ++ *pRes = 0; ++ rc = moveToLeftmost(pCur); ++ pCur->eSkip = SKIP_NONE; ++ 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. ++*/ ++static int fileBtreeLast(BtCursor *pCur, int *pRes){ ++ int rc; ++ if( pCur->pPage==0 ) return SQLITE_ABORT; ++ rc = moveToRoot(pCur); ++ if( rc ) return rc; ++ assert( pCur->pPage->isInit ); ++ if( pCur->pPage->nCell==0 ){ ++ *pRes = 1; ++ return SQLITE_OK; ++ } ++ *pRes = 0; ++ rc = moveToRightmost(pCur); ++ pCur->eSkip = SKIP_NONE; ++ return rc; ++} ++ ++/* Move the cursor so that it points to an entry near pKey. ++** Return a success code. ++** ++** 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. ++** ++** The result of comparing the key with the entry to which the ++** cursor is left pointing is stored in pCur->iMatch. The same ++** value is also written to *pRes if pRes!=NULL. The meaning of ++** this value is as follows: ++** ++** *pRes<0 The cursor is left pointing at an entry that ++** is smaller than pKey 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 pKey. ++** ++** *pRes>0 The cursor is left pointing at an entry that ++** is larger than pKey. ++*/ ++static ++int fileBtreeMoveto(BtCursor *pCur, const void *pKey, int nKey, int *pRes){ ++ int rc; ++ if( pCur->pPage==0 ) return SQLITE_ABORT; ++ pCur->eSkip = SKIP_NONE; ++ rc = moveToRoot(pCur); ++ if( rc ) return rc; ++ for(;;){ ++ int lwr, upr; ++ Pgno chldPg; ++ MemPage *pPage = pCur->pPage; ++ int c = -1; /* pRes return if table is empty must be -1 */ ++ lwr = 0; ++ upr = pPage->nCell-1; ++ while( lwr<=upr ){ ++ pCur->idx = (lwr+upr)/2; ++ rc = fileBtreeKeyCompare(pCur, pKey, nKey, 0, &c); ++ if( rc ) return rc; ++ if( c==0 ){ ++ pCur->iMatch = c; ++ if( pRes ) *pRes = 0; ++ return SQLITE_OK; ++ } ++ if( c<0 ){ ++ lwr = pCur->idx+1; ++ }else{ ++ upr = pCur->idx-1; ++ } ++ } ++ assert( lwr==upr+1 ); ++ assert( pPage->isInit ); ++ if( lwr>=pPage->nCell ){ ++ chldPg = pPage->u.hdr.rightChild; ++ }else{ ++ chldPg = pPage->apCell[lwr]->h.leftChild; ++ } ++ if( chldPg==0 ){ ++ pCur->iMatch = c; ++ if( pRes ) *pRes = c; ++ return SQLITE_OK; ++ } ++ pCur->idx = lwr; ++ rc = moveToChild(pCur, chldPg); ++ if( rc ) return rc; ++ } ++ /* NOT REACHED */ ++} ++ ++/* ++** 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. ++*/ ++static int fileBtreeNext(BtCursor *pCur, int *pRes){ ++ int rc; ++ MemPage *pPage = pCur->pPage; ++ assert( pRes!=0 ); ++ if( pPage==0 ){ ++ *pRes = 1; ++ return SQLITE_ABORT; ++ } ++ assert( pPage->isInit ); ++ assert( pCur->eSkip!=SKIP_INVALID ); ++ if( pPage->nCell==0 ){ ++ *pRes = 1; ++ return SQLITE_OK; ++ } ++ assert( pCur->idxnCell ); ++ if( pCur->eSkip==SKIP_NEXT ){ ++ pCur->eSkip = SKIP_NONE; ++ *pRes = 0; ++ return SQLITE_OK; ++ } ++ pCur->eSkip = SKIP_NONE; ++ pCur->idx++; ++ if( pCur->idx>=pPage->nCell ){ ++ if( pPage->u.hdr.rightChild ){ ++ rc = moveToChild(pCur, pPage->u.hdr.rightChild); ++ if( rc ) return rc; ++ rc = moveToLeftmost(pCur); ++ *pRes = 0; ++ return rc; ++ } ++ do{ ++ if( pPage->pParent==0 ){ ++ *pRes = 1; ++ return SQLITE_OK; ++ } ++ moveToParent(pCur); ++ pPage = pCur->pPage; ++ }while( pCur->idx>=pPage->nCell ); ++ *pRes = 0; ++ return SQLITE_OK; ++ } ++ *pRes = 0; ++ if( pPage->u.hdr.rightChild==0 ){ ++ return SQLITE_OK; ++ } ++ rc = moveToLeftmost(pCur); ++ return rc; ++} ++ ++/* ++** 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. ++*/ ++static int fileBtreePrevious(BtCursor *pCur, int *pRes){ ++ int rc; ++ Pgno pgno; ++ MemPage *pPage; ++ pPage = pCur->pPage; ++ if( pPage==0 ){ ++ *pRes = 1; ++ return SQLITE_ABORT; ++ } ++ assert( pPage->isInit ); ++ assert( pCur->eSkip!=SKIP_INVALID ); ++ if( pPage->nCell==0 ){ ++ *pRes = 1; ++ return SQLITE_OK; ++ } ++ if( pCur->eSkip==SKIP_PREV ){ ++ pCur->eSkip = SKIP_NONE; ++ *pRes = 0; ++ return SQLITE_OK; ++ } ++ pCur->eSkip = SKIP_NONE; ++ assert( pCur->idx>=0 ); ++ if( (pgno = pPage->apCell[pCur->idx]->h.leftChild)!=0 ){ ++ rc = moveToChild(pCur, pgno); ++ if( rc ) return rc; ++ rc = moveToRightmost(pCur); ++ }else{ ++ while( pCur->idx==0 ){ ++ if( pPage->pParent==0 ){ ++ if( pRes ) *pRes = 1; ++ return SQLITE_OK; ++ } ++ moveToParent(pCur); ++ pPage = pCur->pPage; ++ } ++ pCur->idx--; ++ rc = SQLITE_OK; ++ } ++ *pRes = 0; ++ return rc; ++} ++ ++/* ++** Allocate a new page from the database file. ++** ++** The new page is marked as dirty. (In other words, sqlitepager_write() ++** has already been called on the new page.) The new page has also ++** been referenced and the calling routine is responsible for calling ++** sqlitepager_unref() on the new page when it is done. ++** ++** SQLITE_OK is returned on success. Any other return value indicates ++** an error. *ppPage and *pPgno are undefined in the event of an error. ++** Do not invoke sqlitepager_unref() on *ppPage if an error is returned. ++** ++** If the "nearby" parameter is not 0, then a (feeble) 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. ++*/ ++static int allocatePage(Btree *pBt, MemPage **ppPage, Pgno *pPgno, Pgno nearby){ ++ PageOne *pPage1 = pBt->page1; ++ int rc; ++ if( pPage1->freeList ){ ++ OverflowPage *pOvfl; ++ FreelistInfo *pInfo; ++ ++ rc = sqlitepager_write(pPage1); ++ if( rc ) return rc; ++ SWAB_ADD(pBt, pPage1->nFree, -1); ++ rc = sqlitepager_get(pBt->pPager, SWAB32(pBt, pPage1->freeList), ++ (void**)&pOvfl); ++ if( rc ) return rc; ++ rc = sqlitepager_write(pOvfl); ++ if( rc ){ ++ sqlitepager_unref(pOvfl); ++ return rc; ++ } ++ pInfo = (FreelistInfo*)pOvfl->aPayload; ++ if( pInfo->nFree==0 ){ ++ *pPgno = SWAB32(pBt, pPage1->freeList); ++ pPage1->freeList = pOvfl->iNext; ++ *ppPage = (MemPage*)pOvfl; ++ }else{ ++ int closest, n; ++ n = SWAB32(pBt, pInfo->nFree); ++ if( n>1 && nearby>0 ){ ++ int i, dist; ++ closest = 0; ++ dist = SWAB32(pBt, pInfo->aFree[0]) - nearby; ++ if( dist<0 ) dist = -dist; ++ for(i=1; iaFree[i]) - nearby; ++ if( d2<0 ) d2 = -d2; ++ if( d2nFree, -1); ++ *pPgno = SWAB32(pBt, pInfo->aFree[closest]); ++ pInfo->aFree[closest] = pInfo->aFree[n-1]; ++ rc = sqlitepager_get(pBt->pPager, *pPgno, (void**)ppPage); ++ sqlitepager_unref(pOvfl); ++ if( rc==SQLITE_OK ){ ++ sqlitepager_dont_rollback(*ppPage); ++ rc = sqlitepager_write(*ppPage); ++ } ++ } ++ }else{ ++ *pPgno = sqlitepager_pagecount(pBt->pPager) + 1; ++ rc = sqlitepager_get(pBt->pPager, *pPgno, (void**)ppPage); ++ if( rc ) return rc; ++ rc = sqlitepager_write(*ppPage); ++ } ++ return rc; ++} ++ ++/* ++** Add a page of the database file to the freelist. Either pgno or ++** pPage but not both may be 0. ++** ++** sqlitepager_unref() is NOT called for pPage. ++*/ ++static int freePage(Btree *pBt, void *pPage, Pgno pgno){ ++ PageOne *pPage1 = pBt->page1; ++ OverflowPage *pOvfl = (OverflowPage*)pPage; ++ int rc; ++ int needUnref = 0; ++ MemPage *pMemPage; ++ ++ if( pgno==0 ){ ++ assert( pOvfl!=0 ); ++ pgno = sqlitepager_pagenumber(pOvfl); ++ } ++ assert( pgno>2 ); ++ assert( sqlitepager_pagenumber(pOvfl)==pgno ); ++ pMemPage = (MemPage*)pPage; ++ pMemPage->isInit = 0; ++ if( pMemPage->pParent ){ ++ sqlitepager_unref(pMemPage->pParent); ++ pMemPage->pParent = 0; ++ } ++ rc = sqlitepager_write(pPage1); ++ if( rc ){ ++ return rc; ++ } ++ SWAB_ADD(pBt, pPage1->nFree, 1); ++ if( pPage1->nFree!=0 && pPage1->freeList!=0 ){ ++ OverflowPage *pFreeIdx; ++ rc = sqlitepager_get(pBt->pPager, SWAB32(pBt, pPage1->freeList), ++ (void**)&pFreeIdx); ++ if( rc==SQLITE_OK ){ ++ FreelistInfo *pInfo = (FreelistInfo*)pFreeIdx->aPayload; ++ int n = SWAB32(pBt, pInfo->nFree); ++ if( n<(sizeof(pInfo->aFree)/sizeof(pInfo->aFree[0])) ){ ++ rc = sqlitepager_write(pFreeIdx); ++ if( rc==SQLITE_OK ){ ++ pInfo->aFree[n] = SWAB32(pBt, pgno); ++ SWAB_ADD(pBt, pInfo->nFree, 1); ++ sqlitepager_unref(pFreeIdx); ++ sqlitepager_dont_write(pBt->pPager, pgno); ++ return rc; ++ } ++ } ++ sqlitepager_unref(pFreeIdx); ++ } ++ } ++ if( pOvfl==0 ){ ++ assert( pgno>0 ); ++ rc = sqlitepager_get(pBt->pPager, pgno, (void**)&pOvfl); ++ if( rc ) return rc; ++ needUnref = 1; ++ } ++ rc = sqlitepager_write(pOvfl); ++ if( rc ){ ++ if( needUnref ) sqlitepager_unref(pOvfl); ++ return rc; ++ } ++ pOvfl->iNext = pPage1->freeList; ++ pPage1->freeList = SWAB32(pBt, pgno); ++ memset(pOvfl->aPayload, 0, OVERFLOW_SIZE); ++ if( needUnref ) rc = sqlitepager_unref(pOvfl); ++ return rc; ++} ++ ++/* ++** Erase all the data out of a cell. This involves returning overflow ++** pages back the freelist. ++*/ ++static int clearCell(Btree *pBt, Cell *pCell){ ++ Pager *pPager = pBt->pPager; ++ OverflowPage *pOvfl; ++ Pgno ovfl, nextOvfl; ++ int rc; ++ ++ if( NKEY(pBt, pCell->h) + NDATA(pBt, pCell->h) <= MX_LOCAL_PAYLOAD ){ ++ return SQLITE_OK; ++ } ++ ovfl = SWAB32(pBt, pCell->ovfl); ++ pCell->ovfl = 0; ++ while( ovfl ){ ++ rc = sqlitepager_get(pPager, ovfl, (void**)&pOvfl); ++ if( rc ) return rc; ++ nextOvfl = SWAB32(pBt, pOvfl->iNext); ++ rc = freePage(pBt, pOvfl, ovfl); ++ if( rc ) return rc; ++ sqlitepager_unref(pOvfl); ++ ovfl = nextOvfl; ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** Create a new cell from key and data. Overflow pages are allocated as ++** necessary and linked to this cell. ++*/ ++static int fillInCell( ++ Btree *pBt, /* The whole Btree. Needed to allocate pages */ ++ Cell *pCell, /* Populate this Cell structure */ ++ const void *pKey, int nKey, /* The key */ ++ const void *pData,int nData /* The data */ ++){ ++ OverflowPage *pOvfl, *pPrior; ++ Pgno *pNext; ++ int spaceLeft; ++ int n, rc; ++ int nPayload; ++ const char *pPayload; ++ char *pSpace; ++ Pgno nearby = 0; ++ ++ pCell->h.leftChild = 0; ++ pCell->h.nKey = SWAB16(pBt, nKey & 0xffff); ++ pCell->h.nKeyHi = nKey >> 16; ++ pCell->h.nData = SWAB16(pBt, nData & 0xffff); ++ pCell->h.nDataHi = nData >> 16; ++ pCell->h.iNext = 0; ++ ++ pNext = &pCell->ovfl; ++ pSpace = pCell->aPayload; ++ spaceLeft = MX_LOCAL_PAYLOAD; ++ pPayload = pKey; ++ pKey = 0; ++ nPayload = nKey; ++ pPrior = 0; ++ while( nPayload>0 ){ ++ if( spaceLeft==0 ){ ++ rc = allocatePage(pBt, (MemPage**)&pOvfl, pNext, nearby); ++ if( rc ){ ++ *pNext = 0; ++ }else{ ++ nearby = *pNext; ++ } ++ if( pPrior ) sqlitepager_unref(pPrior); ++ if( rc ){ ++ clearCell(pBt, pCell); ++ return rc; ++ } ++ if( pBt->needSwab ) *pNext = swab32(*pNext); ++ pPrior = pOvfl; ++ spaceLeft = OVERFLOW_SIZE; ++ pSpace = pOvfl->aPayload; ++ pNext = &pOvfl->iNext; ++ } ++ n = nPayload; ++ if( n>spaceLeft ) n = spaceLeft; ++ memcpy(pSpace, pPayload, n); ++ nPayload -= n; ++ if( nPayload==0 && pData ){ ++ pPayload = pData; ++ nPayload = nData; ++ pData = 0; ++ }else{ ++ pPayload += n; ++ } ++ spaceLeft -= n; ++ pSpace += n; ++ } ++ *pNext = 0; ++ if( pPrior ){ ++ sqlitepager_unref(pPrior); ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** Change the MemPage.pParent pointer on the page whose number is ++** given in the second argument so that MemPage.pParent holds the ++** pointer in the third argument. ++*/ ++static void reparentPage(Pager *pPager, Pgno pgno, MemPage *pNewParent,int idx){ ++ MemPage *pThis; ++ ++ if( pgno==0 ) return; ++ assert( pPager!=0 ); ++ pThis = sqlitepager_lookup(pPager, pgno); ++ if( pThis && pThis->isInit ){ ++ if( pThis->pParent!=pNewParent ){ ++ if( pThis->pParent ) sqlitepager_unref(pThis->pParent); ++ pThis->pParent = pNewParent; ++ if( pNewParent ) sqlitepager_ref(pNewParent); ++ } ++ pThis->idxParent = idx; ++ sqlitepager_unref(pThis); ++ } ++} ++ ++/* ++** Reparent all children of the given page to be the given page. ++** In other words, for every child of pPage, invoke reparentPage() ++** to make sure that each child knows that pPage is its parent. ++** ++** This routine gets called after you memcpy() one page into ++** another. ++*/ ++static void reparentChildPages(Btree *pBt, MemPage *pPage){ ++ int i; ++ Pager *pPager = pBt->pPager; ++ for(i=0; inCell; i++){ ++ reparentPage(pPager, SWAB32(pBt, pPage->apCell[i]->h.leftChild), pPage, i); ++ } ++ reparentPage(pPager, SWAB32(pBt, pPage->u.hdr.rightChild), pPage, i); ++ pPage->idxShift = 0; ++} ++ ++/* ++** 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. ++** ++** Do not bother maintaining the integrity of the linked list of Cells. ++** Only the pPage->apCell[] array is important. The relinkCellList() ++** routine will be called soon after this routine in order to rebuild ++** the linked list. ++*/ ++static void dropCell(Btree *pBt, MemPage *pPage, int idx, int sz){ ++ int j; ++ assert( idx>=0 && idxnCell ); ++ assert( sz==cellSize(pBt, pPage->apCell[idx]) ); ++ assert( sqlitepager_iswriteable(pPage) ); ++ freeSpace(pBt, pPage, Addr(pPage->apCell[idx]) - Addr(pPage), sz); ++ for(j=idx; jnCell-1; j++){ ++ pPage->apCell[j] = pPage->apCell[j+1]; ++ } ++ pPage->nCell--; ++ pPage->idxShift = 1; ++} ++ ++/* ++** 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 just make pPage->apCell[i] point to the content ++** and set pPage->isOverfull. ++** ++** Do not bother maintaining the integrity of the linked list of Cells. ++** Only the pPage->apCell[] array is important. The relinkCellList() ++** routine will be called soon after this routine in order to rebuild ++** the linked list. ++*/ ++static void insertCell(Btree *pBt, MemPage *pPage, int i, Cell *pCell, int sz){ ++ int idx, j; ++ assert( i>=0 && i<=pPage->nCell ); ++ assert( sz==cellSize(pBt, pCell) ); ++ assert( sqlitepager_iswriteable(pPage) ); ++ idx = allocateSpace(pBt, pPage, sz); ++ for(j=pPage->nCell; j>i; j--){ ++ pPage->apCell[j] = pPage->apCell[j-1]; ++ } ++ pPage->nCell++; ++ if( idx<=0 ){ ++ pPage->isOverfull = 1; ++ pPage->apCell[i] = pCell; ++ }else{ ++ memcpy(&pPage->u.aDisk[idx], pCell, sz); ++ pPage->apCell[i] = (Cell*)&pPage->u.aDisk[idx]; ++ } ++ pPage->idxShift = 1; ++} ++ ++/* ++** Rebuild the linked list of cells on a page so that the cells ++** occur in the order specified by the pPage->apCell[] array. ++** Invoke this routine once to repair damage after one or more ++** invocations of either insertCell() or dropCell(). ++*/ ++static void relinkCellList(Btree *pBt, MemPage *pPage){ ++ int i; ++ u16 *pIdx; ++ assert( sqlitepager_iswriteable(pPage) ); ++ pIdx = &pPage->u.hdr.firstCell; ++ for(i=0; inCell; i++){ ++ int idx = Addr(pPage->apCell[i]) - Addr(pPage); ++ assert( idx>0 && idxapCell[i]->h.iNext; ++ } ++ *pIdx = 0; ++} ++ ++/* ++** Make a copy of the contents of pFrom into pTo. The pFrom->apCell[] ++** pointers that point into pFrom->u.aDisk[] must be adjusted to point ++** into pTo->u.aDisk[] instead. But some pFrom->apCell[] entries might ++** not point to pFrom->u.aDisk[]. Those are unchanged. ++*/ ++static void copyPage(MemPage *pTo, MemPage *pFrom){ ++ uptr from, to; ++ int i; ++ memcpy(pTo->u.aDisk, pFrom->u.aDisk, SQLITE_USABLE_SIZE); ++ pTo->pParent = 0; ++ pTo->isInit = 1; ++ pTo->nCell = pFrom->nCell; ++ pTo->nFree = pFrom->nFree; ++ pTo->isOverfull = pFrom->isOverfull; ++ to = Addr(pTo); ++ from = Addr(pFrom); ++ for(i=0; inCell; i++){ ++ uptr x = Addr(pFrom->apCell[i]); ++ if( x>from && xapCell[i]) = x + to - from; ++ }else{ ++ pTo->apCell[i] = pFrom->apCell[i]; ++ } ++ } ++} ++ ++/* ++** 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 */ ++ ++/* ++** This routine redistributes Cells on pPage and up to two siblings ++** of pPage so that all pages have about the same amount of free space. ++** Usually one sibling on either side of pPage is used in the balancing, ++** though both siblings might come from one side if pPage is the first ++** or last child of its parent. If pPage has fewer than two siblings ++** (something which can only happen if pPage is the root page or a ++** child of root) then all available siblings participate in the balancing. ++** ++** The number of siblings of pPage might be increased or decreased by ++** one in an effort to keep pages between 66% and 100% full. The root page ++** is special and is allowed to be less than 66% full. If pPage is ++** the root page, then the depth of the tree might be increased ++** or decreased by one, as necessary, to keep the root page from being ++** overfull or empty. ++** ++** This routine calls relinkCellList() on its input page regardless of ++** whether or not it does any real balancing. Client routines will typically ++** invoke insertCell() or dropCell() before calling this routine, so we ++** need to call relinkCellList() to clean up the mess that those other ++** routines left behind. ++** ++** pCur is left pointing to the same cell as when this routine was called ++** even if that cell gets moved to a different page. pCur may be NULL. ++** Set the pCur parameter to NULL if you do not care about keeping track ++** of a cell as that will save this routine the work of keeping track of it. ++** ++** Note that when this routine is called, some of the Cells on pPage ++** might not actually be stored in pPage->u.aDisk[]. This can happen ++** if the page is overfull. Part of the job of this routine is to ++** make sure all Cells for pPage once again fit in pPage->u.aDisk[]. ++** ++** In the course of balancing the siblings of pPage, the parent of pPage ++** might become overfull or underfull. If that happens, then this routine ++** is called recursively on the parent. ++** ++** 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. ++*/ ++static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){ ++ MemPage *pParent; /* The parent of pPage */ ++ int nCell; /* Number of cells in apCell[] */ ++ int nOld; /* Number of pages in apOld[] */ ++ int nNew; /* Number of pages in apNew[] */ ++ int nDiv; /* Number of cells in apDiv[] */ ++ int i, j, k; /* Loop counters */ ++ int idx; /* Index of pPage in pParent->apCell[] */ ++ int nxDiv; /* Next divider slot in pParent->apCell[] */ ++ int rc; /* The return code */ ++ int iCur; /* apCell[iCur] is the cell of the cursor */ ++ MemPage *pOldCurPage; /* The cursor originally points to this page */ ++ int subtotal; /* Subtotal of bytes in cells on one page */ ++ MemPage *extraUnref = 0; /* A page that needs to be unref-ed */ ++ MemPage *apOld[NB]; /* pPage and up to two siblings */ ++ Pgno pgnoOld[NB]; /* Page numbers for each page in apOld[] */ ++ MemPage *apNew[NB+1]; /* pPage and up to NB siblings after balancing */ ++ Pgno pgnoNew[NB+1]; /* Page numbers for each page in apNew[] */ ++ int idxDiv[NB]; /* Indices of divider cells in pParent */ ++ Cell *apDiv[NB]; /* Divider cells in pParent */ ++ Cell aTemp[NB]; /* Temporary holding area for apDiv[] */ ++ int cntNew[NB+1]; /* Index in apCell[] of cell after i-th page */ ++ int szNew[NB+1]; /* Combined size of cells place on i-th page */ ++ MemPage aOld[NB]; /* Temporary copies of pPage and its siblings */ ++ Cell *apCell[(MX_CELL+2)*NB]; /* All cells from pages being balanced */ ++ int szCell[(MX_CELL+2)*NB]; /* Local size of all cells */ ++ ++ /* ++ ** Return without doing any work if pPage is neither overfull nor ++ ** underfull. ++ */ ++ assert( sqlitepager_iswriteable(pPage) ); ++ if( !pPage->isOverfull && pPage->nFreenCell>=2){ ++ relinkCellList(pBt, pPage); ++ return SQLITE_OK; ++ } ++ ++ /* ++ ** Find the parent of the page to be balanceed. ++ ** If there is no parent, it means this page is the root page and ++ ** special rules apply. ++ */ ++ pParent = pPage->pParent; ++ if( pParent==0 ){ ++ Pgno pgnoChild; ++ MemPage *pChild; ++ assert( pPage->isInit ); ++ if( pPage->nCell==0 ){ ++ if( pPage->u.hdr.rightChild ){ ++ /* ++ ** The root page is empty. Copy the one child page ++ ** into the root page and return. This reduces the depth ++ ** of the BTree by one. ++ */ ++ pgnoChild = SWAB32(pBt, pPage->u.hdr.rightChild); ++ rc = sqlitepager_get(pBt->pPager, pgnoChild, (void**)&pChild); ++ if( rc ) return rc; ++ memcpy(pPage, pChild, SQLITE_USABLE_SIZE); ++ pPage->isInit = 0; ++ rc = initPage(pBt, pPage, sqlitepager_pagenumber(pPage), 0); ++ assert( rc==SQLITE_OK ); ++ reparentChildPages(pBt, pPage); ++ if( pCur && pCur->pPage==pChild ){ ++ sqlitepager_unref(pChild); ++ pCur->pPage = pPage; ++ sqlitepager_ref(pPage); ++ } ++ freePage(pBt, pChild, pgnoChild); ++ sqlitepager_unref(pChild); ++ }else{ ++ relinkCellList(pBt, pPage); ++ } ++ return SQLITE_OK; ++ } ++ if( !pPage->isOverfull ){ ++ /* It is OK for the root page to be less than half full. ++ */ ++ relinkCellList(pBt, pPage); ++ return SQLITE_OK; ++ } ++ /* ++ ** If we get to here, it means the root page is overfull. ++ ** When this happens, Create a new child page and copy the ++ ** contents of the root into the child. Then make the root ++ ** page an empty page with rightChild pointing to the new ++ ** child. Then fall thru to the code below which will cause ++ ** the overfull child page to be split. ++ */ ++ rc = sqlitepager_write(pPage); ++ if( rc ) return rc; ++ rc = allocatePage(pBt, &pChild, &pgnoChild, sqlitepager_pagenumber(pPage)); ++ if( rc ) return rc; ++ assert( sqlitepager_iswriteable(pChild) ); ++ copyPage(pChild, pPage); ++ pChild->pParent = pPage; ++ pChild->idxParent = 0; ++ sqlitepager_ref(pPage); ++ pChild->isOverfull = 1; ++ if( pCur && pCur->pPage==pPage ){ ++ sqlitepager_unref(pPage); ++ pCur->pPage = pChild; ++ }else{ ++ extraUnref = pChild; ++ } ++ zeroPage(pBt, pPage); ++ pPage->u.hdr.rightChild = SWAB32(pBt, pgnoChild); ++ pParent = pPage; ++ pPage = pChild; ++ } ++ rc = sqlitepager_write(pParent); ++ if( rc ) return rc; ++ assert( pParent->isInit ); ++ ++ /* ++ ** Find the Cell in the parent page whose h.leftChild points back ++ ** to pPage. The "idx" variable is the index of that cell. If pPage ++ ** is the rightmost child of pParent then set idx to pParent->nCell ++ */ ++ if( pParent->idxShift ){ ++ Pgno pgno, swabPgno; ++ pgno = sqlitepager_pagenumber(pPage); ++ swabPgno = SWAB32(pBt, pgno); ++ for(idx=0; idxnCell; idx++){ ++ if( pParent->apCell[idx]->h.leftChild==swabPgno ){ ++ break; ++ } ++ } ++ assert( idxnCell || pParent->u.hdr.rightChild==swabPgno ); ++ }else{ ++ idx = pPage->idxParent; ++ } ++ ++ /* ++ ** Initialize variables so that it will be safe to jump ++ ** directly to balance_cleanup at any moment. ++ */ ++ nOld = nNew = 0; ++ sqlitepager_ref(pParent); ++ ++ /* ++ ** Find sibling pages to pPage and 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 ++ ** pPage there are fewer than NN siblings on the other side. If pParent ++ ** has NB or fewer children then all children of pParent are taken. ++ */ ++ nxDiv = idx - NN; ++ if( nxDiv + NB > pParent->nCell ){ ++ nxDiv = pParent->nCell - NB + 1; ++ } ++ if( nxDiv<0 ){ ++ nxDiv = 0; ++ } ++ nDiv = 0; ++ for(i=0, k=nxDiv; inCell ){ ++ idxDiv[i] = k; ++ apDiv[i] = pParent->apCell[k]; ++ nDiv++; ++ pgnoOld[i] = SWAB32(pBt, apDiv[i]->h.leftChild); ++ }else if( k==pParent->nCell ){ ++ pgnoOld[i] = SWAB32(pBt, pParent->u.hdr.rightChild); ++ }else{ ++ break; ++ } ++ rc = sqlitepager_get(pBt->pPager, pgnoOld[i], (void**)&apOld[i]); ++ if( rc ) goto balance_cleanup; ++ rc = initPage(pBt, apOld[i], pgnoOld[i], pParent); ++ if( rc ) goto balance_cleanup; ++ apOld[i]->idxParent = k; ++ nOld++; ++ } ++ ++ /* ++ ** Set iCur to be the index in apCell[] of the cell that the cursor ++ ** is pointing to. We will need this later on in order to keep the ++ ** cursor pointing at the same cell. If pCur points to a page that ++ ** has no involvement with this rebalancing, then set iCur to a large ++ ** number so that the iCur==j tests always fail in the main cell ++ ** distribution loop below. ++ */ ++ if( pCur ){ ++ iCur = 0; ++ for(i=0; ipPage==apOld[i] ){ ++ iCur += pCur->idx; ++ break; ++ } ++ iCur += apOld[i]->nCell; ++ if( ipPage==pParent && pCur->idx==idxDiv[i] ){ ++ break; ++ } ++ iCur++; ++ } ++ pOldCurPage = pCur->pPage; ++ } ++ ++ /* ++ ** Make copies of the content of pPage and its siblings into aOld[]. ++ ** The rest of this function will use data from the copies rather ++ ** that the original pages since the original pages will be in the ++ ** process of being overwritten. ++ */ ++ for(i=0; inCell; j++){ ++ apCell[nCell] = pOld->apCell[j]; ++ szCell[nCell] = cellSize(pBt, apCell[nCell]); ++ nCell++; ++ } ++ if( ih.leftChild)==pgnoOld[i] ); ++ apCell[nCell]->h.leftChild = pOld->u.hdr.rightChild; ++ nCell++; ++ } ++ } ++ ++ /* ++ ** Figure out the number of pages needed to hold all 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 apCell[] of the cell that divides path i from path i+1. ++ ** cntNew[k] should equal nCell. ++ ** ++ ** This little patch of code is critical for keeping the tree ++ ** balanced. ++ */ ++ for(subtotal=k=i=0; i USABLE_SPACE ){ ++ szNew[k] = subtotal - szCell[i]; ++ cntNew[k] = i; ++ subtotal = 0; ++ k++; ++ } ++ } ++ szNew[k] = subtotal; ++ cntNew[k] = nCell; ++ k++; ++ for(i=k-1; i>0; i--){ ++ while( szNew[i]0 ); ++ szNew[i] += szCell[cntNew[i-1]]; ++ szNew[i-1] -= szCell[cntNew[i-1]-1]; ++ } ++ } ++ assert( cntNew[0]>0 ); ++ ++ /* ++ ** Allocate k new pages. Reuse old pages where possible. ++ */ ++ for(i=0; iisInit = 1; ++ } ++ ++ /* Free any old pages that were not reused as new pages. ++ */ ++ while( ii ){ ++ int t; ++ MemPage *pT; ++ t = pgnoNew[i]; ++ pT = apNew[i]; ++ pgnoNew[i] = pgnoNew[minI]; ++ apNew[i] = apNew[minI]; ++ pgnoNew[minI] = t; ++ apNew[minI] = pT; ++ } ++ } ++ ++ /* ++ ** Evenly distribute the data in apCell[] across the new pages. ++ ** Insert divider cells into pParent as necessary. ++ */ ++ j = 0; ++ for(i=0; inFree>=szCell[j] ); ++ if( pCur && iCur==j ){ pCur->pPage = pNew; pCur->idx = pNew->nCell; } ++ insertCell(pBt, pNew, pNew->nCell, apCell[j], szCell[j]); ++ j++; ++ } ++ assert( pNew->nCell>0 ); ++ assert( !pNew->isOverfull ); ++ relinkCellList(pBt, pNew); ++ if( iu.hdr.rightChild = apCell[j]->h.leftChild; ++ apCell[j]->h.leftChild = SWAB32(pBt, pgnoNew[i]); ++ if( pCur && iCur==j ){ pCur->pPage = pParent; pCur->idx = nxDiv; } ++ insertCell(pBt, pParent, nxDiv, apCell[j], szCell[j]); ++ j++; ++ nxDiv++; ++ } ++ } ++ assert( j==nCell ); ++ apNew[nNew-1]->u.hdr.rightChild = aOld[nOld-1].u.hdr.rightChild; ++ if( nxDiv==pParent->nCell ){ ++ pParent->u.hdr.rightChild = SWAB32(pBt, pgnoNew[nNew-1]); ++ }else{ ++ pParent->apCell[nxDiv]->h.leftChild = SWAB32(pBt, pgnoNew[nNew-1]); ++ } ++ if( pCur ){ ++ if( j<=iCur && pCur->pPage==pParent && pCur->idx>idxDiv[nOld-1] ){ ++ assert( pCur->pPage==pOldCurPage ); ++ pCur->idx += nNew - nOld; ++ }else{ ++ assert( pOldCurPage!=0 ); ++ sqlitepager_ref(pCur->pPage); ++ sqlitepager_unref(pOldCurPage); ++ } ++ } ++ ++ /* ++ ** Reparent children of all cells. ++ */ ++ for(i=0; ipPage==0 ){ ++ pCur->pPage = pParent; ++ pCur->idx = 0; ++ }else{ ++ sqlitepager_unref(pParent); ++ } ++ return rc; ++} ++ ++/* ++** This routine checks all cursors that point to the same table ++** as pCur points to. If any of those cursors were opened with ++** wrFlag==0 then this routine returns SQLITE_LOCKED. If all ++** cursors point to the same table were opened with wrFlag==1 ++** then this routine returns SQLITE_OK. ++** ++** In addition to checking for read-locks (where a read-lock ++** means a cursor opened with wrFlag==0) this routine also moves ++** all cursors other than pCur so that they are pointing to the ++** first Cell on root page. This is necessary because an insert ++** or delete might change the number of cells on a page or delete ++** a page entirely and we do not want to leave any cursors ++** pointing to non-existant pages or cells. ++*/ ++static int checkReadLocks(BtCursor *pCur){ ++ BtCursor *p; ++ assert( pCur->wrFlag ); ++ for(p=pCur->pShared; p!=pCur; p=p->pShared){ ++ assert( p ); ++ assert( p->pgnoRoot==pCur->pgnoRoot ); ++ if( p->wrFlag==0 ) return SQLITE_LOCKED; ++ if( sqlitepager_pagenumber(p->pPage)!=p->pgnoRoot ){ ++ moveToRoot(p); ++ } ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** 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 database the record should be inserted into. The cursor ++** is left pointing at the new record. ++*/ ++static int fileBtreeInsert( ++ BtCursor *pCur, /* Insert data into the table of this cursor */ ++ const void *pKey, int nKey, /* The key of the new record */ ++ const void *pData, int nData /* The data of the new record */ ++){ ++ Cell newCell; ++ int rc; ++ int loc; ++ int szNew; ++ MemPage *pPage; ++ Btree *pBt = pCur->pBt; ++ ++ if( pCur->pPage==0 ){ ++ return SQLITE_ABORT; /* A rollback destroyed this cursor */ ++ } ++ if( !pBt->inTrans || nKey+nData==0 ){ ++ /* Must start a transaction before doing an insert */ ++ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; ++ } ++ assert( !pBt->readOnly ); ++ if( !pCur->wrFlag ){ ++ return SQLITE_PERM; /* Cursor not open for writing */ ++ } ++ if( checkReadLocks(pCur) ){ ++ return SQLITE_LOCKED; /* The table pCur points to has a read lock */ ++ } ++ rc = fileBtreeMoveto(pCur, pKey, nKey, &loc); ++ if( rc ) return rc; ++ pPage = pCur->pPage; ++ assert( pPage->isInit ); ++ rc = sqlitepager_write(pPage); ++ if( rc ) return rc; ++ rc = fillInCell(pBt, &newCell, pKey, nKey, pData, nData); ++ if( rc ) return rc; ++ szNew = cellSize(pBt, &newCell); ++ if( loc==0 ){ ++ newCell.h.leftChild = pPage->apCell[pCur->idx]->h.leftChild; ++ rc = clearCell(pBt, pPage->apCell[pCur->idx]); ++ if( rc ) return rc; ++ dropCell(pBt, pPage, pCur->idx, cellSize(pBt, pPage->apCell[pCur->idx])); ++ }else if( loc<0 && pPage->nCell>0 ){ ++ assert( pPage->u.hdr.rightChild==0 ); /* Must be a leaf page */ ++ pCur->idx++; ++ }else{ ++ assert( pPage->u.hdr.rightChild==0 ); /* Must be a leaf page */ ++ } ++ insertCell(pBt, pPage, pCur->idx, &newCell, szNew); ++ rc = balance(pCur->pBt, pPage, pCur); ++ /* sqliteBtreePageDump(pCur->pBt, pCur->pgnoRoot, 1); */ ++ /* fflush(stdout); */ ++ pCur->eSkip = SKIP_INVALID; ++ return rc; ++} ++ ++/* ++** Delete the entry that the cursor is pointing to. ++** ++** The cursor is left pointing at either the next or the previous ++** entry. If the cursor is left pointing to the next entry, then ++** the pCur->eSkip flag is set to SKIP_NEXT which forces the next call to ++** sqliteBtreeNext() to be a no-op. That way, you can always call ++** sqliteBtreeNext() after a delete and the cursor will be left ++** pointing to the first entry after the deleted entry. Similarly, ++** pCur->eSkip is set to SKIP_PREV is the cursor is left pointing to ++** the entry prior to the deleted entry so that a subsequent call to ++** sqliteBtreePrevious() will always leave the cursor pointing at the ++** entry immediately before the one that was deleted. ++*/ ++static int fileBtreeDelete(BtCursor *pCur){ ++ MemPage *pPage = pCur->pPage; ++ Cell *pCell; ++ int rc; ++ Pgno pgnoChild; ++ Btree *pBt = pCur->pBt; ++ ++ assert( pPage->isInit ); ++ if( pCur->pPage==0 ){ ++ return SQLITE_ABORT; /* A rollback destroyed this cursor */ ++ } ++ if( !pBt->inTrans ){ ++ /* Must start a transaction before doing a delete */ ++ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; ++ } ++ assert( !pBt->readOnly ); ++ if( pCur->idx >= pPage->nCell ){ ++ return SQLITE_ERROR; /* The cursor is not pointing to anything */ ++ } ++ if( !pCur->wrFlag ){ ++ return SQLITE_PERM; /* Did not open this cursor for writing */ ++ } ++ if( checkReadLocks(pCur) ){ ++ return SQLITE_LOCKED; /* The table pCur points to has a read lock */ ++ } ++ rc = sqlitepager_write(pPage); ++ if( rc ) return rc; ++ pCell = pPage->apCell[pCur->idx]; ++ pgnoChild = SWAB32(pBt, pCell->h.leftChild); ++ clearCell(pBt, pCell); ++ if( pgnoChild ){ ++ /* ++ ** The entry we are about to delete is not a leaf so if we do not ++ ** do something we will leave a hole on an internal page. ++ ** We have to fill the hole by moving in a cell from a leaf. The ++ ** next Cell after the one to be deleted is guaranteed to exist and ++ ** to be a leaf so we can use it. ++ */ ++ BtCursor leafCur; ++ Cell *pNext; ++ int szNext; ++ int notUsed; ++ getTempCursor(pCur, &leafCur); ++ rc = fileBtreeNext(&leafCur, ¬Used); ++ if( rc!=SQLITE_OK ){ ++ if( rc!=SQLITE_NOMEM ) rc = SQLITE_CORRUPT; ++ return rc; ++ } ++ rc = sqlitepager_write(leafCur.pPage); ++ if( rc ) return rc; ++ dropCell(pBt, pPage, pCur->idx, cellSize(pBt, pCell)); ++ pNext = leafCur.pPage->apCell[leafCur.idx]; ++ szNext = cellSize(pBt, pNext); ++ pNext->h.leftChild = SWAB32(pBt, pgnoChild); ++ insertCell(pBt, pPage, pCur->idx, pNext, szNext); ++ rc = balance(pBt, pPage, pCur); ++ if( rc ) return rc; ++ pCur->eSkip = SKIP_NEXT; ++ dropCell(pBt, leafCur.pPage, leafCur.idx, szNext); ++ rc = balance(pBt, leafCur.pPage, pCur); ++ releaseTempCursor(&leafCur); ++ }else{ ++ dropCell(pBt, pPage, pCur->idx, cellSize(pBt, pCell)); ++ if( pCur->idx>=pPage->nCell ){ ++ pCur->idx = pPage->nCell-1; ++ if( pCur->idx<0 ){ ++ pCur->idx = 0; ++ pCur->eSkip = SKIP_NEXT; ++ }else{ ++ pCur->eSkip = SKIP_PREV; ++ } ++ }else{ ++ pCur->eSkip = SKIP_NEXT; ++ } ++ rc = balance(pBt, pPage, pCur); ++ } ++ return rc; ++} ++ ++/* ++** Create a new BTree table. Write into *piTable the page ++** number for the root page of the new table. ++** ++** In the current implementation, BTree tables and BTree indices are the ++** the same. In the future, we may change this so that BTree tables ++** are restricted to having a 4-byte integer key and arbitrary data and ++** BTree indices are restricted to having an arbitrary key and no data. ++** But for now, this routine also serves to create indices. ++*/ ++static int fileBtreeCreateTable(Btree *pBt, int *piTable){ ++ MemPage *pRoot; ++ Pgno pgnoRoot; ++ int rc; ++ if( !pBt->inTrans ){ ++ /* Must start a transaction first */ ++ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; ++ } ++ if( pBt->readOnly ){ ++ return SQLITE_READONLY; ++ } ++ rc = allocatePage(pBt, &pRoot, &pgnoRoot, 0); ++ if( rc ) return rc; ++ assert( sqlitepager_iswriteable(pRoot) ); ++ zeroPage(pBt, pRoot); ++ sqlitepager_unref(pRoot); ++ *piTable = (int)pgnoRoot; ++ return SQLITE_OK; ++} ++ ++/* ++** Erase the given database page and all its children. Return ++** the page to the freelist. ++*/ ++static int clearDatabasePage(Btree *pBt, Pgno pgno, int freePageFlag){ ++ MemPage *pPage; ++ int rc; ++ Cell *pCell; ++ int idx; ++ ++ rc = sqlitepager_get(pBt->pPager, pgno, (void**)&pPage); ++ if( rc ) return rc; ++ rc = sqlitepager_write(pPage); ++ if( rc ) return rc; ++ rc = initPage(pBt, pPage, pgno, 0); ++ if( rc ) return rc; ++ idx = SWAB16(pBt, pPage->u.hdr.firstCell); ++ while( idx>0 ){ ++ pCell = (Cell*)&pPage->u.aDisk[idx]; ++ idx = SWAB16(pBt, pCell->h.iNext); ++ if( pCell->h.leftChild ){ ++ rc = clearDatabasePage(pBt, SWAB32(pBt, pCell->h.leftChild), 1); ++ if( rc ) return rc; ++ } ++ rc = clearCell(pBt, pCell); ++ if( rc ) return rc; ++ } ++ if( pPage->u.hdr.rightChild ){ ++ rc = clearDatabasePage(pBt, SWAB32(pBt, pPage->u.hdr.rightChild), 1); ++ if( rc ) return rc; ++ } ++ if( freePageFlag ){ ++ rc = freePage(pBt, pPage, pgno); ++ }else{ ++ zeroPage(pBt, pPage); ++ } ++ sqlitepager_unref(pPage); ++ return rc; ++} ++ ++/* ++** Delete all information from a single table in the database. ++*/ ++static int fileBtreeClearTable(Btree *pBt, int iTable){ ++ int rc; ++ BtCursor *pCur; ++ if( !pBt->inTrans ){ ++ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; ++ } ++ for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ ++ if( pCur->pgnoRoot==(Pgno)iTable ){ ++ if( pCur->wrFlag==0 ) return SQLITE_LOCKED; ++ moveToRoot(pCur); ++ } ++ } ++ rc = clearDatabasePage(pBt, (Pgno)iTable, 0); ++ if( rc ){ ++ fileBtreeRollback(pBt); ++ } ++ return rc; ++} ++ ++/* ++** 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 2) is never added to the freelist. ++*/ ++static int fileBtreeDropTable(Btree *pBt, int iTable){ ++ int rc; ++ MemPage *pPage; ++ BtCursor *pCur; ++ if( !pBt->inTrans ){ ++ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; ++ } ++ for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ ++ if( pCur->pgnoRoot==(Pgno)iTable ){ ++ return SQLITE_LOCKED; /* Cannot drop a table that has a cursor */ ++ } ++ } ++ rc = sqlitepager_get(pBt->pPager, (Pgno)iTable, (void**)&pPage); ++ if( rc ) return rc; ++ rc = fileBtreeClearTable(pBt, iTable); ++ if( rc ) return rc; ++ if( iTable>2 ){ ++ rc = freePage(pBt, pPage, iTable); ++ }else{ ++ zeroPage(pBt, pPage); ++ } ++ sqlitepager_unref(pPage); ++ return rc; ++} ++ ++#if 0 /* UNTESTED */ ++/* ++** Copy all cell data from one database file into another. ++** pages back the freelist. ++*/ ++static int copyCell(Btree *pBtFrom, BTree *pBtTo, Cell *pCell){ ++ Pager *pFromPager = pBtFrom->pPager; ++ OverflowPage *pOvfl; ++ Pgno ovfl, nextOvfl; ++ Pgno *pPrev; ++ int rc = SQLITE_OK; ++ MemPage *pNew, *pPrevPg; ++ Pgno new; ++ ++ if( NKEY(pBtTo, pCell->h) + NDATA(pBtTo, pCell->h) <= MX_LOCAL_PAYLOAD ){ ++ return SQLITE_OK; ++ } ++ pPrev = &pCell->ovfl; ++ pPrevPg = 0; ++ ovfl = SWAB32(pBtTo, pCell->ovfl); ++ while( ovfl && rc==SQLITE_OK ){ ++ rc = sqlitepager_get(pFromPager, ovfl, (void**)&pOvfl); ++ if( rc ) return rc; ++ nextOvfl = SWAB32(pBtFrom, pOvfl->iNext); ++ rc = allocatePage(pBtTo, &pNew, &new, 0); ++ if( rc==SQLITE_OK ){ ++ rc = sqlitepager_write(pNew); ++ if( rc==SQLITE_OK ){ ++ memcpy(pNew, pOvfl, SQLITE_USABLE_SIZE); ++ *pPrev = SWAB32(pBtTo, new); ++ if( pPrevPg ){ ++ sqlitepager_unref(pPrevPg); ++ } ++ pPrev = &pOvfl->iNext; ++ pPrevPg = pNew; ++ } ++ } ++ sqlitepager_unref(pOvfl); ++ ovfl = nextOvfl; ++ } ++ if( pPrevPg ){ ++ sqlitepager_unref(pPrevPg); ++ } ++ return rc; ++} ++#endif ++ ++ ++#if 0 /* UNTESTED */ ++/* ++** Copy a page of data from one database over to another. ++*/ ++static int copyDatabasePage( ++ Btree *pBtFrom, ++ Pgno pgnoFrom, ++ Btree *pBtTo, ++ Pgno *pTo ++){ ++ MemPage *pPageFrom, *pPage; ++ Pgno to; ++ int rc; ++ Cell *pCell; ++ int idx; ++ ++ rc = sqlitepager_get(pBtFrom->pPager, pgno, (void**)&pPageFrom); ++ if( rc ) return rc; ++ rc = allocatePage(pBt, &pPage, pTo, 0); ++ if( rc==SQLITE_OK ){ ++ rc = sqlitepager_write(pPage); ++ } ++ if( rc==SQLITE_OK ){ ++ memcpy(pPage, pPageFrom, SQLITE_USABLE_SIZE); ++ idx = SWAB16(pBt, pPage->u.hdr.firstCell); ++ while( idx>0 ){ ++ pCell = (Cell*)&pPage->u.aDisk[idx]; ++ idx = SWAB16(pBt, pCell->h.iNext); ++ if( pCell->h.leftChild ){ ++ Pgno newChld; ++ rc = copyDatabasePage(pBtFrom, SWAB32(pBtFrom, pCell->h.leftChild), ++ pBtTo, &newChld); ++ if( rc ) return rc; ++ pCell->h.leftChild = SWAB32(pBtFrom, newChld); ++ } ++ rc = copyCell(pBtFrom, pBtTo, pCell); ++ if( rc ) return rc; ++ } ++ if( pPage->u.hdr.rightChild ){ ++ Pgno newChld; ++ rc = copyDatabasePage(pBtFrom, SWAB32(pBtFrom, pPage->u.hdr.rightChild), ++ pBtTo, &newChld); ++ if( rc ) return rc; ++ pPage->u.hdr.rightChild = SWAB32(pBtTo, newChild); ++ } ++ } ++ sqlitepager_unref(pPage); ++ return rc; ++} ++#endif ++ ++/* ++** Read the meta-information out of a database file. ++*/ ++static int fileBtreeGetMeta(Btree *pBt, int *aMeta){ ++ PageOne *pP1; ++ int rc; ++ int i; ++ ++ rc = sqlitepager_get(pBt->pPager, 1, (void**)&pP1); ++ if( rc ) return rc; ++ aMeta[0] = SWAB32(pBt, pP1->nFree); ++ for(i=0; iaMeta)/sizeof(pP1->aMeta[0]); i++){ ++ aMeta[i+1] = SWAB32(pBt, pP1->aMeta[i]); ++ } ++ sqlitepager_unref(pP1); ++ return SQLITE_OK; ++} ++ ++/* ++** Write meta-information back into the database. ++*/ ++static int fileBtreeUpdateMeta(Btree *pBt, int *aMeta){ ++ PageOne *pP1; ++ int rc, i; ++ if( !pBt->inTrans ){ ++ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; ++ } ++ pP1 = pBt->page1; ++ rc = sqlitepager_write(pP1); ++ if( rc ) return rc; ++ for(i=0; iaMeta)/sizeof(pP1->aMeta[0]); i++){ ++ pP1->aMeta[i] = SWAB32(pBt, aMeta[i+1]); ++ } ++ return SQLITE_OK; ++} ++ ++/****************************************************************************** ++** The complete implementation of the BTree subsystem is above this line. ++** All the code the follows is for testing and troubleshooting the BTree ++** subsystem. None of the code that follows is used during normal operation. ++******************************************************************************/ ++ ++/* ++** Print a disassembly of the given page on standard output. This routine ++** is used for debugging and testing only. ++*/ ++#ifdef SQLITE_TEST ++static int fileBtreePageDump(Btree *pBt, int pgno, int recursive){ ++ int rc; ++ MemPage *pPage; ++ int i, j; ++ int nFree; ++ u16 idx; ++ char range[20]; ++ unsigned char payload[20]; ++ rc = sqlitepager_get(pBt->pPager, (Pgno)pgno, (void**)&pPage); ++ if( rc ){ ++ return rc; ++ } ++ if( recursive ) printf("PAGE %d:\n", pgno); ++ i = 0; ++ idx = SWAB16(pBt, pPage->u.hdr.firstCell); ++ while( idx>0 && idx<=SQLITE_USABLE_SIZE-MIN_CELL_SIZE ){ ++ Cell *pCell = (Cell*)&pPage->u.aDisk[idx]; ++ int sz = cellSize(pBt, pCell); ++ sprintf(range,"%d..%d", idx, idx+sz-1); ++ sz = NKEY(pBt, pCell->h) + NDATA(pBt, pCell->h); ++ if( sz>sizeof(payload)-1 ) sz = sizeof(payload)-1; ++ memcpy(payload, pCell->aPayload, sz); ++ for(j=0; j0x7f ) payload[j] = '.'; ++ } ++ payload[sz] = 0; ++ printf( ++ "cell %2d: i=%-10s chld=%-4d nk=%-4d nd=%-4d payload=%s\n", ++ i, range, (int)pCell->h.leftChild, ++ NKEY(pBt, pCell->h), NDATA(pBt, pCell->h), ++ payload ++ ); ++ if( pPage->isInit && pPage->apCell[i]!=pCell ){ ++ printf("**** apCell[%d] does not match on prior entry ****\n", i); ++ } ++ i++; ++ idx = SWAB16(pBt, pCell->h.iNext); ++ } ++ if( idx!=0 ){ ++ printf("ERROR: next cell index out of range: %d\n", idx); ++ } ++ printf("right_child: %d\n", SWAB32(pBt, pPage->u.hdr.rightChild)); ++ nFree = 0; ++ i = 0; ++ idx = SWAB16(pBt, pPage->u.hdr.firstFree); ++ while( idx>0 && idxu.aDisk[idx]; ++ sprintf(range,"%d..%d", idx, idx+p->iSize-1); ++ nFree += SWAB16(pBt, p->iSize); ++ printf("freeblock %2d: i=%-10s size=%-4d total=%d\n", ++ i, range, SWAB16(pBt, p->iSize), nFree); ++ idx = SWAB16(pBt, p->iNext); ++ i++; ++ } ++ if( idx!=0 ){ ++ printf("ERROR: next freeblock index out of range: %d\n", idx); ++ } ++ if( recursive && pPage->u.hdr.rightChild!=0 ){ ++ idx = SWAB16(pBt, pPage->u.hdr.firstCell); ++ while( idx>0 && idxu.aDisk[idx]; ++ fileBtreePageDump(pBt, SWAB32(pBt, pCell->h.leftChild), 1); ++ idx = SWAB16(pBt, pCell->h.iNext); ++ } ++ fileBtreePageDump(pBt, SWAB32(pBt, pPage->u.hdr.rightChild), 1); ++ } ++ sqlitepager_unref(pPage); ++ return SQLITE_OK; ++} ++#endif ++ ++#ifdef SQLITE_TEST ++/* ++** Fill aResult[] with information about the entry and page that the ++** cursor is pointing to. ++** ++** aResult[0] = The page number ++** aResult[1] = The entry number ++** aResult[2] = Total number of entries on this page ++** aResult[3] = Size of this entry ++** aResult[4] = Number of free bytes on this page ++** aResult[5] = Number of free blocks on the page ++** aResult[6] = Page number of the left child of this entry ++** aResult[7] = Page number of the right child for the whole page ++** ++** This routine is used for testing and debugging only. ++*/ ++static int fileBtreeCursorDump(BtCursor *pCur, int *aResult){ ++ int cnt, idx; ++ MemPage *pPage = pCur->pPage; ++ Btree *pBt = pCur->pBt; ++ aResult[0] = sqlitepager_pagenumber(pPage); ++ aResult[1] = pCur->idx; ++ aResult[2] = pPage->nCell; ++ if( pCur->idx>=0 && pCur->idxnCell ){ ++ aResult[3] = cellSize(pBt, pPage->apCell[pCur->idx]); ++ aResult[6] = SWAB32(pBt, pPage->apCell[pCur->idx]->h.leftChild); ++ }else{ ++ aResult[3] = 0; ++ aResult[6] = 0; ++ } ++ aResult[4] = pPage->nFree; ++ cnt = 0; ++ idx = SWAB16(pBt, pPage->u.hdr.firstFree); ++ while( idx>0 && idxu.aDisk[idx])->iNext); ++ } ++ aResult[5] = cnt; ++ aResult[7] = SWAB32(pBt, pPage->u.hdr.rightChild); ++ return SQLITE_OK; ++} ++#endif ++ ++/* ++** Return the pager associated with a BTree. This routine is used for ++** testing and debugging only. ++*/ ++static Pager *fileBtreePager(Btree *pBt){ ++ return pBt->pPager; ++} ++ ++/* ++** This structure is passed around through all the sanity checking routines ++** in order to keep track of some global state information. ++*/ ++typedef struct IntegrityCk IntegrityCk; ++struct IntegrityCk { ++ Btree *pBt; /* The tree being checked out */ ++ Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */ ++ int nPage; /* Number of pages in the database */ ++ int *anRef; /* Number of times each page is referenced */ ++ char *zErrMsg; /* An error message. NULL of no errors seen. */ ++}; ++ ++/* ++** Append a message to the error message string. ++*/ ++static void checkAppendMsg(IntegrityCk *pCheck, char *zMsg1, char *zMsg2){ ++ if( pCheck->zErrMsg ){ ++ char *zOld = pCheck->zErrMsg; ++ pCheck->zErrMsg = 0; ++ sqliteSetString(&pCheck->zErrMsg, zOld, "\n", zMsg1, zMsg2, (char*)0); ++ sqliteFree(zOld); ++ }else{ ++ sqliteSetString(&pCheck->zErrMsg, zMsg1, zMsg2, (char*)0); ++ } ++} ++ ++/* ++** 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 ore 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, int iPage, char *zContext){ ++ if( iPage==0 ) return 1; ++ if( iPage>pCheck->nPage || iPage<0 ){ ++ char zBuf[100]; ++ sprintf(zBuf, "invalid page number %d", iPage); ++ checkAppendMsg(pCheck, zContext, zBuf); ++ return 1; ++ } ++ if( pCheck->anRef[iPage]==1 ){ ++ char zBuf[100]; ++ sprintf(zBuf, "2nd reference to page %d", iPage); ++ checkAppendMsg(pCheck, zContext, zBuf); ++ return 1; ++ } ++ return (pCheck->anRef[iPage]++)>1; ++} ++ ++/* ++** 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 */ ++ char *zContext /* Context for error messages */ ++){ ++ int i; ++ char zMsg[100]; ++ while( N-- > 0 ){ ++ OverflowPage *pOvfl; ++ if( iPage<1 ){ ++ sprintf(zMsg, "%d pages missing from overflow list", N+1); ++ checkAppendMsg(pCheck, zContext, zMsg); ++ break; ++ } ++ if( checkRef(pCheck, iPage, zContext) ) break; ++ if( sqlitepager_get(pCheck->pPager, (Pgno)iPage, (void**)&pOvfl) ){ ++ sprintf(zMsg, "failed to get page %d", iPage); ++ checkAppendMsg(pCheck, zContext, zMsg); ++ break; ++ } ++ if( isFreeList ){ ++ FreelistInfo *pInfo = (FreelistInfo*)pOvfl->aPayload; ++ int n = SWAB32(pCheck->pBt, pInfo->nFree); ++ for(i=0; ipBt, pInfo->aFree[i]), zContext); ++ } ++ N -= n; ++ } ++ iPage = SWAB32(pCheck->pBt, pOvfl->iNext); ++ sqlitepager_unref(pOvfl); ++ } ++} ++ ++/* ++** Return negative if zKey1zKey2. ++*/ ++static int keyCompare( ++ const char *zKey1, int nKey1, ++ const char *zKey2, int nKey2 ++){ ++ int min = nKey1>nKey2 ? nKey2 : nKey1; ++ int c = memcmp(zKey1, zKey2, min); ++ if( c==0 ){ ++ c = nKey1 - nKey2; ++ } ++ return c; ++} ++ ++/* ++** Do various sanity checks on a single page of a tree. Return ++** the tree depth. Root pages return 0. Parents of root pages ++** return 1, and so forth. ++** ++** These checks are done: ++** ++** 1. Make sure that cells and freeblocks do not overlap ++** but combine to completely cover the page. ++** 2. Make sure cell keys are in order. ++** 3. Make sure no key is less than or equal to zLowerBound. ++** 4. Make sure no key is greater than or equal to zUpperBound. ++** 5. Check the integrity of overflow pages. ++** 6. Recursively call checkTreePage on all children. ++** 7. Verify that the depth of all children is the same. ++** 8. Make sure this page is at least 33% full or else it is ++** the root of the tree. ++*/ ++static int checkTreePage( ++ IntegrityCk *pCheck, /* Context for the sanity check */ ++ int iPage, /* Page number of the page to check */ ++ MemPage *pParent, /* Parent page */ ++ char *zParentContext, /* Parent context */ ++ char *zLowerBound, /* All keys should be greater than this, if not NULL */ ++ int nLower, /* Number of characters in zLowerBound */ ++ char *zUpperBound, /* All keys should be less than this, if not NULL */ ++ int nUpper /* Number of characters in zUpperBound */ ++){ ++ MemPage *pPage; ++ int i, rc, depth, d2, pgno; ++ char *zKey1, *zKey2; ++ int nKey1, nKey2; ++ BtCursor cur; ++ Btree *pBt; ++ char zMsg[100]; ++ char zContext[100]; ++ char hit[SQLITE_USABLE_SIZE]; ++ ++ /* Check that the page exists ++ */ ++ cur.pBt = pBt = pCheck->pBt; ++ if( iPage==0 ) return 0; ++ if( checkRef(pCheck, iPage, zParentContext) ) return 0; ++ sprintf(zContext, "On tree page %d: ", iPage); ++ if( (rc = sqlitepager_get(pCheck->pPager, (Pgno)iPage, (void**)&pPage))!=0 ){ ++ sprintf(zMsg, "unable to get the page. error code=%d", rc); ++ checkAppendMsg(pCheck, zContext, zMsg); ++ return 0; ++ } ++ if( (rc = initPage(pBt, pPage, (Pgno)iPage, pParent))!=0 ){ ++ sprintf(zMsg, "initPage() returns error code %d", rc); ++ checkAppendMsg(pCheck, zContext, zMsg); ++ sqlitepager_unref(pPage); ++ return 0; ++ } ++ ++ /* Check out all the cells. ++ */ ++ depth = 0; ++ if( zLowerBound ){ ++ zKey1 = sqliteMalloc( nLower+1 ); ++ memcpy(zKey1, zLowerBound, nLower); ++ zKey1[nLower] = 0; ++ }else{ ++ zKey1 = 0; ++ } ++ nKey1 = nLower; ++ cur.pPage = pPage; ++ for(i=0; inCell; i++){ ++ Cell *pCell = pPage->apCell[i]; ++ int sz; ++ ++ /* Check payload overflow pages ++ */ ++ nKey2 = NKEY(pBt, pCell->h); ++ sz = nKey2 + NDATA(pBt, pCell->h); ++ sprintf(zContext, "On page %d cell %d: ", iPage, i); ++ if( sz>MX_LOCAL_PAYLOAD ){ ++ int nPage = (sz - MX_LOCAL_PAYLOAD + OVERFLOW_SIZE - 1)/OVERFLOW_SIZE; ++ checkList(pCheck, 0, SWAB32(pBt, pCell->ovfl), nPage, zContext); ++ } ++ ++ /* Check that keys are in the right order ++ */ ++ cur.idx = i; ++ zKey2 = sqliteMallocRaw( nKey2+1 ); ++ getPayload(&cur, 0, nKey2, zKey2); ++ if( zKey1 && keyCompare(zKey1, nKey1, zKey2, nKey2)>=0 ){ ++ checkAppendMsg(pCheck, zContext, "Key is out of order"); ++ } ++ ++ /* Check sanity of left child page. ++ */ ++ pgno = SWAB32(pBt, pCell->h.leftChild); ++ d2 = checkTreePage(pCheck, pgno, pPage, zContext, zKey1,nKey1,zKey2,nKey2); ++ if( i>0 && d2!=depth ){ ++ checkAppendMsg(pCheck, zContext, "Child page depth differs"); ++ } ++ depth = d2; ++ sqliteFree(zKey1); ++ zKey1 = zKey2; ++ nKey1 = nKey2; ++ } ++ pgno = SWAB32(pBt, pPage->u.hdr.rightChild); ++ sprintf(zContext, "On page %d at right child: ", iPage); ++ checkTreePage(pCheck, pgno, pPage, zContext, zKey1,nKey1,zUpperBound,nUpper); ++ sqliteFree(zKey1); ++ ++ /* Check for complete coverage of the page ++ */ ++ memset(hit, 0, sizeof(hit)); ++ memset(hit, 1, sizeof(PageHdr)); ++ for(i=SWAB16(pBt, pPage->u.hdr.firstCell); i>0 && iu.aDisk[i]; ++ int j; ++ for(j=i+cellSize(pBt, pCell)-1; j>=i; j--) hit[j]++; ++ i = SWAB16(pBt, pCell->h.iNext); ++ } ++ for(i=SWAB16(pBt,pPage->u.hdr.firstFree); i>0 && iu.aDisk[i]; ++ int j; ++ for(j=i+SWAB16(pBt,pFBlk->iSize)-1; j>=i; j--) hit[j]++; ++ i = SWAB16(pBt,pFBlk->iNext); ++ } ++ for(i=0; i1 ){ ++ sprintf(zMsg, "Multiple uses for byte %d of page %d", i, iPage); ++ checkAppendMsg(pCheck, zMsg, 0); ++ break; ++ } ++ } ++ ++ /* Check that free space is kept to a minimum ++ */ ++#if 0 ++ if( pParent && pParent->nCell>2 && pPage->nFree>3*SQLITE_USABLE_SIZE/4 ){ ++ sprintf(zMsg, "free space (%d) greater than max (%d)", pPage->nFree, ++ SQLITE_USABLE_SIZE/3); ++ checkAppendMsg(pCheck, zContext, zMsg); ++ } ++#endif ++ ++ sqlitepager_unref(pPage); ++ return depth; ++} ++ ++/* ++** 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. ++** ++** If everything checks out, this routine returns NULL. If something is ++** amiss, an error message is written into memory obtained from malloc() ++** and a pointer to that error message is returned. The calling function ++** is responsible for freeing the error message when it is done. ++*/ ++char *fileBtreeIntegrityCheck(Btree *pBt, int *aRoot, int nRoot){ ++ int i; ++ int nRef; ++ IntegrityCk sCheck; ++ ++ nRef = *sqlitepager_stats(pBt->pPager); ++ if( lockBtree(pBt)!=SQLITE_OK ){ ++ return sqliteStrDup("Unable to acquire a read lock on the database"); ++ } ++ sCheck.pBt = pBt; ++ sCheck.pPager = pBt->pPager; ++ sCheck.nPage = sqlitepager_pagecount(sCheck.pPager); ++ if( sCheck.nPage==0 ){ ++ unlockBtreeIfUnused(pBt); ++ return 0; ++ } ++ sCheck.anRef = sqliteMallocRaw( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) ); ++ sCheck.anRef[1] = 1; ++ for(i=2; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; } ++ sCheck.zErrMsg = 0; ++ ++ /* Check the integrity of the freelist ++ */ ++ checkList(&sCheck, 1, SWAB32(pBt, pBt->page1->freeList), ++ SWAB32(pBt, pBt->page1->nFree), "Main freelist: "); ++ ++ /* Check all the tables. ++ */ ++ for(i=0; ipPager) ){ ++ char zBuf[100]; ++ sprintf(zBuf, ++ "Outstanding page count goes from %d to %d during this analysis", ++ nRef, *sqlitepager_stats(pBt->pPager) ++ ); ++ checkAppendMsg(&sCheck, zBuf, 0); ++ } ++ ++ /* Clean up and report errors. ++ */ ++ sqliteFree(sCheck.anRef); ++ return sCheck.zErrMsg; ++} ++ ++/* ++** Return the full pathname of the underlying database file. ++*/ ++static const char *fileBtreeGetFilename(Btree *pBt){ ++ assert( pBt->pPager!=0 ); ++ return sqlitepager_filename(pBt->pPager); ++} ++ ++/* ++** Copy the complete content of pBtFrom into pBtTo. A transaction ++** must be active for both files. ++** ++** The size of file pBtFrom may be reduced by this operation. ++** If anything goes wrong, the transaction on pBtFrom is rolled back. ++*/ ++static int fileBtreeCopyFile(Btree *pBtTo, Btree *pBtFrom){ ++ int rc = SQLITE_OK; ++ Pgno i, nPage, nToPage; ++ ++ if( !pBtTo->inTrans || !pBtFrom->inTrans ) return SQLITE_ERROR; ++ if( pBtTo->needSwab!=pBtFrom->needSwab ) return SQLITE_ERROR; ++ if( pBtTo->pCursor ) return SQLITE_BUSY; ++ memcpy(pBtTo->page1, pBtFrom->page1, SQLITE_USABLE_SIZE); ++ rc = sqlitepager_overwrite(pBtTo->pPager, 1, pBtFrom->page1); ++ nToPage = sqlitepager_pagecount(pBtTo->pPager); ++ nPage = sqlitepager_pagecount(pBtFrom->pPager); ++ for(i=2; rc==SQLITE_OK && i<=nPage; i++){ ++ void *pPage; ++ rc = sqlitepager_get(pBtFrom->pPager, i, &pPage); ++ if( rc ) break; ++ rc = sqlitepager_overwrite(pBtTo->pPager, i, pPage); ++ if( rc ) break; ++ sqlitepager_unref(pPage); ++ } ++ for(i=nPage+1; rc==SQLITE_OK && i<=nToPage; i++){ ++ void *pPage; ++ rc = sqlitepager_get(pBtTo->pPager, i, &pPage); ++ if( rc ) break; ++ rc = sqlitepager_write(pPage); ++ sqlitepager_unref(pPage); ++ sqlitepager_dont_write(pBtTo->pPager, i); ++ } ++ if( !rc && nPagepPager, nPage); ++ } ++ if( rc ){ ++ fileBtreeRollback(pBtTo); ++ } ++ return rc; ++} ++ ++/* ++** The following tables contain pointers to all of the interface ++** routines for this implementation of the B*Tree backend. To ++** substitute a different implemention of the backend, one has merely ++** to provide pointers to alternative functions in similar tables. ++*/ ++static BtOps sqliteBtreeOps = { ++ fileBtreeClose, ++ fileBtreeSetCacheSize, ++ fileBtreeSetSafetyLevel, ++ fileBtreeBeginTrans, ++ fileBtreeCommit, ++ fileBtreeRollback, ++ fileBtreeBeginCkpt, ++ fileBtreeCommitCkpt, ++ fileBtreeRollbackCkpt, ++ fileBtreeCreateTable, ++ fileBtreeCreateTable, /* Really sqliteBtreeCreateIndex() */ ++ fileBtreeDropTable, ++ fileBtreeClearTable, ++ fileBtreeCursor, ++ fileBtreeGetMeta, ++ fileBtreeUpdateMeta, ++ fileBtreeIntegrityCheck, ++ fileBtreeGetFilename, ++ fileBtreeCopyFile, ++ fileBtreePager, ++#ifdef SQLITE_TEST ++ fileBtreePageDump, ++#endif ++}; ++static BtCursorOps sqliteBtreeCursorOps = { ++ fileBtreeMoveto, ++ fileBtreeDelete, ++ fileBtreeInsert, ++ fileBtreeFirst, ++ fileBtreeLast, ++ fileBtreeNext, ++ fileBtreePrevious, ++ fileBtreeKeySize, ++ fileBtreeKey, ++ fileBtreeKeyCompare, ++ fileBtreeDataSize, ++ fileBtreeData, ++ fileBtreeCloseCursor, ++#ifdef SQLITE_TEST ++ fileBtreeCursorDump, ++#endif ++}; +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/btree.h +@@ -0,0 +1,156 @@ ++/* ++** 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. ++** ++** @(#) $Id$ ++*/ ++#ifndef _BTREE_H_ ++#define _BTREE_H_ ++ ++/* ++** Forward declarations of structure ++*/ ++typedef struct Btree Btree; ++typedef struct BtCursor BtCursor; ++typedef struct BtOps BtOps; ++typedef struct BtCursorOps BtCursorOps; ++ ++ ++/* ++** An instance of the following structure contains pointers to all ++** methods against an open BTree. Alternative BTree implementations ++** (examples: file based versus in-memory) can be created by substituting ++** different methods. Users of the BTree cannot tell the difference. ++** ++** In C++ we could do this by defining a virtual base class and then ++** creating subclasses for each different implementation. But this is ++** C not C++ so we have to be a little more explicit. ++*/ ++struct BtOps { ++ int (*Close)(Btree*); ++ int (*SetCacheSize)(Btree*, int); ++ int (*SetSafetyLevel)(Btree*, int); ++ int (*BeginTrans)(Btree*); ++ int (*Commit)(Btree*); ++ int (*Rollback)(Btree*); ++ int (*BeginCkpt)(Btree*); ++ int (*CommitCkpt)(Btree*); ++ int (*RollbackCkpt)(Btree*); ++ int (*CreateTable)(Btree*, int*); ++ int (*CreateIndex)(Btree*, int*); ++ int (*DropTable)(Btree*, int); ++ int (*ClearTable)(Btree*, int); ++ int (*Cursor)(Btree*, int iTable, int wrFlag, BtCursor **ppCur); ++ int (*GetMeta)(Btree*, int*); ++ int (*UpdateMeta)(Btree*, int*); ++ char *(*IntegrityCheck)(Btree*, int*, int); ++ const char *(*GetFilename)(Btree*); ++ int (*Copyfile)(Btree*,Btree*); ++ struct Pager *(*Pager)(Btree*); ++#ifdef SQLITE_TEST ++ int (*PageDump)(Btree*, int, int); ++#endif ++}; ++ ++/* ++** An instance of this structure defines all of the methods that can ++** be executed against a cursor. ++*/ ++struct BtCursorOps { ++ int (*Moveto)(BtCursor*, const void *pKey, int nKey, int *pRes); ++ int (*Delete)(BtCursor*); ++ int (*Insert)(BtCursor*, const void *pKey, int nKey, ++ const void *pData, int nData); ++ int (*First)(BtCursor*, int *pRes); ++ int (*Last)(BtCursor*, int *pRes); ++ int (*Next)(BtCursor*, int *pRes); ++ int (*Previous)(BtCursor*, int *pRes); ++ int (*KeySize)(BtCursor*, int *pSize); ++ int (*Key)(BtCursor*, int offset, int amt, char *zBuf); ++ int (*KeyCompare)(BtCursor*, const void *pKey, int nKey, ++ int nIgnore, int *pRes); ++ int (*DataSize)(BtCursor*, int *pSize); ++ int (*Data)(BtCursor*, int offset, int amt, char *zBuf); ++ int (*CloseCursor)(BtCursor*); ++#ifdef SQLITE_TEST ++ int (*CursorDump)(BtCursor*, int*); ++#endif ++}; ++ ++/* ++** The number of 4-byte "meta" values contained on the first page of each ++** database file. ++*/ ++#define SQLITE_N_BTREE_META 10 ++ ++int sqliteBtreeOpen(const char *zFilename, int mode, int nPg, Btree **ppBtree); ++int sqliteRbtreeOpen(const char *zFilename, int mode, int nPg, Btree **ppBtree); ++ ++#define btOps(pBt) (*((BtOps **)(pBt))) ++#define btCOps(pCur) (*((BtCursorOps **)(pCur))) ++ ++#define sqliteBtreeClose(pBt) (btOps(pBt)->Close(pBt)) ++#define sqliteBtreeSetCacheSize(pBt, sz) (btOps(pBt)->SetCacheSize(pBt, sz)) ++#define sqliteBtreeSetSafetyLevel(pBt, sl) (btOps(pBt)->SetSafetyLevel(pBt, sl)) ++#define sqliteBtreeBeginTrans(pBt) (btOps(pBt)->BeginTrans(pBt)) ++#define sqliteBtreeCommit(pBt) (btOps(pBt)->Commit(pBt)) ++#define sqliteBtreeRollback(pBt) (btOps(pBt)->Rollback(pBt)) ++#define sqliteBtreeBeginCkpt(pBt) (btOps(pBt)->BeginCkpt(pBt)) ++#define sqliteBtreeCommitCkpt(pBt) (btOps(pBt)->CommitCkpt(pBt)) ++#define sqliteBtreeRollbackCkpt(pBt) (btOps(pBt)->RollbackCkpt(pBt)) ++#define sqliteBtreeCreateTable(pBt,piTable)\ ++ (btOps(pBt)->CreateTable(pBt,piTable)) ++#define sqliteBtreeCreateIndex(pBt, piIndex)\ ++ (btOps(pBt)->CreateIndex(pBt, piIndex)) ++#define sqliteBtreeDropTable(pBt, iTable) (btOps(pBt)->DropTable(pBt, iTable)) ++#define sqliteBtreeClearTable(pBt, iTable)\ ++ (btOps(pBt)->ClearTable(pBt, iTable)) ++#define sqliteBtreeCursor(pBt, iTable, wrFlag, ppCur)\ ++ (btOps(pBt)->Cursor(pBt, iTable, wrFlag, ppCur)) ++#define sqliteBtreeMoveto(pCur, pKey, nKey, pRes)\ ++ (btCOps(pCur)->Moveto(pCur, pKey, nKey, pRes)) ++#define sqliteBtreeDelete(pCur) (btCOps(pCur)->Delete(pCur)) ++#define sqliteBtreeInsert(pCur, pKey, nKey, pData, nData) \ ++ (btCOps(pCur)->Insert(pCur, pKey, nKey, pData, nData)) ++#define sqliteBtreeFirst(pCur, pRes) (btCOps(pCur)->First(pCur, pRes)) ++#define sqliteBtreeLast(pCur, pRes) (btCOps(pCur)->Last(pCur, pRes)) ++#define sqliteBtreeNext(pCur, pRes) (btCOps(pCur)->Next(pCur, pRes)) ++#define sqliteBtreePrevious(pCur, pRes) (btCOps(pCur)->Previous(pCur, pRes)) ++#define sqliteBtreeKeySize(pCur, pSize) (btCOps(pCur)->KeySize(pCur, pSize) ) ++#define sqliteBtreeKey(pCur, offset, amt, zBuf)\ ++ (btCOps(pCur)->Key(pCur, offset, amt, zBuf)) ++#define sqliteBtreeKeyCompare(pCur, pKey, nKey, nIgnore, pRes)\ ++ (btCOps(pCur)->KeyCompare(pCur, pKey, nKey, nIgnore, pRes)) ++#define sqliteBtreeDataSize(pCur, pSize) (btCOps(pCur)->DataSize(pCur, pSize)) ++#define sqliteBtreeData(pCur, offset, amt, zBuf)\ ++ (btCOps(pCur)->Data(pCur, offset, amt, zBuf)) ++#define sqliteBtreeCloseCursor(pCur) (btCOps(pCur)->CloseCursor(pCur)) ++#define sqliteBtreeGetMeta(pBt, aMeta) (btOps(pBt)->GetMeta(pBt, aMeta)) ++#define sqliteBtreeUpdateMeta(pBt, aMeta) (btOps(pBt)->UpdateMeta(pBt, aMeta)) ++#define sqliteBtreeIntegrityCheck(pBt, aRoot, nRoot)\ ++ (btOps(pBt)->IntegrityCheck(pBt, aRoot, nRoot)) ++#define sqliteBtreeGetFilename(pBt) (btOps(pBt)->GetFilename(pBt)) ++#define sqliteBtreeCopyFile(pBt1, pBt2) (btOps(pBt1)->Copyfile(pBt1, pBt2)) ++#define sqliteBtreePager(pBt) (btOps(pBt)->Pager(pBt)) ++ ++#ifdef SQLITE_TEST ++#define sqliteBtreePageDump(pBt, pgno, recursive)\ ++ (btOps(pBt)->PageDump(pBt, pgno, recursive)) ++#define sqliteBtreeCursorDump(pCur, aResult)\ ++ (btCOps(pCur)->CursorDump(pCur, aResult)) ++int btree_native_byte_order; ++#endif /* SQLITE_TEST */ ++ ++ ++#endif /* _BTREE_H_ */ +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/btree_rb.c +@@ -0,0 +1,1488 @@ ++/* ++** 2003 Feb 4 ++** ++** 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$ ++** ++** This file implements an in-core database using Red-Black balanced ++** binary trees. ++** ++** It was contributed to SQLite by anonymous on 2003-Feb-04 23:24:49 UTC. ++*/ ++#include "btree.h" ++#include "sqliteInt.h" ++#include ++ ++/* ++** Omit this whole file if the SQLITE_OMIT_INMEMORYDB macro is ++** defined. This allows a lot of code to be omitted for installations ++** that do not need it. ++*/ ++#ifndef SQLITE_OMIT_INMEMORYDB ++ ++ ++typedef struct BtRbTree BtRbTree; ++typedef struct BtRbNode BtRbNode; ++typedef struct BtRollbackOp BtRollbackOp; ++typedef struct Rbtree Rbtree; ++typedef struct RbtCursor RbtCursor; ++ ++/* Forward declarations */ ++static BtOps sqliteRbtreeOps; ++static BtCursorOps sqliteRbtreeCursorOps; ++ ++/* ++ * During each transaction (or checkpoint), a linked-list of ++ * "rollback-operations" is accumulated. If the transaction is rolled back, ++ * then the list of operations must be executed (to restore the database to ++ * it's state before the transaction started). If the transaction is to be ++ * committed, just delete the list. ++ * ++ * Each operation is represented as follows, depending on the value of eOp: ++ * ++ * ROLLBACK_INSERT -> Need to insert (pKey, pData) into table iTab. ++ * ROLLBACK_DELETE -> Need to delete the record (pKey) into table iTab. ++ * ROLLBACK_CREATE -> Need to create table iTab. ++ * ROLLBACK_DROP -> Need to drop table iTab. ++ */ ++struct BtRollbackOp { ++ u8 eOp; ++ int iTab; ++ int nKey; ++ void *pKey; ++ int nData; ++ void *pData; ++ BtRollbackOp *pNext; ++}; ++ ++/* ++** Legal values for BtRollbackOp.eOp: ++*/ ++#define ROLLBACK_INSERT 1 /* Insert a record */ ++#define ROLLBACK_DELETE 2 /* Delete a record */ ++#define ROLLBACK_CREATE 3 /* Create a table */ ++#define ROLLBACK_DROP 4 /* Drop a table */ ++ ++struct Rbtree { ++ BtOps *pOps; /* Function table */ ++ int aMetaData[SQLITE_N_BTREE_META]; ++ ++ int next_idx; /* next available table index */ ++ Hash tblHash; /* All created tables, by index */ ++ u8 isAnonymous; /* True if this Rbtree is to be deleted when closed */ ++ u8 eTransState; /* State of this Rbtree wrt transactions */ ++ ++ BtRollbackOp *pTransRollback; ++ BtRollbackOp *pCheckRollback; ++ BtRollbackOp *pCheckRollbackTail; ++}; ++ ++/* ++** Legal values for Rbtree.eTransState. ++*/ ++#define TRANS_NONE 0 /* No transaction is in progress */ ++#define TRANS_INTRANSACTION 1 /* A transaction is in progress */ ++#define TRANS_INCHECKPOINT 2 /* A checkpoint is in progress */ ++#define TRANS_ROLLBACK 3 /* We are currently rolling back a checkpoint or ++ * transaction. */ ++ ++struct RbtCursor { ++ BtCursorOps *pOps; /* Function table */ ++ Rbtree *pRbtree; ++ BtRbTree *pTree; ++ int iTree; /* Index of pTree in pRbtree */ ++ BtRbNode *pNode; ++ RbtCursor *pShared; /* List of all cursors on the same Rbtree */ ++ u8 eSkip; /* Determines if next step operation is a no-op */ ++ u8 wrFlag; /* True if this cursor is open for writing */ ++}; ++ ++/* ++** Legal values for RbtCursor.eSkip. ++*/ ++#define SKIP_NONE 0 /* Always step the cursor */ ++#define SKIP_NEXT 1 /* The next sqliteRbtreeNext() is a no-op */ ++#define SKIP_PREV 2 /* The next sqliteRbtreePrevious() is a no-op */ ++#define SKIP_INVALID 3 /* Calls to Next() and Previous() are invalid */ ++ ++struct BtRbTree { ++ RbtCursor *pCursors; /* All cursors pointing to this tree */ ++ BtRbNode *pHead; /* Head of the tree, or NULL */ ++}; ++ ++struct BtRbNode { ++ int nKey; ++ void *pKey; ++ int nData; ++ void *pData; ++ u8 isBlack; /* true for a black node, 0 for a red node */ ++ BtRbNode *pParent; /* Nodes parent node, NULL for the tree head */ ++ BtRbNode *pLeft; /* Nodes left child, or NULL */ ++ BtRbNode *pRight; /* Nodes right child, or NULL */ ++ ++ int nBlackHeight; /* Only used during the red-black integrity check */ ++}; ++ ++/* Forward declarations */ ++static int memRbtreeMoveto( ++ RbtCursor* pCur, ++ const void *pKey, ++ int nKey, ++ int *pRes ++); ++static int memRbtreeClearTable(Rbtree* tree, int n); ++static int memRbtreeNext(RbtCursor* pCur, int *pRes); ++static int memRbtreeLast(RbtCursor* pCur, int *pRes); ++static int memRbtreePrevious(RbtCursor* pCur, int *pRes); ++ ++ ++/* ++** This routine checks all cursors that point to the same table ++** as pCur points to. If any of those cursors were opened with ++** wrFlag==0 then this routine returns SQLITE_LOCKED. If all ++** cursors point to the same table were opened with wrFlag==1 ++** then this routine returns SQLITE_OK. ++** ++** In addition to checking for read-locks (where a read-lock ++** means a cursor opened with wrFlag==0) this routine also NULLs ++** out the pNode field of all other cursors. ++** This is necessary because an insert ++** or delete might change erase the node out from under ++** another cursor. ++*/ ++static int checkReadLocks(RbtCursor *pCur){ ++ RbtCursor *p; ++ assert( pCur->wrFlag ); ++ for(p=pCur->pTree->pCursors; p; p=p->pShared){ ++ if( p!=pCur ){ ++ if( p->wrFlag==0 ) return SQLITE_LOCKED; ++ p->pNode = 0; ++ } ++ } ++ return SQLITE_OK; ++} ++ ++/* ++ * The key-compare function for the red-black trees. Returns as follows: ++ * ++ * (key1 < key2) -1 ++ * (key1 == key2) 0 ++ * (key1 > key2) 1 ++ * ++ * Keys are compared using memcmp(). If one key is an exact prefix of the ++ * other, then the shorter key is less than the longer key. ++ */ ++static int key_compare(void const*pKey1, int nKey1, void const*pKey2, int nKey2) ++{ ++ int mcmp = memcmp(pKey1, pKey2, (nKey1 <= nKey2)?nKey1:nKey2); ++ if( mcmp == 0){ ++ if( nKey1 == nKey2 ) return 0; ++ return ((nKey1 < nKey2)?-1:1); ++ } ++ return ((mcmp>0)?1:-1); ++} ++ ++/* ++ * Perform the LEFT-rotate transformation on node X of tree pTree. This ++ * transform is part of the red-black balancing code. ++ * ++ * | | ++ * X Y ++ * / \ / \ ++ * a Y X c ++ * / \ / \ ++ * b c a b ++ * ++ * BEFORE AFTER ++ */ ++static void leftRotate(BtRbTree *pTree, BtRbNode *pX) ++{ ++ BtRbNode *pY; ++ BtRbNode *pb; ++ pY = pX->pRight; ++ pb = pY->pLeft; ++ ++ pY->pParent = pX->pParent; ++ if( pX->pParent ){ ++ if( pX->pParent->pLeft == pX ) pX->pParent->pLeft = pY; ++ else pX->pParent->pRight = pY; ++ } ++ pY->pLeft = pX; ++ pX->pParent = pY; ++ pX->pRight = pb; ++ if( pb ) pb->pParent = pX; ++ if( pTree->pHead == pX ) pTree->pHead = pY; ++} ++ ++/* ++ * Perform the RIGHT-rotate transformation on node X of tree pTree. This ++ * transform is part of the red-black balancing code. ++ * ++ * | | ++ * X Y ++ * / \ / \ ++ * Y c a X ++ * / \ / \ ++ * a b b c ++ * ++ * BEFORE AFTER ++ */ ++static void rightRotate(BtRbTree *pTree, BtRbNode *pX) ++{ ++ BtRbNode *pY; ++ BtRbNode *pb; ++ pY = pX->pLeft; ++ pb = pY->pRight; ++ ++ pY->pParent = pX->pParent; ++ if( pX->pParent ){ ++ if( pX->pParent->pLeft == pX ) pX->pParent->pLeft = pY; ++ else pX->pParent->pRight = pY; ++ } ++ pY->pRight = pX; ++ pX->pParent = pY; ++ pX->pLeft = pb; ++ if( pb ) pb->pParent = pX; ++ if( pTree->pHead == pX ) pTree->pHead = pY; ++} ++ ++/* ++ * A string-manipulation helper function for check_redblack_tree(). If (orig == ++ * NULL) a copy of val is returned. If (orig != NULL) then a copy of the * ++ * concatenation of orig and val is returned. The original orig is deleted ++ * (using sqliteFree()). ++ */ ++static char *append_val(char * orig, char const * val){ ++ char *z; ++ if( !orig ){ ++ z = sqliteStrDup( val ); ++ } else{ ++ z = 0; ++ sqliteSetString(&z, orig, val, (char*)0); ++ sqliteFree( orig ); ++ } ++ return z; ++} ++ ++/* ++ * Append a string representation of the entire node to orig and return it. ++ * This is used to produce debugging information if check_redblack_tree() finds ++ * a problem with a red-black binary tree. ++ */ ++static char *append_node(char * orig, BtRbNode *pNode, int indent) ++{ ++ char buf[128]; ++ int i; ++ ++ for( i=0; iisBlack ){ ++ orig = append_val(orig, " B \n"); ++ }else{ ++ orig = append_val(orig, " R \n"); ++ } ++ orig = append_node( orig, pNode->pLeft, indent ); ++ orig = append_node( orig, pNode->pRight, indent ); ++ }else{ ++ orig = append_val(orig, "\n"); ++ } ++ return orig; ++} ++ ++/* ++ * Print a representation of a node to stdout. This function is only included ++ * so you can call it from within a debugger if things get really bad. It ++ * is not called from anyplace in the code. ++ */ ++static void print_node(BtRbNode *pNode) ++{ ++ char * str = append_node(0, pNode, 0); ++ printf("%s", str); ++ ++ /* Suppress a warning message about print_node() being unused */ ++ (void)print_node; ++} ++ ++/* ++ * Check the following properties of the red-black tree: ++ * (1) - If a node is red, both of it's children are black ++ * (2) - Each path from a given node to a leaf (NULL) node passes thru the ++ * same number of black nodes ++ * ++ * If there is a problem, append a description (using append_val() ) to *msg. ++ */ ++static void check_redblack_tree(BtRbTree * tree, char ** msg) ++{ ++ BtRbNode *pNode; ++ ++ /* 0 -> came from parent ++ * 1 -> came from left ++ * 2 -> came from right */ ++ int prev_step = 0; ++ ++ pNode = tree->pHead; ++ while( pNode ){ ++ switch( prev_step ){ ++ case 0: ++ if( pNode->pLeft ){ ++ pNode = pNode->pLeft; ++ }else{ ++ prev_step = 1; ++ } ++ break; ++ case 1: ++ if( pNode->pRight ){ ++ pNode = pNode->pRight; ++ prev_step = 0; ++ }else{ ++ prev_step = 2; ++ } ++ break; ++ case 2: ++ /* Check red-black property (1) */ ++ if( !pNode->isBlack && ++ ( (pNode->pLeft && !pNode->pLeft->isBlack) || ++ (pNode->pRight && !pNode->pRight->isBlack) ) ++ ){ ++ char buf[128]; ++ sprintf(buf, "Red node with red child at %p\n", pNode); ++ *msg = append_val(*msg, buf); ++ *msg = append_node(*msg, tree->pHead, 0); ++ *msg = append_val(*msg, "\n"); ++ } ++ ++ /* Check red-black property (2) */ ++ { ++ int leftHeight = 0; ++ int rightHeight = 0; ++ if( pNode->pLeft ){ ++ leftHeight += pNode->pLeft->nBlackHeight; ++ leftHeight += (pNode->pLeft->isBlack?1:0); ++ } ++ if( pNode->pRight ){ ++ rightHeight += pNode->pRight->nBlackHeight; ++ rightHeight += (pNode->pRight->isBlack?1:0); ++ } ++ if( leftHeight != rightHeight ){ ++ char buf[128]; ++ sprintf(buf, "Different black-heights at %p\n", pNode); ++ *msg = append_val(*msg, buf); ++ *msg = append_node(*msg, tree->pHead, 0); ++ *msg = append_val(*msg, "\n"); ++ } ++ pNode->nBlackHeight = leftHeight; ++ } ++ ++ if( pNode->pParent ){ ++ if( pNode == pNode->pParent->pLeft ) prev_step = 1; ++ else prev_step = 2; ++ } ++ pNode = pNode->pParent; ++ break; ++ default: assert(0); ++ } ++ } ++} ++ ++/* ++ * Node pX has just been inserted into pTree (by code in sqliteRbtreeInsert()). ++ * It is possible that pX is a red node with a red parent, which is a violation ++ * of the red-black tree properties. This function performs rotations and ++ * color changes to rebalance the tree ++ */ ++static void do_insert_balancing(BtRbTree *pTree, BtRbNode *pX) ++{ ++ /* In the first iteration of this loop, pX points to the red node just ++ * inserted in the tree. If the parent of pX exists (pX is not the root ++ * node) and is red, then the properties of the red-black tree are ++ * violated. ++ * ++ * At the start of any subsequent iterations, pX points to a red node ++ * with a red parent. In all other respects the tree is a legal red-black ++ * binary tree. */ ++ while( pX != pTree->pHead && !pX->pParent->isBlack ){ ++ BtRbNode *pUncle; ++ BtRbNode *pGrandparent; ++ ++ /* Grandparent of pX must exist and must be black. */ ++ pGrandparent = pX->pParent->pParent; ++ assert( pGrandparent ); ++ assert( pGrandparent->isBlack ); ++ ++ /* Uncle of pX may or may not exist. */ ++ if( pX->pParent == pGrandparent->pLeft ) ++ pUncle = pGrandparent->pRight; ++ else ++ pUncle = pGrandparent->pLeft; ++ ++ /* If the uncle of pX exists and is red, we do the following: ++ * | | ++ * G(b) G(r) ++ * / \ / \ ++ * U(r) P(r) U(b) P(b) ++ * \ \ ++ * X(r) X(r) ++ * ++ * BEFORE AFTER ++ * pX is then set to G. If the parent of G is red, then the while loop ++ * will run again. */ ++ if( pUncle && !pUncle->isBlack ){ ++ pGrandparent->isBlack = 0; ++ pUncle->isBlack = 1; ++ pX->pParent->isBlack = 1; ++ pX = pGrandparent; ++ }else{ ++ ++ if( pX->pParent == pGrandparent->pLeft ){ ++ if( pX == pX->pParent->pRight ){ ++ /* If pX is a right-child, do the following transform, essentially ++ * to change pX into a left-child: ++ * | | ++ * G(b) G(b) ++ * / \ / \ ++ * P(r) U(b) X(r) U(b) ++ * \ / ++ * X(r) P(r) <-- new X ++ * ++ * BEFORE AFTER ++ */ ++ pX = pX->pParent; ++ leftRotate(pTree, pX); ++ } ++ ++ /* Do the following transform, which balances the tree :) ++ * | | ++ * G(b) P(b) ++ * / \ / \ ++ * P(r) U(b) X(r) G(r) ++ * / \ ++ * X(r) U(b) ++ * ++ * BEFORE AFTER ++ */ ++ assert( pGrandparent == pX->pParent->pParent ); ++ pGrandparent->isBlack = 0; ++ pX->pParent->isBlack = 1; ++ rightRotate( pTree, pGrandparent ); ++ ++ }else{ ++ /* This code is symetric to the illustrated case above. */ ++ if( pX == pX->pParent->pLeft ){ ++ pX = pX->pParent; ++ rightRotate(pTree, pX); ++ } ++ assert( pGrandparent == pX->pParent->pParent ); ++ pGrandparent->isBlack = 0; ++ pX->pParent->isBlack = 1; ++ leftRotate( pTree, pGrandparent ); ++ } ++ } ++ } ++ pTree->pHead->isBlack = 1; ++} ++ ++/* ++ * A child of pParent, which in turn had child pX, has just been removed from ++ * pTree (the figure below depicts the operation, Z is being removed). pParent ++ * or pX, or both may be NULL. ++ * | | ++ * P P ++ * / \ / \ ++ * Z X ++ * / \ ++ * X nil ++ * ++ * This function is only called if Z was black. In this case the red-black tree ++ * properties have been violated, and pX has an "extra black". This function ++ * performs rotations and color-changes to re-balance the tree. ++ */ ++static ++void do_delete_balancing(BtRbTree *pTree, BtRbNode *pX, BtRbNode *pParent) ++{ ++ BtRbNode *pSib; ++ ++ /* TODO: Comment this code! */ ++ while( pX != pTree->pHead && (!pX || pX->isBlack) ){ ++ if( pX == pParent->pLeft ){ ++ pSib = pParent->pRight; ++ if( pSib && !(pSib->isBlack) ){ ++ pSib->isBlack = 1; ++ pParent->isBlack = 0; ++ leftRotate(pTree, pParent); ++ pSib = pParent->pRight; ++ } ++ if( !pSib ){ ++ pX = pParent; ++ }else if( ++ (!pSib->pLeft || pSib->pLeft->isBlack) && ++ (!pSib->pRight || pSib->pRight->isBlack) ) { ++ pSib->isBlack = 0; ++ pX = pParent; ++ }else{ ++ if( (!pSib->pRight || pSib->pRight->isBlack) ){ ++ if( pSib->pLeft ) pSib->pLeft->isBlack = 1; ++ pSib->isBlack = 0; ++ rightRotate( pTree, pSib ); ++ pSib = pParent->pRight; ++ } ++ pSib->isBlack = pParent->isBlack; ++ pParent->isBlack = 1; ++ if( pSib->pRight ) pSib->pRight->isBlack = 1; ++ leftRotate(pTree, pParent); ++ pX = pTree->pHead; ++ } ++ }else{ ++ pSib = pParent->pLeft; ++ if( pSib && !(pSib->isBlack) ){ ++ pSib->isBlack = 1; ++ pParent->isBlack = 0; ++ rightRotate(pTree, pParent); ++ pSib = pParent->pLeft; ++ } ++ if( !pSib ){ ++ pX = pParent; ++ }else if( ++ (!pSib->pLeft || pSib->pLeft->isBlack) && ++ (!pSib->pRight || pSib->pRight->isBlack) ){ ++ pSib->isBlack = 0; ++ pX = pParent; ++ }else{ ++ if( (!pSib->pLeft || pSib->pLeft->isBlack) ){ ++ if( pSib->pRight ) pSib->pRight->isBlack = 1; ++ pSib->isBlack = 0; ++ leftRotate( pTree, pSib ); ++ pSib = pParent->pLeft; ++ } ++ pSib->isBlack = pParent->isBlack; ++ pParent->isBlack = 1; ++ if( pSib->pLeft ) pSib->pLeft->isBlack = 1; ++ rightRotate(pTree, pParent); ++ pX = pTree->pHead; ++ } ++ } ++ pParent = pX->pParent; ++ } ++ if( pX ) pX->isBlack = 1; ++} ++ ++/* ++ * Create table n in tree pRbtree. Table n must not exist. ++ */ ++static void btreeCreateTable(Rbtree* pRbtree, int n) ++{ ++ BtRbTree *pNewTbl = sqliteMalloc(sizeof(BtRbTree)); ++ sqliteHashInsert(&pRbtree->tblHash, 0, n, pNewTbl); ++} ++ ++/* ++ * Log a single "rollback-op" for the given Rbtree. See comments for struct ++ * BtRollbackOp. ++ */ ++static void btreeLogRollbackOp(Rbtree* pRbtree, BtRollbackOp *pRollbackOp) ++{ ++ assert( pRbtree->eTransState == TRANS_INCHECKPOINT || ++ pRbtree->eTransState == TRANS_INTRANSACTION ); ++ if( pRbtree->eTransState == TRANS_INTRANSACTION ){ ++ pRollbackOp->pNext = pRbtree->pTransRollback; ++ pRbtree->pTransRollback = pRollbackOp; ++ } ++ if( pRbtree->eTransState == TRANS_INCHECKPOINT ){ ++ if( !pRbtree->pCheckRollback ){ ++ pRbtree->pCheckRollbackTail = pRollbackOp; ++ } ++ pRollbackOp->pNext = pRbtree->pCheckRollback; ++ pRbtree->pCheckRollback = pRollbackOp; ++ } ++} ++ ++int sqliteRbtreeOpen( ++ const char *zFilename, ++ int mode, ++ int nPg, ++ Btree **ppBtree ++){ ++ Rbtree **ppRbtree = (Rbtree**)ppBtree; ++ *ppRbtree = (Rbtree *)sqliteMalloc(sizeof(Rbtree)); ++ if( sqlite_malloc_failed ) goto open_no_mem; ++ sqliteHashInit(&(*ppRbtree)->tblHash, SQLITE_HASH_INT, 0); ++ ++ /* Create a binary tree for the SQLITE_MASTER table at location 2 */ ++ btreeCreateTable(*ppRbtree, 2); ++ if( sqlite_malloc_failed ) goto open_no_mem; ++ (*ppRbtree)->next_idx = 3; ++ (*ppRbtree)->pOps = &sqliteRbtreeOps; ++ /* Set file type to 4; this is so that "attach ':memory:' as ...." does not ++ ** think that the database in uninitialised and refuse to attach ++ */ ++ (*ppRbtree)->aMetaData[2] = 4; ++ ++ return SQLITE_OK; ++ ++open_no_mem: ++ *ppBtree = 0; ++ return SQLITE_NOMEM; ++} ++ ++/* ++ * Create a new table in the supplied Rbtree. Set *n to the new table number. ++ * Return SQLITE_OK if the operation is a success. ++ */ ++static int memRbtreeCreateTable(Rbtree* tree, int* n) ++{ ++ assert( tree->eTransState != TRANS_NONE ); ++ ++ *n = tree->next_idx++; ++ btreeCreateTable(tree, *n); ++ if( sqlite_malloc_failed ) return SQLITE_NOMEM; ++ ++ /* Set up the rollback structure (if we are not doing this as part of a ++ * rollback) */ ++ if( tree->eTransState != TRANS_ROLLBACK ){ ++ BtRollbackOp *pRollbackOp = sqliteMalloc(sizeof(BtRollbackOp)); ++ if( pRollbackOp==0 ) return SQLITE_NOMEM; ++ pRollbackOp->eOp = ROLLBACK_DROP; ++ pRollbackOp->iTab = *n; ++ btreeLogRollbackOp(tree, pRollbackOp); ++ } ++ ++ return SQLITE_OK; ++} ++ ++/* ++ * Delete table n from the supplied Rbtree. ++ */ ++static int memRbtreeDropTable(Rbtree* tree, int n) ++{ ++ BtRbTree *pTree; ++ assert( tree->eTransState != TRANS_NONE ); ++ ++ memRbtreeClearTable(tree, n); ++ pTree = sqliteHashInsert(&tree->tblHash, 0, n, 0); ++ assert(pTree); ++ assert( pTree->pCursors==0 ); ++ sqliteFree(pTree); ++ ++ if( tree->eTransState != TRANS_ROLLBACK ){ ++ BtRollbackOp *pRollbackOp = sqliteMalloc(sizeof(BtRollbackOp)); ++ if( pRollbackOp==0 ) return SQLITE_NOMEM; ++ pRollbackOp->eOp = ROLLBACK_CREATE; ++ pRollbackOp->iTab = n; ++ btreeLogRollbackOp(tree, pRollbackOp); ++ } ++ ++ return SQLITE_OK; ++} ++ ++static int memRbtreeKeyCompare(RbtCursor* pCur, const void *pKey, int nKey, ++ int nIgnore, int *pRes) ++{ ++ assert(pCur); ++ ++ if( !pCur->pNode ) { ++ *pRes = -1; ++ } else { ++ if( (pCur->pNode->nKey - nIgnore) < 0 ){ ++ *pRes = -1; ++ }else{ ++ *pRes = key_compare(pCur->pNode->pKey, pCur->pNode->nKey-nIgnore, ++ pKey, nKey); ++ } ++ } ++ return SQLITE_OK; ++} ++ ++/* ++ * Get a new cursor for table iTable of the supplied Rbtree. The wrFlag ++ * parameter indicates that the cursor is open for writing. ++ * ++ * Note that RbtCursor.eSkip and RbtCursor.pNode both initialize to 0. ++ */ ++static int memRbtreeCursor( ++ Rbtree* tree, ++ int iTable, ++ int wrFlag, ++ RbtCursor **ppCur ++){ ++ RbtCursor *pCur; ++ assert(tree); ++ pCur = *ppCur = sqliteMalloc(sizeof(RbtCursor)); ++ if( sqlite_malloc_failed ) return SQLITE_NOMEM; ++ pCur->pTree = sqliteHashFind(&tree->tblHash, 0, iTable); ++ assert( pCur->pTree ); ++ pCur->pRbtree = tree; ++ pCur->iTree = iTable; ++ pCur->pOps = &sqliteRbtreeCursorOps; ++ pCur->wrFlag = wrFlag; ++ pCur->pShared = pCur->pTree->pCursors; ++ pCur->pTree->pCursors = pCur; ++ ++ assert( (*ppCur)->pTree ); ++ return SQLITE_OK; ++} ++ ++/* ++ * Insert a new record into the Rbtree. The key is given by (pKey,nKey) ++ * and the data is given by (pData,nData). The cursor is used only to ++ * define what database the record should be inserted into. The cursor ++ * is left pointing at the new record. ++ * ++ * If the key exists already in the tree, just replace the data. ++ */ ++static int memRbtreeInsert( ++ RbtCursor* pCur, ++ const void *pKey, ++ int nKey, ++ const void *pDataInput, ++ int nData ++){ ++ void * pData; ++ int match; ++ ++ /* It is illegal to call sqliteRbtreeInsert() if we are ++ ** not in a transaction */ ++ assert( pCur->pRbtree->eTransState != TRANS_NONE ); ++ ++ /* Make sure some other cursor isn't trying to read this same table */ ++ if( checkReadLocks(pCur) ){ ++ return SQLITE_LOCKED; /* The table pCur points to has a read lock */ ++ } ++ ++ /* Take a copy of the input data now, in case we need it for the ++ * replace case */ ++ pData = sqliteMallocRaw(nData); ++ if( sqlite_malloc_failed ) return SQLITE_NOMEM; ++ memcpy(pData, pDataInput, nData); ++ ++ /* Move the cursor to a node near the key to be inserted. If the key already ++ * exists in the table, then (match == 0). In this case we can just replace ++ * the data associated with the entry, we don't need to manipulate the tree. ++ * ++ * If there is no exact match, then the cursor points at what would be either ++ * the predecessor (match == -1) or successor (match == 1) of the ++ * searched-for key, were it to be inserted. The new node becomes a child of ++ * this node. ++ * ++ * The new node is initially red. ++ */ ++ memRbtreeMoveto( pCur, pKey, nKey, &match); ++ if( match ){ ++ BtRbNode *pNode = sqliteMalloc(sizeof(BtRbNode)); ++ if( pNode==0 ) return SQLITE_NOMEM; ++ pNode->nKey = nKey; ++ pNode->pKey = sqliteMallocRaw(nKey); ++ if( sqlite_malloc_failed ) return SQLITE_NOMEM; ++ memcpy(pNode->pKey, pKey, nKey); ++ pNode->nData = nData; ++ pNode->pData = pData; ++ if( pCur->pNode ){ ++ switch( match ){ ++ case -1: ++ assert( !pCur->pNode->pRight ); ++ pNode->pParent = pCur->pNode; ++ pCur->pNode->pRight = pNode; ++ break; ++ case 1: ++ assert( !pCur->pNode->pLeft ); ++ pNode->pParent = pCur->pNode; ++ pCur->pNode->pLeft = pNode; ++ break; ++ default: ++ assert(0); ++ } ++ }else{ ++ pCur->pTree->pHead = pNode; ++ } ++ ++ /* Point the cursor at the node just inserted, as per SQLite requirements */ ++ pCur->pNode = pNode; ++ ++ /* A new node has just been inserted, so run the balancing code */ ++ do_insert_balancing(pCur->pTree, pNode); ++ ++ /* Set up a rollback-op in case we have to roll this operation back */ ++ if( pCur->pRbtree->eTransState != TRANS_ROLLBACK ){ ++ BtRollbackOp *pOp = sqliteMalloc( sizeof(BtRollbackOp) ); ++ if( pOp==0 ) return SQLITE_NOMEM; ++ pOp->eOp = ROLLBACK_DELETE; ++ pOp->iTab = pCur->iTree; ++ pOp->nKey = pNode->nKey; ++ pOp->pKey = sqliteMallocRaw( pOp->nKey ); ++ if( sqlite_malloc_failed ) return SQLITE_NOMEM; ++ memcpy( pOp->pKey, pNode->pKey, pOp->nKey ); ++ btreeLogRollbackOp(pCur->pRbtree, pOp); ++ } ++ ++ }else{ ++ /* No need to insert a new node in the tree, as the key already exists. ++ * Just clobber the current nodes data. */ ++ ++ /* Set up a rollback-op in case we have to roll this operation back */ ++ if( pCur->pRbtree->eTransState != TRANS_ROLLBACK ){ ++ BtRollbackOp *pOp = sqliteMalloc( sizeof(BtRollbackOp) ); ++ if( pOp==0 ) return SQLITE_NOMEM; ++ pOp->iTab = pCur->iTree; ++ pOp->nKey = pCur->pNode->nKey; ++ pOp->pKey = sqliteMallocRaw( pOp->nKey ); ++ if( sqlite_malloc_failed ) return SQLITE_NOMEM; ++ memcpy( pOp->pKey, pCur->pNode->pKey, pOp->nKey ); ++ pOp->nData = pCur->pNode->nData; ++ pOp->pData = pCur->pNode->pData; ++ pOp->eOp = ROLLBACK_INSERT; ++ btreeLogRollbackOp(pCur->pRbtree, pOp); ++ }else{ ++ sqliteFree( pCur->pNode->pData ); ++ } ++ ++ /* Actually clobber the nodes data */ ++ pCur->pNode->pData = pData; ++ pCur->pNode->nData = nData; ++ } ++ ++ return SQLITE_OK; ++} ++ ++/* Move the cursor so that it points to an entry near pKey. ++** Return a success code. ++** ++** *pRes<0 The cursor is left pointing at an entry that ++** is smaller than pKey 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 pKey. ++** ++** *pRes>0 The cursor is left pointing at an entry that ++** is larger than pKey. ++*/ ++static int memRbtreeMoveto( ++ RbtCursor* pCur, ++ const void *pKey, ++ int nKey, ++ int *pRes ++){ ++ BtRbNode *pTmp = 0; ++ ++ pCur->pNode = pCur->pTree->pHead; ++ *pRes = -1; ++ while( pCur->pNode && *pRes ) { ++ *pRes = key_compare(pCur->pNode->pKey, pCur->pNode->nKey, pKey, nKey); ++ pTmp = pCur->pNode; ++ switch( *pRes ){ ++ case 1: /* cursor > key */ ++ pCur->pNode = pCur->pNode->pLeft; ++ break; ++ case -1: /* cursor < key */ ++ pCur->pNode = pCur->pNode->pRight; ++ break; ++ } ++ } ++ ++ /* If (pCur->pNode == NULL), then we have failed to find a match. Set ++ * pCur->pNode to pTmp, which is either NULL (if the tree is empty) or the ++ * last node traversed in the search. In either case the relation ship ++ * between pTmp and the searched for key is already stored in *pRes. pTmp is ++ * either the successor or predecessor of the key we tried to move to. */ ++ if( !pCur->pNode ) pCur->pNode = pTmp; ++ pCur->eSkip = SKIP_NONE; ++ ++ return SQLITE_OK; ++} ++ ++ ++/* ++** Delete the entry that the cursor is pointing to. ++** ++** The cursor is left pointing at either the next or the previous ++** entry. If the cursor is left pointing to the next entry, then ++** the pCur->eSkip flag is set to SKIP_NEXT which forces the next call to ++** sqliteRbtreeNext() to be a no-op. That way, you can always call ++** sqliteRbtreeNext() after a delete and the cursor will be left ++** pointing to the first entry after the deleted entry. Similarly, ++** pCur->eSkip is set to SKIP_PREV is the cursor is left pointing to ++** the entry prior to the deleted entry so that a subsequent call to ++** sqliteRbtreePrevious() will always leave the cursor pointing at the ++** entry immediately before the one that was deleted. ++*/ ++static int memRbtreeDelete(RbtCursor* pCur) ++{ ++ BtRbNode *pZ; /* The one being deleted */ ++ BtRbNode *pChild; /* The child of the spliced out node */ ++ ++ /* It is illegal to call sqliteRbtreeDelete() if we are ++ ** not in a transaction */ ++ assert( pCur->pRbtree->eTransState != TRANS_NONE ); ++ ++ /* Make sure some other cursor isn't trying to read this same table */ ++ if( checkReadLocks(pCur) ){ ++ return SQLITE_LOCKED; /* The table pCur points to has a read lock */ ++ } ++ ++ pZ = pCur->pNode; ++ if( !pZ ){ ++ return SQLITE_OK; ++ } ++ ++ /* If we are not currently doing a rollback, set up a rollback op for this ++ * deletion */ ++ if( pCur->pRbtree->eTransState != TRANS_ROLLBACK ){ ++ BtRollbackOp *pOp = sqliteMalloc( sizeof(BtRollbackOp) ); ++ if( pOp==0 ) return SQLITE_NOMEM; ++ pOp->iTab = pCur->iTree; ++ pOp->nKey = pZ->nKey; ++ pOp->pKey = pZ->pKey; ++ pOp->nData = pZ->nData; ++ pOp->pData = pZ->pData; ++ pOp->eOp = ROLLBACK_INSERT; ++ btreeLogRollbackOp(pCur->pRbtree, pOp); ++ } ++ ++ /* First do a standard binary-tree delete (node pZ is to be deleted). How ++ * to do this depends on how many children pZ has: ++ * ++ * If pZ has no children or one child, then splice out pZ. If pZ has two ++ * children, splice out the successor of pZ and replace the key and data of ++ * pZ with the key and data of the spliced out successor. */ ++ if( pZ->pLeft && pZ->pRight ){ ++ BtRbNode *pTmp; ++ int dummy; ++ pCur->eSkip = SKIP_NONE; ++ memRbtreeNext(pCur, &dummy); ++ assert( dummy == 0 ); ++ if( pCur->pRbtree->eTransState == TRANS_ROLLBACK ){ ++ sqliteFree(pZ->pKey); ++ sqliteFree(pZ->pData); ++ } ++ pZ->pData = pCur->pNode->pData; ++ pZ->nData = pCur->pNode->nData; ++ pZ->pKey = pCur->pNode->pKey; ++ pZ->nKey = pCur->pNode->nKey; ++ pTmp = pZ; ++ pZ = pCur->pNode; ++ pCur->pNode = pTmp; ++ pCur->eSkip = SKIP_NEXT; ++ }else{ ++ int res; ++ pCur->eSkip = SKIP_NONE; ++ memRbtreeNext(pCur, &res); ++ pCur->eSkip = SKIP_NEXT; ++ if( res ){ ++ memRbtreeLast(pCur, &res); ++ memRbtreePrevious(pCur, &res); ++ pCur->eSkip = SKIP_PREV; ++ } ++ if( pCur->pRbtree->eTransState == TRANS_ROLLBACK ){ ++ sqliteFree(pZ->pKey); ++ sqliteFree(pZ->pData); ++ } ++ } ++ ++ /* pZ now points at the node to be spliced out. This block does the ++ * splicing. */ ++ { ++ BtRbNode **ppParentSlot = 0; ++ assert( !pZ->pLeft || !pZ->pRight ); /* pZ has at most one child */ ++ pChild = ((pZ->pLeft)?pZ->pLeft:pZ->pRight); ++ if( pZ->pParent ){ ++ assert( pZ == pZ->pParent->pLeft || pZ == pZ->pParent->pRight ); ++ ppParentSlot = ((pZ == pZ->pParent->pLeft) ++ ?&pZ->pParent->pLeft:&pZ->pParent->pRight); ++ *ppParentSlot = pChild; ++ }else{ ++ pCur->pTree->pHead = pChild; ++ } ++ if( pChild ) pChild->pParent = pZ->pParent; ++ } ++ ++ /* pZ now points at the spliced out node. pChild is the only child of pZ, or ++ * NULL if pZ has no children. If pZ is black, and not the tree root, then we ++ * will have violated the "same number of black nodes in every path to a ++ * leaf" property of the red-black tree. The code in do_delete_balancing() ++ * repairs this. */ ++ if( pZ->isBlack ){ ++ do_delete_balancing(pCur->pTree, pChild, pZ->pParent); ++ } ++ ++ sqliteFree(pZ); ++ return SQLITE_OK; ++} ++ ++/* ++ * Empty table n of the Rbtree. ++ */ ++static int memRbtreeClearTable(Rbtree* tree, int n) ++{ ++ BtRbTree *pTree; ++ BtRbNode *pNode; ++ ++ pTree = sqliteHashFind(&tree->tblHash, 0, n); ++ assert(pTree); ++ ++ pNode = pTree->pHead; ++ while( pNode ){ ++ if( pNode->pLeft ){ ++ pNode = pNode->pLeft; ++ } ++ else if( pNode->pRight ){ ++ pNode = pNode->pRight; ++ } ++ else { ++ BtRbNode *pTmp = pNode->pParent; ++ if( tree->eTransState == TRANS_ROLLBACK ){ ++ sqliteFree( pNode->pKey ); ++ sqliteFree( pNode->pData ); ++ }else{ ++ BtRollbackOp *pRollbackOp = sqliteMallocRaw(sizeof(BtRollbackOp)); ++ if( pRollbackOp==0 ) return SQLITE_NOMEM; ++ pRollbackOp->eOp = ROLLBACK_INSERT; ++ pRollbackOp->iTab = n; ++ pRollbackOp->nKey = pNode->nKey; ++ pRollbackOp->pKey = pNode->pKey; ++ pRollbackOp->nData = pNode->nData; ++ pRollbackOp->pData = pNode->pData; ++ btreeLogRollbackOp(tree, pRollbackOp); ++ } ++ sqliteFree( pNode ); ++ if( pTmp ){ ++ if( pTmp->pLeft == pNode ) pTmp->pLeft = 0; ++ else if( pTmp->pRight == pNode ) pTmp->pRight = 0; ++ } ++ pNode = pTmp; ++ } ++ } ++ ++ pTree->pHead = 0; ++ return SQLITE_OK; ++} ++ ++static int memRbtreeFirst(RbtCursor* pCur, int *pRes) ++{ ++ if( pCur->pTree->pHead ){ ++ pCur->pNode = pCur->pTree->pHead; ++ while( pCur->pNode->pLeft ){ ++ pCur->pNode = pCur->pNode->pLeft; ++ } ++ } ++ if( pCur->pNode ){ ++ *pRes = 0; ++ }else{ ++ *pRes = 1; ++ } ++ pCur->eSkip = SKIP_NONE; ++ return SQLITE_OK; ++} ++ ++static int memRbtreeLast(RbtCursor* pCur, int *pRes) ++{ ++ if( pCur->pTree->pHead ){ ++ pCur->pNode = pCur->pTree->pHead; ++ while( pCur->pNode->pRight ){ ++ pCur->pNode = pCur->pNode->pRight; ++ } ++ } ++ if( pCur->pNode ){ ++ *pRes = 0; ++ }else{ ++ *pRes = 1; ++ } ++ pCur->eSkip = SKIP_NONE; ++ return SQLITE_OK; ++} ++ ++/* ++** 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. ++*/ ++static int memRbtreeNext(RbtCursor* pCur, int *pRes) ++{ ++ if( pCur->pNode && pCur->eSkip != SKIP_NEXT ){ ++ if( pCur->pNode->pRight ){ ++ pCur->pNode = pCur->pNode->pRight; ++ while( pCur->pNode->pLeft ) ++ pCur->pNode = pCur->pNode->pLeft; ++ }else{ ++ BtRbNode * pX = pCur->pNode; ++ pCur->pNode = pX->pParent; ++ while( pCur->pNode && (pCur->pNode->pRight == pX) ){ ++ pX = pCur->pNode; ++ pCur->pNode = pX->pParent; ++ } ++ } ++ } ++ pCur->eSkip = SKIP_NONE; ++ ++ if( !pCur->pNode ){ ++ *pRes = 1; ++ }else{ ++ *pRes = 0; ++ } ++ ++ return SQLITE_OK; ++} ++ ++static int memRbtreePrevious(RbtCursor* pCur, int *pRes) ++{ ++ if( pCur->pNode && pCur->eSkip != SKIP_PREV ){ ++ if( pCur->pNode->pLeft ){ ++ pCur->pNode = pCur->pNode->pLeft; ++ while( pCur->pNode->pRight ) ++ pCur->pNode = pCur->pNode->pRight; ++ }else{ ++ BtRbNode * pX = pCur->pNode; ++ pCur->pNode = pX->pParent; ++ while( pCur->pNode && (pCur->pNode->pLeft == pX) ){ ++ pX = pCur->pNode; ++ pCur->pNode = pX->pParent; ++ } ++ } ++ } ++ pCur->eSkip = SKIP_NONE; ++ ++ if( !pCur->pNode ){ ++ *pRes = 1; ++ }else{ ++ *pRes = 0; ++ } ++ ++ return SQLITE_OK; ++} ++ ++static int memRbtreeKeySize(RbtCursor* pCur, int *pSize) ++{ ++ if( pCur->pNode ){ ++ *pSize = pCur->pNode->nKey; ++ }else{ ++ *pSize = 0; ++ } ++ return SQLITE_OK; ++} ++ ++static int memRbtreeKey(RbtCursor* pCur, int offset, int amt, char *zBuf) ++{ ++ if( !pCur->pNode ) return 0; ++ if( !pCur->pNode->pKey || ((amt + offset) <= pCur->pNode->nKey) ){ ++ memcpy(zBuf, ((char*)pCur->pNode->pKey)+offset, amt); ++ }else{ ++ memcpy(zBuf, ((char*)pCur->pNode->pKey)+offset, pCur->pNode->nKey-offset); ++ amt = pCur->pNode->nKey-offset; ++ } ++ return amt; ++} ++ ++static int memRbtreeDataSize(RbtCursor* pCur, int *pSize) ++{ ++ if( pCur->pNode ){ ++ *pSize = pCur->pNode->nData; ++ }else{ ++ *pSize = 0; ++ } ++ return SQLITE_OK; ++} ++ ++static int memRbtreeData(RbtCursor *pCur, int offset, int amt, char *zBuf) ++{ ++ if( !pCur->pNode ) return 0; ++ if( (amt + offset) <= pCur->pNode->nData ){ ++ memcpy(zBuf, ((char*)pCur->pNode->pData)+offset, amt); ++ }else{ ++ memcpy(zBuf, ((char*)pCur->pNode->pData)+offset ,pCur->pNode->nData-offset); ++ amt = pCur->pNode->nData-offset; ++ } ++ return amt; ++} ++ ++static int memRbtreeCloseCursor(RbtCursor* pCur) ++{ ++ if( pCur->pTree->pCursors==pCur ){ ++ pCur->pTree->pCursors = pCur->pShared; ++ }else{ ++ RbtCursor *p = pCur->pTree->pCursors; ++ while( p && p->pShared!=pCur ){ p = p->pShared; } ++ assert( p!=0 ); ++ if( p ){ ++ p->pShared = pCur->pShared; ++ } ++ } ++ sqliteFree(pCur); ++ return SQLITE_OK; ++} ++ ++static int memRbtreeGetMeta(Rbtree* tree, int* aMeta) ++{ ++ memcpy( aMeta, tree->aMetaData, sizeof(int) * SQLITE_N_BTREE_META ); ++ return SQLITE_OK; ++} ++ ++static int memRbtreeUpdateMeta(Rbtree* tree, int* aMeta) ++{ ++ memcpy( tree->aMetaData, aMeta, sizeof(int) * SQLITE_N_BTREE_META ); ++ return SQLITE_OK; ++} ++ ++/* ++ * Check that each table in the Rbtree meets the requirements for a red-black ++ * binary tree. If an error is found, return an explanation of the problem in ++ * memory obtained from sqliteMalloc(). Parameters aRoot and nRoot are ignored. ++ */ ++static char *memRbtreeIntegrityCheck(Rbtree* tree, int* aRoot, int nRoot) ++{ ++ char * msg = 0; ++ HashElem *p; ++ ++ for(p=sqliteHashFirst(&tree->tblHash); p; p=sqliteHashNext(p)){ ++ BtRbTree *pTree = sqliteHashData(p); ++ check_redblack_tree(pTree, &msg); ++ } ++ ++ return msg; ++} ++ ++static int memRbtreeSetCacheSize(Rbtree* tree, int sz) ++{ ++ return SQLITE_OK; ++} ++ ++static int memRbtreeSetSafetyLevel(Rbtree *pBt, int level){ ++ return SQLITE_OK; ++} ++ ++static int memRbtreeBeginTrans(Rbtree* tree) ++{ ++ if( tree->eTransState != TRANS_NONE ) ++ return SQLITE_ERROR; ++ ++ assert( tree->pTransRollback == 0 ); ++ tree->eTransState = TRANS_INTRANSACTION; ++ return SQLITE_OK; ++} ++ ++/* ++** Delete a linked list of BtRollbackOp structures. ++*/ ++static void deleteRollbackList(BtRollbackOp *pOp){ ++ while( pOp ){ ++ BtRollbackOp *pTmp = pOp->pNext; ++ sqliteFree(pOp->pData); ++ sqliteFree(pOp->pKey); ++ sqliteFree(pOp); ++ pOp = pTmp; ++ } ++} ++ ++static int memRbtreeCommit(Rbtree* tree){ ++ /* Just delete pTransRollback and pCheckRollback */ ++ deleteRollbackList(tree->pCheckRollback); ++ deleteRollbackList(tree->pTransRollback); ++ tree->pTransRollback = 0; ++ tree->pCheckRollback = 0; ++ tree->pCheckRollbackTail = 0; ++ tree->eTransState = TRANS_NONE; ++ return SQLITE_OK; ++} ++ ++/* ++ * Close the supplied Rbtree. Delete everything associated with it. ++ */ ++static int memRbtreeClose(Rbtree* tree) ++{ ++ HashElem *p; ++ memRbtreeCommit(tree); ++ while( (p=sqliteHashFirst(&tree->tblHash))!=0 ){ ++ tree->eTransState = TRANS_ROLLBACK; ++ memRbtreeDropTable(tree, sqliteHashKeysize(p)); ++ } ++ sqliteHashClear(&tree->tblHash); ++ sqliteFree(tree); ++ return SQLITE_OK; ++} ++ ++/* ++ * Execute and delete the supplied rollback-list on pRbtree. ++ */ ++static void execute_rollback_list(Rbtree *pRbtree, BtRollbackOp *pList) ++{ ++ BtRollbackOp *pTmp; ++ RbtCursor cur; ++ int res; ++ ++ cur.pRbtree = pRbtree; ++ cur.wrFlag = 1; ++ while( pList ){ ++ switch( pList->eOp ){ ++ case ROLLBACK_INSERT: ++ cur.pTree = sqliteHashFind( &pRbtree->tblHash, 0, pList->iTab ); ++ assert(cur.pTree); ++ cur.iTree = pList->iTab; ++ cur.eSkip = SKIP_NONE; ++ memRbtreeInsert( &cur, pList->pKey, ++ pList->nKey, pList->pData, pList->nData ); ++ break; ++ case ROLLBACK_DELETE: ++ cur.pTree = sqliteHashFind( &pRbtree->tblHash, 0, pList->iTab ); ++ assert(cur.pTree); ++ cur.iTree = pList->iTab; ++ cur.eSkip = SKIP_NONE; ++ memRbtreeMoveto(&cur, pList->pKey, pList->nKey, &res); ++ assert(res == 0); ++ memRbtreeDelete( &cur ); ++ break; ++ case ROLLBACK_CREATE: ++ btreeCreateTable(pRbtree, pList->iTab); ++ break; ++ case ROLLBACK_DROP: ++ memRbtreeDropTable(pRbtree, pList->iTab); ++ break; ++ default: ++ assert(0); ++ } ++ sqliteFree(pList->pKey); ++ sqliteFree(pList->pData); ++ pTmp = pList->pNext; ++ sqliteFree(pList); ++ pList = pTmp; ++ } ++} ++ ++static int memRbtreeRollback(Rbtree* tree) ++{ ++ tree->eTransState = TRANS_ROLLBACK; ++ execute_rollback_list(tree, tree->pCheckRollback); ++ execute_rollback_list(tree, tree->pTransRollback); ++ tree->pTransRollback = 0; ++ tree->pCheckRollback = 0; ++ tree->pCheckRollbackTail = 0; ++ tree->eTransState = TRANS_NONE; ++ return SQLITE_OK; ++} ++ ++static int memRbtreeBeginCkpt(Rbtree* tree) ++{ ++ if( tree->eTransState != TRANS_INTRANSACTION ) ++ return SQLITE_ERROR; ++ ++ assert( tree->pCheckRollback == 0 ); ++ assert( tree->pCheckRollbackTail == 0 ); ++ tree->eTransState = TRANS_INCHECKPOINT; ++ return SQLITE_OK; ++} ++ ++static int memRbtreeCommitCkpt(Rbtree* tree) ++{ ++ if( tree->eTransState == TRANS_INCHECKPOINT ){ ++ if( tree->pCheckRollback ){ ++ tree->pCheckRollbackTail->pNext = tree->pTransRollback; ++ tree->pTransRollback = tree->pCheckRollback; ++ tree->pCheckRollback = 0; ++ tree->pCheckRollbackTail = 0; ++ } ++ tree->eTransState = TRANS_INTRANSACTION; ++ } ++ return SQLITE_OK; ++} ++ ++static int memRbtreeRollbackCkpt(Rbtree* tree) ++{ ++ if( tree->eTransState != TRANS_INCHECKPOINT ) return SQLITE_OK; ++ tree->eTransState = TRANS_ROLLBACK; ++ execute_rollback_list(tree, tree->pCheckRollback); ++ tree->pCheckRollback = 0; ++ tree->pCheckRollbackTail = 0; ++ tree->eTransState = TRANS_INTRANSACTION; ++ return SQLITE_OK; ++} ++ ++#ifdef SQLITE_TEST ++static int memRbtreePageDump(Rbtree* tree, int pgno, int rec) ++{ ++ assert(!"Cannot call sqliteRbtreePageDump"); ++ return SQLITE_OK; ++} ++ ++static int memRbtreeCursorDump(RbtCursor* pCur, int* aRes) ++{ ++ assert(!"Cannot call sqliteRbtreeCursorDump"); ++ return SQLITE_OK; ++} ++#endif ++ ++static struct Pager *memRbtreePager(Rbtree* tree) ++{ ++ return 0; ++} ++ ++/* ++** Return the full pathname of the underlying database file. ++*/ ++static const char *memRbtreeGetFilename(Rbtree *pBt){ ++ return 0; /* A NULL return indicates there is no underlying file */ ++} ++ ++/* ++** The copy file function is not implemented for the in-memory database ++*/ ++static int memRbtreeCopyFile(Rbtree *pBt, Rbtree *pBt2){ ++ return SQLITE_INTERNAL; /* Not implemented */ ++} ++ ++static BtOps sqliteRbtreeOps = { ++ (int(*)(Btree*)) memRbtreeClose, ++ (int(*)(Btree*,int)) memRbtreeSetCacheSize, ++ (int(*)(Btree*,int)) memRbtreeSetSafetyLevel, ++ (int(*)(Btree*)) memRbtreeBeginTrans, ++ (int(*)(Btree*)) memRbtreeCommit, ++ (int(*)(Btree*)) memRbtreeRollback, ++ (int(*)(Btree*)) memRbtreeBeginCkpt, ++ (int(*)(Btree*)) memRbtreeCommitCkpt, ++ (int(*)(Btree*)) memRbtreeRollbackCkpt, ++ (int(*)(Btree*,int*)) memRbtreeCreateTable, ++ (int(*)(Btree*,int*)) memRbtreeCreateTable, ++ (int(*)(Btree*,int)) memRbtreeDropTable, ++ (int(*)(Btree*,int)) memRbtreeClearTable, ++ (int(*)(Btree*,int,int,BtCursor**)) memRbtreeCursor, ++ (int(*)(Btree*,int*)) memRbtreeGetMeta, ++ (int(*)(Btree*,int*)) memRbtreeUpdateMeta, ++ (char*(*)(Btree*,int*,int)) memRbtreeIntegrityCheck, ++ (const char*(*)(Btree*)) memRbtreeGetFilename, ++ (int(*)(Btree*,Btree*)) memRbtreeCopyFile, ++ (struct Pager*(*)(Btree*)) memRbtreePager, ++#ifdef SQLITE_TEST ++ (int(*)(Btree*,int,int)) memRbtreePageDump, ++#endif ++}; ++ ++static BtCursorOps sqliteRbtreeCursorOps = { ++ (int(*)(BtCursor*,const void*,int,int*)) memRbtreeMoveto, ++ (int(*)(BtCursor*)) memRbtreeDelete, ++ (int(*)(BtCursor*,const void*,int,const void*,int)) memRbtreeInsert, ++ (int(*)(BtCursor*,int*)) memRbtreeFirst, ++ (int(*)(BtCursor*,int*)) memRbtreeLast, ++ (int(*)(BtCursor*,int*)) memRbtreeNext, ++ (int(*)(BtCursor*,int*)) memRbtreePrevious, ++ (int(*)(BtCursor*,int*)) memRbtreeKeySize, ++ (int(*)(BtCursor*,int,int,char*)) memRbtreeKey, ++ (int(*)(BtCursor*,const void*,int,int,int*)) memRbtreeKeyCompare, ++ (int(*)(BtCursor*,int*)) memRbtreeDataSize, ++ (int(*)(BtCursor*,int,int,char*)) memRbtreeData, ++ (int(*)(BtCursor*)) memRbtreeCloseCursor, ++#ifdef SQLITE_TEST ++ (int(*)(BtCursor*,int*)) memRbtreeCursorDump, ++#endif ++ ++}; ++ ++#endif /* SQLITE_OMIT_INMEMORYDB */ +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/build.c +@@ -0,0 +1,2156 @@ ++/* ++** 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 ++** PRAGMA ++** ++** $Id$ ++*/ ++#include "sqliteInt.h" ++#include ++ ++/* ++** This routine is called when a new SQL statement is beginning to ++** be parsed. Check to see if the schema for the database needs ++** to be read from the SQLITE_MASTER and SQLITE_TEMP_MASTER tables. ++** If it does, then read it. ++*/ ++void sqliteBeginParse(Parse *pParse, int explainFlag){ ++ sqlite *db = pParse->db; ++ int i; ++ pParse->explain = explainFlag; ++ if((db->flags & SQLITE_Initialized)==0 && db->init.busy==0 ){ ++ int rc = sqliteInit(db, &pParse->zErrMsg); ++ if( rc!=SQLITE_OK ){ ++ pParse->rc = rc; ++ pParse->nErr++; ++ } ++ } ++ for(i=0; inDb; i++){ ++ DbClearProperty(db, i, DB_Locked); ++ if( !db->aDb[i].inTrans ){ ++ DbClearProperty(db, i, DB_Cookie); ++ } ++ } ++ pParse->nVar = 0; ++} ++ ++/* ++** This routine is called after a single SQL statement has been ++** parsed and we want to execute the VDBE code to implement ++** that statement. Prior action routines should have already ++** constructed VDBE code to do the work of the SQL statement. ++** This routine just has to execute the VDBE code. ++** ++** Note that if an error occurred, it might be the case that ++** no VDBE code was generated. ++*/ ++void sqliteExec(Parse *pParse){ ++ sqlite *db = pParse->db; ++ Vdbe *v = pParse->pVdbe; ++ ++ if( v==0 && (v = sqliteGetVdbe(pParse))!=0 ){ ++ sqliteVdbeAddOp(v, OP_Halt, 0, 0); ++ } ++ if( sqlite_malloc_failed ) return; ++ if( v && pParse->nErr==0 ){ ++ FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0; ++ sqliteVdbeTrace(v, trace); ++ sqliteVdbeMakeReady(v, pParse->nVar, pParse->explain); ++ pParse->rc = pParse->nErr ? SQLITE_ERROR : SQLITE_DONE; ++ pParse->colNamesSet = 0; ++ }else if( pParse->rc==SQLITE_OK ){ ++ pParse->rc = SQLITE_ERROR; ++ } ++ pParse->nTab = 0; ++ pParse->nMem = 0; ++ pParse->nSet = 0; ++ pParse->nAgg = 0; ++ pParse->nVar = 0; ++} ++ ++/* ++** 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 sqliteLocateTable(). ++*/ ++Table *sqliteFindTable(sqlite *db, const char *zName, const char *zDatabase){ ++ Table *p = 0; ++ int i; ++ for(i=0; inDb; i++){ ++ int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ ++ if( zDatabase!=0 && sqliteStrICmp(zDatabase, db->aDb[j].zName) ) continue; ++ p = sqliteHashFind(&db->aDb[j].tblHash, zName, strlen(zName)+1); ++ 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 sqliteFindTable() ++** is that this routine leaves an error message in pParse->zErrMsg ++** where sqliteFindTable() does not. ++*/ ++Table *sqliteLocateTable(Parse *pParse, const char *zName, const char *zDbase){ ++ Table *p; ++ ++ p = sqliteFindTable(pParse->db, zName, zDbase); ++ if( p==0 ){ ++ if( zDbase ){ ++ sqliteErrorMsg(pParse, "no such table: %s.%s", zDbase, zName); ++ }else if( sqliteFindTable(pParse->db, zName, 0)!=0 ){ ++ sqliteErrorMsg(pParse, "table \"%s\" is not in database \"%s\"", ++ zName, zDbase); ++ }else{ ++ sqliteErrorMsg(pParse, "no such table: %s", zName); ++ } ++ } ++ return p; ++} ++ ++/* ++** 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. ++*/ ++Index *sqliteFindIndex(sqlite *db, const char *zName, const char *zDb){ ++ Index *p = 0; ++ int i; ++ for(i=0; inDb; i++){ ++ int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ ++ if( zDb && sqliteStrICmp(zDb, db->aDb[j].zName) ) continue; ++ p = sqliteHashFind(&db->aDb[j].idxHash, zName, strlen(zName)+1); ++ if( p ) break; ++ } ++ return p; ++} ++ ++/* ++** Remove the given index from the index hash table, and free ++** its memory structures. ++** ++** The index is removed from the database hash tables but ++** it is not unlinked from the Table that it indexes. ++** Unlinking from the Table must be done by the calling function. ++*/ ++static void sqliteDeleteIndex(sqlite *db, Index *p){ ++ Index *pOld; ++ ++ assert( db!=0 && p->zName!=0 ); ++ pOld = sqliteHashInsert(&db->aDb[p->iDb].idxHash, p->zName, ++ strlen(p->zName)+1, 0); ++ if( pOld!=0 && pOld!=p ){ ++ sqliteHashInsert(&db->aDb[p->iDb].idxHash, pOld->zName, ++ strlen(pOld->zName)+1, pOld); ++ } ++ sqliteFree(p); ++} ++ ++/* ++** Unlink the given index from its table, then remove ++** the index from the index hash table and free its memory ++** structures. ++*/ ++void sqliteUnlinkAndDeleteIndex(sqlite *db, Index *pIndex){ ++ if( pIndex->pTable->pIndex==pIndex ){ ++ pIndex->pTable->pIndex = pIndex->pNext; ++ }else{ ++ Index *p; ++ for(p=pIndex->pTable->pIndex; p && p->pNext!=pIndex; p=p->pNext){} ++ if( p && p->pNext==pIndex ){ ++ p->pNext = pIndex->pNext; ++ } ++ } ++ sqliteDeleteIndex(db, pIndex); ++} ++ ++/* ++** Erase all schema information from the in-memory hash tables of ++** database connection. This routine is called to reclaim memory ++** before the connection closes. It is also called during a rollback ++** if there were schema changes during the transaction. ++** ++** If iDb<=0 then reset the internal schema tables for all database ++** files. If iDb>=2 then reset the internal schema for only the ++** single file indicated. ++*/ ++void sqliteResetInternalSchema(sqlite *db, int iDb){ ++ HashElem *pElem; ++ Hash temp1; ++ Hash temp2; ++ int i, j; ++ ++ assert( iDb>=0 && iDbnDb ); ++ db->flags &= ~SQLITE_Initialized; ++ for(i=iDb; inDb; i++){ ++ Db *pDb = &db->aDb[i]; ++ temp1 = pDb->tblHash; ++ temp2 = pDb->trigHash; ++ sqliteHashInit(&pDb->trigHash, SQLITE_HASH_STRING, 0); ++ sqliteHashClear(&pDb->aFKey); ++ sqliteHashClear(&pDb->idxHash); ++ for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){ ++ Trigger *pTrigger = sqliteHashData(pElem); ++ sqliteDeleteTrigger(pTrigger); ++ } ++ sqliteHashClear(&temp2); ++ sqliteHashInit(&pDb->tblHash, SQLITE_HASH_STRING, 0); ++ for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){ ++ Table *pTab = sqliteHashData(pElem); ++ sqliteDeleteTable(db, pTab); ++ } ++ sqliteHashClear(&temp1); ++ DbClearProperty(db, i, DB_SchemaLoaded); ++ if( iDb>0 ) return; ++ } ++ assert( iDb==0 ); ++ db->flags &= ~SQLITE_InternChanges; ++ ++ /* If one or more of the auxiliary database files has been closed, ++ ** then remove then from the auxiliary database list. We take the ++ ** opportunity to do this here since we have just deleted all of the ++ ** schema hash tables and therefore do not have to make any changes ++ ** to any of those tables. ++ */ ++ for(i=0; inDb; i++){ ++ struct Db *pDb = &db->aDb[i]; ++ if( pDb->pBt==0 ){ ++ if( pDb->pAux && pDb->xFreeAux ) pDb->xFreeAux(pDb->pAux); ++ pDb->pAux = 0; ++ } ++ } ++ for(i=j=2; inDb; i++){ ++ struct Db *pDb = &db->aDb[i]; ++ if( pDb->pBt==0 ){ ++ sqliteFree(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])); ++ sqliteFree(db->aDb); ++ db->aDb = db->aDbStatic; ++ } ++} ++ ++/* ++** This routine is called whenever a rollback occurs. If there were ++** schema changes during the transaction, then we have to reset the ++** internal hash tables and reload them from disk. ++*/ ++void sqliteRollbackInternalChanges(sqlite *db){ ++ if( db->flags & SQLITE_InternChanges ){ ++ sqliteResetInternalSchema(db, 0); ++ } ++} ++ ++/* ++** This routine is called when a commit occurs. ++*/ ++void sqliteCommitInternalChanges(sqlite *db){ ++ db->aDb[0].schema_cookie = db->next_cookie; ++ db->flags &= ~SQLITE_InternChanges; ++} ++ ++/* ++** 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. Nor does it remove ++** foreign keys from the sqlite.aFKey hash table. But it does destroy ++** memory structures of the indices and foreign keys associated with ++** the table. ++** ++** Indices associated with the table are unlinked from the "db" ++** data structure if db!=NULL. If db==NULL, indices attached to ++** the table are deleted, but it is assumed they have already been ++** unlinked. ++*/ ++void sqliteDeleteTable(sqlite *db, Table *pTable){ ++ int i; ++ Index *pIndex, *pNext; ++ FKey *pFKey, *pNextFKey; ++ ++ if( pTable==0 ) return; ++ ++ /* Delete all indices associated with this table ++ */ ++ for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){ ++ pNext = pIndex->pNext; ++ assert( pIndex->iDb==pTable->iDb || (pTable->iDb==0 && pIndex->iDb==1) ); ++ sqliteDeleteIndex(db, pIndex); ++ } ++ ++ /* Delete all foreign keys associated with this table. The keys ++ ** should have already been unlinked from the db->aFKey hash table ++ */ ++ for(pFKey=pTable->pFKey; pFKey; pFKey=pNextFKey){ ++ pNextFKey = pFKey->pNextFrom; ++ assert( pTable->iDbnDb ); ++ assert( sqliteHashFind(&db->aDb[pTable->iDb].aFKey, ++ pFKey->zTo, strlen(pFKey->zTo)+1)!=pFKey ); ++ sqliteFree(pFKey); ++ } ++ ++ /* Delete the Table structure itself. ++ */ ++ for(i=0; inCol; i++){ ++ sqliteFree(pTable->aCol[i].zName); ++ sqliteFree(pTable->aCol[i].zDflt); ++ sqliteFree(pTable->aCol[i].zType); ++ } ++ sqliteFree(pTable->zName); ++ sqliteFree(pTable->aCol); ++ sqliteSelectDelete(pTable->pSelect); ++ sqliteFree(pTable); ++} ++ ++/* ++** Unlink the given table from the hash tables and the delete the ++** table structure with all its indices and foreign keys. ++*/ ++static void sqliteUnlinkAndDeleteTable(sqlite *db, Table *p){ ++ Table *pOld; ++ FKey *pF1, *pF2; ++ int i = p->iDb; ++ assert( db!=0 ); ++ pOld = sqliteHashInsert(&db->aDb[i].tblHash, p->zName, strlen(p->zName)+1, 0); ++ assert( pOld==0 || pOld==p ); ++ for(pF1=p->pFKey; pF1; pF1=pF1->pNextFrom){ ++ int nTo = strlen(pF1->zTo) + 1; ++ pF2 = sqliteHashFind(&db->aDb[i].aFKey, pF1->zTo, nTo); ++ if( pF2==pF1 ){ ++ sqliteHashInsert(&db->aDb[i].aFKey, pF1->zTo, nTo, pF1->pNextTo); ++ }else{ ++ while( pF2 && pF2->pNextTo!=pF1 ){ pF2=pF2->pNextTo; } ++ if( pF2 ){ ++ pF2->pNextTo = pF1->pNextTo; ++ } ++ } ++ } ++ sqliteDeleteTable(db, p); ++} ++ ++/* ++** Construct the name of a user table or index from a token. ++** ++** Space to hold the name is obtained from sqliteMalloc() and must ++** be freed by the calling function. ++*/ ++char *sqliteTableNameFromToken(Token *pName){ ++ char *zName = sqliteStrNDup(pName->z, pName->n); ++ sqliteDequote(zName); ++ return zName; ++} ++ ++/* ++** Generate code to open the appropriate master table. The table ++** opened will be SQLITE_MASTER for persistent tables and ++** SQLITE_TEMP_MASTER for temporary tables. The table is opened ++** on cursor 0. ++*/ ++void sqliteOpenMasterTable(Vdbe *v, int isTemp){ ++ sqliteVdbeAddOp(v, OP_Integer, isTemp, 0); ++ sqliteVdbeAddOp(v, OP_OpenWrite, 0, 2); ++} ++ ++/* ++** 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 ++** pStart token is the CREATE and pName is 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 sqliteEndTable() routine ++** is called to complete the construction of the new table record. ++*/ ++void sqliteStartTable( ++ Parse *pParse, /* Parser context */ ++ Token *pStart, /* The "CREATE" token */ ++ Token *pName, /* Name of table or view to create */ ++ int isTemp, /* True if this is a TEMP table */ ++ int isView /* True if this is a VIEW */ ++){ ++ Table *pTable; ++ Index *pIdx; ++ char *zName; ++ sqlite *db = pParse->db; ++ Vdbe *v; ++ int iDb; ++ ++ pParse->sFirstToken = *pStart; ++ zName = sqliteTableNameFromToken(pName); ++ if( zName==0 ) return; ++ if( db->init.iDb==1 ) isTemp = 1; ++#ifndef SQLITE_OMIT_AUTHORIZATION ++ assert( (isTemp & 1)==isTemp ); ++ { ++ int code; ++ char *zDb = isTemp ? "temp" : "main"; ++ if( sqliteAuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){ ++ sqliteFree(zName); ++ return; ++ } ++ if( isView ){ ++ if( isTemp ){ ++ code = SQLITE_CREATE_TEMP_VIEW; ++ }else{ ++ code = SQLITE_CREATE_VIEW; ++ } ++ }else{ ++ if( isTemp ){ ++ code = SQLITE_CREATE_TEMP_TABLE; ++ }else{ ++ code = SQLITE_CREATE_TABLE; ++ } ++ } ++ if( sqliteAuthCheck(pParse, code, zName, 0, zDb) ){ ++ sqliteFree(zName); ++ return; ++ } ++ } ++#endif ++ ++ ++ /* Before trying to create a temporary table, make sure the Btree for ++ ** holding temporary tables is open. ++ */ ++ if( isTemp && db->aDb[1].pBt==0 && !pParse->explain ){ ++ int rc = sqliteBtreeFactory(db, 0, 0, MAX_PAGES, &db->aDb[1].pBt); ++ if( rc!=SQLITE_OK ){ ++ sqliteErrorMsg(pParse, "unable to open a temporary database " ++ "file for storing temporary tables"); ++ pParse->nErr++; ++ return; ++ } ++ if( db->flags & SQLITE_InTrans ){ ++ rc = sqliteBtreeBeginTrans(db->aDb[1].pBt); ++ if( rc!=SQLITE_OK ){ ++ sqliteErrorMsg(pParse, "unable to get a write lock on " ++ "the temporary database file"); ++ return; ++ } ++ } ++ } ++ ++ /* Make sure the new table name does not collide with an existing ++ ** index or table name. Issue an error message if it does. ++ ** ++ ** If we are re-reading the sqlite_master table because of a schema ++ ** change and a new permanent table is found whose name collides with ++ ** an existing temporary table, that is not an error. ++ */ ++ pTable = sqliteFindTable(db, zName, 0); ++ iDb = isTemp ? 1 : db->init.iDb; ++ if( pTable!=0 && (pTable->iDb==iDb || !db->init.busy) ){ ++ sqliteErrorMsg(pParse, "table %T already exists", pName); ++ sqliteFree(zName); ++ return; ++ } ++ if( (pIdx = sqliteFindIndex(db, zName, 0))!=0 && ++ (pIdx->iDb==0 || !db->init.busy) ){ ++ sqliteErrorMsg(pParse, "there is already an index named %s", zName); ++ sqliteFree(zName); ++ return; ++ } ++ pTable = sqliteMalloc( sizeof(Table) ); ++ if( pTable==0 ){ ++ sqliteFree(zName); ++ return; ++ } ++ pTable->zName = zName; ++ pTable->nCol = 0; ++ pTable->aCol = 0; ++ pTable->iPKey = -1; ++ pTable->pIndex = 0; ++ pTable->iDb = iDb; ++ if( pParse->pNewTable ) sqliteDeleteTable(db, pParse->pNewTable); ++ pParse->pNewTable = pTable; ++ ++ /* 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 = sqliteGetVdbe(pParse))!=0 ){ ++ sqliteBeginWriteOperation(pParse, 0, isTemp); ++ if( !isTemp ){ ++ sqliteVdbeAddOp(v, OP_Integer, db->file_format, 0); ++ sqliteVdbeAddOp(v, OP_SetCookie, 0, 1); ++ } ++ sqliteOpenMasterTable(v, isTemp); ++ sqliteVdbeAddOp(v, OP_NewRecno, 0, 0); ++ sqliteVdbeAddOp(v, OP_Dup, 0, 0); ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ sqliteVdbeAddOp(v, OP_PutIntKey, 0, 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. sqliteStartTable() gets called ++** first to get things going. Then this routine is called for each ++** column. ++*/ ++void sqliteAddColumn(Parse *pParse, Token *pName){ ++ Table *p; ++ int i; ++ char *z = 0; ++ Column *pCol; ++ if( (p = pParse->pNewTable)==0 ) return; ++ sqliteSetNString(&z, pName->z, pName->n, 0); ++ if( z==0 ) return; ++ sqliteDequote(z); ++ for(i=0; inCol; i++){ ++ if( sqliteStrICmp(z, p->aCol[i].zName)==0 ){ ++ sqliteErrorMsg(pParse, "duplicate column name: %s", z); ++ sqliteFree(z); ++ return; ++ } ++ } ++ if( (p->nCol & 0x7)==0 ){ ++ Column *aNew; ++ aNew = sqliteRealloc( p->aCol, (p->nCol+8)*sizeof(p->aCol[0])); ++ if( aNew==0 ) return; ++ p->aCol = aNew; ++ } ++ pCol = &p->aCol[p->nCol]; ++ memset(pCol, 0, sizeof(p->aCol[0])); ++ pCol->zName = z; ++ pCol->sortOrder = SQLITE_SO_NUM; ++ 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. ++*/ ++void sqliteAddNotNull(Parse *pParse, int onError){ ++ Table *p; ++ int i; ++ if( (p = pParse->pNewTable)==0 ) return; ++ i = p->nCol-1; ++ if( i>=0 ) p->aCol[i].notNull = onError; ++} ++ ++/* ++** 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. ++*/ ++void sqliteAddColumnType(Parse *pParse, Token *pFirst, Token *pLast){ ++ Table *p; ++ int i, j; ++ int n; ++ char *z, **pz; ++ Column *pCol; ++ if( (p = pParse->pNewTable)==0 ) return; ++ i = p->nCol-1; ++ if( i<0 ) return; ++ pCol = &p->aCol[i]; ++ pz = &pCol->zType; ++ n = pLast->n + Addr(pLast->z) - Addr(pFirst->z); ++ sqliteSetNString(pz, pFirst->z, n, 0); ++ z = *pz; ++ if( z==0 ) return; ++ for(i=j=0; z[i]; i++){ ++ int c = z[i]; ++ if( isspace(c) ) continue; ++ z[j++] = c; ++ } ++ z[j] = 0; ++ if( pParse->db->file_format>=4 ){ ++ pCol->sortOrder = sqliteCollateType(z, n); ++ }else{ ++ pCol->sortOrder = SQLITE_SO_NUM; ++ } ++} ++ ++/* ++** The given token is the default value for the last column added to ++** the table currently under construction. If "minusFlag" is true, it ++** means the value token was preceded by a minus sign. ++** ++** This routine is called by the parser while in the middle of ++** parsing a CREATE TABLE statement. ++*/ ++void sqliteAddDefaultValue(Parse *pParse, Token *pVal, int minusFlag){ ++ Table *p; ++ int i; ++ char **pz; ++ if( (p = pParse->pNewTable)==0 ) return; ++ i = p->nCol-1; ++ if( i<0 ) return; ++ pz = &p->aCol[i].zDflt; ++ if( minusFlag ){ ++ sqliteSetNString(pz, "-", 1, pVal->z, pVal->n, 0); ++ }else{ ++ sqliteSetNString(pz, pVal->z, pVal->n, 0); ++ } ++ sqliteDequote(*pz); ++} ++ ++/* ++** 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 row id. (Exception: ++** For backwards compatibility with older databases, do not do this ++** if the file format version number is less than 1.) 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. ++*/ ++void sqliteAddPrimaryKey(Parse *pParse, IdList *pList, int onError){ ++ Table *pTab = pParse->pNewTable; ++ char *zType = 0; ++ int iCol = -1, i; ++ if( pTab==0 ) goto primary_key_exit; ++ if( pTab->hasPrimKey ){ ++ sqliteErrorMsg(pParse, ++ "table \"%s\" has more than one primary key", pTab->zName); ++ goto primary_key_exit; ++ } ++ pTab->hasPrimKey = 1; ++ if( pList==0 ){ ++ iCol = pTab->nCol - 1; ++ pTab->aCol[iCol].isPrimKey = 1; ++ }else{ ++ for(i=0; inId; i++){ ++ for(iCol=0; iColnCol; iCol++){ ++ if( sqliteStrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ) break; ++ } ++ if( iColnCol ) pTab->aCol[iCol].isPrimKey = 1; ++ } ++ if( pList->nId>1 ) iCol = -1; ++ } ++ if( iCol>=0 && iColnCol ){ ++ zType = pTab->aCol[iCol].zType; ++ } ++ if( pParse->db->file_format>=1 && ++ zType && sqliteStrICmp(zType, "INTEGER")==0 ){ ++ pTab->iPKey = iCol; ++ pTab->keyConf = onError; ++ }else{ ++ sqliteCreateIndex(pParse, 0, 0, pList, onError, 0, 0); ++ pList = 0; ++ } ++ ++primary_key_exit: ++ sqliteIdListDelete(pList); ++ return; ++} ++ ++/* ++** Return the appropriate collating type given a type name. ++** ++** The collation type is text (SQLITE_SO_TEXT) if the type ++** name contains the character stream "text" or "blob" or ++** "clob". Any other type name is collated as numeric ++** (SQLITE_SO_NUM). ++*/ ++int sqliteCollateType(const char *zType, int nType){ ++ int i; ++ for(i=0; ipNewTable)==0 ) return; ++ i = p->nCol-1; ++ if( i>=0 ) p->aCol[i].sortOrder = collType; ++} ++ ++/* ++** Come up with a new random value for the schema cookie. Make sure ++** the new value is different from the old. ++** ++** 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. ++*/ ++void sqliteChangeCookie(sqlite *db, Vdbe *v){ ++ if( db->next_cookie==db->aDb[0].schema_cookie ){ ++ unsigned char r; ++ sqliteRandomness(1, &r); ++ db->next_cookie = db->aDb[0].schema_cookie + r + 1; ++ db->flags |= SQLITE_InternChanges; ++ sqliteVdbeAddOp(v, OP_Integer, db->next_cookie, 0); ++ sqliteVdbeAddOp(v, OP_SetCookie, 0, 0); ++ } ++} ++ ++/* ++** 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. ++*/ ++static int identLength(const char *z){ ++ int n; ++ int needQuote = 0; ++ for(n=0; *z; n++, z++){ ++ if( *z=='\'' ){ n++; needQuote=1; } ++ } ++ return n + needQuote*2; ++} ++ ++/* ++** Write an identifier onto the end of the given string. Add ++** quote characters as needed. ++*/ ++static void identPut(char *z, int *pIdx, char *zIdent){ ++ int i, j, needQuote; ++ i = *pIdx; ++ for(j=0; zIdent[j]; j++){ ++ if( !isalnum(zIdent[j]) && zIdent[j]!='_' ) break; ++ } ++ needQuote = zIdent[j]!=0 || isdigit(zIdent[0]) ++ || sqliteKeywordCode(zIdent, j)!=TK_ID; ++ 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(Table *p){ ++ int i, k, n; ++ char *zStmt; ++ char *zSep, *zSep2, *zEnd; ++ n = 0; ++ for(i=0; inCol; i++){ ++ n += identLength(p->aCol[i].zName); ++ } ++ n += identLength(p->zName); ++ if( n<40 ){ ++ zSep = ""; ++ zSep2 = ","; ++ zEnd = ")"; ++ }else{ ++ zSep = "\n "; ++ zSep2 = ",\n "; ++ zEnd = "\n)"; ++ } ++ n += 35 + 6*p->nCol; ++ zStmt = sqliteMallocRaw( n ); ++ if( zStmt==0 ) return 0; ++ strcpy(zStmt, p->iDb==1 ? "CREATE TEMP TABLE " : "CREATE TABLE "); ++ k = strlen(zStmt); ++ identPut(zStmt, &k, p->zName); ++ zStmt[k++] = '('; ++ for(i=0; inCol; i++){ ++ strcpy(&zStmt[k], zSep); ++ k += strlen(&zStmt[k]); ++ zSep = zSep2; ++ identPut(zStmt, &k, p->aCol[i].zName); ++ } ++ strcpy(&zStmt[k], zEnd); ++ return zStmt; ++} ++ ++/* ++** 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 changes, 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. ++*/ ++void sqliteEndTable(Parse *pParse, Token *pEnd, Select *pSelect){ ++ Table *p; ++ sqlite *db = pParse->db; ++ ++ if( (pEnd==0 && pSelect==0) || pParse->nErr || sqlite_malloc_failed ) return; ++ p = pParse->pNewTable; ++ if( p==0 ) return; ++ ++ /* If the table is generated from a SELECT, then construct the ++ ** list of columns and the text of the table. ++ */ ++ if( pSelect ){ ++ Table *pSelTab = sqliteResultSetOfSelect(pParse, 0, pSelect); ++ if( pSelTab==0 ) return; ++ assert( p->aCol==0 ); ++ p->nCol = pSelTab->nCol; ++ p->aCol = pSelTab->aCol; ++ pSelTab->nCol = 0; ++ pSelTab->aCol = 0; ++ sqliteDeleteTable(0, pSelTab); ++ } ++ ++ /* 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; ++ } ++ ++ /* If not initializing, then create a record for the new table ++ ** in the SQLITE_MASTER table of the database. The record number ++ ** for the new table entry should already be on the stack. ++ ** ++ ** 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; ++ ++ v = sqliteGetVdbe(pParse); ++ if( v==0 ) return; ++ if( p->pSelect==0 ){ ++ /* A regular table */ ++ sqliteVdbeOp3(v, OP_CreateTable, 0, p->iDb, (char*)&p->tnum, P3_POINTER); ++ }else{ ++ /* A view */ ++ sqliteVdbeAddOp(v, OP_Integer, 0, 0); ++ } ++ p->tnum = 0; ++ sqliteVdbeAddOp(v, OP_Pull, 1, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, p->pSelect==0?"table":"view", P3_STATIC); ++ sqliteVdbeOp3(v, OP_String, 0, 0, p->zName, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, p->zName, 0); ++ sqliteVdbeAddOp(v, OP_Dup, 4, 0); ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ if( pSelect ){ ++ char *z = createTableStmt(p); ++ n = z ? strlen(z) : 0; ++ sqliteVdbeChangeP3(v, -1, z, n); ++ sqliteFree(z); ++ }else{ ++ assert( pEnd!=0 ); ++ n = Addr(pEnd->z) - Addr(pParse->sFirstToken.z) + 1; ++ sqliteVdbeChangeP3(v, -1, pParse->sFirstToken.z, n); ++ } ++ sqliteVdbeAddOp(v, OP_MakeRecord, 5, 0); ++ sqliteVdbeAddOp(v, OP_PutIntKey, 0, 0); ++ if( !p->iDb ){ ++ sqliteChangeCookie(db, v); ++ } ++ sqliteVdbeAddOp(v, OP_Close, 0, 0); ++ if( pSelect ){ ++ sqliteVdbeAddOp(v, OP_Integer, p->iDb, 0); ++ sqliteVdbeAddOp(v, OP_OpenWrite, 1, 0); ++ pParse->nTab = 2; ++ sqliteSelect(pParse, pSelect, SRT_Table, 1, 0, 0, 0); ++ } ++ sqliteEndWriteOperation(pParse); ++ } ++ ++ /* Add the table to the in-memory representation of the database. ++ */ ++ if( pParse->explain==0 && pParse->nErr==0 ){ ++ Table *pOld; ++ FKey *pFKey; ++ pOld = sqliteHashInsert(&db->aDb[p->iDb].tblHash, ++ p->zName, strlen(p->zName)+1, p); ++ if( pOld ){ ++ assert( p==pOld ); /* Malloc must have failed inside HashInsert() */ ++ return; ++ } ++ for(pFKey=p->pFKey; pFKey; pFKey=pFKey->pNextFrom){ ++ int nTo = strlen(pFKey->zTo) + 1; ++ pFKey->pNextTo = sqliteHashFind(&db->aDb[p->iDb].aFKey, pFKey->zTo, nTo); ++ sqliteHashInsert(&db->aDb[p->iDb].aFKey, pFKey->zTo, nTo, pFKey); ++ } ++ pParse->pNewTable = 0; ++ db->nTable++; ++ db->flags |= SQLITE_InternChanges; ++ } ++} ++ ++/* ++** The parser calls this routine in order to create a new VIEW ++*/ ++void sqliteCreateView( ++ Parse *pParse, /* The parsing context */ ++ Token *pBegin, /* The CREATE token that begins the statement */ ++ Token *pName, /* The token that holds the name of the view */ ++ Select *pSelect, /* A SELECT statement that will become the new view */ ++ int isTemp /* TRUE for a TEMPORARY view */ ++){ ++ Table *p; ++ int n; ++ const char *z; ++ Token sEnd; ++ DbFixer sFix; ++ ++ sqliteStartTable(pParse, pBegin, pName, isTemp, 1); ++ p = pParse->pNewTable; ++ if( p==0 || pParse->nErr ){ ++ sqliteSelectDelete(pSelect); ++ return; ++ } ++ if( sqliteFixInit(&sFix, pParse, p->iDb, "view", pName) ++ && sqliteFixSelect(&sFix, pSelect) ++ ){ ++ sqliteSelectDelete(pSelect); ++ return; ++ } ++ ++ /* 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 sqlite_exec() call returns. ++ */ ++ p->pSelect = sqliteSelectDup(pSelect); ++ sqliteSelectDelete(pSelect); ++ if( !pParse->db->init.busy ){ ++ sqliteViewGetColumnNames(pParse, p); ++ } ++ ++ /* Locate the end of the CREATE VIEW statement. Make sEnd point to ++ ** the end. ++ */ ++ sEnd = pParse->sLastToken; ++ if( sEnd.z[0]!=0 && sEnd.z[0]!=';' ){ ++ sEnd.z += sEnd.n; ++ } ++ sEnd.n = 0; ++ n = sEnd.z - pBegin->z; ++ z = pBegin->z; ++ while( n>0 && (z[n-1]==';' || isspace(z[n-1])) ){ n--; } ++ sEnd.z = &z[n-1]; ++ sEnd.n = 1; ++ ++ /* Use sqliteEndTable() to add the view to the SQLITE_MASTER table */ ++ sqliteEndTable(pParse, &sEnd, 0); ++ return; ++} ++ ++/* ++** 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. ++*/ ++int sqliteViewGetColumnNames(Parse *pParse, Table *pTable){ ++ ExprList *pEList; ++ Select *pSel; ++ Table *pSelTab; ++ int nErr = 0; ++ ++ assert( pTable ); ++ ++ /* 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, this error is caught previously and so the following test ++ ** should always fail. But we will leave it in place just to be safe. ++ */ ++ if( pTable->nCol<0 ){ ++ sqliteErrorMsg(pParse, "view %s is circularly defined", pTable->zName); ++ return 1; ++ } ++ ++ /* If we get this far, it means we need to compute the table names. ++ */ ++ assert( pTable->pSelect ); /* If nCol==0, then pTable must be a VIEW */ ++ pSel = pTable->pSelect; ++ ++ /* Note that the call to sqliteResultSetOfSelect() will expand any ++ ** "*" elements in this list. But we will need to restore the list ++ ** back to its original configuration afterwards, so we save a copy of ++ ** the original in pEList. ++ */ ++ pEList = pSel->pEList; ++ pSel->pEList = sqliteExprListDup(pEList); ++ if( pSel->pEList==0 ){ ++ pSel->pEList = pEList; ++ return 1; /* Malloc failed */ ++ } ++ pTable->nCol = -1; ++ pSelTab = sqliteResultSetOfSelect(pParse, 0, pSel); ++ if( pSelTab ){ ++ assert( pTable->aCol==0 ); ++ pTable->nCol = pSelTab->nCol; ++ pTable->aCol = pSelTab->aCol; ++ pSelTab->nCol = 0; ++ pSelTab->aCol = 0; ++ sqliteDeleteTable(0, pSelTab); ++ DbSetProperty(pParse->db, pTable->iDb, DB_UnresetViews); ++ }else{ ++ pTable->nCol = 0; ++ nErr++; ++ } ++ sqliteSelectUnbind(pSel); ++ sqliteExprListDelete(pSel->pEList); ++ pSel->pEList = pEList; ++ return nErr; ++} ++ ++/* ++** Clear the column names from the VIEW pTable. ++** ++** This routine is called whenever any other table or view is modified. ++** The view passed into this routine might depend directly or indirectly ++** on the modified or deleted table so we need to clear the old column ++** names so that they will be recomputed. ++*/ ++static void sqliteViewResetColumnNames(Table *pTable){ ++ int i; ++ Column *pCol; ++ assert( pTable!=0 && pTable->pSelect!=0 ); ++ for(i=0, pCol=pTable->aCol; inCol; i++, pCol++){ ++ sqliteFree(pCol->zName); ++ sqliteFree(pCol->zDflt); ++ sqliteFree(pCol->zType); ++ } ++ sqliteFree(pTable->aCol); ++ pTable->aCol = 0; ++ pTable->nCol = 0; ++} ++ ++/* ++** Clear the column names from every VIEW in database idx. ++*/ ++static void sqliteViewResetAll(sqlite *db, int idx){ ++ HashElem *i; ++ if( !DbHasProperty(db, idx, DB_UnresetViews) ) return; ++ for(i=sqliteHashFirst(&db->aDb[idx].tblHash); i; i=sqliteHashNext(i)){ ++ Table *pTab = sqliteHashData(i); ++ if( pTab->pSelect ){ ++ sqliteViewResetColumnNames(pTab); ++ } ++ } ++ DbClearProperty(db, idx, DB_UnresetViews); ++} ++ ++/* ++** Given a token, look up a table with that name. If not found, leave ++** an error for the parser to find and return NULL. ++*/ ++Table *sqliteTableFromToken(Parse *pParse, Token *pTok){ ++ char *zName; ++ Table *pTab; ++ zName = sqliteTableNameFromToken(pTok); ++ if( zName==0 ) return 0; ++ pTab = sqliteFindTable(pParse->db, zName, 0); ++ sqliteFree(zName); ++ if( pTab==0 ){ ++ sqliteErrorMsg(pParse, "no such table: %T", pTok); ++ } ++ return pTab; ++} ++ ++/* ++** This routine is called to do the work of a DROP TABLE statement. ++** pName is the name of the table to be dropped. ++*/ ++void sqliteDropTable(Parse *pParse, Token *pName, int isView){ ++ Table *pTable; ++ Vdbe *v; ++ int base; ++ sqlite *db = pParse->db; ++ int iDb; ++ ++ if( pParse->nErr || sqlite_malloc_failed ) return; ++ pTable = sqliteTableFromToken(pParse, pName); ++ if( pTable==0 ) return; ++ iDb = pTable->iDb; ++ assert( iDb>=0 && iDbnDb ); ++#ifndef SQLITE_OMIT_AUTHORIZATION ++ { ++ int code; ++ const char *zTab = SCHEMA_TABLE(pTable->iDb); ++ const char *zDb = db->aDb[pTable->iDb].zName; ++ if( sqliteAuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){ ++ return; ++ } ++ if( isView ){ ++ if( iDb==1 ){ ++ code = SQLITE_DROP_TEMP_VIEW; ++ }else{ ++ code = SQLITE_DROP_VIEW; ++ } ++ }else{ ++ if( iDb==1 ){ ++ code = SQLITE_DROP_TEMP_TABLE; ++ }else{ ++ code = SQLITE_DROP_TABLE; ++ } ++ } ++ if( sqliteAuthCheck(pParse, code, pTable->zName, 0, zDb) ){ ++ return; ++ } ++ if( sqliteAuthCheck(pParse, SQLITE_DELETE, pTable->zName, 0, zDb) ){ ++ return; ++ } ++ } ++#endif ++ if( pTable->readOnly ){ ++ sqliteErrorMsg(pParse, "table %s may not be dropped", pTable->zName); ++ pParse->nErr++; ++ return; ++ } ++ if( isView && pTable->pSelect==0 ){ ++ sqliteErrorMsg(pParse, "use DROP TABLE to delete table %s", pTable->zName); ++ return; ++ } ++ if( !isView && pTable->pSelect ){ ++ sqliteErrorMsg(pParse, "use DROP VIEW to delete view %s", pTable->zName); ++ return; ++ } ++ ++ /* Generate code to remove the table from the master table ++ ** on disk. ++ */ ++ v = sqliteGetVdbe(pParse); ++ if( v ){ ++ static VdbeOpList dropTable[] = { ++ { OP_Rewind, 0, ADDR(8), 0}, ++ { OP_String, 0, 0, 0}, /* 1 */ ++ { OP_MemStore, 1, 1, 0}, ++ { OP_MemLoad, 1, 0, 0}, /* 3 */ ++ { OP_Column, 0, 2, 0}, ++ { OP_Ne, 0, ADDR(7), 0}, ++ { OP_Delete, 0, 0, 0}, ++ { OP_Next, 0, ADDR(3), 0}, /* 7 */ ++ }; ++ Index *pIdx; ++ Trigger *pTrigger; ++ sqliteBeginWriteOperation(pParse, 0, pTable->iDb); ++ ++ /* Drop all triggers associated with the table being dropped */ ++ pTrigger = pTable->pTrigger; ++ while( pTrigger ){ ++ assert( pTrigger->iDb==pTable->iDb || pTrigger->iDb==1 ); ++ sqliteDropTriggerPtr(pParse, pTrigger, 1); ++ if( pParse->explain ){ ++ pTrigger = pTrigger->pNext; ++ }else{ ++ pTrigger = pTable->pTrigger; ++ } ++ } ++ ++ /* Drop all SQLITE_MASTER entries that refer to the table */ ++ sqliteOpenMasterTable(v, pTable->iDb); ++ base = sqliteVdbeAddOpList(v, ArraySize(dropTable), dropTable); ++ sqliteVdbeChangeP3(v, base+1, pTable->zName, 0); ++ ++ /* Drop all SQLITE_TEMP_MASTER entries that refer to the table */ ++ if( pTable->iDb!=1 ){ ++ sqliteOpenMasterTable(v, 1); ++ base = sqliteVdbeAddOpList(v, ArraySize(dropTable), dropTable); ++ sqliteVdbeChangeP3(v, base+1, pTable->zName, 0); ++ } ++ ++ if( pTable->iDb==0 ){ ++ sqliteChangeCookie(db, v); ++ } ++ sqliteVdbeAddOp(v, OP_Close, 0, 0); ++ if( !isView ){ ++ sqliteVdbeAddOp(v, OP_Destroy, pTable->tnum, pTable->iDb); ++ for(pIdx=pTable->pIndex; pIdx; pIdx=pIdx->pNext){ ++ sqliteVdbeAddOp(v, OP_Destroy, pIdx->tnum, pIdx->iDb); ++ } ++ } ++ sqliteEndWriteOperation(pParse); ++ } ++ ++ /* Delete the in-memory description of the table. ++ ** ++ ** Exception: if the SQL statement began with the EXPLAIN keyword, ++ ** then no changes should be made. ++ */ ++ if( !pParse->explain ){ ++ sqliteUnlinkAndDeleteTable(db, pTable); ++ db->flags |= SQLITE_InternChanges; ++ } ++ sqliteViewResetAll(db, iDb); ++} ++ ++/* ++** This routine constructs a P3 string suitable for an OP_MakeIdxKey ++** opcode and adds that P3 string to the most recently inserted instruction ++** in the virtual machine. The P3 string consists of a single character ++** for each column in the index pIdx of table pTab. If the column uses ++** a numeric sort order, then the P3 string character corresponding to ++** that column is 'n'. If the column uses a text sort order, then the ++** P3 string is 't'. See the OP_MakeIdxKey opcode documentation for ++** additional information. See also the sqliteAddKeyType() routine. ++*/ ++void sqliteAddIdxKeyType(Vdbe *v, Index *pIdx){ ++ char *zType; ++ Table *pTab; ++ int i, n; ++ assert( pIdx!=0 && pIdx->pTable!=0 ); ++ pTab = pIdx->pTable; ++ n = pIdx->nColumn; ++ zType = sqliteMallocRaw( n+1 ); ++ if( zType==0 ) return; ++ for(i=0; iaiColumn[i]; ++ assert( iCol>=0 && iColnCol ); ++ if( (pTab->aCol[iCol].sortOrder & SQLITE_SO_TYPEMASK)==SQLITE_SO_TEXT ){ ++ zType[i] = 't'; ++ }else{ ++ zType[i] = 'n'; ++ } ++ } ++ zType[n] = 0; ++ sqliteVdbeChangeP3(v, -1, zType, n); ++ sqliteFree(zType); ++} ++ ++/* ++** 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. pToCol is a list of tables in the other ++** pTo table that the foreign key points to. 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 new FKey ++** is not linked into db->aFKey at this point - that does not happen ++** until sqliteEndTable(). ++** ++** The foreign key is set for IMMEDIATE processing. A subsequent call ++** to sqliteDeferForeignKey() might change this to DEFERRED. ++*/ ++void sqliteCreateForeignKey( ++ Parse *pParse, /* Parsing context */ ++ IdList *pFromCol, /* Columns in this table that point to other table */ ++ Token *pTo, /* Name of the other table */ ++ IdList *pToCol, /* Columns in the other table */ ++ int flags /* Conflict resolution algorithms. */ ++){ ++ Table *p = pParse->pNewTable; ++ int nByte; ++ int i; ++ int nCol; ++ char *z; ++ FKey *pFKey = 0; ++ ++ assert( pTo!=0 ); ++ if( p==0 || pParse->nErr ) goto fk_end; ++ if( pFromCol==0 ){ ++ int iCol = p->nCol-1; ++ if( iCol<0 ) goto fk_end; ++ if( pToCol && pToCol->nId!=1 ){ ++ sqliteErrorMsg(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->nId!=pFromCol->nId ){ ++ sqliteErrorMsg(pParse, ++ "number of columns in foreign key does not match the number of " ++ "columns in the referenced table"); ++ goto fk_end; ++ }else{ ++ nCol = pFromCol->nId; ++ } ++ nByte = sizeof(*pFKey) + nCol*sizeof(pFKey->aCol[0]) + pTo->n + 1; ++ if( pToCol ){ ++ for(i=0; inId; i++){ ++ nByte += strlen(pToCol->a[i].zName) + 1; ++ } ++ } ++ pFKey = sqliteMalloc( nByte ); ++ if( pFKey==0 ) goto fk_end; ++ pFKey->pFrom = p; ++ pFKey->pNextFrom = p->pFKey; ++ z = (char*)&pFKey[1]; ++ pFKey->aCol = (struct sColMap*)z; ++ z += sizeof(struct sColMap)*nCol; ++ pFKey->zTo = z; ++ memcpy(z, pTo->z, pTo->n); ++ z[pTo->n] = 0; ++ z += pTo->n+1; ++ pFKey->pNextTo = 0; ++ pFKey->nCol = nCol; ++ if( pFromCol==0 ){ ++ pFKey->aCol[0].iFrom = p->nCol-1; ++ }else{ ++ for(i=0; inCol; j++){ ++ if( sqliteStrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){ ++ pFKey->aCol[i].iFrom = j; ++ break; ++ } ++ } ++ if( j>=p->nCol ){ ++ sqliteErrorMsg(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->deleteConf = flags & 0xff; ++ pFKey->updateConf = (flags >> 8 ) & 0xff; ++ pFKey->insertConf = (flags >> 16 ) & 0xff; ++ ++ /* Link the foreign key to the table as the last step. ++ */ ++ p->pFKey = pFKey; ++ pFKey = 0; ++ ++fk_end: ++ sqliteFree(pFKey); ++ sqliteIdListDelete(pFromCol); ++ sqliteIdListDelete(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. ++*/ ++void sqliteDeferForeignKey(Parse *pParse, int isDeferred){ ++ Table *pTab; ++ FKey *pFKey; ++ if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return; ++ pFKey->isDeferred = isDeferred; ++} ++ ++/* ++** Create a new index for an SQL table. pIndex is the name of the index ++** and pTable 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. ++*/ ++void sqliteCreateIndex( ++ Parse *pParse, /* All information about this parse */ ++ Token *pName, /* Name of the index. May be NULL */ ++ SrcList *pTable, /* Name of the table to index. Use pParse->pNewTable if 0 */ ++ IdList *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 a CREATE TABLE statement */ ++ Token *pEnd /* The ")" that closes the CREATE INDEX statement */ ++){ ++ Table *pTab; /* Table to be indexed */ ++ Index *pIndex; /* The index to be created */ ++ char *zName = 0; ++ int i, j; ++ Token nullId; /* Fake token for an empty ID list */ ++ DbFixer sFix; /* For assigning database names to pTable */ ++ int isTemp; /* True for a temporary index */ ++ sqlite *db = pParse->db; ++ ++ if( pParse->nErr || sqlite_malloc_failed ) goto exit_create_index; ++ if( db->init.busy ++ && sqliteFixInit(&sFix, pParse, db->init.iDb, "index", pName) ++ && sqliteFixSrcList(&sFix, pTable) ++ ){ ++ goto exit_create_index; ++ } ++ ++ /* ++ ** Find the table that is to be indexed. Return early if not found. ++ */ ++ if( pTable!=0 ){ ++ assert( pName!=0 ); ++ assert( pTable->nSrc==1 ); ++ pTab = sqliteSrcListLookup(pParse, pTable); ++ }else{ ++ assert( pName==0 ); ++ pTab = pParse->pNewTable; ++ } ++ if( pTab==0 || pParse->nErr ) goto exit_create_index; ++ if( pTab->readOnly ){ ++ sqliteErrorMsg(pParse, "table %s may not be indexed", pTab->zName); ++ goto exit_create_index; ++ } ++ if( pTab->iDb>=2 && db->init.busy==0 ){ ++ sqliteErrorMsg(pParse, "table %s may not have indices added", pTab->zName); ++ goto exit_create_index; ++ } ++ if( pTab->pSelect ){ ++ sqliteErrorMsg(pParse, "views may not be indexed"); ++ goto exit_create_index; ++ } ++ isTemp = pTab->iDb==1; ++ ++ /* ++ ** 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 && !db->init.busy ){ ++ Index *pISameName; /* Another index with the same name */ ++ Table *pTSameName; /* A table with same name as the index */ ++ zName = sqliteTableNameFromToken(pName); ++ if( zName==0 ) goto exit_create_index; ++ if( (pISameName = sqliteFindIndex(db, zName, 0))!=0 ){ ++ sqliteErrorMsg(pParse, "index %s already exists", zName); ++ goto exit_create_index; ++ } ++ if( (pTSameName = sqliteFindTable(db, zName, 0))!=0 ){ ++ sqliteErrorMsg(pParse, "there is already a table named %s", zName); ++ goto exit_create_index; ++ } ++ }else if( pName==0 ){ ++ char zBuf[30]; ++ int n; ++ Index *pLoop; ++ for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){} ++ sprintf(zBuf,"%d)",n); ++ zName = 0; ++ sqliteSetString(&zName, "(", pTab->zName, " autoindex ", zBuf, (char*)0); ++ if( zName==0 ) goto exit_create_index; ++ }else{ ++ zName = sqliteTableNameFromToken(pName); ++ } ++ ++ /* Check for authorization to create an index. ++ */ ++#ifndef SQLITE_OMIT_AUTHORIZATION ++ { ++ const char *zDb = db->aDb[pTab->iDb].zName; ++ ++ assert( pTab->iDb==db->init.iDb || isTemp ); ++ if( sqliteAuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){ ++ goto exit_create_index; ++ } ++ i = SQLITE_CREATE_INDEX; ++ if( isTemp ) i = SQLITE_CREATE_TEMP_INDEX; ++ if( sqliteAuthCheck(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 ){ ++ nullId.z = pTab->aCol[pTab->nCol-1].zName; ++ nullId.n = strlen(nullId.z); ++ pList = sqliteIdListAppend(0, &nullId); ++ if( pList==0 ) goto exit_create_index; ++ } ++ ++ /* ++ ** Allocate the index structure. ++ */ ++ pIndex = sqliteMalloc( sizeof(Index) + strlen(zName) + 1 + ++ sizeof(int)*pList->nId ); ++ if( pIndex==0 ) goto exit_create_index; ++ pIndex->aiColumn = (int*)&pIndex[1]; ++ pIndex->zName = (char*)&pIndex->aiColumn[pList->nId]; ++ strcpy(pIndex->zName, zName); ++ pIndex->pTable = pTab; ++ pIndex->nColumn = pList->nId; ++ pIndex->onError = onError; ++ pIndex->autoIndex = pName==0; ++ pIndex->iDb = isTemp ? 1 : db->init.iDb; ++ ++ /* Scan the names of the columns of the table to be indexed and ++ ** load the column indices into the Index structure. Report an error ++ ** if any column is not found. ++ */ ++ for(i=0; inId; i++){ ++ for(j=0; jnCol; j++){ ++ if( sqliteStrICmp(pList->a[i].zName, pTab->aCol[j].zName)==0 ) break; ++ } ++ if( j>=pTab->nCol ){ ++ sqliteErrorMsg(pParse, "table %s has no column named %s", ++ pTab->zName, pList->a[i].zName); ++ sqliteFree(pIndex); ++ goto exit_create_index; ++ } ++ pIndex->aiColumn[i] = j; ++ } ++ ++ /* Link the new Index structure to its table and to the other ++ ** in-memory database structures. ++ */ ++ if( !pParse->explain ){ ++ Index *p; ++ p = sqliteHashInsert(&db->aDb[pIndex->iDb].idxHash, ++ pIndex->zName, strlen(pIndex->zName)+1, pIndex); ++ if( p ){ ++ assert( p==pIndex ); /* Malloc must have failed */ ++ sqliteFree(pIndex); ++ goto exit_create_index; ++ } ++ db->flags |= SQLITE_InternChanges; ++ } ++ ++ /* 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 operation of UPDATE ++ ** and INSERT. ++ */ ++ 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; ++ } ++ ++ /* If the db->init.busy is 1 it means we are reading the SQL off the ++ ** "sqlite_master" table on the disk. So do not write to the disk ++ ** again. Extract the table number from the db->init.newTnum field. ++ */ ++ if( db->init.busy && pTable!=0 ){ ++ pIndex->tnum = db->init.newTnum; ++ } ++ ++ /* If the db->init.busy is 0 then create the index on disk. This ++ ** involves writing the index into the master table and filling in the ++ ** index with the current table contents. ++ ** ++ ** The db->init.busy is 0 when the user first enters a CREATE INDEX ++ ** command. db->init.busy is 1 when a database is opened and ++ ** CREATE INDEX statements are read out of the master table. In ++ ** the latter case the index already exists on disk, which is why ++ ** we don't want to recreate it. ++ ** ++ ** If pTable==0 it means this index is generated as a primary key ++ ** or UNIQUE constraint of 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( db->init.busy==0 ){ ++ int n; ++ Vdbe *v; ++ int lbl1, lbl2; ++ int i; ++ int addr; ++ ++ v = sqliteGetVdbe(pParse); ++ if( v==0 ) goto exit_create_index; ++ if( pTable!=0 ){ ++ sqliteBeginWriteOperation(pParse, 0, isTemp); ++ sqliteOpenMasterTable(v, isTemp); ++ } ++ sqliteVdbeAddOp(v, OP_NewRecno, 0, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, "index", P3_STATIC); ++ sqliteVdbeOp3(v, OP_String, 0, 0, pIndex->zName, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, pTab->zName, 0); ++ sqliteVdbeOp3(v, OP_CreateIndex, 0, isTemp,(char*)&pIndex->tnum,P3_POINTER); ++ pIndex->tnum = 0; ++ if( pTable ){ ++ sqliteVdbeCode(v, ++ OP_Dup, 0, 0, ++ OP_Integer, isTemp, 0, ++ OP_OpenWrite, 1, 0, ++ 0); ++ } ++ addr = sqliteVdbeAddOp(v, OP_String, 0, 0); ++ if( pStart && pEnd ){ ++ n = Addr(pEnd->z) - Addr(pStart->z) + 1; ++ sqliteVdbeChangeP3(v, addr, pStart->z, n); ++ } ++ sqliteVdbeAddOp(v, OP_MakeRecord, 5, 0); ++ sqliteVdbeAddOp(v, OP_PutIntKey, 0, 0); ++ if( pTable ){ ++ sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); ++ sqliteVdbeOp3(v, OP_OpenRead, 2, pTab->tnum, pTab->zName, 0); ++ lbl2 = sqliteVdbeMakeLabel(v); ++ sqliteVdbeAddOp(v, OP_Rewind, 2, lbl2); ++ lbl1 = sqliteVdbeAddOp(v, OP_Recno, 2, 0); ++ for(i=0; inColumn; i++){ ++ int iCol = pIndex->aiColumn[i]; ++ if( pTab->iPKey==iCol ){ ++ sqliteVdbeAddOp(v, OP_Dup, i, 0); ++ }else{ ++ sqliteVdbeAddOp(v, OP_Column, 2, iCol); ++ } ++ } ++ sqliteVdbeAddOp(v, OP_MakeIdxKey, pIndex->nColumn, 0); ++ if( db->file_format>=4 ) sqliteAddIdxKeyType(v, pIndex); ++ sqliteVdbeOp3(v, OP_IdxPut, 1, pIndex->onError!=OE_None, ++ "indexed columns are not unique", P3_STATIC); ++ sqliteVdbeAddOp(v, OP_Next, 2, lbl1); ++ sqliteVdbeResolveLabel(v, lbl2); ++ sqliteVdbeAddOp(v, OP_Close, 2, 0); ++ sqliteVdbeAddOp(v, OP_Close, 1, 0); ++ } ++ if( pTable!=0 ){ ++ if( !isTemp ){ ++ sqliteChangeCookie(db, v); ++ } ++ sqliteVdbeAddOp(v, OP_Close, 0, 0); ++ sqliteEndWriteOperation(pParse); ++ } ++ } ++ ++ /* Clean up before exiting */ ++exit_create_index: ++ sqliteIdListDelete(pList); ++ sqliteSrcListDelete(pTable); ++ sqliteFree(zName); ++ return; ++} ++ ++/* ++** This routine will drop an existing named index. This routine ++** implements the DROP INDEX statement. ++*/ ++void sqliteDropIndex(Parse *pParse, SrcList *pName){ ++ Index *pIndex; ++ Vdbe *v; ++ sqlite *db = pParse->db; ++ ++ if( pParse->nErr || sqlite_malloc_failed ) return; ++ assert( pName->nSrc==1 ); ++ pIndex = sqliteFindIndex(db, pName->a[0].zName, pName->a[0].zDatabase); ++ if( pIndex==0 ){ ++ sqliteErrorMsg(pParse, "no such index: %S", pName, 0); ++ goto exit_drop_index; ++ } ++ if( pIndex->autoIndex ){ ++ sqliteErrorMsg(pParse, "index associated with UNIQUE " ++ "or PRIMARY KEY constraint cannot be dropped", 0); ++ goto exit_drop_index; ++ } ++ if( pIndex->iDb>1 ){ ++ sqliteErrorMsg(pParse, "cannot alter schema of attached " ++ "databases", 0); ++ goto exit_drop_index; ++ } ++#ifndef SQLITE_OMIT_AUTHORIZATION ++ { ++ int code = SQLITE_DROP_INDEX; ++ Table *pTab = pIndex->pTable; ++ const char *zDb = db->aDb[pIndex->iDb].zName; ++ const char *zTab = SCHEMA_TABLE(pIndex->iDb); ++ if( sqliteAuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ ++ goto exit_drop_index; ++ } ++ if( pIndex->iDb ) code = SQLITE_DROP_TEMP_INDEX; ++ if( sqliteAuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){ ++ goto exit_drop_index; ++ } ++ } ++#endif ++ ++ /* Generate code to remove the index and from the master table */ ++ v = sqliteGetVdbe(pParse); ++ if( v ){ ++ static VdbeOpList dropIndex[] = { ++ { OP_Rewind, 0, ADDR(9), 0}, ++ { OP_String, 0, 0, 0}, /* 1 */ ++ { OP_MemStore, 1, 1, 0}, ++ { OP_MemLoad, 1, 0, 0}, /* 3 */ ++ { OP_Column, 0, 1, 0}, ++ { OP_Eq, 0, ADDR(8), 0}, ++ { OP_Next, 0, ADDR(3), 0}, ++ { OP_Goto, 0, ADDR(9), 0}, ++ { OP_Delete, 0, 0, 0}, /* 8 */ ++ }; ++ int base; ++ ++ sqliteBeginWriteOperation(pParse, 0, pIndex->iDb); ++ sqliteOpenMasterTable(v, pIndex->iDb); ++ base = sqliteVdbeAddOpList(v, ArraySize(dropIndex), dropIndex); ++ sqliteVdbeChangeP3(v, base+1, pIndex->zName, 0); ++ if( pIndex->iDb==0 ){ ++ sqliteChangeCookie(db, v); ++ } ++ sqliteVdbeAddOp(v, OP_Close, 0, 0); ++ sqliteVdbeAddOp(v, OP_Destroy, pIndex->tnum, pIndex->iDb); ++ sqliteEndWriteOperation(pParse); ++ } ++ ++ /* Delete the in-memory description of this index. ++ */ ++ if( !pParse->explain ){ ++ sqliteUnlinkAndDeleteIndex(db, pIndex); ++ db->flags |= SQLITE_InternChanges; ++ } ++ ++exit_drop_index: ++ sqliteSrcListDelete(pName); ++} ++ ++/* ++** 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. ++*/ ++IdList *sqliteIdListAppend(IdList *pList, Token *pToken){ ++ if( pList==0 ){ ++ pList = sqliteMalloc( sizeof(IdList) ); ++ if( pList==0 ) return 0; ++ pList->nAlloc = 0; ++ } ++ if( pList->nId>=pList->nAlloc ){ ++ struct IdList_item *a; ++ pList->nAlloc = pList->nAlloc*2 + 5; ++ a = sqliteRealloc(pList->a, pList->nAlloc*sizeof(pList->a[0]) ); ++ if( a==0 ){ ++ sqliteIdListDelete(pList); ++ return 0; ++ } ++ pList->a = a; ++ } ++ memset(&pList->a[pList->nId], 0, sizeof(pList->a[0])); ++ if( pToken ){ ++ char **pz = &pList->a[pList->nId].zName; ++ sqliteSetNString(pz, pToken->z, pToken->n, 0); ++ if( *pz==0 ){ ++ sqliteIdListDelete(pList); ++ return 0; ++ }else{ ++ sqliteDequote(*pz); ++ } ++ } ++ pList->nId++; ++ return pList; ++} ++ ++/* ++** 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 pToken is NULL. ++** ++** A new SrcList is returned, or NULL if malloc() fails. ++** ++** 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: ++** ++** sqliteSrcListAppend(A,B,0); ++** ++** Then B is a table name and the database name is unspecified. If called ++** like this: ++** ++** sqliteSrcListAppend(A,B,C); ++** ++** Then C is the table name and B is the database name. ++*/ ++SrcList *sqliteSrcListAppend(SrcList *pList, Token *pTable, Token *pDatabase){ ++ if( pList==0 ){ ++ pList = sqliteMalloc( sizeof(SrcList) ); ++ if( pList==0 ) return 0; ++ pList->nAlloc = 1; ++ } ++ if( pList->nSrc>=pList->nAlloc ){ ++ SrcList *pNew; ++ pList->nAlloc *= 2; ++ pNew = sqliteRealloc(pList, ++ sizeof(*pList) + (pList->nAlloc-1)*sizeof(pList->a[0]) ); ++ if( pNew==0 ){ ++ sqliteSrcListDelete(pList); ++ return 0; ++ } ++ pList = pNew; ++ } ++ memset(&pList->a[pList->nSrc], 0, sizeof(pList->a[0])); ++ if( pDatabase && pDatabase->z==0 ){ ++ pDatabase = 0; ++ } ++ if( pDatabase && pTable ){ ++ Token *pTemp = pDatabase; ++ pDatabase = pTable; ++ pTable = pTemp; ++ } ++ if( pTable ){ ++ char **pz = &pList->a[pList->nSrc].zName; ++ sqliteSetNString(pz, pTable->z, pTable->n, 0); ++ if( *pz==0 ){ ++ sqliteSrcListDelete(pList); ++ return 0; ++ }else{ ++ sqliteDequote(*pz); ++ } ++ } ++ if( pDatabase ){ ++ char **pz = &pList->a[pList->nSrc].zDatabase; ++ sqliteSetNString(pz, pDatabase->z, pDatabase->n, 0); ++ if( *pz==0 ){ ++ sqliteSrcListDelete(pList); ++ return 0; ++ }else{ ++ sqliteDequote(*pz); ++ } ++ } ++ pList->a[pList->nSrc].iCursor = -1; ++ pList->nSrc++; ++ return pList; ++} ++ ++/* ++** Assign cursors to all tables in a SrcList ++*/ ++void sqliteSrcListAssignCursors(Parse *pParse, SrcList *pList){ ++ int i; ++ for(i=0; inSrc; i++){ ++ if( pList->a[i].iCursor<0 ){ ++ pList->a[i].iCursor = pParse->nTab++; ++ } ++ } ++} ++ ++/* ++** Add an alias to the last identifier on the given identifier list. ++*/ ++void sqliteSrcListAddAlias(SrcList *pList, Token *pToken){ ++ if( pList && pList->nSrc>0 ){ ++ int i = pList->nSrc - 1; ++ sqliteSetNString(&pList->a[i].zAlias, pToken->z, pToken->n, 0); ++ sqliteDequote(pList->a[i].zAlias); ++ } ++} ++ ++/* ++** Delete an IdList. ++*/ ++void sqliteIdListDelete(IdList *pList){ ++ int i; ++ if( pList==0 ) return; ++ for(i=0; inId; i++){ ++ sqliteFree(pList->a[i].zName); ++ } ++ sqliteFree(pList->a); ++ sqliteFree(pList); ++} ++ ++/* ++** Return the index in pList of the identifier named zId. Return -1 ++** if not found. ++*/ ++int sqliteIdListIndex(IdList *pList, const char *zName){ ++ int i; ++ if( pList==0 ) return -1; ++ for(i=0; inId; i++){ ++ if( sqliteStrICmp(pList->a[i].zName, zName)==0 ) return i; ++ } ++ return -1; ++} ++ ++/* ++** Delete an entire SrcList including all its substructure. ++*/ ++void sqliteSrcListDelete(SrcList *pList){ ++ int i; ++ if( pList==0 ) return; ++ for(i=0; inSrc; i++){ ++ sqliteFree(pList->a[i].zDatabase); ++ sqliteFree(pList->a[i].zName); ++ sqliteFree(pList->a[i].zAlias); ++ if( pList->a[i].pTab && pList->a[i].pTab->isTransient ){ ++ sqliteDeleteTable(0, pList->a[i].pTab); ++ } ++ sqliteSelectDelete(pList->a[i].pSelect); ++ sqliteExprDelete(pList->a[i].pOn); ++ sqliteIdListDelete(pList->a[i].pUsing); ++ } ++ sqliteFree(pList); ++} ++ ++/* ++** Begin a transaction ++*/ ++void sqliteBeginTransaction(Parse *pParse, int onError){ ++ sqlite *db; ++ ++ if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return; ++ if( pParse->nErr || sqlite_malloc_failed ) return; ++ if( sqliteAuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ) return; ++ if( db->flags & SQLITE_InTrans ){ ++ sqliteErrorMsg(pParse, "cannot start a transaction within a transaction"); ++ return; ++ } ++ sqliteBeginWriteOperation(pParse, 0, 0); ++ if( !pParse->explain ){ ++ db->flags |= SQLITE_InTrans; ++ db->onError = onError; ++ } ++} ++ ++/* ++** Commit a transaction ++*/ ++void sqliteCommitTransaction(Parse *pParse){ ++ sqlite *db; ++ ++ if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return; ++ if( pParse->nErr || sqlite_malloc_failed ) return; ++ if( sqliteAuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ) return; ++ if( (db->flags & SQLITE_InTrans)==0 ){ ++ sqliteErrorMsg(pParse, "cannot commit - no transaction is active"); ++ return; ++ } ++ if( !pParse->explain ){ ++ db->flags &= ~SQLITE_InTrans; ++ } ++ sqliteEndWriteOperation(pParse); ++ if( !pParse->explain ){ ++ db->onError = OE_Default; ++ } ++} ++ ++/* ++** Rollback a transaction ++*/ ++void sqliteRollbackTransaction(Parse *pParse){ ++ sqlite *db; ++ Vdbe *v; ++ ++ if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return; ++ if( pParse->nErr || sqlite_malloc_failed ) return; ++ if( sqliteAuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ) return; ++ if( (db->flags & SQLITE_InTrans)==0 ){ ++ sqliteErrorMsg(pParse, "cannot rollback - no transaction is active"); ++ return; ++ } ++ v = sqliteGetVdbe(pParse); ++ if( v ){ ++ sqliteVdbeAddOp(v, OP_Rollback, 0, 0); ++ } ++ if( !pParse->explain ){ ++ db->flags &= ~SQLITE_InTrans; ++ db->onError = OE_Default; ++ } ++} ++ ++/* ++** Generate VDBE code that will verify the schema cookie for all ++** named database files. ++*/ ++void sqliteCodeVerifySchema(Parse *pParse, int iDb){ ++ sqlite *db = pParse->db; ++ Vdbe *v = sqliteGetVdbe(pParse); ++ assert( iDb>=0 && iDbnDb ); ++ assert( db->aDb[iDb].pBt!=0 ); ++ if( iDb!=1 && !DbHasProperty(db, iDb, DB_Cookie) ){ ++ sqliteVdbeAddOp(v, OP_VerifyCookie, iDb, db->aDb[iDb].schema_cookie); ++ DbSetProperty(db, iDb, DB_Cookie); ++ } ++} ++ ++/* ++** 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 setCheckpoint 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. ++** ++** Only database iDb and the temp database are made writable by this call. ++** If iDb==0, then the main and temp databases are made writable. If ++** iDb==1 then only the temp database is made writable. If iDb>1 then the ++** specified auxiliary database and the temp database are made writable. ++*/ ++void sqliteBeginWriteOperation(Parse *pParse, int setCheckpoint, int iDb){ ++ Vdbe *v; ++ sqlite *db = pParse->db; ++ if( DbHasProperty(db, iDb, DB_Locked) ) return; ++ v = sqliteGetVdbe(pParse); ++ if( v==0 ) return; ++ if( !db->aDb[iDb].inTrans ){ ++ sqliteVdbeAddOp(v, OP_Transaction, iDb, 0); ++ DbSetProperty(db, iDb, DB_Locked); ++ sqliteCodeVerifySchema(pParse, iDb); ++ if( iDb!=1 ){ ++ sqliteBeginWriteOperation(pParse, setCheckpoint, 1); ++ } ++ }else if( setCheckpoint ){ ++ sqliteVdbeAddOp(v, OP_Checkpoint, iDb, 0); ++ DbSetProperty(db, iDb, DB_Locked); ++ } ++} ++ ++/* ++** Generate code that concludes an operation that may have changed ++** the database. If a statement transaction was started, then emit ++** an OP_Commit that will cause the changes to be committed to disk. ++** ++** Note that checkpoints are automatically committed at the end of ++** a statement. Note also that there can be multiple calls to ++** sqliteBeginWriteOperation() but there should only be a single ++** call to sqliteEndWriteOperation() at the conclusion of the statement. ++*/ ++void sqliteEndWriteOperation(Parse *pParse){ ++ Vdbe *v; ++ sqlite *db = pParse->db; ++ if( pParse->trigStack ) return; /* if this is in a trigger */ ++ v = sqliteGetVdbe(pParse); ++ if( v==0 ) return; ++ if( db->flags & SQLITE_InTrans ){ ++ /* A BEGIN has executed. Do not commit until we see an explicit ++ ** COMMIT statement. */ ++ }else{ ++ sqliteVdbeAddOp(v, OP_Commit, 0, 0); ++ } ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/config_static.w32.h +@@ -0,0 +1 @@ ++#define SQLITE_PTR_SZ 4 +\ No newline at end of file +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/copy.c +@@ -0,0 +1,110 @@ ++/* ++** 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 COPY command. ++** ++** $Id$ ++*/ ++#include "sqliteInt.h" ++ ++/* ++** The COPY command is for compatibility with PostgreSQL and specificially ++** for the ability to read the output of pg_dump. The format is as ++** follows: ++** ++** COPY table FROM file [USING DELIMITERS string] ++** ++** "table" is an existing table name. We will read lines of code from ++** file to fill this table with data. File might be "stdin". The optional ++** delimiter string identifies the field separators. The default is a tab. ++*/ ++void sqliteCopy( ++ Parse *pParse, /* The parser context */ ++ SrcList *pTableName, /* The name of the table into which we will insert */ ++ Token *pFilename, /* The file from which to obtain information */ ++ Token *pDelimiter, /* Use this as the field delimiter */ ++ int onError /* What to do if a constraint fails */ ++){ ++ Table *pTab; ++ int i; ++ Vdbe *v; ++ int addr, end; ++ char *zFile = 0; ++ const char *zDb; ++ sqlite *db = pParse->db; ++ ++ ++ if( sqlite_malloc_failed ) goto copy_cleanup; ++ assert( pTableName->nSrc==1 ); ++ pTab = sqliteSrcListLookup(pParse, pTableName); ++ if( pTab==0 || sqliteIsReadOnly(pParse, pTab, 0) ) goto copy_cleanup; ++ zFile = sqliteStrNDup(pFilename->z, pFilename->n); ++ sqliteDequote(zFile); ++ assert( pTab->iDbnDb ); ++ zDb = db->aDb[pTab->iDb].zName; ++ if( sqliteAuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ++ || sqliteAuthCheck(pParse, SQLITE_COPY, pTab->zName, zFile, zDb) ){ ++ goto copy_cleanup; ++ } ++ v = sqliteGetVdbe(pParse); ++ if( v ){ ++ sqliteBeginWriteOperation(pParse, 1, pTab->iDb); ++ addr = sqliteVdbeOp3(v, OP_FileOpen, 0, 0, pFilename->z, pFilename->n); ++ sqliteVdbeDequoteP3(v, addr); ++ sqliteOpenTableAndIndices(pParse, pTab, 0); ++ if( db->flags & SQLITE_CountRows ){ ++ sqliteVdbeAddOp(v, OP_Integer, 0, 0); /* Initialize the row count */ ++ } ++ end = sqliteVdbeMakeLabel(v); ++ addr = sqliteVdbeAddOp(v, OP_FileRead, pTab->nCol, end); ++ if( pDelimiter ){ ++ sqliteVdbeChangeP3(v, addr, pDelimiter->z, pDelimiter->n); ++ sqliteVdbeDequoteP3(v, addr); ++ }else{ ++ sqliteVdbeChangeP3(v, addr, "\t", 1); ++ } ++ if( pTab->iPKey>=0 ){ ++ sqliteVdbeAddOp(v, OP_FileColumn, pTab->iPKey, 0); ++ sqliteVdbeAddOp(v, OP_MustBeInt, 0, 0); ++ }else{ ++ sqliteVdbeAddOp(v, OP_NewRecno, 0, 0); ++ } ++ for(i=0; inCol; i++){ ++ if( i==pTab->iPKey ){ ++ /* The integer primary key column is filled with NULL since its ++ ** value is always pulled from the record number */ ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ }else{ ++ sqliteVdbeAddOp(v, OP_FileColumn, i, 0); ++ } ++ } ++ sqliteGenerateConstraintChecks(pParse, pTab, 0, 0, pTab->iPKey>=0, ++ 0, onError, addr); ++ sqliteCompleteInsertion(pParse, pTab, 0, 0, 0, 0, -1); ++ if( (db->flags & SQLITE_CountRows)!=0 ){ ++ sqliteVdbeAddOp(v, OP_AddImm, 1, 0); /* Increment row count */ ++ } ++ sqliteVdbeAddOp(v, OP_Goto, 0, addr); ++ sqliteVdbeResolveLabel(v, end); ++ sqliteVdbeAddOp(v, OP_Noop, 0, 0); ++ sqliteEndWriteOperation(pParse); ++ if( db->flags & SQLITE_CountRows ){ ++ sqliteVdbeAddOp(v, OP_ColumnName, 0, 1); ++ sqliteVdbeChangeP3(v, -1, "rows inserted", P3_STATIC); ++ sqliteVdbeAddOp(v, OP_Callback, 1, 0); ++ } ++ } ++ ++copy_cleanup: ++ sqliteSrcListDelete(pTableName); ++ sqliteFree(zFile); ++ return; ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/date.c +@@ -0,0 +1,881 @@ ++/* ++** 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 ++** sqliteRegisterDateTimeFunctions() found at the bottom of the file. ++** All other code has file scope. ++** ++** $Id$ ++** ++** NOTES: ++** ++** 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 implemention 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 "os.h" ++#include "sqliteInt.h" ++#include ++#include ++#include ++#include ++#ifndef PHP_WIN32 ++#include "main/php_reentrancy.h" ++#endif ++ ++#ifndef SQLITE_OMIT_DATETIME_FUNCS ++ ++/* ++** A structure for holding a single date and time. ++*/ ++typedef struct DateTime DateTime; ++struct DateTime { ++ double rJD; /* The julian day number */ ++ 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 if Y,M,D are valid */ ++ char validHMS; /* True if h,m,s are valid */ ++ char validJD; /* True if rJD is valid */ ++ char validTZ; /* True 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( !isdigit(*zDate) ){ ++ return cnt; ++ } ++ val = val*10 + *zDate - '0'; ++ zDate++; ++ } ++ if( valmax || (nextC!=0 && nextC!=*zDate) ){ ++ return cnt; ++ } ++ *pVal = val; ++ zDate++; ++ cnt++; ++ }while( nextC ); ++ return cnt; ++} ++ ++/* ++** Read text from z[] and convert into a floating point number. Return ++** the number of digits converted. ++*/ ++static int getValue(const char *z, double *pR){ ++ const char *zEnd; ++ *pR = sqliteAtoF(z, &zEnd); ++ return zEnd - z; ++} ++ ++/* ++** Parse a timezone extension on the end of a date-time. ++** The extension is of the form: ++** ++** (+/-)HH:MM ++** ++** If the parse is successful, write the number of minutes ++** of change in *pnMin and return 0. If a parser error occurs, ++** return 0. ++** ++** A missing specifier is not considered an error. ++*/ ++static int parseTimezone(const char *zDate, DateTime *p){ ++ int sgn = 0; ++ int nHr, nMn; ++ while( isspace(*zDate) ){ zDate++; } ++ p->tz = 0; ++ if( *zDate=='-' ){ ++ sgn = -1; ++ }else if( *zDate=='+' ){ ++ sgn = +1; ++ }else{ ++ return *zDate!=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); ++ while( isspace(*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=='.' && isdigit(zDate[1]) ){ ++ double rScale = 1.0; ++ zDate++; ++ while( isdigit(*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; ++ 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 = 365.25*(Y+4716); ++ X2 = 30.6001*(M+1); ++ p->rJD = X1 + X2 + D + B - 1524.5; ++ p->validJD = 1; ++ p->validYMD = 0; ++ if( p->validHMS ){ ++ p->rJD += (p->h*3600.0 + p->m*60.0 + p->s)/86400.0; ++ if( p->validTZ ){ ++ p->rJD += p->tz*60/86400.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( isspace(*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; ++} ++ ++/* ++** 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(const char *zDate, DateTime *p){ ++ memset(p, 0, sizeof(*p)); ++ if( parseYyyyMmDd(zDate,p)==0 ){ ++ return 0; ++ }else if( parseHhMmSs(zDate, p)==0 ){ ++ return 0; ++ }else if( sqliteStrICmp(zDate,"now")==0){ ++ double r; ++ if( sqliteOsCurrentTime(&r)==0 ){ ++ p->rJD = r; ++ p->validJD = 1; ++ return 0; ++ } ++ return 1; ++ }else if( sqliteIsNumber(zDate) ){ ++ p->rJD = sqliteAtoF(zDate, 0); ++ 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 = p->rJD + 0.5; ++ A = (Z - 1867216.25)/36524.25; ++ A = Z + 1 + A - (A/4); ++ B = A + 1524; ++ C = (B - 122.1)/365.25; ++ D = 365.25*C; ++ E = (B-D)/30.6001; ++ X1 = 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 Z, s; ++ if( p->validHMS ) return; ++ Z = p->rJD + 0.5; ++ s = (p->rJD + 0.5 - Z)*86400000.0 + 0.5; ++ p->s = 0.001*s; ++ s = 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; ++} ++ ++/* ++** Compute the difference (in days) between localtime and UTC (a.k.a. GMT) ++** for the time value p where p is in UTC. ++*/ ++static double localtimeOffset(DateTime *p){ ++ DateTime x, y; ++ time_t t; ++ struct tm *pTm, tmbuf; ++ x = *p; ++ computeYMD_HMS(&x); ++ if( x.Y<1971 || x.Y>=2038 ){ ++ x.Y = 2000; ++ x.M = 1; ++ x.D = 1; ++ x.h = 0; ++ x.m = 0; ++ x.s = 0.0; ++ } else { ++ int s = x.s + 0.5; ++ x.s = s; ++ } ++ x.tz = 0; ++ x.validJD = 0; ++ computeJD(&x); ++ t = (x.rJD-2440587.5)*86400.0 + 0.5; ++ sqliteOsEnterMutex(); ++ pTm = php_localtime_r(&t, &tmbuf); ++ if (!pTm) { ++ return 0; ++ } ++ y.Y = pTm->tm_year + 1900; ++ y.M = pTm->tm_mon + 1; ++ y.D = pTm->tm_mday; ++ y.h = pTm->tm_hour; ++ y.m = pTm->tm_min; ++ y.s = pTm->tm_sec; ++ sqliteOsLeaveMutex(); ++ y.validYMD = 1; ++ y.validHMS = 1; ++ y.validJD = 0; ++ y.validTZ = 0; ++ computeJD(&y); ++ return y.rJD - x.rJD; ++} ++ ++/* ++** 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. ++*/ ++static int parseModifier(const char *zMod, DateTime *p){ ++ int rc = 1; ++ int n; ++ double r; ++ char *z, zBuf[30]; ++ z = zBuf; ++ for(n=0; nrJD += localtimeOffset(p); ++ clearYMD_HMS_TZ(p); ++ rc = 0; ++ } ++ break; ++ } ++ case 'u': { ++ /* ++ ** unixepoch ++ ** ++ ** Treat the current value of p->rJD as the number of ++ ** seconds since 1970. Convert to a real julian day number. ++ */ ++ if( strcmp(z, "unixepoch")==0 && p->validJD ){ ++ p->rJD = p->rJD/86400.0 + 2440587.5; ++ clearYMD_HMS_TZ(p); ++ rc = 0; ++ }else if( strcmp(z, "utc")==0 ){ ++ double c1; ++ computeJD(p); ++ c1 = localtimeOffset(p); ++ p->rJD -= c1; ++ clearYMD_HMS_TZ(p); ++ p->rJD += c1 - localtimeOffset(p); ++ rc = 0; ++ } ++ break; ++ } ++ case 'w': { ++ /* ++ ** weekday N ++ ** ++ ** Move the date to the same time on the next occurrance 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 && getValue(&z[8],&r)>0 ++ && (n=r)==r && n>=0 && r<7 ){ ++ int Z; ++ computeYMD_HMS(p); ++ p->validTZ = 0; ++ p->validJD = 0; ++ computeJD(p); ++ Z = p->rJD + 1.5; ++ Z %= 7; ++ if( Z>n ) Z -= 7; ++ p->rJD += n - Z; ++ 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': { ++ n = getValue(z, &r); ++ if( n<=0 ) 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; ++ int day; ++ if( !isdigit(*z2) ) z2++; ++ memset(&tx, 0, sizeof(tx)); ++ if( parseHhMmSs(z2, &tx) ) break; ++ computeJD(&tx); ++ tx.rJD -= 0.5; ++ day = (int)tx.rJD; ++ tx.rJD -= day; ++ if( z[0]=='-' ) tx.rJD = -tx.rJD; ++ computeJD(p); ++ clearYMD_HMS_TZ(p); ++ p->rJD += tx.rJD; ++ rc = 0; ++ break; ++ } ++ z += n; ++ while( isspace(z[0]) ) z++; ++ n = strlen(z); ++ if( n>10 || n<3 ) break; ++ if( z[n-1]=='s' ){ z[n-1] = 0; n--; } ++ computeJD(p); ++ rc = 0; ++ if( n==3 && strcmp(z,"day")==0 ){ ++ p->rJD += r; ++ }else if( n==4 && strcmp(z,"hour")==0 ){ ++ p->rJD += r/24.0; ++ }else if( n==6 && strcmp(z,"minute")==0 ){ ++ p->rJD += r/(24.0*60.0); ++ }else if( n==6 && strcmp(z,"second")==0 ){ ++ p->rJD += r/(24.0*60.0*60.0); ++ }else if( n==5 && strcmp(z,"month")==0 ){ ++ int x, y; ++ computeYMD_HMS(p); ++ p->M += 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 = r; ++ if( y!=r ){ ++ p->rJD += (r - y)*30.0; ++ } ++ }else if( n==4 && strcmp(z,"year")==0 ){ ++ computeYMD_HMS(p); ++ p->Y += r; ++ p->validJD = 0; ++ computeJD(p); ++ }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. ++*/ ++static int isDate(int argc, const char **argv, DateTime *p){ ++ int i; ++ if( argc==0 ) return 1; ++ if( argv[0]==0 || parseDateOrTime(argv[0], p) ) return 1; ++ for(i=1; izErrMsg and return NULL. If all tables ++** are found, return a pointer to the last table. ++*/ ++Table *sqliteSrcListLookup(Parse *pParse, SrcList *pSrc){ ++ Table *pTab = 0; ++ int i; ++ for(i=0; inSrc; i++){ ++ const char *zTab = pSrc->a[i].zName; ++ const char *zDb = pSrc->a[i].zDatabase; ++ pTab = sqliteLocateTable(pParse, zTab, zDb); ++ pSrc->a[i].pTab = pTab; ++ } ++ 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; ++*/ ++int sqliteIsReadOnly(Parse *pParse, Table *pTab, int viewOk){ ++ if( pTab->readOnly ){ ++ sqliteErrorMsg(pParse, "table %s may not be modified", pTab->zName); ++ return 1; ++ } ++ if( !viewOk && pTab->pSelect ){ ++ sqliteErrorMsg(pParse, "cannot modify %s because it is a view",pTab->zName); ++ return 1; ++ } ++ return 0; ++} ++ ++/* ++** Process a DELETE FROM statement. ++*/ ++void sqliteDeleteFrom( ++ 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 end, addr; /* A couple addresses of generated code */ ++ int i; /* Loop counter */ ++ WhereInfo *pWInfo; /* Information about the WHERE clause */ ++ Index *pIdx; /* For looping over indices of the table */ ++ int iCur; /* VDBE Cursor number for pTab */ ++ sqlite *db; /* Main database structure */ ++ int isView; /* True if attempting to delete from a view */ ++ AuthContext sContext; /* Authorization context */ ++ ++ int row_triggers_exist = 0; /* True if any triggers exist */ ++ int before_triggers; /* True if there are BEFORE triggers */ ++ int after_triggers; /* True if there are AFTER triggers */ ++ int oldIdx = -1; /* Cursor for the OLD table of AFTER triggers */ ++ ++ sContext.pParse = 0; ++ if( pParse->nErr || sqlite_malloc_failed ){ ++ pTabList = 0; ++ goto delete_from_cleanup; ++ } ++ db = pParse->db; ++ 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 = sqliteSrcListLookup(pParse, pTabList); ++ if( pTab==0 ) goto delete_from_cleanup; ++ before_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, ++ TK_DELETE, TK_BEFORE, TK_ROW, 0); ++ after_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, ++ TK_DELETE, TK_AFTER, TK_ROW, 0); ++ row_triggers_exist = before_triggers || after_triggers; ++ isView = pTab->pSelect!=0; ++ if( sqliteIsReadOnly(pParse, pTab, before_triggers) ){ ++ goto delete_from_cleanup; ++ } ++ assert( pTab->iDbnDb ); ++ zDb = db->aDb[pTab->iDb].zName; ++ if( sqliteAuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){ ++ goto delete_from_cleanup; ++ } ++ ++ /* If pTab is really a view, make sure it has been initialized. ++ */ ++ if( isView && sqliteViewGetColumnNames(pParse, pTab) ){ ++ goto delete_from_cleanup; ++ } ++ ++ /* Allocate a cursor used to store the old.* data for a trigger. ++ */ ++ if( row_triggers_exist ){ ++ oldIdx = pParse->nTab++; ++ } ++ ++ /* Resolve the column names in all the expressions. ++ */ ++ assert( pTabList->nSrc==1 ); ++ iCur = pTabList->a[0].iCursor = pParse->nTab++; ++ if( pWhere ){ ++ if( sqliteExprResolveIds(pParse, pTabList, 0, pWhere) ){ ++ goto delete_from_cleanup; ++ } ++ if( sqliteExprCheck(pParse, pWhere, 0, 0) ){ ++ goto delete_from_cleanup; ++ } ++ } ++ ++ /* Start the view context ++ */ ++ if( isView ){ ++ sqliteAuthContextPush(pParse, &sContext, pTab->zName); ++ } ++ ++ /* Begin generating code. ++ */ ++ v = sqliteGetVdbe(pParse); ++ if( v==0 ){ ++ goto delete_from_cleanup; ++ } ++ sqliteBeginWriteOperation(pParse, row_triggers_exist, pTab->iDb); ++ ++ /* If we are trying to delete from a view, construct that view into ++ ** a temporary table. ++ */ ++ if( isView ){ ++ Select *pView = sqliteSelectDup(pTab->pSelect); ++ sqliteSelect(pParse, pView, SRT_TempTable, iCur, 0, 0, 0); ++ sqliteSelectDelete(pView); ++ } ++ ++ /* Initialize the counter of the number of rows deleted, if ++ ** we are counting rows. ++ */ ++ if( db->flags & SQLITE_CountRows ){ ++ sqliteVdbeAddOp(v, OP_Integer, 0, 0); ++ } ++ ++ /* Special case: A DELETE without a WHERE clause deletes everything. ++ ** It is easier just to erase the whole table. Note, however, that ++ ** this means that the row change count will be incorrect. ++ */ ++ if( pWhere==0 && !row_triggers_exist ){ ++ if( db->flags & SQLITE_CountRows ){ ++ /* If counting rows deleted, just count the total number of ++ ** entries in the table. */ ++ int endOfLoop = sqliteVdbeMakeLabel(v); ++ int addr; ++ if( !isView ){ ++ sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); ++ sqliteVdbeAddOp(v, OP_OpenRead, iCur, pTab->tnum); ++ } ++ sqliteVdbeAddOp(v, OP_Rewind, iCur, sqliteVdbeCurrentAddr(v)+2); ++ addr = sqliteVdbeAddOp(v, OP_AddImm, 1, 0); ++ sqliteVdbeAddOp(v, OP_Next, iCur, addr); ++ sqliteVdbeResolveLabel(v, endOfLoop); ++ sqliteVdbeAddOp(v, OP_Close, iCur, 0); ++ } ++ if( !isView ){ ++ sqliteVdbeAddOp(v, OP_Clear, pTab->tnum, pTab->iDb); ++ for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ ++ sqliteVdbeAddOp(v, OP_Clear, pIdx->tnum, pIdx->iDb); ++ } ++ } ++ } ++ ++ /* The usual case: There is a WHERE clause so we have to scan through ++ ** the table and pick which records to delete. ++ */ ++ else{ ++ /* Begin the database scan ++ */ ++ pWInfo = sqliteWhereBegin(pParse, pTabList, pWhere, 1, 0); ++ if( pWInfo==0 ) goto delete_from_cleanup; ++ ++ /* Remember the key of every item to be deleted. ++ */ ++ sqliteVdbeAddOp(v, OP_ListWrite, 0, 0); ++ if( db->flags & SQLITE_CountRows ){ ++ sqliteVdbeAddOp(v, OP_AddImm, 1, 0); ++ } ++ ++ /* End the database scan loop. ++ */ ++ sqliteWhereEnd(pWInfo); ++ ++ /* Open the pseudo-table used to store OLD if there are triggers. ++ */ ++ if( row_triggers_exist ){ ++ sqliteVdbeAddOp(v, OP_OpenPseudo, oldIdx, 0); ++ } ++ ++ /* Delete every item whose key was written to the list during the ++ ** database scan. We have to delete items after the scan is complete ++ ** because deleting an item can change the scan order. ++ */ ++ sqliteVdbeAddOp(v, OP_ListRewind, 0, 0); ++ end = sqliteVdbeMakeLabel(v); ++ ++ /* This is the beginning of the delete loop when there are ++ ** row triggers. ++ */ ++ if( row_triggers_exist ){ ++ addr = sqliteVdbeAddOp(v, OP_ListRead, 0, end); ++ sqliteVdbeAddOp(v, OP_Dup, 0, 0); ++ if( !isView ){ ++ sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); ++ sqliteVdbeAddOp(v, OP_OpenRead, iCur, pTab->tnum); ++ } ++ sqliteVdbeAddOp(v, OP_MoveTo, iCur, 0); ++ ++ sqliteVdbeAddOp(v, OP_Recno, iCur, 0); ++ sqliteVdbeAddOp(v, OP_RowData, iCur, 0); ++ sqliteVdbeAddOp(v, OP_PutIntKey, oldIdx, 0); ++ if( !isView ){ ++ sqliteVdbeAddOp(v, OP_Close, iCur, 0); ++ } ++ ++ sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_BEFORE, pTab, -1, ++ oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default, ++ addr); ++ } ++ ++ if( !isView ){ ++ /* Open cursors for the table we are deleting from and all its ++ ** indices. If there are row triggers, this happens inside the ++ ** OP_ListRead loop because the cursor have to all be closed ++ ** before the trigger fires. If there are no row triggers, the ++ ** cursors are opened only once on the outside the loop. ++ */ ++ pParse->nTab = iCur + 1; ++ sqliteOpenTableAndIndices(pParse, pTab, iCur); ++ ++ /* This is the beginning of the delete loop when there are no ++ ** row triggers */ ++ if( !row_triggers_exist ){ ++ addr = sqliteVdbeAddOp(v, OP_ListRead, 0, end); ++ } ++ ++ /* Delete the row */ ++ sqliteGenerateRowDelete(db, v, pTab, iCur, pParse->trigStack==0); ++ } ++ ++ /* If there are row triggers, close all cursors then invoke ++ ** the AFTER triggers ++ */ ++ if( row_triggers_exist ){ ++ if( !isView ){ ++ for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ ++ sqliteVdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum); ++ } ++ sqliteVdbeAddOp(v, OP_Close, iCur, 0); ++ } ++ sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_AFTER, pTab, -1, ++ oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default, ++ addr); ++ } ++ ++ /* End of the delete loop */ ++ sqliteVdbeAddOp(v, OP_Goto, 0, addr); ++ sqliteVdbeResolveLabel(v, end); ++ sqliteVdbeAddOp(v, OP_ListReset, 0, 0); ++ ++ /* Close the cursors after the loop if there are no row triggers */ ++ if( !row_triggers_exist ){ ++ for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ ++ sqliteVdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum); ++ } ++ sqliteVdbeAddOp(v, OP_Close, iCur, 0); ++ pParse->nTab = iCur; ++ } ++ } ++ sqliteVdbeAddOp(v, OP_SetCounts, 0, 0); ++ sqliteEndWriteOperation(pParse); ++ ++ /* ++ ** Return the number of rows that were deleted. ++ */ ++ if( db->flags & SQLITE_CountRows ){ ++ sqliteVdbeAddOp(v, OP_ColumnName, 0, 1); ++ sqliteVdbeChangeP3(v, -1, "rows deleted", P3_STATIC); ++ sqliteVdbeAddOp(v, OP_Callback, 1, 0); ++ } ++ ++delete_from_cleanup: ++ sqliteAuthContextPop(&sContext); ++ sqliteSrcListDelete(pTabList); ++ sqliteExprDelete(pWhere); ++ return; ++} ++ ++/* ++** This routine generates VDBE code that causes a single row of a ++** single table to be deleted. ++** ++** The VDBE must be in a particular state when this routine is called. ++** These are the requirements: ++** ++** 1. A read/write cursor pointing to pTab, the table containing the row ++** to be deleted, must be opened as cursor number "base". ++** ++** 2. Read/write cursors for all indices of pTab must be open as ++** cursor number base+i for the i-th index. ++** ++** 3. The record number of the row to be deleted must be on the top ++** of the stack. ++** ++** This routine pops the top of the stack to remove the record number ++** and then generates code to remove both the table record and all index ++** entries that point to that record. ++*/ ++void sqliteGenerateRowDelete( ++ sqlite *db, /* The database containing the index */ ++ Vdbe *v, /* Generate code into this VDBE */ ++ Table *pTab, /* Table containing the row to be deleted */ ++ int iCur, /* Cursor number for the table */ ++ int count /* Increment the row change counter */ ++){ ++ int addr; ++ addr = sqliteVdbeAddOp(v, OP_NotExists, iCur, 0); ++ sqliteGenerateRowIndexDelete(db, v, pTab, iCur, 0); ++ sqliteVdbeAddOp(v, OP_Delete, iCur, ++ (count?OPFLAG_NCHANGE:0) | OPFLAG_CSCHANGE); ++ sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v)); ++} ++ ++/* ++** This routine generates VDBE code that causes the deletion of all ++** index entries associated with a single row of a single table. ++** ++** The VDBE must be in a particular state when this routine is called. ++** These are the requirements: ++** ++** 1. A read/write cursor pointing to pTab, the table containing the row ++** to be deleted, must be opened as cursor number "iCur". ++** ++** 2. Read/write cursors for all indices of pTab must be open as ++** cursor number iCur+i for the i-th index. ++** ++** 3. The "iCur" cursor must be pointing to the row that is to be ++** deleted. ++*/ ++void sqliteGenerateRowIndexDelete( ++ sqlite *db, /* The database containing the index */ ++ Vdbe *v, /* Generate code into this VDBE */ ++ Table *pTab, /* Table containing the row to be deleted */ ++ int iCur, /* Cursor number for the table */ ++ char *aIdxUsed /* Only delete if aIdxUsed!=0 && aIdxUsed[i]!=0 */ ++){ ++ int i; ++ Index *pIdx; ++ ++ for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ ++ int j; ++ if( aIdxUsed!=0 && aIdxUsed[i-1]==0 ) continue; ++ sqliteVdbeAddOp(v, OP_Recno, iCur, 0); ++ for(j=0; jnColumn; j++){ ++ int idx = pIdx->aiColumn[j]; ++ if( idx==pTab->iPKey ){ ++ sqliteVdbeAddOp(v, OP_Dup, j, 0); ++ }else{ ++ sqliteVdbeAddOp(v, OP_Column, iCur, idx); ++ } ++ } ++ sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0); ++ if( db->file_format>=4 ) sqliteAddIdxKeyType(v, pIdx); ++ sqliteVdbeAddOp(v, OP_IdxDelete, iCur+i, 0); ++ } ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/encode.c +@@ -0,0 +1,257 @@ ++/* ++** 2002 April 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 helper routines used to translate binary data into ++** a null-terminated string (suitable for use in SQLite) and back again. ++** These are convenience routines for use by people who want to store binary ++** data in an SQLite database. The code in this file is not used by any other ++** part of the SQLite library. ++** ++** $Id$ ++*/ ++#include ++#include ++ ++/* ++** How This Encoder Works ++** ++** The output is allowed to contain any character except 0x27 (') and ++** 0x00. This is accomplished by using an escape character to encode ++** 0x27 and 0x00 as a two-byte sequence. The escape character is always ++** 0x01. An 0x00 is encoded as the two byte sequence 0x01 0x01. The ++** 0x27 character is encoded as the two byte sequence 0x01 0x28. Finally, ++** the escape character itself is encoded as the two-character sequence ++** 0x01 0x02. ++** ++** To summarize, the encoder works by using an escape sequences as follows: ++** ++** 0x00 -> 0x01 0x01 ++** 0x01 -> 0x01 0x02 ++** 0x27 -> 0x01 0x28 ++** ++** If that were all the encoder did, it would work, but in certain cases ++** it could double the size of the encoded string. For example, to ++** encode a string of 100 0x27 characters would require 100 instances of ++** the 0x01 0x03 escape sequence resulting in a 200-character output. ++** We would prefer to keep the size of the encoded string smaller than ++** this. ++** ++** To minimize the encoding size, we first add a fixed offset value to each ++** byte in the sequence. The addition is modulo 256. (That is to say, if ++** the sum of the original character value and the offset exceeds 256, then ++** the higher order bits are truncated.) The offset is chosen to minimize ++** the number of characters in the string that need to be escaped. For ++** example, in the case above where the string was composed of 100 0x27 ++** characters, the offset might be 0x01. Each of the 0x27 characters would ++** then be converted into an 0x28 character which would not need to be ++** escaped at all and so the 100 character input string would be converted ++** into just 100 characters of output. Actually 101 characters of output - ++** we have to record the offset used as the first byte in the sequence so ++** that the string can be decoded. Since the offset value is stored as ++** part of the output string and the output string is not allowed to contain ++** characters 0x00 or 0x27, the offset cannot be 0x00 or 0x27. ++** ++** Here, then, are the encoding steps: ++** ++** (1) Choose an offset value and make it the first character of ++** output. ++** ++** (2) Copy each input character into the output buffer, one by ++** one, adding the offset value as you copy. ++** ++** (3) If the value of an input character plus offset is 0x00, replace ++** that one character by the two-character sequence 0x01 0x01. ++** If the sum is 0x01, replace it with 0x01 0x02. If the sum ++** is 0x27, replace it with 0x01 0x03. ++** ++** (4) Put a 0x00 terminator at the end of the output. ++** ++** Decoding is obvious: ++** ++** (5) Copy encoded characters except the first into the decode ++** buffer. Set the first encoded character aside for use as ++** the offset in step 7 below. ++** ++** (6) Convert each 0x01 0x01 sequence into a single character 0x00. ++** Convert 0x01 0x02 into 0x01. Convert 0x01 0x28 into 0x27. ++** ++** (7) Subtract the offset value that was the first character of ++** the encoded buffer from all characters in the output buffer. ++** ++** The only tricky part is step (1) - how to compute an offset value to ++** minimize the size of the output buffer. This is accomplished by testing ++** all offset values and picking the one that results in the fewest number ++** of escapes. To do that, we first scan the entire input and count the ++** number of occurances of each character value in the input. Suppose ++** the number of 0x00 characters is N(0), the number of occurances of 0x01 ++** is N(1), and so forth up to the number of occurances of 0xff is N(255). ++** An offset of 0 is not allowed so we don't have to test it. The number ++** of escapes required for an offset of 1 is N(1)+N(2)+N(40). The number ++** of escapes required for an offset of 2 is N(2)+N(3)+N(41). And so forth. ++** In this way we find the offset that gives the minimum number of escapes, ++** and thus minimizes the length of the output string. ++*/ ++ ++/* ++** Encode a binary buffer "in" of size n bytes so that it contains ++** no instances of characters '\'' or '\000'. The output is ++** null-terminated and can be used as a string value in an INSERT ++** or UPDATE statement. Use sqlite_decode_binary() to convert the ++** string back into its original binary. ++** ++** The result is written into a preallocated output buffer "out". ++** "out" must be able to hold at least 2 +(257*n)/254 bytes. ++** In other words, the output will be expanded by as much as 3 ++** bytes for every 254 bytes of input plus 2 bytes of fixed overhead. ++** (This is approximately 2 + 1.0118*n or about a 1.2% size increase.) ++** ++** The return value is the number of characters in the encoded ++** string, excluding the "\000" terminator. ++** ++** If out==NULL then no output is generated but the routine still returns ++** the number of characters that would have been generated if out had ++** not been NULL. ++*/ ++int sqlite_encode_binary(const unsigned char *in, int n, unsigned char *out){ ++ int i, j, e, m; ++ unsigned char x; ++ int cnt[256]; ++ if( n<=0 ){ ++ if( out ){ ++ out[0] = 'x'; ++ out[1] = 0; ++ } ++ return 1; ++ } ++ memset(cnt, 0, sizeof(cnt)); ++ for(i=n-1; i>=0; i--){ cnt[in[i]]++; } ++ m = n; ++ for(i=1; i<256; i++){ ++ int sum; ++ if( i=='\'' ) continue; ++ sum = cnt[i] + cnt[(i+1)&0xff] + cnt[(i+'\'')&0xff]; ++ if( sum ++/* ++** The subroutines above are not tested by the usual test suite. To test ++** these routines, compile just this one file with a -DENCODER_TEST=1 option ++** and run the result. ++*/ ++int main(int argc, char **argv){ ++ int i, j, n, m, nOut, nByteIn, nByteOut; ++ unsigned char in[30000]; ++ unsigned char out[33000]; ++ ++ nByteIn = nByteOut = 0; ++ for(i=0; i%d (max %d)", n, strlen(out)+1, m); ++ if( strlen(out)+1>m ){ ++ printf(" ERROR output too big\n"); ++ exit(1); ++ } ++ for(j=0; out[j]; j++){ ++ if( out[j]=='\'' ){ ++ printf(" ERROR contains (')\n"); ++ exit(1); ++ } ++ } ++ j = sqlite_decode_binary(out, out); ++ if( j!=n ){ ++ printf(" ERROR decode size %d\n", j); ++ exit(1); ++ } ++ if( memcmp(in, out, n)!=0 ){ ++ printf(" ERROR decode mismatch\n"); ++ exit(1); ++ } ++ printf(" OK\n"); ++ } ++ fprintf(stderr,"Finished. Total encoding: %d->%d bytes\n", ++ nByteIn, nByteOut); ++ fprintf(stderr,"Avg size increase: %.3f%%\n", ++ (nByteOut-nByteIn)*100.0/(double)nByteIn); ++} ++#endif /* ENCODER_TEST */ +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/expr.c +@@ -0,0 +1,1662 @@ ++/* ++** 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. ++** ++** $Id$ ++*/ ++#include "sqliteInt.h" ++#include ++ ++/* ++** Construct a new expression node and return a pointer to it. Memory ++** for this node is obtained from sqliteMalloc(). The calling function ++** is responsible for making sure the node eventually gets freed. ++*/ ++Expr *sqliteExpr(int op, Expr *pLeft, Expr *pRight, Token *pToken){ ++ Expr *pNew; ++ pNew = sqliteMalloc( sizeof(Expr) ); ++ if( pNew==0 ){ ++ /* When malloc fails, we leak memory from pLeft and pRight */ ++ return 0; ++ } ++ pNew->op = op; ++ pNew->pLeft = pLeft; ++ pNew->pRight = pRight; ++ if( pToken ){ ++ assert( pToken->dyn==0 ); ++ pNew->token = *pToken; ++ pNew->span = *pToken; ++ }else{ ++ assert( pNew->token.dyn==0 ); ++ assert( pNew->token.z==0 ); ++ assert( pNew->token.n==0 ); ++ if( pLeft && pRight ){ ++ sqliteExprSpan(pNew, &pLeft->span, &pRight->span); ++ }else{ ++ pNew->span = pNew->token; ++ } ++ } ++ return pNew; ++} ++ ++/* ++** Set the Expr.span field of the given expression to span all ++** text between the two given tokens. ++*/ ++void sqliteExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){ ++ assert( pRight!=0 ); ++ assert( pLeft!=0 ); ++ /* Note: pExpr might be NULL due to a prior malloc failure */ ++ if( pExpr && pRight->z && pLeft->z ){ ++ if( pLeft->dyn==0 && pRight->dyn==0 ){ ++ pExpr->span.z = pLeft->z; ++ pExpr->span.n = pRight->n + Addr(pRight->z) - Addr(pLeft->z); ++ }else{ ++ pExpr->span.z = 0; ++ } ++ } ++} ++ ++/* ++** Construct a new expression node for a function with multiple ++** arguments. ++*/ ++Expr *sqliteExprFunction(ExprList *pList, Token *pToken){ ++ Expr *pNew; ++ pNew = sqliteMalloc( sizeof(Expr) ); ++ if( pNew==0 ){ ++ /* sqliteExprListDelete(pList); // Leak pList when malloc fails */ ++ return 0; ++ } ++ pNew->op = TK_FUNCTION; ++ pNew->pList = pList; ++ if( pToken ){ ++ assert( pToken->dyn==0 ); ++ pNew->token = *pToken; ++ }else{ ++ pNew->token.z = 0; ++ } ++ pNew->span = pNew->token; ++ return pNew; ++} ++ ++/* ++** Recursively delete an expression tree. ++*/ ++void sqliteExprDelete(Expr *p){ ++ if( p==0 ) return; ++ if( p->span.dyn ) sqliteFree((char*)p->span.z); ++ if( p->token.dyn ) sqliteFree((char*)p->token.z); ++ sqliteExprDelete(p->pLeft); ++ sqliteExprDelete(p->pRight); ++ sqliteExprListDelete(p->pList); ++ sqliteSelectDelete(p->pSelect); ++ sqliteFree(p); ++} ++ ++ ++/* ++** 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 sqliteExprListDup(), ++** sqliteIdListDup(), and sqliteSrcListDup() can not be further expanded ++** by subsequent calls to sqlite*ListAppend() routines. ++** ++** Any tables that the SrcList might point to are not duplicated. ++*/ ++Expr *sqliteExprDup(Expr *p){ ++ Expr *pNew; ++ if( p==0 ) return 0; ++ pNew = sqliteMallocRaw( sizeof(*p) ); ++ if( pNew==0 ) return 0; ++ memcpy(pNew, p, sizeof(*pNew)); ++ if( p->token.z!=0 ){ ++ pNew->token.z = sqliteStrNDup(p->token.z, p->token.n); ++ pNew->token.dyn = 1; ++ }else{ ++ assert( pNew->token.z==0 ); ++ } ++ pNew->span.z = 0; ++ pNew->pLeft = sqliteExprDup(p->pLeft); ++ pNew->pRight = sqliteExprDup(p->pRight); ++ pNew->pList = sqliteExprListDup(p->pList); ++ pNew->pSelect = sqliteSelectDup(p->pSelect); ++ return pNew; ++} ++void sqliteTokenCopy(Token *pTo, Token *pFrom){ ++ if( pTo->dyn ) sqliteFree((char*)pTo->z); ++ if( pFrom->z ){ ++ pTo->n = pFrom->n; ++ pTo->z = sqliteStrNDup(pFrom->z, pFrom->n); ++ pTo->dyn = 1; ++ }else{ ++ pTo->z = 0; ++ } ++} ++ExprList *sqliteExprListDup(ExprList *p){ ++ ExprList *pNew; ++ struct ExprList_item *pItem; ++ int i; ++ if( p==0 ) return 0; ++ pNew = sqliteMalloc( sizeof(*pNew) ); ++ if( pNew==0 ) return 0; ++ pNew->nExpr = pNew->nAlloc = p->nExpr; ++ pNew->a = pItem = sqliteMalloc( p->nExpr*sizeof(p->a[0]) ); ++ if( pItem==0 ){ ++ sqliteFree(pNew); ++ return 0; ++ } ++ for(i=0; inExpr; i++, pItem++){ ++ Expr *pNewExpr, *pOldExpr; ++ pItem->pExpr = pNewExpr = sqliteExprDup(pOldExpr = p->a[i].pExpr); ++ if( pOldExpr->span.z!=0 && pNewExpr ){ ++ /* Always make a copy of the span for top-level expressions in the ++ ** expression list. The logic in SELECT processing that determines ++ ** the names of columns in the result set needs this information */ ++ sqliteTokenCopy(&pNewExpr->span, &pOldExpr->span); ++ } ++ assert( pNewExpr==0 || pNewExpr->span.z!=0 ++ || pOldExpr->span.z==0 || sqlite_malloc_failed ); ++ pItem->zName = sqliteStrDup(p->a[i].zName); ++ pItem->sortOrder = p->a[i].sortOrder; ++ pItem->isAgg = p->a[i].isAgg; ++ pItem->done = 0; ++ } ++ return pNew; ++} ++SrcList *sqliteSrcListDup(SrcList *p){ ++ 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 = sqliteMallocRaw( 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]; ++ pNewItem->zDatabase = sqliteStrDup(pOldItem->zDatabase); ++ pNewItem->zName = sqliteStrDup(pOldItem->zName); ++ pNewItem->zAlias = sqliteStrDup(pOldItem->zAlias); ++ pNewItem->jointype = pOldItem->jointype; ++ pNewItem->iCursor = pOldItem->iCursor; ++ pNewItem->pTab = 0; ++ pNewItem->pSelect = sqliteSelectDup(pOldItem->pSelect); ++ pNewItem->pOn = sqliteExprDup(pOldItem->pOn); ++ pNewItem->pUsing = sqliteIdListDup(pOldItem->pUsing); ++ } ++ return pNew; ++} ++IdList *sqliteIdListDup(IdList *p){ ++ IdList *pNew; ++ int i; ++ if( p==0 ) return 0; ++ pNew = sqliteMallocRaw( sizeof(*pNew) ); ++ if( pNew==0 ) return 0; ++ pNew->nId = pNew->nAlloc = p->nId; ++ pNew->a = sqliteMallocRaw( p->nId*sizeof(p->a[0]) ); ++ if( pNew->a==0 ) return 0; ++ for(i=0; inId; i++){ ++ struct IdList_item *pNewItem = &pNew->a[i]; ++ struct IdList_item *pOldItem = &p->a[i]; ++ pNewItem->zName = sqliteStrDup(pOldItem->zName); ++ pNewItem->idx = pOldItem->idx; ++ } ++ return pNew; ++} ++Select *sqliteSelectDup(Select *p){ ++ Select *pNew; ++ if( p==0 ) return 0; ++ pNew = sqliteMallocRaw( sizeof(*p) ); ++ if( pNew==0 ) return 0; ++ pNew->isDistinct = p->isDistinct; ++ pNew->pEList = sqliteExprListDup(p->pEList); ++ pNew->pSrc = sqliteSrcListDup(p->pSrc); ++ pNew->pWhere = sqliteExprDup(p->pWhere); ++ pNew->pGroupBy = sqliteExprListDup(p->pGroupBy); ++ pNew->pHaving = sqliteExprDup(p->pHaving); ++ pNew->pOrderBy = sqliteExprListDup(p->pOrderBy); ++ pNew->op = p->op; ++ pNew->pPrior = sqliteSelectDup(p->pPrior); ++ pNew->nLimit = p->nLimit; ++ pNew->nOffset = p->nOffset; ++ pNew->zSelect = 0; ++ pNew->iLimit = -1; ++ pNew->iOffset = -1; ++ return pNew; ++} ++ ++ ++/* ++** Add a new element to the end of an expression list. If pList is ++** initially NULL, then create a new expression list. ++*/ ++ExprList *sqliteExprListAppend(ExprList *pList, Expr *pExpr, Token *pName){ ++ if( pList==0 ){ ++ pList = sqliteMalloc( sizeof(ExprList) ); ++ if( pList==0 ){ ++ /* sqliteExprDelete(pExpr); // Leak memory if malloc fails */ ++ return 0; ++ } ++ assert( pList->nAlloc==0 ); ++ } ++ if( pList->nAlloc<=pList->nExpr ){ ++ pList->nAlloc = pList->nAlloc*2 + 4; ++ pList->a = sqliteRealloc(pList->a, pList->nAlloc*sizeof(pList->a[0])); ++ if( pList->a==0 ){ ++ /* sqliteExprDelete(pExpr); // Leak memory if malloc fails */ ++ pList->nExpr = pList->nAlloc = 0; ++ return pList; ++ } ++ } ++ assert( pList->a!=0 ); ++ if( pExpr || pName ){ ++ struct ExprList_item *pItem = &pList->a[pList->nExpr++]; ++ memset(pItem, 0, sizeof(*pItem)); ++ pItem->pExpr = pExpr; ++ if( pName ){ ++ sqliteSetNString(&pItem->zName, pName->z, pName->n, 0); ++ sqliteDequote(pItem->zName); ++ } ++ } ++ return pList; ++} ++ ++/* ++** Delete an entire expression list. ++*/ ++void sqliteExprListDelete(ExprList *pList){ ++ int i; ++ if( pList==0 ) return; ++ assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) ); ++ assert( pList->nExpr<=pList->nAlloc ); ++ for(i=0; inExpr; i++){ ++ sqliteExprDelete(pList->a[i].pExpr); ++ sqliteFree(pList->a[i].zName); ++ } ++ sqliteFree(pList->a); ++ sqliteFree(pList); ++} ++ ++/* ++** Walk an expression tree. Return 1 if the expression is constant ++** and 0 if it involves 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. ++*/ ++int sqliteExprIsConstant(Expr *p){ ++ switch( p->op ){ ++ case TK_ID: ++ case TK_COLUMN: ++ case TK_DOT: ++ case TK_FUNCTION: ++ return 0; ++ case TK_NULL: ++ case TK_STRING: ++ case TK_INTEGER: ++ case TK_FLOAT: ++ case TK_VARIABLE: ++ return 1; ++ default: { ++ if( p->pLeft && !sqliteExprIsConstant(p->pLeft) ) return 0; ++ if( p->pRight && !sqliteExprIsConstant(p->pRight) ) return 0; ++ if( p->pList ){ ++ int i; ++ for(i=0; ipList->nExpr; i++){ ++ if( !sqliteExprIsConstant(p->pList->a[i].pExpr) ) return 0; ++ } ++ } ++ return p->pLeft!=0 || p->pRight!=0 || (p->pList && p->pList->nExpr>0); ++ } ++ } ++ return 0; ++} ++ ++/* ++** If the given expression 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. ++*/ ++int sqliteExprIsInteger(Expr *p, int *pValue){ ++ switch( p->op ){ ++ case TK_INTEGER: { ++ if( sqliteFitsIn32Bits(p->token.z) ){ ++ *pValue = atoi(p->token.z); ++ return 1; ++ } ++ break; ++ } ++ case TK_STRING: { ++ const char *z = p->token.z; ++ int n = p->token.n; ++ if( n>0 && z[0]=='-' ){ z++; n--; } ++ while( n>0 && *z && isdigit(*z) ){ z++; n--; } ++ if( n==0 && sqliteFitsIn32Bits(p->token.z) ){ ++ *pValue = atoi(p->token.z); ++ return 1; ++ } ++ break; ++ } ++ case TK_UPLUS: { ++ return sqliteExprIsInteger(p->pLeft, pValue); ++ } ++ case TK_UMINUS: { ++ int v; ++ if( sqliteExprIsInteger(p->pLeft, &v) ){ ++ *pValue = -v; ++ return 1; ++ } ++ break; ++ } ++ default: break; ++ } ++ return 0; ++} ++ ++/* ++** Return TRUE if the given string is a row-id column name. ++*/ ++int sqliteIsRowid(const char *z){ ++ if( sqliteStrICmp(z, "_ROWID_")==0 ) return 1; ++ if( sqliteStrICmp(z, "ROWID")==0 ) return 1; ++ if( sqliteStrICmp(z, "OID")==0 ) return 1; ++ return 0; ++} ++ ++/* ++** 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 holding ++** the table. ++** pExpr->iTable Set to the cursor number for the table obtained ++** from pSrcList. ++** pExpr->iColumn Set to the column number within the table. ++** pExpr->dataType Set to the appropriate data type for the column. ++** 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 pDbToken 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 pTableToken is the name of the table (the "Y"). This ++** value can be NULL if pDbToken is also NULL. If pTableToken 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 non-zero. Return zero on success. ++*/ ++static int lookupName( ++ Parse *pParse, /* The parsing context */ ++ Token *pDbToken, /* Name of the database containing table, or NULL */ ++ Token *pTableToken, /* Name of table containing column, or NULL */ ++ Token *pColumnToken, /* Name of the column. */ ++ SrcList *pSrcList, /* List of tables used to resolve column names */ ++ ExprList *pEList, /* List of expressions used to resolve "AS" */ ++ Expr *pExpr /* Make this EXPR node point to the selected column */ ++){ ++ char *zDb = 0; /* Name of the database. The "X" in X.Y.Z */ ++ char *zTab = 0; /* Name of the table. The "Y" in X.Y.Z or Y.Z */ ++ char *zCol = 0; /* Name of the column. The "Z" */ ++ int i, j; /* Loop counters */ ++ int cnt = 0; /* Number of matching column names */ ++ int cntTab = 0; /* Number of matching table names */ ++ sqlite *db = pParse->db; /* The database */ ++ ++ assert( pColumnToken && pColumnToken->z ); /* The Z in X.Y.Z cannot be NULL */ ++ if( pDbToken && pDbToken->z ){ ++ zDb = sqliteStrNDup(pDbToken->z, pDbToken->n); ++ sqliteDequote(zDb); ++ }else{ ++ zDb = 0; ++ } ++ if( pTableToken && pTableToken->z ){ ++ zTab = sqliteStrNDup(pTableToken->z, pTableToken->n); ++ sqliteDequote(zTab); ++ }else{ ++ assert( zDb==0 ); ++ zTab = 0; ++ } ++ zCol = sqliteStrNDup(pColumnToken->z, pColumnToken->n); ++ sqliteDequote(zCol); ++ if( sqlite_malloc_failed ){ ++ return 1; /* Leak memory (zDb and zTab) if malloc fails */ ++ } ++ assert( zTab==0 || pEList==0 ); ++ ++ pExpr->iTable = -1; ++ for(i=0; inSrc; i++){ ++ struct SrcList_item *pItem = &pSrcList->a[i]; ++ Table *pTab = pItem->pTab; ++ Column *pCol; ++ ++ if( pTab==0 ) continue; ++ assert( pTab->nCol>0 ); ++ if( zTab ){ ++ if( pItem->zAlias ){ ++ char *zTabName = pItem->zAlias; ++ if( sqliteStrICmp(zTabName, zTab)!=0 ) continue; ++ }else{ ++ char *zTabName = pTab->zName; ++ if( zTabName==0 || sqliteStrICmp(zTabName, zTab)!=0 ) continue; ++ if( zDb!=0 && sqliteStrICmp(db->aDb[pTab->iDb].zName, zDb)!=0 ){ ++ continue; ++ } ++ } ++ } ++ if( 0==(cntTab++) ){ ++ pExpr->iTable = pItem->iCursor; ++ pExpr->iDb = pTab->iDb; ++ } ++ for(j=0, pCol=pTab->aCol; jnCol; j++, pCol++){ ++ if( sqliteStrICmp(pCol->zName, zCol)==0 ){ ++ cnt++; ++ pExpr->iTable = pItem->iCursor; ++ pExpr->iDb = pTab->iDb; ++ /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ ++ pExpr->iColumn = j==pTab->iPKey ? -1 : j; ++ pExpr->dataType = pCol->sortOrder & SQLITE_SO_TYPEMASK; ++ break; ++ } ++ } ++ } ++ ++ /* If we have not already resolved the name, then maybe ++ ** it is a new.* or old.* trigger argument reference ++ */ ++ if( zDb==0 && zTab!=0 && cnt==0 && pParse->trigStack!=0 ){ ++ TriggerStack *pTriggerStack = pParse->trigStack; ++ Table *pTab = 0; ++ if( pTriggerStack->newIdx != -1 && sqliteStrICmp("new", zTab) == 0 ){ ++ pExpr->iTable = pTriggerStack->newIdx; ++ assert( pTriggerStack->pTab ); ++ pTab = pTriggerStack->pTab; ++ }else if( pTriggerStack->oldIdx != -1 && sqliteStrICmp("old", zTab) == 0 ){ ++ pExpr->iTable = pTriggerStack->oldIdx; ++ assert( pTriggerStack->pTab ); ++ pTab = pTriggerStack->pTab; ++ } ++ ++ if( pTab ){ ++ int j; ++ Column *pCol = pTab->aCol; ++ ++ pExpr->iDb = pTab->iDb; ++ cntTab++; ++ for(j=0; j < pTab->nCol; j++, pCol++) { ++ if( sqliteStrICmp(pCol->zName, zCol)==0 ){ ++ cnt++; ++ pExpr->iColumn = j==pTab->iPKey ? -1 : j; ++ pExpr->dataType = pCol->sortOrder & SQLITE_SO_TYPEMASK; ++ break; ++ } ++ } ++ } ++ } ++ ++ /* ++ ** Perhaps the name is a reference to the ROWID ++ */ ++ if( cnt==0 && cntTab==1 && sqliteIsRowid(zCol) ){ ++ cnt = 1; ++ pExpr->iColumn = -1; ++ pExpr->dataType = SQLITE_SO_NUM; ++ } ++ ++ /* ++ ** 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. ++ */ ++ if( cnt==0 && pEList!=0 ){ ++ for(j=0; jnExpr; j++){ ++ char *zAs = pEList->a[j].zName; ++ if( zAs!=0 && sqliteStrICmp(zAs, zCol)==0 ){ ++ assert( pExpr->pLeft==0 && pExpr->pRight==0 ); ++ pExpr->op = TK_AS; ++ pExpr->iColumn = j; ++ pExpr->pLeft = sqliteExprDup(pEList->a[j].pExpr); ++ sqliteFree(zCol); ++ assert( zTab==0 && zDb==0 ); ++ return 0; ++ } ++ } ++ } ++ ++ /* ++ ** 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. ++ */ ++ if( cnt==0 && zTab==0 && pColumnToken->z[0]=='"' ){ ++ sqliteFree(zCol); ++ return 0; ++ } ++ ++ /* ++ ** 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 ){ ++ char *z = 0; ++ char *zErr; ++ zErr = cnt==0 ? "no such column: %s" : "ambiguous column name: %s"; ++ if( zDb ){ ++ sqliteSetString(&z, zDb, ".", zTab, ".", zCol, 0); ++ }else if( zTab ){ ++ sqliteSetString(&z, zTab, ".", zCol, 0); ++ }else{ ++ z = sqliteStrDup(zCol); ++ } ++ sqliteErrorMsg(pParse, zErr, z); ++ sqliteFree(z); ++ } ++ ++ /* Clean up and return ++ */ ++ sqliteFree(zDb); ++ sqliteFree(zTab); ++ sqliteFree(zCol); ++ sqliteExprDelete(pExpr->pLeft); ++ pExpr->pLeft = 0; ++ sqliteExprDelete(pExpr->pRight); ++ pExpr->pRight = 0; ++ pExpr->op = TK_COLUMN; ++ sqliteAuthRead(pParse, pExpr, pSrcList); ++ return cnt!=1; ++} ++ ++/* ++** This routine walks an expression tree and resolves references to ++** table columns. Nodes of the form ID.ID or ID resolve into an ++** index to the table in the table list and a column offset. The ++** Expr.opcode for such nodes is changed to TK_COLUMN. The Expr.iTable ++** value is changed to the index of the referenced table in pTabList ++** plus the "base" value. The base value will ultimately become the ++** VDBE cursor number for a cursor that is pointing into the referenced ++** table. The Expr.iColumn value is changed to the index of the column ++** of the referenced table. The Expr.iColumn value for the special ++** ROWID column is -1. Any INTEGER PRIMARY KEY column is tried as an ++** alias for ROWID. ++** ++** We also check for instances of the IN operator. IN comes in two ++** forms: ++** ++** expr IN (exprlist) ++** and ++** expr IN (SELECT ...) ++** ++** The first form is handled by creating a set holding the list ++** of allowed values. The second form causes the SELECT to generate ++** a temporary table. ++** ++** This routine also looks for scalar SELECTs that are part of an expression. ++** If it finds any, it generates code to write the value of that select ++** into a memory cell. ++** ++** Unknown columns or tables provoke an error. The function returns ++** the number of errors seen and leaves an error message on pParse->zErrMsg. ++*/ ++int sqliteExprResolveIds( ++ Parse *pParse, /* The parser context */ ++ SrcList *pSrcList, /* List of tables used to resolve column names */ ++ ExprList *pEList, /* List of expressions used to resolve "AS" */ ++ Expr *pExpr /* The expression to be analyzed. */ ++){ ++ int i; ++ ++ if( pExpr==0 || pSrcList==0 ) return 0; ++ for(i=0; inSrc; i++){ ++ assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursornTab ); ++ } ++ switch( pExpr->op ){ ++ /* Double-quoted strings (ex: "abc") are used as identifiers if ++ ** possible. Otherwise they remain as strings. Single-quoted ++ ** strings (ex: 'abc') are always string literals. ++ */ ++ case TK_STRING: { ++ if( pExpr->token.z[0]=='\'' ) break; ++ /* Fall thru into the TK_ID case if this is a double-quoted string */ ++ } ++ /* A lone identifier is the name of a columnd. ++ */ ++ case TK_ID: { ++ if( lookupName(pParse, 0, 0, &pExpr->token, pSrcList, pEList, pExpr) ){ ++ return 1; ++ } ++ break; ++ } ++ ++ /* A table name and column name: ID.ID ++ ** Or a database, table and column: ID.ID.ID ++ */ ++ case TK_DOT: { ++ Token *pColumn; ++ Token *pTable; ++ Token *pDb; ++ Expr *pRight; ++ ++ pRight = pExpr->pRight; ++ if( pRight->op==TK_ID ){ ++ pDb = 0; ++ pTable = &pExpr->pLeft->token; ++ pColumn = &pRight->token; ++ }else{ ++ assert( pRight->op==TK_DOT ); ++ pDb = &pExpr->pLeft->token; ++ pTable = &pRight->pLeft->token; ++ pColumn = &pRight->pRight->token; ++ } ++ if( lookupName(pParse, pDb, pTable, pColumn, pSrcList, 0, pExpr) ){ ++ return 1; ++ } ++ break; ++ } ++ ++ case TK_IN: { ++ Vdbe *v = sqliteGetVdbe(pParse); ++ if( v==0 ) return 1; ++ if( sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){ ++ return 1; ++ } ++ if( pExpr->pSelect ){ ++ /* Case 1: expr IN (SELECT ...) ++ ** ++ ** Generate code to write the results of the select into a temporary ++ ** table. The cursor number of the temporary table has already ++ ** been put in iTable by sqliteExprResolveInSelect(). ++ */ ++ pExpr->iTable = pParse->nTab++; ++ sqliteVdbeAddOp(v, OP_OpenTemp, pExpr->iTable, 1); ++ sqliteSelect(pParse, pExpr->pSelect, SRT_Set, pExpr->iTable, 0,0,0); ++ }else if( pExpr->pList ){ ++ /* Case 2: expr IN (exprlist) ++ ** ++ ** Create a set to put the exprlist values in. The Set id is stored ++ ** in iTable. ++ */ ++ int i, iSet; ++ for(i=0; ipList->nExpr; i++){ ++ Expr *pE2 = pExpr->pList->a[i].pExpr; ++ if( !sqliteExprIsConstant(pE2) ){ ++ sqliteErrorMsg(pParse, ++ "right-hand side of IN operator must be constant"); ++ return 1; ++ } ++ if( sqliteExprCheck(pParse, pE2, 0, 0) ){ ++ return 1; ++ } ++ } ++ iSet = pExpr->iTable = pParse->nSet++; ++ for(i=0; ipList->nExpr; i++){ ++ Expr *pE2 = pExpr->pList->a[i].pExpr; ++ switch( pE2->op ){ ++ case TK_FLOAT: ++ case TK_INTEGER: ++ case TK_STRING: { ++ int addr; ++ assert( pE2->token.z ); ++ addr = sqliteVdbeOp3(v, OP_SetInsert, iSet, 0, ++ pE2->token.z, pE2->token.n); ++ sqliteVdbeDequoteP3(v, addr); ++ break; ++ } ++ default: { ++ sqliteExprCode(pParse, pE2); ++ sqliteVdbeAddOp(v, OP_SetInsert, iSet, 0); ++ break; ++ } ++ } ++ } ++ } ++ break; ++ } ++ ++ case TK_SELECT: { ++ /* 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. ++ */ ++ pExpr->iColumn = pParse->nMem++; ++ if( sqliteSelect(pParse, pExpr->pSelect, SRT_Mem, pExpr->iColumn,0,0,0) ){ ++ return 1; ++ } ++ break; ++ } ++ ++ /* For all else, just recursively walk the tree */ ++ default: { ++ if( pExpr->pLeft ++ && sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){ ++ return 1; ++ } ++ if( pExpr->pRight ++ && sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pRight) ){ ++ return 1; ++ } ++ if( pExpr->pList ){ ++ int i; ++ ExprList *pList = pExpr->pList; ++ for(i=0; inExpr; i++){ ++ Expr *pArg = pList->a[i].pExpr; ++ if( sqliteExprResolveIds(pParse, pSrcList, pEList, pArg) ){ ++ return 1; ++ } ++ } ++ } ++ } ++ } ++ return 0; ++} ++ ++/* ++** pExpr is a node that defines a function of some kind. It might ++** be a syntactic function like "count(x)" or it might be a function ++** that implements an operator, like "a LIKE b". ++** ++** This routine makes *pzName point to the name of the function and ++** *pnName hold the number of characters in the function name. ++*/ ++static void getFunctionName(Expr *pExpr, const char **pzName, int *pnName){ ++ switch( pExpr->op ){ ++ case TK_FUNCTION: { ++ *pzName = pExpr->token.z; ++ *pnName = pExpr->token.n; ++ break; ++ } ++ case TK_LIKE: { ++ *pzName = "like"; ++ *pnName = 4; ++ break; ++ } ++ case TK_GLOB: { ++ *pzName = "glob"; ++ *pnName = 4; ++ break; ++ } ++ default: { ++ *pzName = "can't happen"; ++ *pnName = 12; ++ break; ++ } ++ } ++} ++ ++/* ++** Error check the functions in an expression. Make sure all ++** function names are recognized and all functions have the correct ++** number of arguments. Leave an error message in pParse->zErrMsg ++** if anything is amiss. Return the number of errors. ++** ++** if pIsAgg is not null and this expression is an aggregate function ++** (like count(*) or max(value)) then write a 1 into *pIsAgg. ++*/ ++int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){ ++ int nErr = 0; ++ if( pExpr==0 ) return 0; ++ switch( pExpr->op ){ ++ case TK_GLOB: ++ case TK_LIKE: ++ case TK_FUNCTION: { ++ int n = pExpr->pList ? pExpr->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 i; ++ int nId; /* Number of characters in function name */ ++ const char *zId; /* The function name. */ ++ FuncDef *pDef; ++ ++ getFunctionName(pExpr, &zId, &nId); ++ pDef = sqliteFindFunction(pParse->db, zId, nId, n, 0); ++ if( pDef==0 ){ ++ pDef = sqliteFindFunction(pParse->db, zId, nId, -1, 0); ++ if( pDef==0 ){ ++ no_such_func = 1; ++ }else{ ++ wrong_num_args = 1; ++ } ++ }else{ ++ is_agg = pDef->xFunc==0; ++ } ++ if( is_agg && !allowAgg ){ ++ sqliteErrorMsg(pParse, "misuse of aggregate function %.*s()", nId, zId); ++ nErr++; ++ is_agg = 0; ++ }else if( no_such_func ){ ++ sqliteErrorMsg(pParse, "no such function: %.*s", nId, zId); ++ nErr++; ++ }else if( wrong_num_args ){ ++ sqliteErrorMsg(pParse,"wrong number of arguments to function %.*s()", ++ nId, zId); ++ nErr++; ++ } ++ if( is_agg ){ ++ pExpr->op = TK_AGG_FUNCTION; ++ if( pIsAgg ) *pIsAgg = 1; ++ } ++ for(i=0; nErr==0 && ipList->a[i].pExpr, ++ allowAgg && !is_agg, pIsAgg); ++ } ++ if( pDef==0 ){ ++ /* Already reported an error */ ++ }else if( pDef->dataType>=0 ){ ++ if( pDef->dataTypedataType = ++ sqliteExprType(pExpr->pList->a[pDef->dataType].pExpr); ++ }else{ ++ pExpr->dataType = SQLITE_SO_NUM; ++ } ++ }else if( pDef->dataType==SQLITE_ARGS ){ ++ pDef->dataType = SQLITE_SO_TEXT; ++ for(i=0; ipList->a[i].pExpr)==SQLITE_SO_NUM ){ ++ pExpr->dataType = SQLITE_SO_NUM; ++ break; ++ } ++ } ++ }else if( pDef->dataType==SQLITE_NUMERIC ){ ++ pExpr->dataType = SQLITE_SO_NUM; ++ }else{ ++ pExpr->dataType = SQLITE_SO_TEXT; ++ } ++ } ++ default: { ++ if( pExpr->pLeft ){ ++ nErr = sqliteExprCheck(pParse, pExpr->pLeft, allowAgg, pIsAgg); ++ } ++ if( nErr==0 && pExpr->pRight ){ ++ nErr = sqliteExprCheck(pParse, pExpr->pRight, allowAgg, pIsAgg); ++ } ++ if( nErr==0 && pExpr->pList ){ ++ int n = pExpr->pList->nExpr; ++ int i; ++ for(i=0; nErr==0 && ipList->a[i].pExpr; ++ nErr = sqliteExprCheck(pParse, pE2, allowAgg, pIsAgg); ++ } ++ } ++ break; ++ } ++ } ++ return nErr; ++} ++ ++/* ++** Return either SQLITE_SO_NUM or SQLITE_SO_TEXT to indicate whether the ++** given expression should sort as numeric values or as text. ++** ++** The sqliteExprResolveIds() and sqliteExprCheck() routines must have ++** both been called on the expression before it is passed to this routine. ++*/ ++int sqliteExprType(Expr *p){ ++ if( p==0 ) return SQLITE_SO_NUM; ++ while( p ) switch( p->op ){ ++ case TK_PLUS: ++ case TK_MINUS: ++ case TK_STAR: ++ case TK_SLASH: ++ case TK_AND: ++ case TK_OR: ++ case TK_ISNULL: ++ case TK_NOTNULL: ++ case TK_NOT: ++ case TK_UMINUS: ++ case TK_UPLUS: ++ case TK_BITAND: ++ case TK_BITOR: ++ case TK_BITNOT: ++ case TK_LSHIFT: ++ case TK_RSHIFT: ++ case TK_REM: ++ case TK_INTEGER: ++ case TK_FLOAT: ++ case TK_IN: ++ case TK_BETWEEN: ++ case TK_GLOB: ++ case TK_LIKE: ++ return SQLITE_SO_NUM; ++ ++ case TK_STRING: ++ case TK_NULL: ++ case TK_CONCAT: ++ case TK_VARIABLE: ++ return SQLITE_SO_TEXT; ++ ++ case TK_LT: ++ case TK_LE: ++ case TK_GT: ++ case TK_GE: ++ case TK_NE: ++ case TK_EQ: ++ if( sqliteExprType(p->pLeft)==SQLITE_SO_NUM ){ ++ return SQLITE_SO_NUM; ++ } ++ p = p->pRight; ++ break; ++ ++ case TK_AS: ++ p = p->pLeft; ++ break; ++ ++ case TK_COLUMN: ++ case TK_FUNCTION: ++ case TK_AGG_FUNCTION: ++ return p->dataType; ++ ++ case TK_SELECT: ++ assert( p->pSelect ); ++ assert( p->pSelect->pEList ); ++ assert( p->pSelect->pEList->nExpr>0 ); ++ p = p->pSelect->pEList->a[0].pExpr; ++ break; ++ ++ case TK_CASE: { ++ if( p->pRight && sqliteExprType(p->pRight)==SQLITE_SO_NUM ){ ++ return SQLITE_SO_NUM; ++ } ++ if( p->pList ){ ++ int i; ++ ExprList *pList = p->pList; ++ for(i=1; inExpr; i+=2){ ++ if( sqliteExprType(pList->a[i].pExpr)==SQLITE_SO_NUM ){ ++ return SQLITE_SO_NUM; ++ } ++ } ++ } ++ return SQLITE_SO_TEXT; ++ } ++ ++ default: ++ assert( p->op==TK_ABORT ); /* Can't Happen */ ++ break; ++ } ++ return SQLITE_SO_NUM; ++} ++ ++/* ++** Generate code into the current Vdbe to evaluate the given ++** expression and leave the result on the top of stack. ++*/ ++void sqliteExprCode(Parse *pParse, Expr *pExpr){ ++ Vdbe *v = pParse->pVdbe; ++ int op; ++ if( v==0 || pExpr==0 ) return; ++ switch( pExpr->op ){ ++ case TK_PLUS: op = OP_Add; break; ++ case TK_MINUS: op = OP_Subtract; break; ++ case TK_STAR: op = OP_Multiply; break; ++ case TK_SLASH: op = OP_Divide; break; ++ case TK_AND: op = OP_And; break; ++ case TK_OR: op = OP_Or; break; ++ case TK_LT: op = OP_Lt; break; ++ case TK_LE: op = OP_Le; break; ++ case TK_GT: op = OP_Gt; break; ++ case TK_GE: op = OP_Ge; break; ++ case TK_NE: op = OP_Ne; break; ++ case TK_EQ: op = OP_Eq; break; ++ case TK_ISNULL: op = OP_IsNull; break; ++ case TK_NOTNULL: op = OP_NotNull; break; ++ case TK_NOT: op = OP_Not; break; ++ case TK_UMINUS: op = OP_Negative; break; ++ case TK_BITAND: op = OP_BitAnd; break; ++ case TK_BITOR: op = OP_BitOr; break; ++ case TK_BITNOT: op = OP_BitNot; break; ++ case TK_LSHIFT: op = OP_ShiftLeft; break; ++ case TK_RSHIFT: op = OP_ShiftRight; break; ++ case TK_REM: op = OP_Remainder; break; ++ default: break; ++ } ++ switch( pExpr->op ){ ++ case TK_COLUMN: { ++ if( pParse->useAgg ){ ++ sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); ++ }else if( pExpr->iColumn>=0 ){ ++ sqliteVdbeAddOp(v, OP_Column, pExpr->iTable, pExpr->iColumn); ++ }else{ ++ sqliteVdbeAddOp(v, OP_Recno, pExpr->iTable, 0); ++ } ++ break; ++ } ++ case TK_STRING: ++ case TK_FLOAT: ++ case TK_INTEGER: { ++ if( pExpr->op==TK_INTEGER && sqliteFitsIn32Bits(pExpr->token.z) ){ ++ sqliteVdbeAddOp(v, OP_Integer, atoi(pExpr->token.z), 0); ++ }else{ ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ } ++ assert( pExpr->token.z ); ++ sqliteVdbeChangeP3(v, -1, pExpr->token.z, pExpr->token.n); ++ sqliteVdbeDequoteP3(v, -1); ++ break; ++ } ++ case TK_NULL: { ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ break; ++ } ++ case TK_VARIABLE: { ++ sqliteVdbeAddOp(v, OP_Variable, pExpr->iTable, 0); ++ break; ++ } ++ case TK_LT: ++ case TK_LE: ++ case TK_GT: ++ case TK_GE: ++ case TK_NE: ++ case TK_EQ: { ++ if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){ ++ op += 6; /* Convert numeric opcodes to text opcodes */ ++ } ++ /* Fall through into the next case */ ++ } ++ 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: { ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteExprCode(pParse, pExpr->pRight); ++ sqliteVdbeAddOp(v, op, 0, 0); ++ break; ++ } ++ case TK_LSHIFT: ++ case TK_RSHIFT: { ++ sqliteExprCode(pParse, pExpr->pRight); ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteVdbeAddOp(v, op, 0, 0); ++ break; ++ } ++ case TK_CONCAT: { ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteExprCode(pParse, pExpr->pRight); ++ sqliteVdbeAddOp(v, OP_Concat, 2, 0); ++ break; ++ } ++ case TK_UMINUS: { ++ assert( pExpr->pLeft ); ++ if( pExpr->pLeft->op==TK_FLOAT || pExpr->pLeft->op==TK_INTEGER ){ ++ Token *p = &pExpr->pLeft->token; ++ char *z = sqliteMalloc( p->n + 2 ); ++ sprintf(z, "-%.*s", p->n, p->z); ++ if( pExpr->pLeft->op==TK_INTEGER && sqliteFitsIn32Bits(z) ){ ++ sqliteVdbeAddOp(v, OP_Integer, atoi(z), 0); ++ }else{ ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ } ++ sqliteVdbeChangeP3(v, -1, z, p->n+1); ++ sqliteFree(z); ++ break; ++ } ++ /* Fall through into TK_NOT */ ++ } ++ case TK_BITNOT: ++ case TK_NOT: { ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteVdbeAddOp(v, op, 0, 0); ++ break; ++ } ++ case TK_ISNULL: ++ case TK_NOTNULL: { ++ int dest; ++ sqliteVdbeAddOp(v, OP_Integer, 1, 0); ++ sqliteExprCode(pParse, pExpr->pLeft); ++ dest = sqliteVdbeCurrentAddr(v) + 2; ++ sqliteVdbeAddOp(v, op, 1, dest); ++ sqliteVdbeAddOp(v, OP_AddImm, -1, 0); ++ break; ++ } ++ case TK_AGG_FUNCTION: { ++ sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); ++ break; ++ } ++ case TK_GLOB: ++ case TK_LIKE: ++ case TK_FUNCTION: { ++ ExprList *pList = pExpr->pList; ++ int nExpr = pList ? pList->nExpr : 0; ++ FuncDef *pDef; ++ int nId; ++ const char *zId; ++ getFunctionName(pExpr, &zId, &nId); ++ pDef = sqliteFindFunction(pParse->db, zId, nId, nExpr, 0); ++ assert( pDef!=0 ); ++ nExpr = sqliteExprCodeExprList(pParse, pList, pDef->includeTypes); ++ sqliteVdbeOp3(v, OP_Function, nExpr, 0, (char*)pDef, P3_POINTER); ++ break; ++ } ++ case TK_SELECT: { ++ sqliteVdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0); ++ break; ++ } ++ case TK_IN: { ++ int addr; ++ sqliteVdbeAddOp(v, OP_Integer, 1, 0); ++ sqliteExprCode(pParse, pExpr->pLeft); ++ addr = sqliteVdbeCurrentAddr(v); ++ sqliteVdbeAddOp(v, OP_NotNull, -1, addr+4); ++ sqliteVdbeAddOp(v, OP_Pop, 2, 0); ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ sqliteVdbeAddOp(v, OP_Goto, 0, addr+6); ++ if( pExpr->pSelect ){ ++ sqliteVdbeAddOp(v, OP_Found, pExpr->iTable, addr+6); ++ }else{ ++ sqliteVdbeAddOp(v, OP_SetFound, pExpr->iTable, addr+6); ++ } ++ sqliteVdbeAddOp(v, OP_AddImm, -1, 0); ++ break; ++ } ++ case TK_BETWEEN: { ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteVdbeAddOp(v, OP_Dup, 0, 0); ++ sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); ++ sqliteVdbeAddOp(v, OP_Ge, 0, 0); ++ sqliteVdbeAddOp(v, OP_Pull, 1, 0); ++ sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); ++ sqliteVdbeAddOp(v, OP_Le, 0, 0); ++ sqliteVdbeAddOp(v, OP_And, 0, 0); ++ break; ++ } ++ case TK_UPLUS: ++ case TK_AS: { ++ sqliteExprCode(pParse, pExpr->pLeft); ++ break; ++ } ++ case TK_CASE: { ++ int expr_end_label; ++ int jumpInst; ++ int addr; ++ int nExpr; ++ int i; ++ ++ assert(pExpr->pList); ++ assert((pExpr->pList->nExpr % 2) == 0); ++ assert(pExpr->pList->nExpr > 0); ++ nExpr = pExpr->pList->nExpr; ++ expr_end_label = sqliteVdbeMakeLabel(v); ++ if( pExpr->pLeft ){ ++ sqliteExprCode(pParse, pExpr->pLeft); ++ } ++ for(i=0; ipList->a[i].pExpr); ++ if( pExpr->pLeft ){ ++ sqliteVdbeAddOp(v, OP_Dup, 1, 1); ++ jumpInst = sqliteVdbeAddOp(v, OP_Ne, 1, 0); ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ }else{ ++ jumpInst = sqliteVdbeAddOp(v, OP_IfNot, 1, 0); ++ } ++ sqliteExprCode(pParse, pExpr->pList->a[i+1].pExpr); ++ sqliteVdbeAddOp(v, OP_Goto, 0, expr_end_label); ++ addr = sqliteVdbeCurrentAddr(v); ++ sqliteVdbeChangeP2(v, jumpInst, addr); ++ } ++ if( pExpr->pLeft ){ ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ } ++ if( pExpr->pRight ){ ++ sqliteExprCode(pParse, pExpr->pRight); ++ }else{ ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ } ++ sqliteVdbeResolveLabel(v, expr_end_label); ++ break; ++ } ++ case TK_RAISE: { ++ if( !pParse->trigStack ){ ++ sqliteErrorMsg(pParse, ++ "RAISE() may only be used within a trigger-program"); ++ pParse->nErr++; ++ return; ++ } ++ if( pExpr->iColumn == OE_Rollback || ++ pExpr->iColumn == OE_Abort || ++ pExpr->iColumn == OE_Fail ){ ++ sqliteVdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, ++ pExpr->token.z, pExpr->token.n); ++ sqliteVdbeDequoteP3(v, -1); ++ } else { ++ assert( pExpr->iColumn == OE_Ignore ); ++ sqliteVdbeOp3(v, OP_Goto, 0, pParse->trigStack->ignoreJump, ++ "(IGNORE jump)", 0); ++ } ++ } ++ break; ++ } ++} ++ ++/* ++** Generate code that pushes the value of every element of the given ++** expression list onto the stack. If the includeTypes flag is true, ++** then also push a string that is the datatype of each element onto ++** the stack after the value. ++** ++** Return the number of elements pushed onto the stack. ++*/ ++int sqliteExprCodeExprList( ++ Parse *pParse, /* Parsing context */ ++ ExprList *pList, /* The expression list to be coded */ ++ int includeTypes /* TRUE to put datatypes on the stack too */ ++){ ++ struct ExprList_item *pItem; ++ int i, n; ++ Vdbe *v; ++ if( pList==0 ) return 0; ++ v = sqliteGetVdbe(pParse); ++ n = pList->nExpr; ++ for(pItem=pList->a, i=0; ipExpr); ++ if( includeTypes ){ ++ sqliteVdbeOp3(v, OP_String, 0, 0, ++ sqliteExprType(pItem->pExpr)==SQLITE_SO_NUM ? "numeric" : "text", ++ P3_STATIC); ++ } ++ } ++ return includeTypes ? n*2 : n; ++} ++ ++/* ++** 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 true. ++*/ ++void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ ++ Vdbe *v = pParse->pVdbe; ++ int op = 0; ++ if( v==0 || pExpr==0 ) return; ++ switch( pExpr->op ){ ++ case TK_LT: op = OP_Lt; break; ++ case TK_LE: op = OP_Le; break; ++ case TK_GT: op = OP_Gt; break; ++ case TK_GE: op = OP_Ge; break; ++ case TK_NE: op = OP_Ne; break; ++ case TK_EQ: op = OP_Eq; break; ++ case TK_ISNULL: op = OP_IsNull; break; ++ case TK_NOTNULL: op = OP_NotNull; break; ++ default: break; ++ } ++ switch( pExpr->op ){ ++ case TK_AND: { ++ int d2 = sqliteVdbeMakeLabel(v); ++ sqliteExprIfFalse(pParse, pExpr->pLeft, d2, !jumpIfNull); ++ sqliteExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); ++ sqliteVdbeResolveLabel(v, d2); ++ break; ++ } ++ case TK_OR: { ++ sqliteExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); ++ sqliteExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); ++ break; ++ } ++ case TK_NOT: { ++ sqliteExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); ++ break; ++ } ++ case TK_LT: ++ case TK_LE: ++ case TK_GT: ++ case TK_GE: ++ case TK_NE: ++ case TK_EQ: { ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteExprCode(pParse, pExpr->pRight); ++ if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){ ++ op += 6; /* Convert numeric opcodes to text opcodes */ ++ } ++ sqliteVdbeAddOp(v, op, jumpIfNull, dest); ++ break; ++ } ++ case TK_ISNULL: ++ case TK_NOTNULL: { ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteVdbeAddOp(v, op, 1, dest); ++ break; ++ } ++ case TK_IN: { ++ int addr; ++ sqliteExprCode(pParse, pExpr->pLeft); ++ addr = sqliteVdbeCurrentAddr(v); ++ sqliteVdbeAddOp(v, OP_NotNull, -1, addr+3); ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ sqliteVdbeAddOp(v, OP_Goto, 0, jumpIfNull ? dest : addr+4); ++ if( pExpr->pSelect ){ ++ sqliteVdbeAddOp(v, OP_Found, pExpr->iTable, dest); ++ }else{ ++ sqliteVdbeAddOp(v, OP_SetFound, pExpr->iTable, dest); ++ } ++ break; ++ } ++ case TK_BETWEEN: { ++ int addr; ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteVdbeAddOp(v, OP_Dup, 0, 0); ++ sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); ++ addr = sqliteVdbeAddOp(v, OP_Lt, !jumpIfNull, 0); ++ sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); ++ sqliteVdbeAddOp(v, OP_Le, jumpIfNull, dest); ++ sqliteVdbeAddOp(v, OP_Integer, 0, 0); ++ sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v)); ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ break; ++ } ++ default: { ++ sqliteExprCode(pParse, pExpr); ++ sqliteVdbeAddOp(v, OP_If, jumpIfNull, dest); ++ break; ++ } ++ } ++} ++ ++/* ++** 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 true or fall through if jumpIfNull is false. ++*/ ++void sqliteExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ ++ Vdbe *v = pParse->pVdbe; ++ int op = 0; ++ if( v==0 || pExpr==0 ) return; ++ switch( pExpr->op ){ ++ case TK_LT: op = OP_Ge; break; ++ case TK_LE: op = OP_Gt; break; ++ case TK_GT: op = OP_Le; break; ++ case TK_GE: op = OP_Lt; break; ++ case TK_NE: op = OP_Eq; break; ++ case TK_EQ: op = OP_Ne; break; ++ case TK_ISNULL: op = OP_NotNull; break; ++ case TK_NOTNULL: op = OP_IsNull; break; ++ default: break; ++ } ++ switch( pExpr->op ){ ++ case TK_AND: { ++ sqliteExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); ++ sqliteExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); ++ break; ++ } ++ case TK_OR: { ++ int d2 = sqliteVdbeMakeLabel(v); ++ sqliteExprIfTrue(pParse, pExpr->pLeft, d2, !jumpIfNull); ++ sqliteExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); ++ sqliteVdbeResolveLabel(v, d2); ++ break; ++ } ++ case TK_NOT: { ++ sqliteExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); ++ break; ++ } ++ case TK_LT: ++ case TK_LE: ++ case TK_GT: ++ case TK_GE: ++ case TK_NE: ++ case TK_EQ: { ++ if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){ ++ /* Convert numeric comparison opcodes into text comparison opcodes. ++ ** This step depends on the fact that the text comparision opcodes are ++ ** always 6 greater than their corresponding numeric comparison ++ ** opcodes. ++ */ ++ assert( OP_Eq+6 == OP_StrEq ); ++ op += 6; ++ } ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteExprCode(pParse, pExpr->pRight); ++ sqliteVdbeAddOp(v, op, jumpIfNull, dest); ++ break; ++ } ++ case TK_ISNULL: ++ case TK_NOTNULL: { ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteVdbeAddOp(v, op, 1, dest); ++ break; ++ } ++ case TK_IN: { ++ int addr; ++ sqliteExprCode(pParse, pExpr->pLeft); ++ addr = sqliteVdbeCurrentAddr(v); ++ sqliteVdbeAddOp(v, OP_NotNull, -1, addr+3); ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ sqliteVdbeAddOp(v, OP_Goto, 0, jumpIfNull ? dest : addr+4); ++ if( pExpr->pSelect ){ ++ sqliteVdbeAddOp(v, OP_NotFound, pExpr->iTable, dest); ++ }else{ ++ sqliteVdbeAddOp(v, OP_SetNotFound, pExpr->iTable, dest); ++ } ++ break; ++ } ++ case TK_BETWEEN: { ++ int addr; ++ sqliteExprCode(pParse, pExpr->pLeft); ++ sqliteVdbeAddOp(v, OP_Dup, 0, 0); ++ sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); ++ addr = sqliteVdbeCurrentAddr(v); ++ sqliteVdbeAddOp(v, OP_Ge, !jumpIfNull, addr+3); ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ sqliteVdbeAddOp(v, OP_Goto, 0, dest); ++ sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); ++ sqliteVdbeAddOp(v, OP_Gt, jumpIfNull, dest); ++ break; ++ } ++ default: { ++ sqliteExprCode(pParse, pExpr); ++ sqliteVdbeAddOp(v, OP_IfNot, jumpIfNull, dest); ++ break; ++ } ++ } ++} ++ ++/* ++** Do a deep comparison of two expression trees. Return TRUE (non-zero) ++** if they are identical and return FALSE if they differ in any way. ++*/ ++int sqliteExprCompare(Expr *pA, Expr *pB){ ++ int i; ++ if( pA==0 ){ ++ return pB==0; ++ }else if( pB==0 ){ ++ return 0; ++ } ++ if( pA->op!=pB->op ) return 0; ++ if( !sqliteExprCompare(pA->pLeft, pB->pLeft) ) return 0; ++ if( !sqliteExprCompare(pA->pRight, pB->pRight) ) return 0; ++ if( pA->pList ){ ++ if( pB->pList==0 ) return 0; ++ if( pA->pList->nExpr!=pB->pList->nExpr ) return 0; ++ for(i=0; ipList->nExpr; i++){ ++ if( !sqliteExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){ ++ return 0; ++ } ++ } ++ }else if( pB->pList ){ ++ return 0; ++ } ++ if( pA->pSelect || pB->pSelect ) return 0; ++ if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0; ++ if( pA->token.z ){ ++ if( pB->token.z==0 ) return 0; ++ if( pB->token.n!=pA->token.n ) return 0; ++ if( sqliteStrNICmp(pA->token.z, pB->token.z, pB->token.n)!=0 ) return 0; ++ } ++ return 1; ++} ++ ++/* ++** Add a new element to the pParse->aAgg[] array and return its index. ++*/ ++static int appendAggInfo(Parse *pParse){ ++ if( (pParse->nAgg & 0x7)==0 ){ ++ int amt = pParse->nAgg + 8; ++ AggExpr *aAgg = sqliteRealloc(pParse->aAgg, amt*sizeof(pParse->aAgg[0])); ++ if( aAgg==0 ){ ++ return -1; ++ } ++ pParse->aAgg = aAgg; ++ } ++ memset(&pParse->aAgg[pParse->nAgg], 0, sizeof(pParse->aAgg[0])); ++ return pParse->nAgg++; ++} ++ ++/* ++** Analyze the given expression looking for aggregate functions and ++** for variables that need to be added to the pParse->aAgg[] array. ++** Make additional entries to the pParse->aAgg[] array as necessary. ++** ++** This routine should only be called after the expression has been ++** analyzed by sqliteExprResolveIds() and sqliteExprCheck(). ++** ++** If errors are seen, leave an error message in zErrMsg and return ++** the number of errors. ++*/ ++int sqliteExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){ ++ int i; ++ AggExpr *aAgg; ++ int nErr = 0; ++ ++ if( pExpr==0 ) return 0; ++ switch( pExpr->op ){ ++ case TK_COLUMN: { ++ aAgg = pParse->aAgg; ++ for(i=0; inAgg; i++){ ++ if( aAgg[i].isAgg ) continue; ++ if( aAgg[i].pExpr->iTable==pExpr->iTable ++ && aAgg[i].pExpr->iColumn==pExpr->iColumn ){ ++ break; ++ } ++ } ++ if( i>=pParse->nAgg ){ ++ i = appendAggInfo(pParse); ++ if( i<0 ) return 1; ++ pParse->aAgg[i].isAgg = 0; ++ pParse->aAgg[i].pExpr = pExpr; ++ } ++ pExpr->iAgg = i; ++ break; ++ } ++ case TK_AGG_FUNCTION: { ++ aAgg = pParse->aAgg; ++ for(i=0; inAgg; i++){ ++ if( !aAgg[i].isAgg ) continue; ++ if( sqliteExprCompare(aAgg[i].pExpr, pExpr) ){ ++ break; ++ } ++ } ++ if( i>=pParse->nAgg ){ ++ i = appendAggInfo(pParse); ++ if( i<0 ) return 1; ++ pParse->aAgg[i].isAgg = 1; ++ pParse->aAgg[i].pExpr = pExpr; ++ pParse->aAgg[i].pFunc = sqliteFindFunction(pParse->db, ++ pExpr->token.z, pExpr->token.n, ++ pExpr->pList ? pExpr->pList->nExpr : 0, 0); ++ } ++ pExpr->iAgg = i; ++ break; ++ } ++ default: { ++ if( pExpr->pLeft ){ ++ nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pLeft); ++ } ++ if( nErr==0 && pExpr->pRight ){ ++ nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pRight); ++ } ++ if( nErr==0 && pExpr->pList ){ ++ int n = pExpr->pList->nExpr; ++ int i; ++ for(i=0; nErr==0 && ipList->a[i].pExpr); ++ } ++ } ++ break; ++ } ++ } ++ return nErr; ++} ++ ++/* ++** Locate a user function given a name and a number of arguments. ++** 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. When createFlag is true ++** and the nArg parameter is -1, then only a function that accepts ++** any number of arguments will be returned. ++** ++** If createFlag is false and nArg is -1, then the first valid ++** function found is returned. A function is valid if either xFunc ++** or xStep is non-zero. ++*/ ++FuncDef *sqliteFindFunction( ++ sqlite *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 */ ++ int createFlag /* Create new entry if true and does not otherwise exist */ ++){ ++ FuncDef *pFirst, *p, *pMaybe; ++ pFirst = p = (FuncDef*)sqliteHashFind(&db->aFunc, zName, nName); ++ if( p && !createFlag && nArg<0 ){ ++ while( p && p->xFunc==0 && p->xStep==0 ){ p = p->pNext; } ++ return p; ++ } ++ pMaybe = 0; ++ while( p && p->nArg!=nArg ){ ++ if( p->nArg<0 && !createFlag && (p->xFunc || p->xStep) ) pMaybe = p; ++ p = p->pNext; ++ } ++ if( p && !createFlag && p->xFunc==0 && p->xStep==0 ){ ++ return 0; ++ } ++ if( p==0 && pMaybe ){ ++ assert( createFlag==0 ); ++ return pMaybe; ++ } ++ if( p==0 && createFlag && (p = sqliteMalloc(sizeof(*p)))!=0 ){ ++ p->nArg = nArg; ++ p->pNext = pFirst; ++ p->dataType = pFirst ? pFirst->dataType : SQLITE_NUMERIC; ++ sqliteHashInsert(&db->aFunc, zName, nName, (void*)p); ++ } ++ return p; ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/func.c +@@ -0,0 +1,658 @@ ++/* ++** 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 functions that implement various SQL ++** functions of SQLite. ++** ++** There is only one exported symbol in this file - the function ++** sqliteRegisterBuildinFunctions() found at the bottom of the file. ++** All other code has file scope. ++** ++** $Id$ ++*/ ++#include ++#include ++#include ++#include ++#include "sqliteInt.h" ++#include "os.h" ++ ++/* ++** Implementation of the non-aggregate min() and max() functions ++*/ ++static void minmaxFunc(sqlite_func *context, int argc, const char **argv){ ++ const char *zBest; ++ int i; ++ int (*xCompare)(const char*, const char*); ++ int mask; /* 0 for min() or 0xffffffff for max() */ ++ ++ if( argc==0 ) return; ++ mask = (int)sqlite_user_data(context); ++ zBest = argv[0]; ++ if( zBest==0 ) return; ++ if( argv[1][0]=='n' ){ ++ xCompare = sqliteCompare; ++ }else{ ++ xCompare = strcmp; ++ } ++ for(i=2; i0 ){ ++ p1--; ++ } ++ if( p1+p2>len ){ ++ p2 = len-p1; ++ } ++#ifdef SQLITE_UTF8 ++ for(i=0; i30 ) n = 30; ++ if( n<0 ) n = 0; ++ r = sqliteAtoF(argv[0], 0); ++ sprintf(zBuf,"%.*f",n,r); ++ sqlite_set_result_string(context, zBuf, -1); ++} ++ ++/* ++** Implementation of the upper() and lower() SQL functions. ++*/ ++static void upperFunc(sqlite_func *context, int argc, const char **argv){ ++ unsigned char *z; ++ int i; ++ if( argc<1 || argv[0]==0 ) return; ++ z = (unsigned char*)sqlite_set_result_string(context, argv[0], -1); ++ if( z==0 ) return; ++ for(i=0; z[i]; i++){ ++ if( islower(z[i]) ) z[i] = toupper(z[i]); ++ } ++} ++static void lowerFunc(sqlite_func *context, int argc, const char **argv){ ++ unsigned char *z; ++ int i; ++ if( argc<1 || argv[0]==0 ) return; ++ z = (unsigned char*)sqlite_set_result_string(context, argv[0], -1); ++ if( z==0 ) return; ++ for(i=0; z[i]; i++){ ++ if( isupper(z[i]) ) z[i] = tolower(z[i]); ++ } ++} ++ ++/* ++** Implementation of the IFNULL(), NVL(), and COALESCE() functions. ++** All three do the same thing. They return the first non-NULL ++** argument. ++*/ ++static void ifnullFunc(sqlite_func *context, int argc, const char **argv){ ++ int i; ++ for(i=0; i0 ){ ++ zResult[j++] = code + '0'; ++ } ++ } ++ while( j<4 ){ ++ zResult[j++] = '0'; ++ } ++ zResult[j] = 0; ++ sqlite_set_result_string(context, zResult, 4); ++ }else{ ++ sqlite_set_result_string(context, "?000", 4); ++ } ++} ++#endif ++ ++#ifdef SQLITE_TEST ++/* ++** This function generates a string of random characters. Used for ++** generating test data. ++*/ ++static void randStr(sqlite_func *context, int argc, const char **argv){ ++ static const unsigned char zSrc[] = ++ "abcdefghijklmnopqrstuvwxyz" ++ "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ++ "0123456789" ++ ".-!,:*^+=_|?/<> "; ++ int iMin, iMax, n, r, i; ++ unsigned char zBuf[1000]; ++ if( argc>=1 ){ ++ iMin = atoi(argv[0]); ++ if( iMin<0 ) iMin = 0; ++ if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1; ++ }else{ ++ iMin = 1; ++ } ++ if( argc>=2 ){ ++ iMax = atoi(argv[1]); ++ if( iMax=sizeof(zBuf) ) iMax = sizeof(zBuf)-1; ++ }else{ ++ iMax = 50; ++ } ++ n = iMin; ++ if( iMax>iMin ){ ++ sqliteRandomness(sizeof(r), &r); ++ r &= 0x7fffffff; ++ n += r%(iMax + 1 - iMin); ++ } ++ assert( nsum += sqliteAtoF(argv[0], 0); ++ p->cnt++; ++ } ++} ++static void sumFinalize(sqlite_func *context){ ++ SumCtx *p; ++ p = sqlite_aggregate_context(context, sizeof(*p)); ++ sqlite_set_result_double(context, p ? p->sum : 0.0); ++} ++static void avgFinalize(sqlite_func *context){ ++ SumCtx *p; ++ p = sqlite_aggregate_context(context, sizeof(*p)); ++ if( p && p->cnt>0 ){ ++ sqlite_set_result_double(context, p->sum/(double)p->cnt); ++ } ++} ++ ++/* ++** An instance of the following structure holds the context of a ++** variance or standard deviation computation. ++*/ ++typedef struct StdDevCtx StdDevCtx; ++struct StdDevCtx { ++ double sum; /* Sum of terms */ ++ double sum2; /* Sum of the squares of terms */ ++ int cnt; /* Number of terms counted */ ++}; ++ ++#if 0 /* Omit because math library is required */ ++/* ++** Routines used to compute the standard deviation as an aggregate. ++*/ ++static void stdDevStep(sqlite_func *context, int argc, const char **argv){ ++ StdDevCtx *p; ++ double x; ++ if( argc<1 ) return; ++ p = sqlite_aggregate_context(context, sizeof(*p)); ++ if( p && argv[0] ){ ++ x = sqliteAtoF(argv[0], 0); ++ p->sum += x; ++ p->sum2 += x*x; ++ p->cnt++; ++ } ++} ++static void stdDevFinalize(sqlite_func *context){ ++ double rN = sqlite_aggregate_count(context); ++ StdDevCtx *p = sqlite_aggregate_context(context, sizeof(*p)); ++ if( p && p->cnt>1 ){ ++ double rCnt = cnt; ++ sqlite_set_result_double(context, ++ sqrt((p->sum2 - p->sum*p->sum/rCnt)/(rCnt-1.0))); ++ } ++} ++#endif ++ ++/* ++** The following structure keeps track of state information for the ++** count() aggregate function. ++*/ ++typedef struct CountCtx CountCtx; ++struct CountCtx { ++ int n; ++}; ++ ++/* ++** Routines to implement the count() aggregate function. ++*/ ++static void countStep(sqlite_func *context, int argc, const char **argv){ ++ CountCtx *p; ++ p = sqlite_aggregate_context(context, sizeof(*p)); ++ if( (argc==0 || argv[0]) && p ){ ++ p->n++; ++ } ++} ++static void countFinalize(sqlite_func *context){ ++ CountCtx *p; ++ p = sqlite_aggregate_context(context, sizeof(*p)); ++ sqlite_set_result_int(context, p ? p->n : 0); ++} ++ ++/* ++** This function tracks state information for the min() and max() ++** aggregate functions. ++*/ ++typedef struct MinMaxCtx MinMaxCtx; ++struct MinMaxCtx { ++ char *z; /* The best so far */ ++ char zBuf[28]; /* Space that can be used for storage */ ++}; ++ ++/* ++** Routines to implement min() and max() aggregate functions. ++*/ ++static void minmaxStep(sqlite_func *context, int argc, const char **argv){ ++ MinMaxCtx *p; ++ int (*xCompare)(const char*, const char*); ++ int mask; /* 0 for min() or 0xffffffff for max() */ ++ ++ assert( argc==2 ); ++ if( argv[0]==0 ) return; /* Ignore NULL values */ ++ if( argv[1][0]=='n' ){ ++ xCompare = sqliteCompare; ++ }else{ ++ xCompare = strcmp; ++ } ++ mask = (int)sqlite_user_data(context); ++ assert( mask==0 || mask==-1 ); ++ p = sqlite_aggregate_context(context, sizeof(*p)); ++ if( p==0 || argc<1 ) return; ++ if( p->z==0 || (xCompare(argv[0],p->z)^mask)<0 ){ ++ int len; ++ if( p->zBuf[0] ){ ++ sqliteFree(p->z); ++ } ++ len = strlen(argv[0]); ++ if( len < sizeof(p->zBuf)-1 ){ ++ p->z = &p->zBuf[1]; ++ p->zBuf[0] = 0; ++ }else{ ++ p->z = sqliteMalloc( len+1 ); ++ p->zBuf[0] = 1; ++ if( p->z==0 ) return; ++ } ++ strcpy(p->z, argv[0]); ++ } ++} ++static void minMaxFinalize(sqlite_func *context){ ++ MinMaxCtx *p; ++ p = sqlite_aggregate_context(context, sizeof(*p)); ++ if( p && p->z && p->zBuf[0]<2 ){ ++ sqlite_set_result_string(context, p->z, strlen(p->z)); ++ } ++ if( p && p->zBuf[0] ){ ++ sqliteFree(p->z); ++ } ++} ++ ++/* ++** This function registered all of the above C functions as SQL ++** functions. This should be the only routine in this file with ++** external linkage. ++*/ ++void sqliteRegisterBuiltinFunctions(sqlite *db){ ++ static struct { ++ char *zName; ++ signed char nArg; ++ signed char dataType; ++ u8 argType; /* 0: none. 1: db 2: (-1) */ ++ void (*xFunc)(sqlite_func*,int,const char**); ++ } aFuncs[] = { ++ { "min", -1, SQLITE_ARGS, 0, minmaxFunc }, ++ { "min", 0, 0, 0, 0 }, ++ { "max", -1, SQLITE_ARGS, 2, minmaxFunc }, ++ { "max", 0, 0, 2, 0 }, ++ { "typeof", 1, SQLITE_TEXT, 0, typeofFunc }, ++ { "length", 1, SQLITE_NUMERIC, 0, lengthFunc }, ++ { "substr", 3, SQLITE_TEXT, 0, substrFunc }, ++ { "abs", 1, SQLITE_NUMERIC, 0, absFunc }, ++ { "round", 1, SQLITE_NUMERIC, 0, roundFunc }, ++ { "round", 2, SQLITE_NUMERIC, 0, roundFunc }, ++ { "upper", 1, SQLITE_TEXT, 0, upperFunc }, ++ { "lower", 1, SQLITE_TEXT, 0, lowerFunc }, ++ { "coalesce", -1, SQLITE_ARGS, 0, ifnullFunc }, ++ { "coalesce", 0, 0, 0, 0 }, ++ { "coalesce", 1, 0, 0, 0 }, ++ { "ifnull", 2, SQLITE_ARGS, 0, ifnullFunc }, ++ { "random", -1, SQLITE_NUMERIC, 0, randomFunc }, ++ { "like", 2, SQLITE_NUMERIC, 0, likeFunc }, ++ { "glob", 2, SQLITE_NUMERIC, 0, globFunc }, ++ { "nullif", 2, SQLITE_ARGS, 0, nullifFunc }, ++ { "sqlite_version",0,SQLITE_TEXT, 0, versionFunc}, ++ { "quote", 1, SQLITE_ARGS, 0, quoteFunc }, ++ { "last_insert_rowid", 0, SQLITE_NUMERIC, 1, last_insert_rowid }, ++ { "change_count", 0, SQLITE_NUMERIC, 1, change_count }, ++ { "last_statement_change_count", ++ 0, SQLITE_NUMERIC, 1, last_statement_change_count }, ++#ifdef SQLITE_SOUNDEX ++ { "soundex", 1, SQLITE_TEXT, 0, soundexFunc}, ++#endif ++#ifdef SQLITE_TEST ++ { "randstr", 2, SQLITE_TEXT, 0, randStr }, ++#endif ++ }; ++ static struct { ++ char *zName; ++ signed char nArg; ++ signed char dataType; ++ u8 argType; ++ void (*xStep)(sqlite_func*,int,const char**); ++ void (*xFinalize)(sqlite_func*); ++ } aAggs[] = { ++ { "min", 1, 0, 0, minmaxStep, minMaxFinalize }, ++ { "max", 1, 0, 2, minmaxStep, minMaxFinalize }, ++ { "sum", 1, SQLITE_NUMERIC, 0, sumStep, sumFinalize }, ++ { "avg", 1, SQLITE_NUMERIC, 0, sumStep, avgFinalize }, ++ { "count", 0, SQLITE_NUMERIC, 0, countStep, countFinalize }, ++ { "count", 1, SQLITE_NUMERIC, 0, countStep, countFinalize }, ++#if 0 ++ { "stddev", 1, SQLITE_NUMERIC, 0, stdDevStep, stdDevFinalize }, ++#endif ++ }; ++ static const char *azTypeFuncs[] = { "min", "max", "typeof" }; ++ int i; ++ ++ for(i=0; iaFunc, azTypeFuncs[i], n); ++ while( p ){ ++ p->includeTypes = 1; ++ p = p->pNext; ++ } ++ } ++ sqliteRegisterDateTimeFunctions(db); ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/hash.c +@@ -0,0 +1,356 @@ ++/* ++** 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. ++** ++** $Id$ ++*/ ++#include "sqliteInt.h" ++#include ++ ++/* Turn bulk memory into a hash table object by initializing the ++** fields of the Hash structure. ++** ++** "new" is a pointer to the hash table that is to be initialized. ++** keyClass is one of the constants SQLITE_HASH_INT, SQLITE_HASH_POINTER, ++** SQLITE_HASH_BINARY, or SQLITE_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. CopyKey only makes ++** sense for SQLITE_HASH_STRING and SQLITE_HASH_BINARY and is ignored ++** for other key classes. ++*/ ++void sqliteHashInit(Hash *new, int keyClass, int copyKey){ ++ assert( new!=0 ); ++ assert( keyClass>=SQLITE_HASH_INT && keyClass<=SQLITE_HASH_BINARY ); ++ new->keyClass = keyClass; ++ new->copyKey = copyKey && ++ (keyClass==SQLITE_HASH_STRING || keyClass==SQLITE_HASH_BINARY); ++ new->first = 0; ++ new->count = 0; ++ new->htsize = 0; ++ new->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. ++*/ ++void sqliteHashClear(Hash *pH){ ++ HashElem *elem; /* For looping over all elements of the table */ ++ ++ assert( pH!=0 ); ++ elem = pH->first; ++ pH->first = 0; ++ if( pH->ht ) sqliteFree(pH->ht); ++ pH->ht = 0; ++ pH->htsize = 0; ++ while( elem ){ ++ HashElem *next_elem = elem->next; ++ if( pH->copyKey && elem->pKey ){ ++ sqliteFree(elem->pKey); ++ } ++ sqliteFree(elem); ++ elem = next_elem; ++ } ++ pH->count = 0; ++} ++ ++/* ++** Hash and comparison functions when the mode is SQLITE_HASH_INT ++*/ ++static int intHash(const void *pKey, int nKey){ ++ return nKey ^ (nKey<<8) ^ (nKey>>8); ++} ++static int intCompare(const void *pKey1, int n1, const void *pKey2, int n2){ ++ return n2 - n1; ++} ++ ++#if 0 /* NOT USED */ ++/* ++** Hash and comparison functions when the mode is SQLITE_HASH_POINTER ++*/ ++static int ptrHash(const void *pKey, int nKey){ ++ uptr x = Addr(pKey); ++ return x ^ (x<<8) ^ (x>>8); ++} ++static int ptrCompare(const void *pKey1, int n1, const void *pKey2, int n2){ ++ if( pKey1==pKey2 ) return 0; ++ if( pKey1 0 ){ ++ h = (h<<3) ^ h ^ *(z++); ++ } ++ return h & 0x7fffffff; ++} ++static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){ ++ if( n1!=n2 ) return n2-n1; ++ 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 "hashFunction". The function takes a ++** single parameter "keyClass". The return value of hashFunction() ++** is a pointer to another function. Specifically, the return value ++** of hashFunction() is a pointer to a function that takes two parameters ++** with types "const void*" and "int" and returns an "int". ++*/ ++static int (*hashFunction(int keyClass))(const void*,int){ ++ switch( keyClass ){ ++ case SQLITE_HASH_INT: return &intHash; ++ /* case SQLITE_HASH_POINTER: return &ptrHash; // NOT USED */ ++ case SQLITE_HASH_STRING: return &strHash; ++ case SQLITE_HASH_BINARY: return &binHash;; ++ default: break; ++ } ++ return 0; ++} ++ ++/* ++** 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 (*compareFunction(int keyClass))(const void*,int,const void*,int){ ++ switch( keyClass ){ ++ case SQLITE_HASH_INT: return &intCompare; ++ /* case SQLITE_HASH_POINTER: return &ptrCompare; // NOT USED */ ++ case SQLITE_HASH_STRING: return &strCompare; ++ case SQLITE_HASH_BINARY: return &binCompare; ++ default: break; ++ } ++ return 0; ++} ++ ++ ++/* 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. ++*/ ++static void rehash(Hash *pH, int new_size){ ++ struct _ht *new_ht; /* The new hash table */ ++ HashElem *elem, *next_elem; /* For looping over existing elements */ ++ HashElem *x; /* Element being copied to new hash table */ ++ int (*xHash)(const void*,int); /* The hash function */ ++ ++ assert( (new_size & (new_size-1))==0 ); ++ new_ht = (struct _ht *)sqliteMalloc( new_size*sizeof(struct _ht) ); ++ if( new_ht==0 ) return; ++ if( pH->ht ) sqliteFree(pH->ht); ++ pH->ht = new_ht; ++ pH->htsize = new_size; ++ xHash = hashFunction(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; ++ x = new_ht[h].chain; ++ if( x ){ ++ elem->next = x; ++ elem->prev = x->prev; ++ if( x->prev ) x->prev->next = elem; ++ else pH->first = elem; ++ x->prev = elem; ++ }else{ ++ elem->next = pH->first; ++ if( pH->first ) pH->first->prev = elem; ++ elem->prev = 0; ++ pH->first = elem; ++ } ++ new_ht[h].chain = elem; ++ new_ht[h].count++; ++ } ++} ++ ++/* 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 HashElem *findElementGivenHash( ++ const Hash *pH, /* The pH to be searched */ ++ const void *pKey, /* The key we are searching for */ ++ int nKey, ++ int h /* The hash for this key. */ ++){ ++ HashElem *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 ){ ++ elem = pH->ht[h].chain; ++ count = pH->ht[h].count; ++ xCompare = compareFunction(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 removeElementGivenHash( ++ Hash *pH, /* The pH containing "elem" */ ++ HashElem* elem, /* The element to be removed from the pH */ ++ int h /* Hash value for the element */ ++){ ++ if( elem->prev ){ ++ elem->prev->next = elem->next; ++ }else{ ++ pH->first = elem->next; ++ } ++ if( elem->next ){ ++ elem->next->prev = elem->prev; ++ } ++ if( pH->ht[h].chain==elem ){ ++ pH->ht[h].chain = elem->next; ++ } ++ pH->ht[h].count--; ++ if( pH->ht[h].count<=0 ){ ++ pH->ht[h].chain = 0; ++ } ++ if( pH->copyKey && elem->pKey ){ ++ sqliteFree(elem->pKey); ++ } ++ sqliteFree( elem ); ++ pH->count--; ++} ++ ++/* 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. ++*/ ++void *sqliteHashFind(const Hash *pH, const void *pKey, int nKey){ ++ int h; /* A hash on key */ ++ HashElem *elem; /* The element that matches key */ ++ int (*xHash)(const void*,int); /* The hash function */ ++ ++ if( pH==0 || pH->ht==0 ) return 0; ++ xHash = hashFunction(pH->keyClass); ++ assert( xHash!=0 ); ++ h = (*xHash)(pKey,nKey); ++ assert( (pH->htsize & (pH->htsize-1))==0 ); ++ elem = findElementGivenHash(pH,pKey,nKey, h & (pH->htsize-1)); ++ return elem ? elem->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. ++*/ ++void *sqliteHashInsert(Hash *pH, const void *pKey, int nKey, void *data){ ++ int hraw; /* Raw hash value of the key */ ++ 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 */ ++ int (*xHash)(const void*,int); /* The hash function */ ++ ++ assert( pH!=0 ); ++ xHash = hashFunction(pH->keyClass); ++ assert( xHash!=0 ); ++ hraw = (*xHash)(pKey, nKey); ++ assert( (pH->htsize & (pH->htsize-1))==0 ); ++ h = hraw & (pH->htsize-1); ++ elem = findElementGivenHash(pH,pKey,nKey,h); ++ if( elem ){ ++ void *old_data = elem->data; ++ if( data==0 ){ ++ removeElementGivenHash(pH,elem,h); ++ }else{ ++ elem->data = data; ++ } ++ return old_data; ++ } ++ if( data==0 ) return 0; ++ new_elem = (HashElem*)sqliteMalloc( sizeof(HashElem) ); ++ if( new_elem==0 ) return data; ++ if( pH->copyKey && pKey!=0 ){ ++ new_elem->pKey = sqliteMallocRaw( nKey ); ++ if( new_elem->pKey==0 ){ ++ sqliteFree(new_elem); ++ return data; ++ } ++ memcpy((void*)new_elem->pKey, pKey, nKey); ++ }else{ ++ new_elem->pKey = (void*)pKey; ++ } ++ new_elem->nKey = nKey; ++ pH->count++; ++ if( pH->htsize==0 ) rehash(pH,8); ++ if( pH->htsize==0 ){ ++ pH->count = 0; ++ sqliteFree(new_elem); ++ return data; ++ } ++ if( pH->count > pH->htsize ){ ++ rehash(pH,pH->htsize*2); ++ } ++ assert( (pH->htsize & (pH->htsize-1))==0 ); ++ h = hraw & (pH->htsize-1); ++ elem = pH->ht[h].chain; ++ if( elem ){ ++ new_elem->next = elem; ++ new_elem->prev = elem->prev; ++ if( elem->prev ){ elem->prev->next = new_elem; } ++ else { pH->first = new_elem; } ++ elem->prev = new_elem; ++ }else{ ++ new_elem->next = pH->first; ++ new_elem->prev = 0; ++ if( pH->first ){ pH->first->prev = new_elem; } ++ pH->first = new_elem; ++ } ++ pH->ht[h].count++; ++ pH->ht[h].chain = new_elem; ++ new_elem->data = data; ++ return 0; ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/hash.h +@@ -0,0 +1,109 @@ ++/* ++** 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 implemenation ++** used in SQLite. ++** ++** $Id$ ++*/ ++#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, 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 Hash { ++ char keyClass; /* SQLITE_HASH_INT, _POINTER, _STRING, _BINARY */ ++ char copyKey; /* True if copy of key made on insert */ ++ int count; /* Number of entries in this table */ ++ HashElem *first; /* The first element of the array */ ++ int htsize; /* Number of buckets in the hash table */ ++ 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 */ ++ void *pKey; int nKey; /* Key associated with this element */ ++}; ++ ++/* ++** There are 4 different modes of operation for a hash table: ++** ++** SQLITE_HASH_INT nKey is used as the key and pKey is ignored. ++** ++** SQLITE_HASH_POINTER pKey is used as the key and nKey is ignored. ++** ++** SQLITE_HASH_STRING pKey points to a string that is nKey bytes long ++** (including the null-terminator, if any). Case ++** is ignored in comparisons. ++** ++** SQLITE_HASH_BINARY pKey points to binary data nKey bytes long. ++** memcmp() is used to compare keys. ++** ++** A copy of the key is made for SQLITE_HASH_STRING and SQLITE_HASH_BINARY ++** if the copyKey parameter to HashInit is 1. ++*/ ++#define SQLITE_HASH_INT 1 ++/* #define SQLITE_HASH_POINTER 2 // NOT USED */ ++#define SQLITE_HASH_STRING 3 ++#define SQLITE_HASH_BINARY 4 ++ ++/* ++** Access routines. To delete, insert a NULL pointer. ++*/ ++void sqliteHashInit(Hash*, int keytype, int copyKey); ++void *sqliteHashInsert(Hash*, const void *pKey, int nKey, void *pData); ++void *sqliteHashFind(const Hash*, const void *pKey, int nKey); ++void sqliteHashClear(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) ++#define sqliteHashKeysize(E) ((E)->nKey) ++ ++/* ++** Number of entries in a hash table ++*/ ++#define sqliteHashCount(H) ((H)->count) ++ ++#endif /* _SQLITE_HASH_H_ */ +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/insert.c +@@ -0,0 +1,919 @@ ++/* ++** 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. ++** ++** $Id$ ++*/ ++#include "sqliteInt.h" ++ ++/* ++** This routine is call to handle SQL of the following forms: ++** ++** insert into TABLE (IDLIST) values(EXPRLIST) ++** insert into TABLE (IDLIST) select ++** ++** The IDLIST following the table name is always optional. If omitted, ++** then a list of all columns for the table is substituted. The IDLIST ++** appears in the pColumn parameter. pColumn is NULL if IDLIST is omitted. ++** ++** The pList parameter holds EXPRLIST in the first form of the INSERT ++** statement above, and pSelect is NULL. For the second form, pList is ++** NULL and pSelect is a pointer to the select statement used to generate ++** data for the insert. ++** ++** The code generated follows one of three templates. For a simple ++** select with data coming from a VALUES clause, the code executes ++** once straight down through. The template looks like this: ++** ++** open write cursor to and its indices ++** puts VALUES clause expressions onto the stack ++** write the resulting record into
++** cleanup ++** ++** If the statement is of the form ++** ++** INSERT INTO
SELECT ... ++** ++** And the SELECT clause does not read from
at any time, then ++** the generated code follows this template: ++** ++** goto B ++** A: setup for the SELECT ++** loop over the tables in the SELECT ++** gosub C ++** end loop ++** cleanup after the SELECT ++** goto D ++** B: open write cursor to
and its indices ++** goto A ++** C: insert the select result into
++** return ++** D: cleanup ++** ++** The third 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 a intermediate table to store the results of ++** the select. The template is like this: ++** ++** goto B ++** A: setup for the SELECT ++** loop over the tables in the SELECT ++** gosub C ++** end loop ++** cleanup after the SELECT ++** goto D ++** C: insert the select result into the intermediate table ++** return ++** B: open a cursor to an intermediate table ++** goto A ++** D: open write cursor to
and its indices ++** loop over the intermediate table ++** transfer values form intermediate table into
++** end the loop ++** cleanup ++*/ ++void sqliteInsert( ++ Parse *pParse, /* Parser context */ ++ SrcList *pTabList, /* Name of table into which we are inserting */ ++ ExprList *pList, /* List of values to be inserted */ ++ 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 */ ++){ ++ Table *pTab; /* The table to insert into */ ++ 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 base; /* VDBE Cursor number for pTab */ ++ int iCont, iBreak; /* Beginning and end of the loop over srcTab */ ++ sqlite *db; /* The main database structure */ ++ int keyColumn = -1; /* Column that is the INTEGER PRIMARY KEY */ ++ int endOfLoop; /* Label for the end of the insertion loop */ ++ int useTempTable; /* Store SELECT results in intermediate table */ ++ int srcTab; /* Data comes from this temporary cursor if >=0 */ ++ int iSelectLoop; /* Address of code that implements the SELECT */ ++ int iCleanup; /* Address of the cleanup code */ ++ int iInsertBlock; /* Address of the subroutine used to insert data */ ++ int iCntMem; /* Memory cell used for the row counter */ ++ int isView; /* True if attempting to insert into a view */ ++ ++ int row_triggers_exist = 0; /* True if there are FOR EACH ROW triggers */ ++ int before_triggers; /* True if there are BEFORE triggers */ ++ int after_triggers; /* True if there are AFTER triggers */ ++ int newIdx = -1; /* Cursor for the NEW table */ ++ ++ if( pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup; ++ db = pParse->db; ++ ++ /* Locate the table into which we will be inserting new information. ++ */ ++ assert( pTabList->nSrc==1 ); ++ zTab = pTabList->a[0].zName; ++ if( zTab==0 ) goto insert_cleanup; ++ pTab = sqliteSrcListLookup(pParse, pTabList); ++ if( pTab==0 ){ ++ goto insert_cleanup; ++ } ++ assert( pTab->iDbnDb ); ++ zDb = db->aDb[pTab->iDb].zName; ++ if( sqliteAuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){ ++ goto insert_cleanup; ++ } ++ ++ /* Ensure that: ++ * (a) the table is not read-only, ++ * (b) that if it is a view then ON INSERT triggers exist ++ */ ++ before_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, TK_INSERT, ++ TK_BEFORE, TK_ROW, 0); ++ after_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, TK_INSERT, ++ TK_AFTER, TK_ROW, 0); ++ row_triggers_exist = before_triggers || after_triggers; ++ isView = pTab->pSelect!=0; ++ if( sqliteIsReadOnly(pParse, pTab, before_triggers) ){ ++ goto insert_cleanup; ++ } ++ if( pTab==0 ) goto insert_cleanup; ++ ++ /* If pTab is really a view, make sure it has been initialized. ++ */ ++ if( isView && sqliteViewGetColumnNames(pParse, pTab) ){ ++ goto insert_cleanup; ++ } ++ ++ /* Allocate a VDBE ++ */ ++ v = sqliteGetVdbe(pParse); ++ if( v==0 ) goto insert_cleanup; ++ sqliteBeginWriteOperation(pParse, pSelect || row_triggers_exist, pTab->iDb); ++ ++ /* if there are row triggers, allocate a temp table for new.* references. */ ++ if( row_triggers_exist ){ ++ newIdx = pParse->nTab++; ++ } ++ ++ /* Figure out how many columns of data are supplied. If the data ++ ** is coming from a SELECT statement, then this step also generates ++ ** all the code to implement the SELECT statement and invoke a subroutine ++ ** to process each row of the result. (Template 2.) If the SELECT ++ ** statement uses the the table that is being inserted into, then the ++ ** subroutine is also coded here. That subroutine stores the SELECT ++ ** results in a temporary table. (Template 3.) ++ */ ++ if( pSelect ){ ++ /* Data is coming from a SELECT. Generate code to implement that SELECT ++ */ ++ int rc, iInitCode; ++ iInitCode = sqliteVdbeAddOp(v, OP_Goto, 0, 0); ++ iSelectLoop = sqliteVdbeCurrentAddr(v); ++ iInsertBlock = sqliteVdbeMakeLabel(v); ++ rc = sqliteSelect(pParse, pSelect, SRT_Subroutine, iInsertBlock, 0,0,0); ++ if( rc || pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup; ++ iCleanup = sqliteVdbeMakeLabel(v); ++ sqliteVdbeAddOp(v, OP_Goto, 0, iCleanup); ++ 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. Set to FALSE if each ++ ** row of the SELECT can be written directly into the result table. ++ ** ++ ** 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( row_triggers_exist ){ ++ useTempTable = 1; ++ }else{ ++ int addr = sqliteVdbeFindOp(v, OP_OpenRead, pTab->tnum); ++ useTempTable = 0; ++ if( addr>0 ){ ++ VdbeOp *pOp = sqliteVdbeGetOp(v, addr-2); ++ if( pOp->opcode==OP_Integer && pOp->p1==pTab->iDb ){ ++ useTempTable = 1; ++ } ++ } ++ } ++ ++ if( useTempTable ){ ++ /* Generate the subroutine that SELECT calls to process each row of ++ ** the result. Store the result in a temporary table ++ */ ++ srcTab = pParse->nTab++; ++ sqliteVdbeResolveLabel(v, iInsertBlock); ++ sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, 0); ++ sqliteVdbeAddOp(v, OP_NewRecno, srcTab, 0); ++ sqliteVdbeAddOp(v, OP_Pull, 1, 0); ++ sqliteVdbeAddOp(v, OP_PutIntKey, srcTab, 0); ++ sqliteVdbeAddOp(v, OP_Return, 0, 0); ++ ++ /* The following code runs first because the GOTO at the very top ++ ** of the program jumps to it. Create the temporary table, then jump ++ ** back up and execute the SELECT code above. ++ */ ++ sqliteVdbeChangeP2(v, iInitCode, sqliteVdbeCurrentAddr(v)); ++ sqliteVdbeAddOp(v, OP_OpenTemp, srcTab, 0); ++ sqliteVdbeAddOp(v, OP_Goto, 0, iSelectLoop); ++ sqliteVdbeResolveLabel(v, iCleanup); ++ }else{ ++ sqliteVdbeChangeP2(v, iInitCode, sqliteVdbeCurrentAddr(v)); ++ } ++ }else{ ++ /* This is the case if the data for the INSERT is coming from a VALUES ++ ** clause ++ */ ++ SrcList dummy; ++ assert( pList!=0 ); ++ srcTab = -1; ++ useTempTable = 0; ++ assert( pList ); ++ nColumn = pList->nExpr; ++ dummy.nSrc = 0; ++ for(i=0; ia[i].pExpr) ){ ++ goto insert_cleanup; ++ } ++ if( sqliteExprCheck(pParse, pList->a[i].pExpr, 0, 0) ){ ++ goto insert_cleanup; ++ } ++ } ++ } ++ ++ /* Make sure the number of columns in the source data matches the number ++ ** of columns to be inserted into the table. ++ */ ++ if( pColumn==0 && nColumn!=pTab->nCol ){ ++ sqliteErrorMsg(pParse, ++ "table %S has %d columns but %d values were supplied", ++ pTabList, 0, pTab->nCol, nColumn); ++ goto insert_cleanup; ++ } ++ if( pColumn!=0 && nColumn!=pColumn->nId ){ ++ sqliteErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId); ++ goto insert_cleanup; ++ } ++ ++ /* 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 keyColumn variable ++ ** the index into IDLIST of the primary key column. keyColumn is ++ ** the index of the primary key as it appears in IDLIST, not as ++ ** is appears in the original table. (The index of the primary ++ ** key in the original table is pTab->iPKey.) ++ */ ++ if( pColumn ){ ++ for(i=0; inId; i++){ ++ pColumn->a[i].idx = -1; ++ } ++ for(i=0; inId; i++){ ++ for(j=0; jnCol; j++){ ++ if( sqliteStrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){ ++ pColumn->a[i].idx = j; ++ if( j==pTab->iPKey ){ ++ keyColumn = i; ++ } ++ break; ++ } ++ } ++ if( j>=pTab->nCol ){ ++ if( sqliteIsRowid(pColumn->a[i].zName) ){ ++ keyColumn = i; ++ }else{ ++ sqliteErrorMsg(pParse, "table %S has no column named %s", ++ pTabList, 0, pColumn->a[i].zName); ++ pParse->nErr++; ++ goto insert_cleanup; ++ } ++ } ++ } ++ } ++ ++ /* If there is no IDLIST term but the table has an integer primary ++ ** key, the set the keyColumn variable to the primary key column index ++ ** in the original table definition. ++ */ ++ if( pColumn==0 ){ ++ keyColumn = pTab->iPKey; ++ } ++ ++ /* Open the temp table for FOR EACH ROW triggers ++ */ ++ if( row_triggers_exist ){ ++ sqliteVdbeAddOp(v, OP_OpenPseudo, newIdx, 0); ++ } ++ ++ /* Initialize the count of rows to be inserted ++ */ ++ if( db->flags & SQLITE_CountRows ){ ++ iCntMem = pParse->nMem++; ++ sqliteVdbeAddOp(v, OP_Integer, 0, 0); ++ sqliteVdbeAddOp(v, OP_MemStore, iCntMem, 1); ++ } ++ ++ /* Open tables and indices if there are no row triggers */ ++ if( !row_triggers_exist ){ ++ base = pParse->nTab; ++ idx = sqliteOpenTableAndIndices(pParse, pTab, base); ++ pParse->nTab += idx; ++ } ++ ++ /* If the data source is a temporary table, then we have to create ++ ** a loop because there might be multiple rows of data. If the data ++ ** source is a subroutine call from the SELECT statement, then we need ++ ** to launch the SELECT statement processing. ++ */ ++ if( useTempTable ){ ++ iBreak = sqliteVdbeMakeLabel(v); ++ sqliteVdbeAddOp(v, OP_Rewind, srcTab, iBreak); ++ iCont = sqliteVdbeCurrentAddr(v); ++ }else if( pSelect ){ ++ sqliteVdbeAddOp(v, OP_Goto, 0, iSelectLoop); ++ sqliteVdbeResolveLabel(v, iInsertBlock); ++ } ++ ++ /* Run the BEFORE and INSTEAD OF triggers, if there are any ++ */ ++ endOfLoop = sqliteVdbeMakeLabel(v); ++ if( before_triggers ){ ++ ++ /* 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( keyColumn<0 ){ ++ sqliteVdbeAddOp(v, OP_Integer, -1, 0); ++ }else if( useTempTable ){ ++ sqliteVdbeAddOp(v, OP_Column, srcTab, keyColumn); ++ }else if( pSelect ){ ++ sqliteVdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1); ++ }else{ ++ sqliteExprCode(pParse, pList->a[keyColumn].pExpr); ++ sqliteVdbeAddOp(v, OP_NotNull, -1, sqliteVdbeCurrentAddr(v)+3); ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ sqliteVdbeAddOp(v, OP_Integer, -1, 0); ++ sqliteVdbeAddOp(v, OP_MustBeInt, 0, 0); ++ } ++ ++ /* 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( pColumn && j>=pColumn->nId ){ ++ sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zDflt, P3_STATIC); ++ }else if( useTempTable ){ ++ sqliteVdbeAddOp(v, OP_Column, srcTab, j); ++ }else if( pSelect ){ ++ sqliteVdbeAddOp(v, OP_Dup, nColumn-j-1, 1); ++ }else{ ++ sqliteExprCode(pParse, pList->a[j].pExpr); ++ } ++ } ++ sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); ++ sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0); ++ ++ /* Fire BEFORE or INSTEAD OF triggers */ ++ if( sqliteCodeRowTrigger(pParse, TK_INSERT, 0, TK_BEFORE, pTab, ++ newIdx, -1, onError, endOfLoop) ){ ++ goto insert_cleanup; ++ } ++ } ++ ++ /* If any triggers exists, the opening of tables and indices is deferred ++ ** until now. ++ */ ++ if( row_triggers_exist && !isView ){ ++ base = pParse->nTab; ++ idx = sqliteOpenTableAndIndices(pParse, pTab, base); ++ pParse->nTab += idx; ++ } ++ ++ /* Push the record number for the new entry onto the stack. The ++ ** record number is a randomly generate integer created by NewRecno ++ ** except when the table has an INTEGER PRIMARY KEY column, in which ++ ** case the record number is the same as that column. ++ */ ++ if( !isView ){ ++ if( keyColumn>=0 ){ ++ if( useTempTable ){ ++ sqliteVdbeAddOp(v, OP_Column, srcTab, keyColumn); ++ }else if( pSelect ){ ++ sqliteVdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1); ++ }else{ ++ sqliteExprCode(pParse, pList->a[keyColumn].pExpr); ++ } ++ /* If the PRIMARY KEY expression is NULL, then use OP_NewRecno ++ ** to generate a unique primary key value. ++ */ ++ sqliteVdbeAddOp(v, OP_NotNull, -1, sqliteVdbeCurrentAddr(v)+3); ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ sqliteVdbeAddOp(v, OP_NewRecno, base, 0); ++ sqliteVdbeAddOp(v, OP_MustBeInt, 0, 0); ++ }else{ ++ sqliteVdbeAddOp(v, OP_NewRecno, base, 0); ++ } ++ ++ /* Push onto the stack, data for all columns of the new entry, beginning ++ ** with the first column. ++ */ ++ for(i=0; inCol; i++){ ++ if( i==pTab->iPKey ){ ++ /* The value of the INTEGER PRIMARY KEY column is always a NULL. ++ ** Whenever this column is read, the record number will be substituted ++ ** in its place. So will fill this column with a NULL to avoid ++ ** taking up data space with information that will never be used. */ ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ continue; ++ } ++ if( pColumn==0 ){ ++ j = i; ++ }else{ ++ for(j=0; jnId; j++){ ++ if( pColumn->a[j].idx==i ) break; ++ } ++ } ++ if( pColumn && j>=pColumn->nId ){ ++ sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zDflt, P3_STATIC); ++ }else if( useTempTable ){ ++ sqliteVdbeAddOp(v, OP_Column, srcTab, j); ++ }else if( pSelect ){ ++ sqliteVdbeAddOp(v, OP_Dup, i+nColumn-j, 1); ++ }else{ ++ sqliteExprCode(pParse, pList->a[j].pExpr); ++ } ++ } ++ ++ /* Generate code to check constraints and generate index keys and ++ ** do the insertion. ++ */ ++ sqliteGenerateConstraintChecks(pParse, pTab, base, 0, keyColumn>=0, ++ 0, onError, endOfLoop); ++ sqliteCompleteInsertion(pParse, pTab, base, 0,0,0, ++ after_triggers ? newIdx : -1); ++ } ++ ++ /* Update the count of rows that are inserted ++ */ ++ if( (db->flags & SQLITE_CountRows)!=0 ){ ++ sqliteVdbeAddOp(v, OP_MemIncr, iCntMem, 0); ++ } ++ ++ if( row_triggers_exist ){ ++ /* Close all tables opened */ ++ if( !isView ){ ++ sqliteVdbeAddOp(v, OP_Close, base, 0); ++ for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){ ++ sqliteVdbeAddOp(v, OP_Close, idx+base, 0); ++ } ++ } ++ ++ /* Code AFTER triggers */ ++ if( sqliteCodeRowTrigger(pParse, TK_INSERT, 0, TK_AFTER, pTab, newIdx, -1, ++ onError, endOfLoop) ){ ++ goto insert_cleanup; ++ } ++ } ++ ++ /* The bottom of the loop, if the data source is a SELECT statement ++ */ ++ sqliteVdbeResolveLabel(v, endOfLoop); ++ if( useTempTable ){ ++ sqliteVdbeAddOp(v, OP_Next, srcTab, iCont); ++ sqliteVdbeResolveLabel(v, iBreak); ++ sqliteVdbeAddOp(v, OP_Close, srcTab, 0); ++ }else if( pSelect ){ ++ sqliteVdbeAddOp(v, OP_Pop, nColumn, 0); ++ sqliteVdbeAddOp(v, OP_Return, 0, 0); ++ sqliteVdbeResolveLabel(v, iCleanup); ++ } ++ ++ if( !row_triggers_exist ){ ++ /* Close all tables opened */ ++ sqliteVdbeAddOp(v, OP_Close, base, 0); ++ for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){ ++ sqliteVdbeAddOp(v, OP_Close, idx+base, 0); ++ } ++ } ++ ++ sqliteVdbeAddOp(v, OP_SetCounts, 0, 0); ++ sqliteEndWriteOperation(pParse); ++ ++ /* ++ ** Return the number of rows inserted. ++ */ ++ if( db->flags & SQLITE_CountRows ){ ++ sqliteVdbeOp3(v, OP_ColumnName, 0, 1, "rows inserted", P3_STATIC); ++ sqliteVdbeAddOp(v, OP_MemLoad, iCntMem, 0); ++ sqliteVdbeAddOp(v, OP_Callback, 1, 0); ++ } ++ ++insert_cleanup: ++ sqliteSrcListDelete(pTabList); ++ if( pList ) sqliteExprListDelete(pList); ++ if( pSelect ) sqliteSelectDelete(pSelect); ++ sqliteIdListDelete(pColumn); ++} ++ ++/* ++** Generate code to do a constraint check prior to an INSERT or an UPDATE. ++** ++** When this routine is called, the stack contains (from bottom to top) ++** the following values: ++** ++** 1. The recno of the row to be updated before the update. This ++** value is omitted unless we are doing an UPDATE that involves a ++** change to the record number. ++** ++** 2. The recno of the row after the update. ++** ++** 3. The data in the first column of the entry after the update. ++** ++** i. Data from middle columns... ++** ++** N. The data in the last column of the entry after the update. ++** ++** The old recno shown as entry (1) above is omitted unless both isUpdate ++** and recnoChng are 1. isUpdate is true for UPDATEs and false for ++** INSERTs and recnoChng is true if the record number is being changed. ++** ++** The code generated by this routine pushes additional entries onto ++** the stack which are the keys for new index entries for the new record. ++** The order of index keys is the same as the order of the indices on ++** the pTable->pIndex list. A key is only created for index i if ++** aIdxUsed!=0 and aIdxUsed[i]!=0. ++** ++** 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 ++** sqlite_exec() 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 sqlite_exec() to return immediately ++** with SQLITE_CONSTRAINT. ++** ++** any FAIL Sqlite_exec() returns immediately with a ++** return code of SQLITE_CONSTRAINT. The ++** transaction is not rolled back and any ++** prior changes are retained. ++** ++** any IGNORE The record number and data is popped from ++** the stack and there is an immediate jump ++** to label 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. ++** ++** The calling routine must open a read/write cursor for pTab with ++** cursor number "base". All indices of pTab must also have open ++** read/write cursors with cursor number base+i for the i-th cursor. ++** Except, if there is no possibility of a REPLACE action then ++** cursors do not need to be open for indices where aIdxUsed[i]==0. ++** ++** If the isUpdate flag is true, it means that the "base" cursor is ++** initially pointing to an entry that is being updated. The isUpdate ++** flag causes extra code to be generated so that the "base" cursor ++** is still pointing at the same entry after the routine returns. ++** Without the isUpdate flag, the "base" cursor might be moved. ++*/ ++void sqliteGenerateConstraintChecks( ++ Parse *pParse, /* The parser context */ ++ Table *pTab, /* the table into which we are inserting */ ++ int base, /* Index of a read/write cursor pointing at pTab */ ++ char *aIdxUsed, /* Which indices are used. NULL means all are used */ ++ int recnoChng, /* True if the record number will change */ ++ int isUpdate, /* True for UPDATE, False for INSERT */ ++ int overrideError, /* Override onError to this if not OE_Default */ ++ int ignoreDest /* Jump to this label on an OE_Ignore resolution */ ++){ ++ int i; ++ Vdbe *v; ++ int nCol; ++ int onError; ++ int addr; ++ int extra; ++ int iCur; ++ Index *pIdx; ++ int seenReplace = 0; ++ int jumpInst1, jumpInst2; ++ int contAddr; ++ int hasTwoRecnos = (isUpdate && recnoChng); ++ ++ v = sqliteGetVdbe(pParse); ++ assert( v!=0 ); ++ assert( pTab->pSelect==0 ); /* This table is not a VIEW */ ++ nCol = pTab->nCol; ++ ++ /* 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( pParse->db->onError!=OE_Default ){ ++ onError = pParse->db->onError; ++ }else if( onError==OE_Default ){ ++ onError = OE_Abort; ++ } ++ if( onError==OE_Replace && pTab->aCol[i].zDflt==0 ){ ++ onError = OE_Abort; ++ } ++ sqliteVdbeAddOp(v, OP_Dup, nCol-1-i, 1); ++ addr = sqliteVdbeAddOp(v, OP_NotNull, 1, 0); ++ switch( onError ){ ++ case OE_Rollback: ++ case OE_Abort: ++ case OE_Fail: { ++ char *zMsg = 0; ++ sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError); ++ sqliteSetString(&zMsg, pTab->zName, ".", pTab->aCol[i].zName, ++ " may not be NULL", (char*)0); ++ sqliteVdbeChangeP3(v, -1, zMsg, P3_DYNAMIC); ++ break; ++ } ++ case OE_Ignore: { ++ sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0); ++ sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest); ++ break; ++ } ++ case OE_Replace: { ++ sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zDflt, P3_STATIC); ++ sqliteVdbeAddOp(v, OP_Push, nCol-i, 0); ++ break; ++ } ++ default: assert(0); ++ } ++ sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v)); ++ } ++ ++ /* Test all CHECK constraints ++ */ ++ /**** TBD ****/ ++ ++ /* If we have an INTEGER PRIMARY KEY, make sure the primary key ++ ** of the new record does not previously exist. Except, if this ++ ** is an UPDATE and the primary key is not changing, that is OK. ++ */ ++ if( recnoChng ){ ++ onError = pTab->keyConf; ++ if( overrideError!=OE_Default ){ ++ onError = overrideError; ++ }else if( pParse->db->onError!=OE_Default ){ ++ onError = pParse->db->onError; ++ }else if( onError==OE_Default ){ ++ onError = OE_Abort; ++ } ++ ++ if( isUpdate ){ ++ sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1); ++ sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1); ++ jumpInst1 = sqliteVdbeAddOp(v, OP_Eq, 0, 0); ++ } ++ sqliteVdbeAddOp(v, OP_Dup, nCol, 1); ++ jumpInst2 = sqliteVdbeAddOp(v, OP_NotExists, base, 0); ++ switch( onError ){ ++ default: { ++ onError = OE_Abort; ++ /* Fall thru into the next case */ ++ } ++ case OE_Rollback: ++ case OE_Abort: ++ case OE_Fail: { ++ sqliteVdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, ++ "PRIMARY KEY must be unique", P3_STATIC); ++ break; ++ } ++ case OE_Replace: { ++ sqliteGenerateRowIndexDelete(pParse->db, v, pTab, base, 0); ++ if( isUpdate ){ ++ sqliteVdbeAddOp(v, OP_Dup, nCol+hasTwoRecnos, 1); ++ sqliteVdbeAddOp(v, OP_MoveTo, base, 0); ++ } ++ seenReplace = 1; ++ break; ++ } ++ case OE_Ignore: { ++ assert( seenReplace==0 ); ++ sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0); ++ sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest); ++ break; ++ } ++ } ++ contAddr = sqliteVdbeCurrentAddr(v); ++ sqliteVdbeChangeP2(v, jumpInst2, contAddr); ++ if( isUpdate ){ ++ sqliteVdbeChangeP2(v, jumpInst1, contAddr); ++ sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1); ++ sqliteVdbeAddOp(v, OP_MoveTo, base, 0); ++ } ++ } ++ ++ /* Test all UNIQUE constraints by creating entries for each UNIQUE ++ ** index and making sure that duplicate entries do not already exist. ++ ** Add the new records to the indices as we go. ++ */ ++ extra = -1; ++ for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){ ++ if( aIdxUsed && aIdxUsed[iCur]==0 ) continue; /* Skip unused indices */ ++ extra++; ++ ++ /* Create a key for accessing the index entry */ ++ sqliteVdbeAddOp(v, OP_Dup, nCol+extra, 1); ++ for(i=0; inColumn; i++){ ++ int idx = pIdx->aiColumn[i]; ++ if( idx==pTab->iPKey ){ ++ sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol+1, 1); ++ }else{ ++ sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol-idx, 1); ++ } ++ } ++ jumpInst1 = sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0); ++ if( pParse->db->file_format>=4 ) sqliteAddIdxKeyType(v, pIdx); ++ ++ /* Find out what action to take in case there is an indexing conflict */ ++ onError = pIdx->onError; ++ if( onError==OE_None ) continue; /* pIdx is not a UNIQUE index */ ++ if( overrideError!=OE_Default ){ ++ onError = overrideError; ++ }else if( pParse->db->onError!=OE_Default ){ ++ onError = pParse->db->onError; ++ }else if( onError==OE_Default ){ ++ onError = OE_Abort; ++ } ++ if( seenReplace ){ ++ if( onError==OE_Ignore ) onError = OE_Replace; ++ else if( onError==OE_Fail ) onError = OE_Abort; ++ } ++ ++ ++ /* Check to see if the new index entry will be unique */ ++ sqliteVdbeAddOp(v, OP_Dup, extra+nCol+1+hasTwoRecnos, 1); ++ jumpInst2 = sqliteVdbeAddOp(v, OP_IsUnique, base+iCur+1, 0); ++ ++ /* Generate code that executes if the new index entry is not unique */ ++ switch( onError ){ ++ case OE_Rollback: ++ case OE_Abort: ++ case OE_Fail: { ++ int j, n1, n2; ++ char zErrMsg[200]; ++ strcpy(zErrMsg, pIdx->nColumn>1 ? "columns " : "column "); ++ n1 = strlen(zErrMsg); ++ for(j=0; jnColumn && n1aCol[pIdx->aiColumn[j]].zName; ++ n2 = strlen(zCol); ++ if( j>0 ){ ++ strcpy(&zErrMsg[n1], ", "); ++ n1 += 2; ++ } ++ if( n1+n2>sizeof(zErrMsg)-30 ){ ++ strcpy(&zErrMsg[n1], "..."); ++ n1 += 3; ++ break; ++ }else{ ++ strcpy(&zErrMsg[n1], zCol); ++ n1 += n2; ++ } ++ } ++ strcpy(&zErrMsg[n1], ++ pIdx->nColumn>1 ? " are not unique" : " is not unique"); ++ sqliteVdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, zErrMsg, 0); ++ break; ++ } ++ case OE_Ignore: { ++ assert( seenReplace==0 ); ++ sqliteVdbeAddOp(v, OP_Pop, nCol+extra+3+hasTwoRecnos, 0); ++ sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest); ++ break; ++ } ++ case OE_Replace: { ++ sqliteGenerateRowDelete(pParse->db, v, pTab, base, 0); ++ if( isUpdate ){ ++ sqliteVdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRecnos, 1); ++ sqliteVdbeAddOp(v, OP_MoveTo, base, 0); ++ } ++ seenReplace = 1; ++ break; ++ } ++ default: assert(0); ++ } ++ contAddr = sqliteVdbeCurrentAddr(v); ++#if NULL_DISTINCT_FOR_UNIQUE ++ sqliteVdbeChangeP2(v, jumpInst1, contAddr); ++#endif ++ sqliteVdbeChangeP2(v, jumpInst2, contAddr); ++ } ++} ++ ++/* ++** This routine generates code to finish the INSERT or UPDATE operation ++** that was started by a prior call to sqliteGenerateConstraintChecks. ++** The stack must contain keys for all active indices followed by data ++** and the recno for the new entry. This routine creates the new ++** entries in all indices and in the main table. ++** ++** The arguments to this routine should be the same as the first six ++** arguments to sqliteGenerateConstraintChecks. ++*/ ++void sqliteCompleteInsertion( ++ Parse *pParse, /* The parser context */ ++ Table *pTab, /* the table into which we are inserting */ ++ int base, /* Index of a read/write cursor pointing at pTab */ ++ char *aIdxUsed, /* Which indices are used. NULL means all are used */ ++ int recnoChng, /* True if the record number will change */ ++ int isUpdate, /* True for UPDATE, False for INSERT */ ++ int newIdx /* Index of NEW table for triggers. -1 if none */ ++){ ++ int i; ++ Vdbe *v; ++ int nIdx; ++ Index *pIdx; ++ ++ v = sqliteGetVdbe(pParse); ++ assert( v!=0 ); ++ assert( pTab->pSelect==0 ); /* This table is not a VIEW */ ++ for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){} ++ for(i=nIdx-1; i>=0; i--){ ++ if( aIdxUsed && aIdxUsed[i]==0 ) continue; ++ sqliteVdbeAddOp(v, OP_IdxPut, base+i+1, 0); ++ } ++ sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); ++ if( newIdx>=0 ){ ++ sqliteVdbeAddOp(v, OP_Dup, 1, 0); ++ sqliteVdbeAddOp(v, OP_Dup, 1, 0); ++ sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0); ++ } ++ sqliteVdbeAddOp(v, OP_PutIntKey, base, ++ (pParse->trigStack?0:OPFLAG_NCHANGE) | ++ (isUpdate?0:OPFLAG_LASTROWID) | OPFLAG_CSCHANGE); ++ if( isUpdate && recnoChng ){ ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ } ++} ++ ++/* ++** Generate code that will open write cursors for a table and for all ++** indices of that table. The "base" parameter is the cursor number used ++** for the table. Indices are opened on subsequent cursors. ++** ++** Return the total number of cursors opened. This is always at least ++** 1 (for the main table) plus more for each cursor. ++*/ ++int sqliteOpenTableAndIndices(Parse *pParse, Table *pTab, int base){ ++ int i; ++ Index *pIdx; ++ Vdbe *v = sqliteGetVdbe(pParse); ++ assert( v!=0 ); ++ sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); ++ sqliteVdbeOp3(v, OP_OpenWrite, base, pTab->tnum, pTab->zName, P3_STATIC); ++ for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ ++ sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0); ++ sqliteVdbeOp3(v, OP_OpenWrite, i+base, pIdx->tnum, pIdx->zName, P3_STATIC); ++ } ++ return i; ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/libsqlite.dsp +@@ -0,0 +1,353 @@ ++# Microsoft Developer Studio Project File - Name="libsqlite" - Package Owner=<4> ++# Microsoft Developer Studio Generated Build File, Format Version 6.00 ++# ** DO NOT EDIT ** ++ ++# TARGTYPE "Win32 (x86) Static Library" 0x0104 ++ ++CFG=libsqlite - Win32 Debug_TS ++!MESSAGE This is not a valid makefile. To build this project using NMAKE, ++!MESSAGE use the Export Makefile command and run ++!MESSAGE ++!MESSAGE NMAKE /f "libsqlite.mak". ++!MESSAGE ++!MESSAGE You can specify a configuration when running NMAKE ++!MESSAGE by defining the macro CFG on the command line. For example: ++!MESSAGE ++!MESSAGE NMAKE /f "libsqlite.mak" CFG="libsqlite - Win32 Debug_TS" ++!MESSAGE ++!MESSAGE Possible choices for configuration are: ++!MESSAGE ++!MESSAGE "libsqlite - Win32 Debug_TS" (based on "Win32 (x86) Static Library") ++!MESSAGE "libsqlite - Win32 Release_TS" (based on "Win32 (x86) Static Library") ++!MESSAGE "libsqlite - Win32 Release_TSDbg" (based on "Win32 (x86) Static Library") ++!MESSAGE ++ ++# Begin Project ++# PROP AllowPerConfigDependencies 0 ++# PROP Scc_ProjName "" ++# PROP Scc_LocalPath "" ++CPP=cl.exe ++RSC=rc.exe ++ ++!IF "$(CFG)" == "libsqlite - Win32 Debug_TS" ++ ++# PROP BASE Use_MFC 0 ++# PROP BASE Use_Debug_Libraries 1 ++# PROP BASE Output_Dir "Debug_TS" ++# PROP BASE Intermediate_Dir "Debug_TS" ++# PROP BASE Target_Dir "" ++# PROP Use_MFC 0 ++# PROP Use_Debug_Libraries 1 ++# PROP Output_Dir "..\..\Debug_TS" ++# PROP Intermediate_Dir "..\..\Debug_TS" ++# PROP Target_Dir "" ++# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c ++# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D THREADSAFE=1 /YX /FD /GZ /c ++# ADD BASE RSC /l 0x406 /d "_DEBUG" ++# ADD RSC /l 0x406 /d "_DEBUG" ++BSC32=bscmake.exe ++# ADD BASE BSC32 /nologo ++# ADD BSC32 /nologo ++LIB32=link.exe -lib ++# ADD BASE LIB32 /nologo ++# ADD LIB32 /nologo ++ ++!ELSEIF "$(CFG)" == "libsqlite - Win32 Release_TS" ++ ++# PROP BASE Use_MFC 0 ++# PROP BASE Use_Debug_Libraries 0 ++# PROP BASE Output_Dir "Release_TS" ++# PROP BASE Intermediate_Dir "Release_TS" ++# PROP BASE Target_Dir "" ++# PROP Use_MFC 0 ++# PROP Use_Debug_Libraries 0 ++# PROP Output_Dir "..\..\Release_TS" ++# PROP Intermediate_Dir "..\..\Release_TS" ++# PROP Target_Dir "" ++# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c ++# ADD CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /D THREADSAFE=1 /YX /FD /c ++# ADD BASE RSC /l 0x406 /d "NDEBUG" ++# ADD RSC /l 0x406 /d "NDEBUG" ++BSC32=bscmake.exe ++# ADD BASE BSC32 /nologo ++# ADD BSC32 /nologo ++LIB32=link.exe -lib ++# ADD BASE LIB32 /nologo ++# ADD LIB32 /nologo ++ ++!ELSEIF "$(CFG)" == "libsqlite - Win32 Release_TSDbg" ++ ++# PROP BASE Use_MFC 0 ++# PROP BASE Use_Debug_Libraries 0 ++# PROP BASE Output_Dir "libsqlite___Win32_Release_TSDbg" ++# PROP BASE Intermediate_Dir "libsqlite___Win32_Release_TSDbg" ++# PROP BASE Target_Dir "" ++# PROP Use_MFC 0 ++# PROP Use_Debug_Libraries 0 ++# PROP Output_Dir "..\..\Release_TSDbg" ++# PROP Intermediate_Dir "..\..\Release_TSDbg" ++# PROP Target_Dir "" ++# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /D THREADSAFE=1 /YX /FD /c ++# ADD CPP /nologo /MD /W3 /GX /Zi /Od /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /D THREADSAFE=1 /YX /FD /c ++# ADD BASE RSC /l 0x406 /d "NDEBUG" ++# ADD RSC /l 0x406 /d "NDEBUG" ++BSC32=bscmake.exe ++# ADD BASE BSC32 /nologo ++# ADD BSC32 /nologo ++LIB32=link.exe -lib ++# ADD BASE LIB32 /nologo /out:"Release_TS\libsqlite.lib" ++# ADD LIB32 /nologo ++ ++!ENDIF ++ ++# Begin Target ++ ++# Name "libsqlite - Win32 Debug_TS" ++# Name "libsqlite - Win32 Release_TS" ++# Name "libsqlite - Win32 Release_TSDbg" ++# Begin Group "Source Files" ++ ++# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" ++# Begin Source File ++ ++SOURCE=attach.c ++# End Source File ++# Begin Source File ++ ++SOURCE=auth.c ++# End Source File ++# Begin Source File ++ ++SOURCE=btree.c ++# End Source File ++# Begin Source File ++ ++SOURCE=btree_rb.c ++# End Source File ++# Begin Source File ++ ++SOURCE=build.c ++# End Source File ++# Begin Source File ++ ++SOURCE=copy.c ++# End Source File ++# Begin Source File ++ ++SOURCE=.\date.c ++# End Source File ++# Begin Source File ++ ++SOURCE=delete.c ++# End Source File ++# Begin Source File ++ ++SOURCE=encode.c ++# End Source File ++# Begin Source File ++ ++SOURCE=expr.c ++# End Source File ++# Begin Source File ++ ++SOURCE=func.c ++# End Source File ++# Begin Source File ++ ++SOURCE=hash.c ++# End Source File ++# Begin Source File ++ ++SOURCE=insert.c ++# End Source File ++# Begin Source File ++ ++SOURCE=main.c ++# End Source File ++# Begin Source File ++ ++SOURCE=opcodes.c ++# End Source File ++# Begin Source File ++ ++SOURCE=os.c ++# End Source File ++# Begin Source File ++ ++SOURCE=pager.c ++# End Source File ++# Begin Source File ++ ++SOURCE=parse.c ++# End Source File ++# Begin Source File ++ ++SOURCE=pragma.c ++# End Source File ++# Begin Source File ++ ++SOURCE=printf.c ++# End Source File ++# Begin Source File ++ ++SOURCE=random.c ++# End Source File ++# Begin Source File ++ ++SOURCE=select.c ++# End Source File ++# Begin Source File ++ ++SOURCE=table.c ++# End Source File ++# Begin Source File ++ ++SOURCE=tokenize.c ++# End Source File ++# Begin Source File ++ ++SOURCE=trigger.c ++# End Source File ++# Begin Source File ++ ++SOURCE=update.c ++# End Source File ++# Begin Source File ++ ++SOURCE=util.c ++# End Source File ++# Begin Source File ++ ++SOURCE=vacuum.c ++# End Source File ++# Begin Source File ++ ++SOURCE=vdbe.c ++# End Source File ++# Begin Source File ++ ++SOURCE=.\vdbeaux.c ++# End Source File ++# Begin Source File ++ ++SOURCE=where.c ++# End Source File ++# End Group ++# Begin Group "Header Files" ++ ++# PROP Default_Filter "h;hpp;hxx;hm;inl" ++# Begin Source File ++ ++SOURCE=btree.h ++# End Source File ++# Begin Source File ++ ++SOURCE=config_static.w32.h ++ ++!IF "$(CFG)" == "libsqlite - Win32 Debug_TS" ++ ++# Begin Custom Build ++InputDir=. ++InputPath=config_static.w32.h ++ ++"$(InputDir)\config.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" ++ copy $(InputPath) $(InputDir)\config.h ++ ++# End Custom Build ++ ++!ELSEIF "$(CFG)" == "libsqlite - Win32 Release_TS" ++ ++# Begin Custom Build ++InputDir=. ++InputPath=config_static.w32.h ++ ++"$(InputDir)\config.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" ++ copy $(InputPath) $(InputDir)\config.h ++ ++# End Custom Build ++ ++!ELSEIF "$(CFG)" == "libsqlite - Win32 Release_TSDbg" ++ ++# Begin Custom Build ++InputDir=. ++InputPath=config_static.w32.h ++ ++"$(InputDir)\config.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" ++ copy $(InputPath) $(InputDir)\config.h ++ ++# End Custom Build ++ ++!ENDIF ++ ++# End Source File ++# Begin Source File ++ ++SOURCE=hash.h ++# End Source File ++# Begin Source File ++ ++SOURCE=opcodes.h ++# End Source File ++# Begin Source File ++ ++SOURCE=os.h ++# End Source File ++# Begin Source File ++ ++SOURCE=pager.h ++# End Source File ++# Begin Source File ++ ++SOURCE=parse.h ++# End Source File ++# Begin Source File ++ ++SOURCE=sqlite.w32.h ++ ++!IF "$(CFG)" == "libsqlite - Win32 Debug_TS" ++ ++# Begin Custom Build ++InputDir=. ++InputPath=sqlite.w32.h ++ ++"$(InputDir)\sqlite.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" ++ copy $(InputPath) $(InputDir)\sqlite.h ++ ++# End Custom Build ++ ++!ELSEIF "$(CFG)" == "libsqlite - Win32 Release_TS" ++ ++# Begin Custom Build ++InputDir=. ++InputPath=sqlite.w32.h ++ ++"$(InputDir)\sqlite.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" ++ copy $(InputPath) $(InputDir)\sqlite.h ++ ++# End Custom Build ++ ++!ELSEIF "$(CFG)" == "libsqlite - Win32 Release_TSDbg" ++ ++# Begin Custom Build ++InputDir=. ++InputPath=sqlite.w32.h ++ ++"$(InputDir)\sqlite.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" ++ copy $(InputPath) $(InputDir)\sqlite.h ++ ++# End Custom Build ++ ++!ENDIF ++ ++# End Source File ++# Begin Source File ++ ++SOURCE=sqliteInt.h ++# End Source File ++# Begin Source File ++ ++SOURCE=vdbe.h ++# End Source File ++# End Group ++# End Target ++# End Project +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/main.c +@@ -0,0 +1,1143 @@ ++/* ++** 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. ++** ++** $Id$ ++*/ ++#include "sqliteInt.h" ++#include "os.h" ++#include ++ ++/* ++** A pointer to this structure is used to communicate information ++** from sqliteInit into the sqliteInitCallback. ++*/ ++typedef struct { ++ sqlite *db; /* The database being initialized */ ++ char **pzErrMsg; /* Error message stored here */ ++} InitData; ++ ++/* ++** Fill the InitData structure with an error message that indicates ++** that the database is corrupt. ++*/ ++static void corruptSchema(InitData *pData, const char *zExtra){ ++ sqliteSetString(pData->pzErrMsg, "malformed database schema", ++ zExtra!=0 && zExtra[0]!=0 ? " - " : (char*)0, zExtra, (char*)0); ++} ++ ++/* ++** This is the callback routine for the code that initializes the ++** database. See sqliteInit() below for additional information. ++** ++** Each callback contains the following information: ++** ++** argv[0] = "file-format" or "schema-cookie" or "table" or "index" ++** argv[1] = table or index name or meta statement type. ++** argv[2] = root page number for table or index. NULL for meta. ++** argv[3] = SQL text for a CREATE TABLE or CREATE INDEX statement. ++** argv[4] = "1" for temporary files, "0" for main database, "2" or more ++** for auxiliary database files. ++** ++*/ ++static ++int sqliteInitCallback(void *pInit, int argc, char **argv, char **azColName){ ++ InitData *pData = (InitData*)pInit; ++ int nErr = 0; ++ ++ assert( argc==5 ); ++ if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ ++ if( argv[0]==0 ){ ++ corruptSchema(pData, 0); ++ return 1; ++ } ++ switch( argv[0][0] ){ ++ case 'v': ++ case 'i': ++ case 't': { /* CREATE TABLE, CREATE INDEX, or CREATE VIEW statements */ ++ sqlite *db = pData->db; ++ if( argv[2]==0 || argv[4]==0 ){ ++ corruptSchema(pData, 0); ++ return 1; ++ } ++ if( argv[3] && argv[3][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. ++ */ ++ char *zErr; ++ assert( db->init.busy ); ++ db->init.iDb = atoi(argv[4]); ++ assert( db->init.iDb>=0 && db->init.iDbnDb ); ++ db->init.newTnum = atoi(argv[2]); ++ if( sqlite_exec(db, argv[3], 0, 0, &zErr) ){ ++ corruptSchema(pData, zErr); ++ sqlite_freemem(zErr); ++ } ++ db->init.iDb = 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. ++ */ ++ int iDb; ++ Index *pIndex; ++ ++ iDb = atoi(argv[4]); ++ assert( iDb>=0 && iDbnDb ); ++ pIndex = sqliteFindIndex(db, argv[1], db->aDb[iDb].zName); ++ if( pIndex==0 || pIndex->tnum!=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{ ++ pIndex->tnum = atoi(argv[2]); ++ } ++ } ++ break; ++ } ++ default: { ++ /* This can not happen! */ ++ nErr = 1; ++ assert( nErr==0 ); ++ } ++ } ++ return nErr; ++} ++ ++/* ++** This is a callback procedure used to reconstruct a table. The ++** name of the table to be reconstructed is passed in as argv[0]. ++** ++** This routine is used to automatically upgrade a database from ++** format version 1 or 2 to version 3. The correct operation of ++** this routine relys on the fact that no indices are used when ++** copying a table out to a temporary file. ++** ++** The change from version 2 to version 3 occurred between SQLite ++** version 2.5.6 and 2.6.0 on 2002-July-18. ++*/ ++static ++int upgrade_3_callback(void *pInit, int argc, char **argv, char **NotUsed){ ++ InitData *pData = (InitData*)pInit; ++ int rc; ++ Table *pTab; ++ Trigger *pTrig; ++ char *zErr = 0; ++ ++ pTab = sqliteFindTable(pData->db, argv[0], 0); ++ assert( pTab!=0 ); ++ assert( sqliteStrICmp(pTab->zName, argv[0])==0 ); ++ if( pTab ){ ++ pTrig = pTab->pTrigger; ++ pTab->pTrigger = 0; /* Disable all triggers before rebuilding the table */ ++ } ++ rc = sqlite_exec_printf(pData->db, ++ "CREATE TEMP TABLE sqlite_x AS SELECT * FROM '%q'; " ++ "DELETE FROM '%q'; " ++ "INSERT INTO '%q' SELECT * FROM sqlite_x; " ++ "DROP TABLE sqlite_x;", ++ 0, 0, &zErr, argv[0], argv[0], argv[0]); ++ if( zErr ){ ++ if( *pData->pzErrMsg ) sqlite_freemem(*pData->pzErrMsg); ++ *pData->pzErrMsg = zErr; ++ } ++ ++ /* If an error occurred in the SQL above, then the transaction will ++ ** rollback which will delete the internal symbol tables. This will ++ ** cause the structure that pTab points to be deleted. In case that ++ ** happened, we need to refetch pTab. ++ */ ++ pTab = sqliteFindTable(pData->db, argv[0], 0); ++ if( pTab ){ ++ assert( sqliteStrICmp(pTab->zName, argv[0])==0 ); ++ pTab->pTrigger = pTrig; /* Re-enable triggers */ ++ } ++ return rc!=SQLITE_OK; ++} ++ ++ ++ ++/* ++** 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 sqliteInitOne(sqlite *db, int iDb, char **pzErrMsg){ ++ int rc; ++ BtCursor *curMain; ++ int size; ++ Table *pTab; ++ char const *azArg[6]; ++ char zDbNum[30]; ++ int meta[SQLITE_N_BTREE_META]; ++ InitData initData; ++ char const *zMasterSchema; ++ char const *zMasterName; ++ char *zSql = 0; ++ ++ /* ++ ** The master database table has a structure like this ++ */ ++ static char master_schema[] = ++ "CREATE TABLE sqlite_master(\n" ++ " type text,\n" ++ " name text,\n" ++ " tbl_name text,\n" ++ " rootpage integer,\n" ++ " sql text\n" ++ ")" ++ ; ++ static 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" ++ ")" ++ ; ++ ++ assert( iDb>=0 && iDbnDb ); ++ ++ /* zMasterSchema and zInitScript are set to point at the master schema ++ ** and initialisation script appropriate for the database being ++ ** initialised. zMasterName is the name of the master table. ++ */ ++ if( iDb==1 ){ ++ zMasterSchema = temp_master_schema; ++ zMasterName = TEMP_MASTER_NAME; ++ }else{ ++ zMasterSchema = master_schema; ++ zMasterName = MASTER_NAME; ++ } ++ ++ /* Construct the schema table. ++ */ ++ sqliteSafetyOff(db); ++ azArg[0] = "table"; ++ azArg[1] = zMasterName; ++ azArg[2] = "2"; ++ azArg[3] = zMasterSchema; ++ sprintf(zDbNum, "%d", iDb); ++ azArg[4] = zDbNum; ++ azArg[5] = 0; ++ initData.db = db; ++ initData.pzErrMsg = pzErrMsg; ++ sqliteInitCallback(&initData, 5, (char **)azArg, 0); ++ pTab = sqliteFindTable(db, zMasterName, db->aDb[iDb].zName); ++ if( pTab ){ ++ pTab->readOnly = 1; ++ }else{ ++ return SQLITE_NOMEM; ++ } ++ sqliteSafetyOn(db); ++ ++ /* Create a cursor to hold the database open ++ */ ++ if( db->aDb[iDb].pBt==0 ) return SQLITE_OK; ++ rc = sqliteBtreeCursor(db->aDb[iDb].pBt, 2, 0, &curMain); ++ if( rc ){ ++ sqliteSetString(pzErrMsg, sqlite_error_string(rc), (char*)0); ++ return rc; ++ } ++ ++ /* Get the database meta information ++ */ ++ rc = sqliteBtreeGetMeta(db->aDb[iDb].pBt, meta); ++ if( rc ){ ++ sqliteSetString(pzErrMsg, sqlite_error_string(rc), (char*)0); ++ sqliteBtreeCloseCursor(curMain); ++ return rc; ++ } ++ db->aDb[iDb].schema_cookie = meta[1]; ++ if( iDb==0 ){ ++ db->next_cookie = meta[1]; ++ db->file_format = meta[2]; ++ size = meta[3]; ++ if( size==0 ){ size = MAX_PAGES; } ++ db->cache_size = size; ++ db->safety_level = meta[4]; ++ if( meta[6]>0 && meta[6]<=2 && db->temp_store==0 ){ ++ db->temp_store = meta[6]; ++ } ++ if( db->safety_level==0 ) db->safety_level = 2; ++ ++ /* ++ ** file_format==1 Version 2.1.0. ++ ** file_format==2 Version 2.2.0. Add support for INTEGER PRIMARY KEY. ++ ** file_format==3 Version 2.6.0. Fix empty-string index bug. ++ ** file_format==4 Version 2.7.0. Add support for separate numeric and ++ ** text datatypes. ++ */ ++ if( db->file_format==0 ){ ++ /* This happens if the database was initially empty */ ++ db->file_format = 4; ++ }else if( db->file_format>4 ){ ++ sqliteBtreeCloseCursor(curMain); ++ sqliteSetString(pzErrMsg, "unsupported file format", (char*)0); ++ return SQLITE_ERROR; ++ } ++ }else if( iDb!=1 && (db->file_format!=meta[2] || db->file_format<4) ){ ++ assert( db->file_format>=4 ); ++ if( meta[2]==0 ){ ++ sqliteSetString(pzErrMsg, "cannot attach empty database: ", ++ db->aDb[iDb].zName, (char*)0); ++ }else{ ++ sqliteSetString(pzErrMsg, "incompatible file format in auxiliary " ++ "database: ", db->aDb[iDb].zName, (char*)0); ++ } ++ sqliteBtreeClose(db->aDb[iDb].pBt); ++ db->aDb[iDb].pBt = 0; ++ return SQLITE_FORMAT; ++ } ++ sqliteBtreeSetCacheSize(db->aDb[iDb].pBt, db->cache_size); ++ sqliteBtreeSetSafetyLevel(db->aDb[iDb].pBt, meta[4]==0 ? 2 : meta[4]); ++ ++ /* Read the schema information out of the schema tables ++ */ ++ assert( db->init.busy ); ++ sqliteSafetyOff(db); ++ ++ /* The following SQL will read the schema from the master tables. ++ ** The first version works with SQLite file formats 2 or greater. ++ ** The second version is for format 1 files. ++ ** ++ ** Beginning with file format 2, the rowid for new table entries ++ ** (including entries in sqlite_master) is an increasing integer. ++ ** So for file format 2 and later, we can play back sqlite_master ++ ** and all the CREATE statements will appear in the right order. ++ ** But with file format 1, table entries were random and so we ++ ** have to make sure the CREATE TABLEs occur before their corresponding ++ ** CREATE INDEXs. (We don't have to deal with CREATE VIEW or ++ ** CREATE TRIGGER in file format 1 because those constructs did ++ ** not exist then.) ++ */ ++ if( db->file_format>=2 ){ ++ sqliteSetString(&zSql, ++ "SELECT type, name, rootpage, sql, ", zDbNum, " FROM \"", ++ db->aDb[iDb].zName, "\".", zMasterName, (char*)0); ++ }else{ ++ sqliteSetString(&zSql, ++ "SELECT type, name, rootpage, sql, ", zDbNum, " FROM \"", ++ db->aDb[iDb].zName, "\".", zMasterName, ++ " WHERE type IN ('table', 'index')" ++ " ORDER BY CASE type WHEN 'table' THEN 0 ELSE 1 END", (char*)0); ++ } ++ rc = sqlite_exec(db, zSql, sqliteInitCallback, &initData, 0); ++ ++ sqliteFree(zSql); ++ sqliteSafetyOn(db); ++ sqliteBtreeCloseCursor(curMain); ++ if( sqlite_malloc_failed ){ ++ sqliteSetString(pzErrMsg, "out of memory", (char*)0); ++ rc = SQLITE_NOMEM; ++ sqliteResetInternalSchema(db, 0); ++ } ++ if( rc==SQLITE_OK ){ ++ DbSetProperty(db, iDb, DB_SchemaLoaded); ++ }else{ ++ sqliteResetInternalSchema(db, iDb); ++ } ++ 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 the database is initialized, the SQLITE_Initialized ++** bit is set in the flags field of the sqlite structure. An ++** attempt is made to initialize the database as soon as it ++** is opened. If that fails (perhaps because another process ++** has the sqlite_master table locked) than another attempt ++** is made the first time the database is accessed. ++*/ ++int sqliteInit(sqlite *db, char **pzErrMsg){ ++ int i, rc; ++ ++ if( db->init.busy ) return SQLITE_OK; ++ assert( (db->flags & SQLITE_Initialized)==0 ); ++ rc = SQLITE_OK; ++ db->init.busy = 1; ++ for(i=0; rc==SQLITE_OK && inDb; i++){ ++ if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue; ++ rc = sqliteInitOne(db, i, pzErrMsg); ++ if( rc ){ ++ sqliteResetInternalSchema(db, i); ++ } ++ } ++ ++ /* Once all the other databases have been initialised, load the schema ++ ** for the TEMP database. This is loaded last, as the TEMP database ++ ** schema may contain references to objects in other databases. ++ */ ++ if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){ ++ rc = sqliteInitOne(db, 1, pzErrMsg); ++ if( rc ){ ++ sqliteResetInternalSchema(db, 1); ++ } ++ } ++ ++ db->init.busy = 0; ++ if( rc==SQLITE_OK ){ ++ db->flags |= SQLITE_Initialized; ++ sqliteCommitInternalChanges(db); ++ } ++ ++ /* If the database is in formats 1 or 2, then upgrade it to ++ ** version 3. This will reconstruct all indices. If the ++ ** upgrade fails for any reason (ex: out of disk space, database ++ ** is read only, interrupt received, etc.) then fail the init. ++ */ ++ if( rc==SQLITE_OK && db->file_format<3 ){ ++ char *zErr = 0; ++ InitData initData; ++ int meta[SQLITE_N_BTREE_META]; ++ ++ db->magic = SQLITE_MAGIC_OPEN; ++ initData.db = db; ++ initData.pzErrMsg = &zErr; ++ db->file_format = 3; ++ rc = sqlite_exec(db, ++ "BEGIN; SELECT name FROM sqlite_master WHERE type='table';", ++ upgrade_3_callback, ++ &initData, ++ &zErr); ++ if( rc==SQLITE_OK ){ ++ sqliteBtreeGetMeta(db->aDb[0].pBt, meta); ++ meta[2] = 4; ++ sqliteBtreeUpdateMeta(db->aDb[0].pBt, meta); ++ sqlite_exec(db, "COMMIT", 0, 0, 0); ++ } ++ if( rc!=SQLITE_OK ){ ++ sqliteSetString(pzErrMsg, ++ "unable to upgrade database to the version 2.6 format", ++ zErr ? ": " : 0, zErr, (char*)0); ++ } ++ sqlite_freemem(zErr); ++ } ++ ++ if( rc!=SQLITE_OK ){ ++ db->flags &= ~SQLITE_Initialized; ++ } ++ return rc; ++} ++ ++/* ++** The version of the library ++*/ ++const char rcsid[] = "@(#) \044Id: SQLite version " SQLITE_VERSION " $"; ++const char sqlite_version[] = SQLITE_VERSION; ++ ++/* ++** Does the library expect data to be encoded as UTF-8 or iso8859? The ++** following global constant always lets us know. ++*/ ++#ifdef SQLITE_UTF8 ++const char sqlite_encoding[] = "UTF-8"; ++#else ++const char sqlite_encoding[] = "iso8859"; ++#endif ++ ++/* ++** Open a new SQLite database. Construct an "sqlite" structure to define ++** the state of this database and return a pointer to that structure. ++** ++** An attempt is made to initialize the in-memory data structures that ++** hold the database schema. But if this fails (because the schema file ++** is locked) then that step is deferred until the first call to ++** sqlite_exec(). ++*/ ++sqlite *sqlite_open(const char *zFilename, int mode, char **pzErrMsg){ ++ sqlite *db; ++ int rc, i; ++ ++ /* Allocate the sqlite data structure */ ++ db = sqliteMalloc( sizeof(sqlite) ); ++ if( pzErrMsg ) *pzErrMsg = 0; ++ if( db==0 ) goto no_mem_on_open; ++ db->onError = OE_Default; ++ db->priorNewRowid = 0; ++ db->magic = SQLITE_MAGIC_BUSY; ++ db->nDb = 2; ++ db->aDb = db->aDbStatic; ++ /* db->flags |= SQLITE_ShortColNames; */ ++ sqliteHashInit(&db->aFunc, SQLITE_HASH_STRING, 1); ++ for(i=0; inDb; i++){ ++ sqliteHashInit(&db->aDb[i].tblHash, SQLITE_HASH_STRING, 0); ++ sqliteHashInit(&db->aDb[i].idxHash, SQLITE_HASH_STRING, 0); ++ sqliteHashInit(&db->aDb[i].trigHash, SQLITE_HASH_STRING, 0); ++ sqliteHashInit(&db->aDb[i].aFKey, SQLITE_HASH_STRING, 1); ++ } ++ ++ /* Open the backend database driver */ ++ if( zFilename[0]==':' && strcmp(zFilename,":memory:")==0 ){ ++ db->temp_store = 2; ++ } ++ rc = sqliteBtreeFactory(db, zFilename, 0, MAX_PAGES, &db->aDb[0].pBt); ++ if( rc!=SQLITE_OK ){ ++ switch( rc ){ ++ default: { ++ sqliteSetString(pzErrMsg, "unable to open database: ", ++ zFilename, (char*)0); ++ } ++ } ++ sqliteFree(db); ++ sqliteStrRealloc(pzErrMsg); ++ return 0; ++ } ++ db->aDb[0].zName = "main"; ++ db->aDb[1].zName = "temp"; ++ ++ /* Attempt to read the schema */ ++ sqliteRegisterBuiltinFunctions(db); ++ rc = sqliteInit(db, pzErrMsg); ++ db->magic = SQLITE_MAGIC_OPEN; ++ if( sqlite_malloc_failed ){ ++ sqlite_close(db); ++ goto no_mem_on_open; ++ }else if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){ ++ sqlite_close(db); ++ sqliteStrRealloc(pzErrMsg); ++ return 0; ++ }else if( pzErrMsg ){ ++ sqliteFree(*pzErrMsg); ++ *pzErrMsg = 0; ++ } ++ ++ /* Return a pointer to the newly opened database structure */ ++ return db; ++ ++no_mem_on_open: ++ sqliteSetString(pzErrMsg, "out of memory", (char*)0); ++ sqliteStrRealloc(pzErrMsg); ++ return 0; ++} ++ ++/* ++** Return the ROWID of the most recent insert ++*/ ++int sqlite_last_insert_rowid(sqlite *db){ ++ return db->lastRowid; ++} ++ ++/* ++** Return the number of changes in the most recent call to sqlite_exec(). ++*/ ++int sqlite_changes(sqlite *db){ ++ return db->nChange; ++} ++ ++/* ++** Return the number of changes produced by the last INSERT, UPDATE, or ++** DELETE statement to complete execution. The count does not include ++** changes due to SQL statements executed in trigger programs that were ++** triggered by that statement ++*/ ++int sqlite_last_statement_changes(sqlite *db){ ++ return db->lsChange; ++} ++ ++/* ++** Close an existing SQLite database ++*/ ++void sqlite_close(sqlite *db){ ++ HashElem *i; ++ int j; ++ db->want_to_close = 1; ++ if( sqliteSafetyCheck(db) || sqliteSafetyOn(db) ){ ++ /* printf("DID NOT CLOSE\n"); fflush(stdout); */ ++ return; ++ } ++ db->magic = SQLITE_MAGIC_CLOSED; ++ for(j=0; jnDb; j++){ ++ struct Db *pDb = &db->aDb[j]; ++ if( pDb->pBt ){ ++ sqliteBtreeClose(pDb->pBt); ++ pDb->pBt = 0; ++ } ++ } ++ sqliteResetInternalSchema(db, 0); ++ assert( db->nDb<=2 ); ++ assert( db->aDb==db->aDbStatic ); ++ for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){ ++ FuncDef *pFunc, *pNext; ++ for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){ ++ pNext = pFunc->pNext; ++ sqliteFree(pFunc); ++ } ++ } ++ sqliteHashClear(&db->aFunc); ++ sqliteFree(db); ++} ++ ++/* ++** Rollback all database files. ++*/ ++void sqliteRollbackAll(sqlite *db){ ++ int i; ++ for(i=0; inDb; i++){ ++ if( db->aDb[i].pBt ){ ++ sqliteBtreeRollback(db->aDb[i].pBt); ++ db->aDb[i].inTrans = 0; ++ } ++ } ++ sqliteResetInternalSchema(db, 0); ++ /* sqliteRollbackInternalChanges(db); */ ++} ++ ++/* ++** 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. ++*/ ++int sqlite_exec( ++ sqlite *db, /* The database on which the SQL executes */ ++ const char *zSql, /* The SQL to be executed */ ++ sqlite_callback xCallback, /* Invoke this callback routine */ ++ void *pArg, /* First argument to xCallback() */ ++ char **pzErrMsg /* Write error messages here */ ++){ ++ int rc = SQLITE_OK; ++ const char *zLeftover; ++ sqlite_vm *pVm; ++ int nRetry = 0; ++ int nChange = 0; ++ int nCallback; ++ ++ if( zSql==0 ) return SQLITE_OK; ++ while( rc==SQLITE_OK && zSql[0] ){ ++ pVm = 0; ++ rc = sqlite_compile(db, zSql, &zLeftover, &pVm, pzErrMsg); ++ if( rc!=SQLITE_OK ){ ++ assert( pVm==0 || sqlite_malloc_failed ); ++ return rc; ++ } ++ if( pVm==0 ){ ++ /* This happens if the zSql input contained only whitespace */ ++ break; ++ } ++ db->nChange += nChange; ++ nCallback = 0; ++ while(1){ ++ int nArg; ++ char **azArg, **azCol; ++ rc = sqlite_step(pVm, &nArg, (const char***)&azArg,(const char***)&azCol); ++ if( rc==SQLITE_ROW ){ ++ if( xCallback!=0 && xCallback(pArg, nArg, azArg, azCol) ){ ++ sqlite_finalize(pVm, 0); ++ return SQLITE_ABORT; ++ } ++ nCallback++; ++ }else{ ++ if( rc==SQLITE_DONE && nCallback==0 ++ && (db->flags & SQLITE_NullCallback)!=0 && xCallback!=0 ){ ++ xCallback(pArg, nArg, azArg, azCol); ++ } ++ rc = sqlite_finalize(pVm, pzErrMsg); ++ if( rc==SQLITE_SCHEMA && nRetry<2 ){ ++ nRetry++; ++ rc = SQLITE_OK; ++ break; ++ } ++ if( db->pVdbe==0 ){ ++ nChange = db->nChange; ++ } ++ nRetry = 0; ++ zSql = zLeftover; ++ while( isspace(zSql[0]) ) zSql++; ++ break; ++ } ++ } ++ } ++ return rc; ++} ++ ++ ++/* ++** Compile a single statement of SQL into a virtual machine. 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. ++*/ ++int sqlite_compile( ++ sqlite *db, /* The database on which the SQL executes */ ++ const char *zSql, /* The SQL to be executed */ ++ const char **pzTail, /* OUT: Next statement after the first */ ++ sqlite_vm **ppVm, /* OUT: The virtual machine */ ++ char **pzErrMsg /* OUT: Write error messages here */ ++){ ++ Parse sParse; ++ ++ if( pzErrMsg ) *pzErrMsg = 0; ++ if( sqliteSafetyOn(db) ) goto exec_misuse; ++ if( !db->init.busy ){ ++ if( (db->flags & SQLITE_Initialized)==0 ){ ++ int rc, cnt = 1; ++ while( (rc = sqliteInit(db, pzErrMsg))==SQLITE_BUSY ++ && db->xBusyCallback ++ && db->xBusyCallback(db->pBusyArg, "", cnt++)!=0 ){} ++ if( rc!=SQLITE_OK ){ ++ sqliteStrRealloc(pzErrMsg); ++ sqliteSafetyOff(db); ++ return rc; ++ } ++ if( pzErrMsg ){ ++ sqliteFree(*pzErrMsg); ++ *pzErrMsg = 0; ++ } ++ } ++ if( db->file_format<3 ){ ++ sqliteSafetyOff(db); ++ sqliteSetString(pzErrMsg, "obsolete database file format", (char*)0); ++ return SQLITE_ERROR; ++ } ++ } ++ assert( (db->flags & SQLITE_Initialized)!=0 || db->init.busy ); ++ if( db->pVdbe==0 ){ db->nChange = 0; } ++ memset(&sParse, 0, sizeof(sParse)); ++ sParse.db = db; ++ sqliteRunParser(&sParse, zSql, pzErrMsg); ++ if( db->xTrace && !db->init.busy ){ ++ /* Trace only the statment that was compiled. ++ ** Make a copy of that part of the SQL string since zSQL is const ++ ** and we must pass a zero terminated string to the trace function ++ ** The copy is unnecessary if the tail pointer is pointing at the ++ ** beginnig or end of the SQL string. ++ */ ++ if( sParse.zTail && sParse.zTail!=zSql && *sParse.zTail ){ ++ char *tmpSql = sqliteStrNDup(zSql, sParse.zTail - zSql); ++ if( tmpSql ){ ++ db->xTrace(db->pTraceArg, tmpSql); ++ free(tmpSql); ++ }else{ ++ /* If a memory error occurred during the copy, ++ ** trace entire SQL string and fall through to the ++ ** sqlite_malloc_failed test to report the error. ++ */ ++ db->xTrace(db->pTraceArg, zSql); ++ } ++ }else{ ++ db->xTrace(db->pTraceArg, zSql); ++ } ++ } ++ if( sqlite_malloc_failed ){ ++ sqliteSetString(pzErrMsg, "out of memory", (char*)0); ++ sParse.rc = SQLITE_NOMEM; ++ sqliteRollbackAll(db); ++ sqliteResetInternalSchema(db, 0); ++ db->flags &= ~SQLITE_InTrans; ++ } ++ if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK; ++ if( sParse.rc!=SQLITE_OK && pzErrMsg && *pzErrMsg==0 ){ ++ sqliteSetString(pzErrMsg, sqlite_error_string(sParse.rc), (char*)0); ++ } ++ sqliteStrRealloc(pzErrMsg); ++ if( sParse.rc==SQLITE_SCHEMA ){ ++ sqliteResetInternalSchema(db, 0); ++ } ++ assert( ppVm ); ++ *ppVm = (sqlite_vm*)sParse.pVdbe; ++ if( pzTail ) *pzTail = sParse.zTail; ++ if( sqliteSafetyOff(db) ) goto exec_misuse; ++ return sParse.rc; ++ ++exec_misuse: ++ if( pzErrMsg ){ ++ *pzErrMsg = 0; ++ sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), (char*)0); ++ sqliteStrRealloc(pzErrMsg); ++ } ++ return SQLITE_MISUSE; ++} ++ ++ ++/* ++** The following routine destroys a virtual machine that is created by ++** the sqlite_compile() routine. ++** ++** The integer returned is an SQLITE_ success/failure code that describes ++** the result of executing the virtual machine. An error message is ++** written into memory obtained from malloc and *pzErrMsg is made to ++** point to that error if pzErrMsg is not NULL. The calling routine ++** should use sqlite_freemem() to delete the message when it has finished ++** with it. ++*/ ++int sqlite_finalize( ++ sqlite_vm *pVm, /* The virtual machine to be destroyed */ ++ char **pzErrMsg /* OUT: Write error messages here */ ++){ ++ int rc = sqliteVdbeFinalize((Vdbe*)pVm, pzErrMsg); ++ sqliteStrRealloc(pzErrMsg); ++ return rc; ++} ++ ++/* ++** Terminate the current execution of a virtual machine then ++** reset the virtual machine back to its starting state so that it ++** can be reused. Any error message resulting from the prior execution ++** is written into *pzErrMsg. A success code from the prior execution ++** is returned. ++*/ ++int sqlite_reset( ++ sqlite_vm *pVm, /* The virtual machine to be destroyed */ ++ char **pzErrMsg /* OUT: Write error messages here */ ++){ ++ int rc = sqliteVdbeReset((Vdbe*)pVm, pzErrMsg); ++ sqliteVdbeMakeReady((Vdbe*)pVm, -1, 0); ++ sqliteStrRealloc(pzErrMsg); ++ return rc; ++} ++ ++/* ++** Return a static string that describes the kind of error specified in the ++** argument. ++*/ ++const char *sqlite_error_string(int rc){ ++ const char *z; ++ switch( rc ){ ++ case SQLITE_OK: z = "not an error"; break; ++ case SQLITE_ERROR: z = "SQL logic error or missing database"; break; ++ case SQLITE_INTERNAL: z = "internal SQLite implementation flaw"; break; ++ case SQLITE_PERM: z = "access permission denied"; break; ++ case SQLITE_ABORT: z = "callback requested query abort"; break; ++ case SQLITE_BUSY: z = "database is locked"; break; ++ case SQLITE_LOCKED: z = "database table is locked"; break; ++ case SQLITE_NOMEM: z = "out of memory"; break; ++ case SQLITE_READONLY: z = "attempt to write a readonly database"; break; ++ case SQLITE_INTERRUPT: z = "interrupted"; break; ++ case SQLITE_IOERR: z = "disk I/O error"; break; ++ case SQLITE_CORRUPT: z = "database disk image is malformed"; break; ++ case SQLITE_NOTFOUND: z = "table or record not found"; break; ++ case SQLITE_FULL: z = "database is full"; break; ++ case SQLITE_CANTOPEN: z = "unable to open database file"; break; ++ case SQLITE_PROTOCOL: z = "database locking protocol failure"; break; ++ case SQLITE_EMPTY: z = "table contains no data"; break; ++ case SQLITE_SCHEMA: z = "database schema has changed"; break; ++ case SQLITE_TOOBIG: z = "too much data for one table row"; break; ++ case SQLITE_CONSTRAINT: z = "constraint failed"; break; ++ case SQLITE_MISMATCH: z = "datatype mismatch"; break; ++ case SQLITE_MISUSE: z = "library routine called out of sequence";break; ++ case SQLITE_NOLFS: z = "kernel lacks large file support"; break; ++ case SQLITE_AUTH: z = "authorization denied"; break; ++ case SQLITE_FORMAT: z = "auxiliary database format error"; break; ++ case SQLITE_RANGE: z = "bind index out of range"; break; ++ case SQLITE_NOTADB: z = "file is encrypted or is not a database";break; ++ default: z = "unknown error"; break; ++ } ++ return z; ++} ++ ++/* ++** This routine implements a busy callback that sleeps and tries ++** again until a timeout value is reached. The timeout value is ++** an integer number of milliseconds passed in as the first ++** argument. ++*/ ++static int sqliteDefaultBusyCallback( ++ void *Timeout, /* Maximum amount of time to wait */ ++ const char *NotUsed, /* The name of the table that is busy */ ++ int count /* Number of times table has been busy */ ++){ ++#if SQLITE_MIN_SLEEP_MS==1 ++ static const char delays[] = ++ { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 50, 100}; ++ static const short int totals[] = ++ { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228, 287}; ++# define NDELAY (sizeof(delays)/sizeof(delays[0])) ++ int timeout = (int)(long)Timeout; ++ int delay, prior; ++ ++ if( count <= NDELAY ){ ++ delay = delays[count-1]; ++ prior = totals[count-1]; ++ }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; ++ } ++ sqliteOsSleep(delay); ++ return 1; ++#else ++ int timeout = (int)(long)Timeout; ++ if( (count+1)*1000 > timeout ){ ++ return 0; ++ } ++ sqliteOsSleep(1000); ++ return 1; ++#endif ++} ++ ++/* ++** This routine sets the busy callback for an Sqlite database to the ++** given callback function with the given argument. ++*/ ++void sqlite_busy_handler( ++ sqlite *db, ++ int (*xBusy)(void*,const char*,int), ++ void *pArg ++){ ++ db->xBusyCallback = xBusy; ++ db->pBusyArg = pArg; ++} ++ ++#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. ++*/ ++void sqlite_progress_handler( ++ sqlite *db, ++ int nOps, ++ int (*xProgress)(void*), ++ void *pArg ++){ ++ if( nOps>0 ){ ++ db->xProgress = xProgress; ++ db->nProgressOps = nOps; ++ db->pProgressArg = pArg; ++ }else{ ++ db->xProgress = 0; ++ db->nProgressOps = 0; ++ db->pProgressArg = 0; ++ } ++} ++#endif ++ ++ ++/* ++** This routine installs a default busy handler that waits for the ++** specified number of milliseconds before returning 0. ++*/ ++void sqlite_busy_timeout(sqlite *db, int ms){ ++ if( ms>0 ){ ++ sqlite_busy_handler(db, sqliteDefaultBusyCallback, (void*)(long)ms); ++ }else{ ++ sqlite_busy_handler(db, 0, 0); ++ } ++} ++ ++/* ++** Cause any pending operation to stop at its earliest opportunity. ++*/ ++void sqlite_interrupt(sqlite *db){ ++ db->flags |= SQLITE_Interrupt; ++} ++ ++/* ++** Windows systems should call this routine to free memory that ++** is returned in the in the errmsg parameter of sqlite_open() when ++** SQLite is a DLL. For some reason, it does not work to call free() ++** directly. ++** ++** Note that we need to call free() not sqliteFree() here, since every ++** string that is exported from SQLite should have already passed through ++** sqliteStrRealloc(). ++*/ ++void sqlite_freemem(void *p){ free(p); } ++ ++/* ++** Windows systems need functions to call to return the sqlite_version ++** and sqlite_encoding strings since they are unable to access constants ++** within DLLs. ++*/ ++const char *sqlite_libversion(void){ return sqlite_version; } ++const char *sqlite_libencoding(void){ return sqlite_encoding; } ++ ++/* ++** Create new user-defined functions. The sqlite_create_function() ++** routine creates a regular function and sqlite_create_aggregate() ++** creates an aggregate function. ++** ++** Passing a NULL xFunc argument or NULL xStep and xFinalize arguments ++** disables the function. Calling sqlite_create_function() with the ++** same name and number of arguments as a prior call to ++** sqlite_create_aggregate() disables the prior call to ++** sqlite_create_aggregate(), and vice versa. ++** ++** If nArg is -1 it means that this function will accept any number ++** of arguments, including 0. The maximum allowed value of nArg is 127. ++*/ ++int sqlite_create_function( ++ sqlite *db, /* Add the function to this database connection */ ++ const char *zName, /* Name of the function to add */ ++ int nArg, /* Number of arguments */ ++ void (*xFunc)(sqlite_func*,int,const char**), /* The implementation */ ++ void *pUserData /* User data */ ++){ ++ FuncDef *p; ++ int nName; ++ if( db==0 || zName==0 || sqliteSafetyCheck(db) ) return 1; ++ if( nArg<-1 || nArg>127 ) return 1; ++ nName = strlen(zName); ++ if( nName>255 ) return 1; ++ p = sqliteFindFunction(db, zName, nName, nArg, 1); ++ if( p==0 ) return 1; ++ p->xFunc = xFunc; ++ p->xStep = 0; ++ p->xFinalize = 0; ++ p->pUserData = pUserData; ++ return 0; ++} ++int sqlite_create_aggregate( ++ sqlite *db, /* Add the function to this database connection */ ++ const char *zName, /* Name of the function to add */ ++ int nArg, /* Number of arguments */ ++ void (*xStep)(sqlite_func*,int,const char**), /* The step function */ ++ void (*xFinalize)(sqlite_func*), /* The finalizer */ ++ void *pUserData /* User data */ ++){ ++ FuncDef *p; ++ int nName; ++ if( db==0 || zName==0 || sqliteSafetyCheck(db) ) return 1; ++ if( nArg<-1 || nArg>127 ) return 1; ++ nName = strlen(zName); ++ if( nName>255 ) return 1; ++ p = sqliteFindFunction(db, zName, nName, nArg, 1); ++ if( p==0 ) return 1; ++ p->xFunc = 0; ++ p->xStep = xStep; ++ p->xFinalize = xFinalize; ++ p->pUserData = pUserData; ++ return 0; ++} ++ ++/* ++** Change the datatype for all functions with a given name. See the ++** header comment for the prototype of this function in sqlite.h for ++** additional information. ++*/ ++int sqlite_function_type(sqlite *db, const char *zName, int dataType){ ++ FuncDef *p = (FuncDef*)sqliteHashFind(&db->aFunc, zName, strlen(zName)); ++ while( p ){ ++ p->dataType = dataType; ++ p = p->pNext; ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** 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 ++** sqlite_exec(). ++*/ ++void *sqlite_trace(sqlite *db, void (*xTrace)(void*,const char*), void *pArg){ ++ void *pOld = db->pTraceArg; ++ db->xTrace = xTrace; ++ db->pTraceArg = pArg; ++ return pOld; ++} ++ ++/*** EXPERIMENTAL *** ++** ++** Register a function to be invoked when a transaction comments. ++** If either function returns non-zero, then the commit becomes a ++** rollback. ++*/ ++void *sqlite_commit_hook( ++ sqlite *db, /* Attach the hook to this database */ ++ int (*xCallback)(void*), /* Function to invoke on each commit */ ++ void *pArg /* Argument to the function */ ++){ ++ void *pOld = db->pCommitArg; ++ db->xCommitCallback = xCallback; ++ db->pCommitArg = pArg; ++ return pOld; ++} ++ ++ ++/* ++** This routine is called to create a connection to a database BTree ++** driver. If zFilename is the name of a file, then that file is ++** opened and used. If zFilename is the magic name ":memory:" then ++** the database is stored in memory (and is thus forgotten as soon as ++** the connection is closed.) If zFilename is NULL then the database ++** is for temporary use only and is deleted as soon as the connection ++** is closed. ++** ++** A temporary database can be either a disk file (that is automatically ++** deleted when the file is closed) or a set of red-black trees held in memory, ++** depending on the values of the TEMP_STORE compile-time macro and the ++** db->temp_store variable, according to the following chart: ++** ++** TEMP_STORE db->temp_store Location of temporary database ++** ---------- -------------- ------------------------------ ++** 0 any file ++** 1 1 file ++** 1 2 memory ++** 1 0 file ++** 2 1 file ++** 2 2 memory ++** 2 0 memory ++** 3 any memory ++*/ ++int sqliteBtreeFactory( ++ const sqlite *db, /* Main database when opening aux otherwise 0 */ ++ const char *zFilename, /* Name of the file containing the BTree database */ ++ int omitJournal, /* if TRUE then do not journal this file */ ++ int nCache, /* How many pages in the page cache */ ++ Btree **ppBtree){ /* Pointer to new Btree object written here */ ++ ++ assert( ppBtree != 0); ++ ++#ifndef SQLITE_OMIT_INMEMORYDB ++ if( zFilename==0 ){ ++ if (TEMP_STORE == 0) { ++ /* Always use file based temporary DB */ ++ return sqliteBtreeOpen(0, omitJournal, nCache, ppBtree); ++ } else if (TEMP_STORE == 1 || TEMP_STORE == 2) { ++ /* Switch depending on compile-time and/or runtime settings. */ ++ int location = db->temp_store==0 ? TEMP_STORE : db->temp_store; ++ ++ if (location == 1) { ++ return sqliteBtreeOpen(zFilename, omitJournal, nCache, ppBtree); ++ } else { ++ return sqliteRbtreeOpen(0, 0, 0, ppBtree); ++ } ++ } else { ++ /* Always use in-core DB */ ++ return sqliteRbtreeOpen(0, 0, 0, ppBtree); ++ } ++ }else if( zFilename[0]==':' && strcmp(zFilename,":memory:")==0 ){ ++ return sqliteRbtreeOpen(0, 0, 0, ppBtree); ++ }else ++#endif ++ { ++ return sqliteBtreeOpen(zFilename, omitJournal, nCache, ppBtree); ++ } ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/opcodes.c +@@ -0,0 +1,140 @@ ++/* Automatically generated file. Do not edit */ ++char *sqliteOpcodeNames[] = { "???", ++ "Goto", ++ "Gosub", ++ "Return", ++ "Halt", ++ "Integer", ++ "String", ++ "Variable", ++ "Pop", ++ "Dup", ++ "Pull", ++ "Push", ++ "ColumnName", ++ "Callback", ++ "Concat", ++ "Add", ++ "Subtract", ++ "Multiply", ++ "Divide", ++ "Remainder", ++ "Function", ++ "BitAnd", ++ "BitOr", ++ "ShiftLeft", ++ "ShiftRight", ++ "AddImm", ++ "ForceInt", ++ "MustBeInt", ++ "Eq", ++ "Ne", ++ "Lt", ++ "Le", ++ "Gt", ++ "Ge", ++ "StrEq", ++ "StrNe", ++ "StrLt", ++ "StrLe", ++ "StrGt", ++ "StrGe", ++ "And", ++ "Or", ++ "Negative", ++ "AbsValue", ++ "Not", ++ "BitNot", ++ "Noop", ++ "If", ++ "IfNot", ++ "IsNull", ++ "NotNull", ++ "MakeRecord", ++ "MakeIdxKey", ++ "MakeKey", ++ "IncrKey", ++ "Checkpoint", ++ "Transaction", ++ "Commit", ++ "Rollback", ++ "ReadCookie", ++ "SetCookie", ++ "VerifyCookie", ++ "OpenRead", ++ "OpenWrite", ++ "OpenTemp", ++ "OpenPseudo", ++ "Close", ++ "MoveLt", ++ "MoveTo", ++ "Distinct", ++ "NotFound", ++ "Found", ++ "IsUnique", ++ "NotExists", ++ "NewRecno", ++ "PutIntKey", ++ "PutStrKey", ++ "Delete", ++ "SetCounts", ++ "KeyAsData", ++ "RowKey", ++ "RowData", ++ "Column", ++ "Recno", ++ "FullKey", ++ "NullRow", ++ "Last", ++ "Rewind", ++ "Prev", ++ "Next", ++ "IdxPut", ++ "IdxDelete", ++ "IdxRecno", ++ "IdxLT", ++ "IdxGT", ++ "IdxGE", ++ "IdxIsNull", ++ "Destroy", ++ "Clear", ++ "CreateIndex", ++ "CreateTable", ++ "IntegrityCk", ++ "ListWrite", ++ "ListRewind", ++ "ListRead", ++ "ListReset", ++ "ListPush", ++ "ListPop", ++ "ContextPush", ++ "ContextPop", ++ "SortPut", ++ "SortMakeRec", ++ "SortMakeKey", ++ "Sort", ++ "SortNext", ++ "SortCallback", ++ "SortReset", ++ "FileOpen", ++ "FileRead", ++ "FileColumn", ++ "MemStore", ++ "MemLoad", ++ "MemIncr", ++ "AggReset", ++ "AggInit", ++ "AggFunc", ++ "AggFocus", ++ "AggSet", ++ "AggGet", ++ "AggNext", ++ "SetInsert", ++ "SetFound", ++ "SetNotFound", ++ "SetFirst", ++ "SetNext", ++ "Vacuum", ++ "StackDepth", ++ "StackReset", ++}; +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/opcodes.h +@@ -0,0 +1,138 @@ ++/* Automatically generated file. Do not edit */ ++#define OP_Goto 1 ++#define OP_Gosub 2 ++#define OP_Return 3 ++#define OP_Halt 4 ++#define OP_Integer 5 ++#define OP_String 6 ++#define OP_Variable 7 ++#define OP_Pop 8 ++#define OP_Dup 9 ++#define OP_Pull 10 ++#define OP_Push 11 ++#define OP_ColumnName 12 ++#define OP_Callback 13 ++#define OP_Concat 14 ++#define OP_Add 15 ++#define OP_Subtract 16 ++#define OP_Multiply 17 ++#define OP_Divide 18 ++#define OP_Remainder 19 ++#define OP_Function 20 ++#define OP_BitAnd 21 ++#define OP_BitOr 22 ++#define OP_ShiftLeft 23 ++#define OP_ShiftRight 24 ++#define OP_AddImm 25 ++#define OP_ForceInt 26 ++#define OP_MustBeInt 27 ++#define OP_Eq 28 ++#define OP_Ne 29 ++#define OP_Lt 30 ++#define OP_Le 31 ++#define OP_Gt 32 ++#define OP_Ge 33 ++#define OP_StrEq 34 ++#define OP_StrNe 35 ++#define OP_StrLt 36 ++#define OP_StrLe 37 ++#define OP_StrGt 38 ++#define OP_StrGe 39 ++#define OP_And 40 ++#define OP_Or 41 ++#define OP_Negative 42 ++#define OP_AbsValue 43 ++#define OP_Not 44 ++#define OP_BitNot 45 ++#define OP_Noop 46 ++#define OP_If 47 ++#define OP_IfNot 48 ++#define OP_IsNull 49 ++#define OP_NotNull 50 ++#define OP_MakeRecord 51 ++#define OP_MakeIdxKey 52 ++#define OP_MakeKey 53 ++#define OP_IncrKey 54 ++#define OP_Checkpoint 55 ++#define OP_Transaction 56 ++#define OP_Commit 57 ++#define OP_Rollback 58 ++#define OP_ReadCookie 59 ++#define OP_SetCookie 60 ++#define OP_VerifyCookie 61 ++#define OP_OpenRead 62 ++#define OP_OpenWrite 63 ++#define OP_OpenTemp 64 ++#define OP_OpenPseudo 65 ++#define OP_Close 66 ++#define OP_MoveLt 67 ++#define OP_MoveTo 68 ++#define OP_Distinct 69 ++#define OP_NotFound 70 ++#define OP_Found 71 ++#define OP_IsUnique 72 ++#define OP_NotExists 73 ++#define OP_NewRecno 74 ++#define OP_PutIntKey 75 ++#define OP_PutStrKey 76 ++#define OP_Delete 77 ++#define OP_SetCounts 78 ++#define OP_KeyAsData 79 ++#define OP_RowKey 80 ++#define OP_RowData 81 ++#define OP_Column 82 ++#define OP_Recno 83 ++#define OP_FullKey 84 ++#define OP_NullRow 85 ++#define OP_Last 86 ++#define OP_Rewind 87 ++#define OP_Prev 88 ++#define OP_Next 89 ++#define OP_IdxPut 90 ++#define OP_IdxDelete 91 ++#define OP_IdxRecno 92 ++#define OP_IdxLT 93 ++#define OP_IdxGT 94 ++#define OP_IdxGE 95 ++#define OP_IdxIsNull 96 ++#define OP_Destroy 97 ++#define OP_Clear 98 ++#define OP_CreateIndex 99 ++#define OP_CreateTable 100 ++#define OP_IntegrityCk 101 ++#define OP_ListWrite 102 ++#define OP_ListRewind 103 ++#define OP_ListRead 104 ++#define OP_ListReset 105 ++#define OP_ListPush 106 ++#define OP_ListPop 107 ++#define OP_ContextPush 108 ++#define OP_ContextPop 109 ++#define OP_SortPut 110 ++#define OP_SortMakeRec 111 ++#define OP_SortMakeKey 112 ++#define OP_Sort 113 ++#define OP_SortNext 114 ++#define OP_SortCallback 115 ++#define OP_SortReset 116 ++#define OP_FileOpen 117 ++#define OP_FileRead 118 ++#define OP_FileColumn 119 ++#define OP_MemStore 120 ++#define OP_MemLoad 121 ++#define OP_MemIncr 122 ++#define OP_AggReset 123 ++#define OP_AggInit 124 ++#define OP_AggFunc 125 ++#define OP_AggFocus 126 ++#define OP_AggSet 127 ++#define OP_AggGet 128 ++#define OP_AggNext 129 ++#define OP_SetInsert 130 ++#define OP_SetFound 131 ++#define OP_SetNotFound 132 ++#define OP_SetFirst 133 ++#define OP_SetNext 134 ++#define OP_Vacuum 135 ++#define OP_StackDepth 136 ++#define OP_StackReset 137 +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/os.c +@@ -0,0 +1,1850 @@ ++/* ++** 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 file contains code that is specific to particular operating ++** systems. The purpose of this file is to provide a uniform abstraction ++** on which the rest of SQLite can operate. ++*/ ++#include "os.h" /* Must be first to enable large file support */ ++#include "sqliteInt.h" ++ ++#if OS_UNIX ++# include ++# include ++# include ++# 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 ++#endif ++ ++ ++#if OS_WIN ++# include ++#endif ++ ++#if OS_MAC ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++#endif ++ ++/* ++** 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 its DOS - what did you expect? ++*/ ++#ifdef __DJGPP__ ++# define fcntl(A,B,C) 0 ++#endif ++ ++/* ++** Macros used to determine whether or not to use threads. The ++** SQLITE_UNIX_THREADS macro is defined if we are synchronizing for ++** Posix threads and SQLITE_W32_THREADS is defined if we are ++** synchronizing using Win32 threads. ++*/ ++#if OS_UNIX && defined(THREADSAFE) && THREADSAFE ++# include ++# define SQLITE_UNIX_THREADS 1 ++#endif ++#if OS_WIN && defined(THREADSAFE) && THREADSAFE ++# define SQLITE_W32_THREADS 1 ++#endif ++#if OS_MAC && defined(THREADSAFE) && THREADSAFE ++# include ++# define SQLITE_MACOS_MULTITASKING 1 ++#endif ++ ++/* ++** Macros for performance tracing. Normally turned off ++*/ ++#if 0 ++static int last_page = 0; ++__inline__ unsigned long long int hwtime(void){ ++ unsigned long long int x; ++ __asm__("rdtsc\n\t" ++ "mov %%edx, %%ecx\n\t" ++ :"=A" (x)); ++ return x; ++} ++static unsigned long long int g_start; ++static unsigned int elapse; ++#define TIMER_START g_start=hwtime() ++#define TIMER_END elapse=hwtime()-g_start ++#define SEEK(X) last_page=(X) ++#define TRACE1(X) fprintf(stderr,X) ++#define TRACE2(X,Y) fprintf(stderr,X,Y) ++#define TRACE3(X,Y,Z) fprintf(stderr,X,Y,Z) ++#define TRACE4(X,Y,Z,A) fprintf(stderr,X,Y,Z,A) ++#define TRACE5(X,Y,Z,A,B) fprintf(stderr,X,Y,Z,A,B) ++#else ++#define TIMER_START ++#define TIMER_END ++#define SEEK(X) ++#define TRACE1(X) ++#define TRACE2(X,Y) ++#define TRACE3(X,Y,Z) ++#define TRACE4(X,Y,Z,A) ++#define TRACE5(X,Y,Z,A,B) ++#endif ++ ++ ++#if OS_UNIX ++/* ++** Here is the dirt on POSIX advisory locks: 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. ++** ++** Bummer. If you ask me, this is broken. Badly broken. It 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. ++** ++** The OsFile 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 OsFile 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. ++** ++** 2004-Jan-11: ++** More recent discoveries about POSIX advisory locks. (The more ++** I discover, the more I realize the a POSIX advisory locks are ++** an abomination.) ++** ++** 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 OsFile structure contains ++** a pointer to an openCnt structure. There is one openCnt structure ++** per open inode, which means that multiple OsFiles can point to a single ++** openCnt. When an attempt is made to close an OsFile, if there are ++** other OsFiles 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 openCnt structure keeps a list of file descriptors that need to ++** be closed and that list is walked (and cleared) when the last lock ++** clears. ++** ++** First, under Linux threads, because each thread has a separate ++** process ID, lock operations in one thread do not override locks ++** to the same file in other threads. Linux threads behave like ++** separate processes in this respect. But, if you close a file ++** descriptor in linux threads, all locks are cleared, even locks ++** on other threads and even though the other threads have different ++** process IDs. Linux threads is inconsistent in this respect. ++** (I'm beginning to think that linux threads is an abomination too.) ++** The consequence of this all is that the hash table for the lockInfo ++** structure has to include the process id as part of its key because ++** locks in different threads are treated as distinct. But the ++** openCnt structure should not include the process id in its ++** key because close() clears lock on all threads, not just the current ++** thread. Were it not for this goofiness in linux threads, we could ++** combine the lockInfo and openCnt structures into a single structure. ++*/ ++ ++/* ++** An instance of the following structure serves as the key used ++** to locate a particular lockInfo structure given its inode. Note ++** that we have to include the process ID as part of the key. On some ++** threading implementations (ex: linux), each thread has a separate ++** process ID. ++*/ ++struct lockKey { ++ dev_t dev; /* Device number */ ++ ino_t ino; /* Inode number */ ++ pid_t pid; /* Process ID */ ++}; ++ ++/* ++** An instance of the following structure is allocated for each open ++** inode on each thread with a different process ID. (Threads have ++** different process IDs on linux, but not on most other unixes.) ++** ++** A single inode can have multiple file descriptors, so each OsFile ++** structure contains a pointer to an instance of this object and this ++** object keeps a count of the number of OsFiles pointing to it. ++*/ ++struct lockInfo { ++ struct lockKey key; /* The lookup key */ ++ int cnt; /* 0: unlocked. -1: write lock. 1...: read lock. */ ++ int nRef; /* Number of pointers to this structure */ ++}; ++ ++/* ++** An instance of the following structure serves as the key used ++** to locate a particular openCnt structure given its inode. This ++** is the same as the lockKey except that the process ID is omitted. ++*/ ++struct openKey { ++ dev_t dev; /* Device number */ ++ ino_t ino; /* Inode number */ ++}; ++ ++/* ++** An instance of the following structure is allocated for each open ++** inode. This structure keeps track of the number of locks on that ++** inode. If a close is attempted against an inode that is holding ++** locks, the close is deferred until all locks clear by adding the ++** file descriptor to be closed to the pending list. ++*/ ++struct openCnt { ++ struct openKey key; /* The lookup key */ ++ int nRef; /* Number of pointers to this structure */ ++ int nLock; /* Number of outstanding locks */ ++ int nPending; /* Number of pending close() operations */ ++ int *aPending; /* Malloced space holding fd's awaiting a close() */ ++}; ++ ++/* ++** These hash table maps inodes and process IDs into lockInfo and openCnt ++** structures. Access to these hash tables must be protected by a mutex. ++*/ ++static Hash lockHash = { SQLITE_HASH_BINARY, 0, 0, 0, 0, 0 }; ++static Hash openHash = { SQLITE_HASH_BINARY, 0, 0, 0, 0, 0 }; ++ ++/* ++** Release a lockInfo structure previously allocated by findLockInfo(). ++*/ ++static void releaseLockInfo(struct lockInfo *pLock){ ++ pLock->nRef--; ++ if( pLock->nRef==0 ){ ++ sqliteHashInsert(&lockHash, &pLock->key, sizeof(pLock->key), 0); ++ sqliteFree(pLock); ++ } ++} ++ ++/* ++** Release a openCnt structure previously allocated by findLockInfo(). ++*/ ++static void releaseOpenCnt(struct openCnt *pOpen){ ++ pOpen->nRef--; ++ if( pOpen->nRef==0 ){ ++ sqliteHashInsert(&openHash, &pOpen->key, sizeof(pOpen->key), 0); ++ sqliteFree(pOpen->aPending); ++ sqliteFree(pOpen); ++ } ++} ++ ++/* ++** Given a file descriptor, locate lockInfo and openCnt structures that ++** describes that file descriptor. Create a new ones if necessary. The ++** return values might be unset if an error occurs. ++** ++** Return the number of errors. ++*/ ++int findLockInfo( ++ int fd, /* The file descriptor used in the key */ ++ struct lockInfo **ppLock, /* Return the lockInfo structure here */ ++ struct openCnt **ppOpen /* Return the openCnt structure here */ ++){ ++ int rc; ++ struct lockKey key1; ++ struct openKey key2; ++ struct stat statbuf; ++ struct lockInfo *pLock; ++ struct openCnt *pOpen; ++ rc = fstat(fd, &statbuf); ++ if( rc!=0 ) return 1; ++ memset(&key1, 0, sizeof(key1)); ++ key1.dev = statbuf.st_dev; ++ key1.ino = statbuf.st_ino; ++ key1.pid = getpid(); ++ memset(&key2, 0, sizeof(key2)); ++ key2.dev = statbuf.st_dev; ++ key2.ino = statbuf.st_ino; ++ pLock = (struct lockInfo*)sqliteHashFind(&lockHash, &key1, sizeof(key1)); ++ if( pLock==0 ){ ++ struct lockInfo *pOld; ++ pLock = sqliteMallocRaw( sizeof(*pLock) ); ++ if( pLock==0 ) return 1; ++ pLock->key = key1; ++ pLock->nRef = 1; ++ pLock->cnt = 0; ++ pOld = sqliteHashInsert(&lockHash, &pLock->key, sizeof(key1), pLock); ++ if( pOld!=0 ){ ++ assert( pOld==pLock ); ++ sqliteFree(pLock); ++ return 1; ++ } ++ }else{ ++ pLock->nRef++; ++ } ++ *ppLock = pLock; ++ pOpen = (struct openCnt*)sqliteHashFind(&openHash, &key2, sizeof(key2)); ++ if( pOpen==0 ){ ++ struct openCnt *pOld; ++ pOpen = sqliteMallocRaw( sizeof(*pOpen) ); ++ if( pOpen==0 ){ ++ releaseLockInfo(pLock); ++ return 1; ++ } ++ pOpen->key = key2; ++ pOpen->nRef = 1; ++ pOpen->nLock = 0; ++ pOpen->nPending = 0; ++ pOpen->aPending = 0; ++ pOld = sqliteHashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen); ++ if( pOld!=0 ){ ++ assert( pOld==pOpen ); ++ sqliteFree(pOpen); ++ releaseLockInfo(pLock); ++ return 1; ++ } ++ }else{ ++ pOpen->nRef++; ++ } ++ *ppOpen = pOpen; ++ return 0; ++} ++ ++#endif /** POSIX advisory lock work-around **/ ++ ++/* ++** 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 ++int sqlite_io_error_pending = 0; ++#define SimulateIOError(A) \ ++ if( sqlite_io_error_pending ) \ ++ if( sqlite_io_error_pending-- == 1 ){ local_ioerr(); return A; } ++static void local_ioerr(){ ++ sqlite_io_error_pending = 0; /* Really just a place to set a breakpoint */ ++} ++#else ++#define SimulateIOError(A) ++#endif ++ ++/* ++** When testing, keep a count of the number of open files. ++*/ ++#ifdef SQLITE_TEST ++int sqlite_open_file_count = 0; ++#define OpenCounter(X) sqlite_open_file_count+=(X) ++#else ++#define OpenCounter(X) ++#endif ++ ++ ++/* ++** Delete the named file ++*/ ++int sqliteOsDelete(const char *zFilename){ ++#if OS_UNIX ++ unlink(zFilename); ++#endif ++#if OS_WIN ++ DeleteFile(zFilename); ++#endif ++#if OS_MAC ++ unlink(zFilename); ++#endif ++ return SQLITE_OK; ++} ++ ++/* ++** Return TRUE if the named file exists. ++*/ ++int sqliteOsFileExists(const char *zFilename){ ++#if OS_UNIX ++ return access(zFilename, 0)==0; ++#endif ++#if OS_WIN ++ return GetFileAttributes(zFilename) != 0xffffffff; ++#endif ++#if OS_MAC ++ return access(zFilename, 0)==0; ++#endif ++} ++ ++ ++#if 0 /* NOT USED */ ++/* ++** Change the name of an existing file. ++*/ ++int sqliteOsFileRename(const char *zOldName, const char *zNewName){ ++#if OS_UNIX ++ if( link(zOldName, zNewName) ){ ++ return SQLITE_ERROR; ++ } ++ unlink(zOldName); ++ return SQLITE_OK; ++#endif ++#if OS_WIN ++ if( !MoveFile(zOldName, zNewName) ){ ++ return SQLITE_ERROR; ++ } ++ return SQLITE_OK; ++#endif ++#if OS_MAC ++ /**** FIX ME ***/ ++ return SQLITE_ERROR; ++#endif ++} ++#endif /* NOT USED */ ++ ++/* ++** Attempt to open a file for both reading and writing. If that ++** fails, try opening it read-only. If the file does not exist, ++** try to create it. ++** ++** On success, a handle for the open file is written to *id ++** and *pReadonly is set to 0 if the file was opened for reading and ++** writing or 1 if the file was opened read-only. The function returns ++** SQLITE_OK. ++** ++** On failure, the function returns SQLITE_CANTOPEN and leaves ++** *id and *pReadonly unchanged. ++*/ ++int sqliteOsOpenReadWrite( ++ const char *zFilename, ++ OsFile *id, ++ int *pReadonly ++){ ++#if OS_UNIX ++ int rc; ++ id->dirfd = -1; ++ id->fd = open(zFilename, O_RDWR|O_CREAT|O_LARGEFILE|O_BINARY, 0644); ++ if( id->fd<0 ){ ++#ifdef EISDIR ++ if( errno==EISDIR ){ ++ return SQLITE_CANTOPEN; ++ } ++#endif ++ id->fd = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY); ++ if( id->fd<0 ){ ++ return SQLITE_CANTOPEN; ++ } ++ *pReadonly = 1; ++ }else{ ++ *pReadonly = 0; ++ } ++ sqliteOsEnterMutex(); ++ rc = findLockInfo(id->fd, &id->pLock, &id->pOpen); ++ sqliteOsLeaveMutex(); ++ if( rc ){ ++ close(id->fd); ++ return SQLITE_NOMEM; ++ } ++ id->locked = 0; ++ TRACE3("OPEN %-3d %s\n", id->fd, zFilename); ++ OpenCounter(+1); ++ return SQLITE_OK; ++#endif ++#if OS_WIN ++ HANDLE h = CreateFile(zFilename, ++ GENERIC_READ | GENERIC_WRITE, ++ FILE_SHARE_READ | FILE_SHARE_WRITE, ++ NULL, ++ OPEN_ALWAYS, ++ FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, ++ NULL ++ ); ++ if( h==INVALID_HANDLE_VALUE ){ ++ h = CreateFile(zFilename, ++ GENERIC_READ, ++ FILE_SHARE_READ, ++ NULL, ++ OPEN_ALWAYS, ++ FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, ++ NULL ++ ); ++ if( h==INVALID_HANDLE_VALUE ){ ++ return SQLITE_CANTOPEN; ++ } ++ *pReadonly = 1; ++ }else{ ++ *pReadonly = 0; ++ } ++ id->h = h; ++ id->locked = 0; ++ OpenCounter(+1); ++ return SQLITE_OK; ++#endif ++#if OS_MAC ++ FSSpec fsSpec; ++# ifdef _LARGE_FILE ++ HFSUniStr255 dfName; ++ FSRef fsRef; ++ if( __path2fss(zFilename, &fsSpec) != noErr ){ ++ if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr ) ++ return SQLITE_CANTOPEN; ++ } ++ if( FSpMakeFSRef(&fsSpec, &fsRef) != noErr ) ++ return SQLITE_CANTOPEN; ++ FSGetDataForkName(&dfName); ++ if( FSOpenFork(&fsRef, dfName.length, dfName.unicode, ++ fsRdWrShPerm, &(id->refNum)) != noErr ){ ++ if( FSOpenFork(&fsRef, dfName.length, dfName.unicode, ++ fsRdWrPerm, &(id->refNum)) != noErr ){ ++ if (FSOpenFork(&fsRef, dfName.length, dfName.unicode, ++ fsRdPerm, &(id->refNum)) != noErr ) ++ return SQLITE_CANTOPEN; ++ else ++ *pReadonly = 1; ++ } else ++ *pReadonly = 0; ++ } else ++ *pReadonly = 0; ++# else ++ __path2fss(zFilename, &fsSpec); ++ if( !sqliteOsFileExists(zFilename) ){ ++ if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr ) ++ return SQLITE_CANTOPEN; ++ } ++ if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNum)) != noErr ){ ++ if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrPerm, &(id->refNum)) != noErr ){ ++ if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdPerm, &(id->refNum)) != noErr ) ++ return SQLITE_CANTOPEN; ++ else ++ *pReadonly = 1; ++ } else ++ *pReadonly = 0; ++ } else ++ *pReadonly = 0; ++# endif ++ if( HOpenRF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNumRF)) != noErr){ ++ id->refNumRF = -1; ++ } ++ id->locked = 0; ++ id->delOnClose = 0; ++ OpenCounter(+1); ++ return SQLITE_OK; ++#endif ++} ++ ++ ++/* ++** Attempt to open a new file for exclusive access by this process. ++** The file will be opened for both reading and writing. To avoid ++** a potential security problem, we do not allow the file to have ++** previously existed. Nor do we allow the file to be a symbolic ++** link. ++** ++** If delFlag is true, then make arrangements to automatically delete ++** the file when it is closed. ++** ++** On success, write the file handle into *id and return SQLITE_OK. ++** ++** On failure, return SQLITE_CANTOPEN. ++*/ ++int sqliteOsOpenExclusive(const char *zFilename, OsFile *id, int delFlag){ ++#if OS_UNIX ++ int rc; ++ if( access(zFilename, 0)==0 ){ ++ return SQLITE_CANTOPEN; ++ } ++ id->dirfd = -1; ++ id->fd = open(zFilename, ++ O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW|O_LARGEFILE|O_BINARY, 0600); ++ if( id->fd<0 ){ ++ return SQLITE_CANTOPEN; ++ } ++ sqliteOsEnterMutex(); ++ rc = findLockInfo(id->fd, &id->pLock, &id->pOpen); ++ sqliteOsLeaveMutex(); ++ if( rc ){ ++ close(id->fd); ++ unlink(zFilename); ++ return SQLITE_NOMEM; ++ } ++ id->locked = 0; ++ if( delFlag ){ ++ unlink(zFilename); ++ } ++ TRACE3("OPEN-EX %-3d %s\n", id->fd, zFilename); ++ OpenCounter(+1); ++ return SQLITE_OK; ++#endif ++#if OS_WIN ++ HANDLE h; ++ int fileflags; ++ if( delFlag ){ ++ fileflags = FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_RANDOM_ACCESS ++ | FILE_FLAG_DELETE_ON_CLOSE; ++ }else{ ++ fileflags = FILE_FLAG_RANDOM_ACCESS; ++ } ++ h = CreateFile(zFilename, ++ GENERIC_READ | GENERIC_WRITE, ++ 0, ++ NULL, ++ CREATE_ALWAYS, ++ fileflags, ++ NULL ++ ); ++ if( h==INVALID_HANDLE_VALUE ){ ++ return SQLITE_CANTOPEN; ++ } ++ id->h = h; ++ id->locked = 0; ++ OpenCounter(+1); ++ return SQLITE_OK; ++#endif ++#if OS_MAC ++ FSSpec fsSpec; ++# ifdef _LARGE_FILE ++ HFSUniStr255 dfName; ++ FSRef fsRef; ++ __path2fss(zFilename, &fsSpec); ++ if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr ) ++ return SQLITE_CANTOPEN; ++ if( FSpMakeFSRef(&fsSpec, &fsRef) != noErr ) ++ return SQLITE_CANTOPEN; ++ FSGetDataForkName(&dfName); ++ if( FSOpenFork(&fsRef, dfName.length, dfName.unicode, ++ fsRdWrPerm, &(id->refNum)) != noErr ) ++ return SQLITE_CANTOPEN; ++# else ++ __path2fss(zFilename, &fsSpec); ++ if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr ) ++ return SQLITE_CANTOPEN; ++ if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrPerm, &(id->refNum)) != noErr ) ++ return SQLITE_CANTOPEN; ++# endif ++ id->refNumRF = -1; ++ id->locked = 0; ++ id->delOnClose = delFlag; ++ if (delFlag) ++ id->pathToDel = sqliteOsFullPathname(zFilename); ++ OpenCounter(+1); ++ return SQLITE_OK; ++#endif ++} ++ ++/* ++** Attempt to open a new file for read-only access. ++** ++** On success, write the file handle into *id and return SQLITE_OK. ++** ++** On failure, return SQLITE_CANTOPEN. ++*/ ++int sqliteOsOpenReadOnly(const char *zFilename, OsFile *id){ ++#if OS_UNIX ++ int rc; ++ id->dirfd = -1; ++ id->fd = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY); ++ if( id->fd<0 ){ ++ return SQLITE_CANTOPEN; ++ } ++ sqliteOsEnterMutex(); ++ rc = findLockInfo(id->fd, &id->pLock, &id->pOpen); ++ sqliteOsLeaveMutex(); ++ if( rc ){ ++ close(id->fd); ++ return SQLITE_NOMEM; ++ } ++ id->locked = 0; ++ TRACE3("OPEN-RO %-3d %s\n", id->fd, zFilename); ++ OpenCounter(+1); ++ return SQLITE_OK; ++#endif ++#if OS_WIN ++ HANDLE h = CreateFile(zFilename, ++ GENERIC_READ, ++ 0, ++ NULL, ++ OPEN_EXISTING, ++ FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, ++ NULL ++ ); ++ if( h==INVALID_HANDLE_VALUE ){ ++ return SQLITE_CANTOPEN; ++ } ++ id->h = h; ++ id->locked = 0; ++ OpenCounter(+1); ++ return SQLITE_OK; ++#endif ++#if OS_MAC ++ FSSpec fsSpec; ++# ifdef _LARGE_FILE ++ HFSUniStr255 dfName; ++ FSRef fsRef; ++ if( __path2fss(zFilename, &fsSpec) != noErr ) ++ return SQLITE_CANTOPEN; ++ if( FSpMakeFSRef(&fsSpec, &fsRef) != noErr ) ++ return SQLITE_CANTOPEN; ++ FSGetDataForkName(&dfName); ++ if( FSOpenFork(&fsRef, dfName.length, dfName.unicode, ++ fsRdPerm, &(id->refNum)) != noErr ) ++ return SQLITE_CANTOPEN; ++# else ++ __path2fss(zFilename, &fsSpec); ++ if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdPerm, &(id->refNum)) != noErr ) ++ return SQLITE_CANTOPEN; ++# endif ++ if( HOpenRF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNumRF)) != noErr){ ++ id->refNumRF = -1; ++ } ++ id->locked = 0; ++ id->delOnClose = 0; ++ OpenCounter(+1); ++ return SQLITE_OK; ++#endif ++} ++ ++/* ++** Attempt to open a file descriptor for the directory that contains a ++** file. This file descriptor can be used to fsync() the directory ++** in order to make sure the creation of a new file is actually written ++** to disk. ++** ++** This routine is only meaningful for Unix. It is a no-op under ++** windows since windows does not support hard links. ++** ++** On success, a handle for a previously open file is at *id is ++** updated with the new directory file descriptor and SQLITE_OK is ++** returned. ++** ++** On failure, the function returns SQLITE_CANTOPEN and leaves ++** *id unchanged. ++*/ ++int sqliteOsOpenDirectory( ++ const char *zDirname, ++ OsFile *id ++){ ++#if OS_UNIX ++ if( id->fd<0 ){ ++ /* Do not open the directory if the corresponding file is not already ++ ** open. */ ++ return SQLITE_CANTOPEN; ++ } ++ assert( id->dirfd<0 ); ++ id->dirfd = open(zDirname, O_RDONLY|O_BINARY, 0644); ++ if( id->dirfd<0 ){ ++ return SQLITE_CANTOPEN; ++ } ++ TRACE3("OPENDIR %-3d %s\n", id->dirfd, zDirname); ++#endif ++ return SQLITE_OK; ++} ++ ++/* ++** 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. ++*/ ++const char *sqlite_temp_directory = 0; ++ ++/* ++** Create a temporary file name in zBuf. zBuf must be big enough to ++** hold at least SQLITE_TEMPNAME_SIZE characters. ++*/ ++int sqliteOsTempFileName(char *zBuf){ ++#if OS_UNIX ++ static const char *azDirs[] = { ++ 0, ++ "/var/tmp", ++ "/usr/tmp", ++ "/tmp", ++ ".", ++ }; ++ static unsigned char zChars[] = ++ "abcdefghijklmnopqrstuvwxyz" ++ "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ++ "0123456789"; ++ int i, j; ++ struct stat buf; ++ const char *zDir = "."; ++ azDirs[0] = sqlite_temp_directory; ++ for(i=0; i0 && zTempPath[i-1]=='\\'; i--){} ++ zTempPath[i] = 0; ++ zDir = zTempPath; ++ }else{ ++ zDir = sqlite_temp_directory; ++ } ++ for(;;){ ++ sprintf(zBuf, "%s\\"TEMP_FILE_PREFIX, zDir); ++ j = strlen(zBuf); ++ sqliteRandomness(15, &zBuf[j]); ++ for(i=0; i<15; i++, j++){ ++ zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; ++ } ++ zBuf[j] = 0; ++ if( !sqliteOsFileExists(zBuf) ) break; ++ } ++#endif ++#if OS_MAC ++ static char zChars[] = ++ "abcdefghijklmnopqrstuvwxyz" ++ "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ++ "0123456789"; ++ int i, j; ++ char *zDir; ++ char zTempPath[SQLITE_TEMPNAME_SIZE]; ++ char zdirName[32]; ++ CInfoPBRec infoRec; ++ Str31 dirName; ++ memset(&infoRec, 0, sizeof(infoRec)); ++ memset(zTempPath, 0, SQLITE_TEMPNAME_SIZE); ++ if( sqlite_temp_directory!=0 ){ ++ zDir = sqlite_temp_directory; ++ }else if( FindFolder(kOnSystemDisk, kTemporaryFolderType, kCreateFolder, ++ &(infoRec.dirInfo.ioVRefNum), &(infoRec.dirInfo.ioDrParID)) == noErr ){ ++ infoRec.dirInfo.ioNamePtr = dirName; ++ do{ ++ infoRec.dirInfo.ioFDirIndex = -1; ++ infoRec.dirInfo.ioDrDirID = infoRec.dirInfo.ioDrParID; ++ if( PBGetCatInfoSync(&infoRec) == noErr ){ ++ CopyPascalStringToC(dirName, zdirName); ++ i = strlen(zdirName); ++ memmove(&(zTempPath[i+1]), zTempPath, strlen(zTempPath)); ++ strcpy(zTempPath, zdirName); ++ zTempPath[i] = ':'; ++ }else{ ++ *zTempPath = 0; ++ break; ++ } ++ } while( infoRec.dirInfo.ioDrDirID != fsRtDirID ); ++ zDir = zTempPath; ++ } ++ if( zDir[0]==0 ){ ++ getcwd(zTempPath, SQLITE_TEMPNAME_SIZE-24); ++ zDir = zTempPath; ++ } ++ for(;;){ ++ sprintf(zBuf, "%s"TEMP_FILE_PREFIX, zDir); ++ j = strlen(zBuf); ++ sqliteRandomness(15, &zBuf[j]); ++ for(i=0; i<15; i++, j++){ ++ zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; ++ } ++ zBuf[j] = 0; ++ if( !sqliteOsFileExists(zBuf) ) break; ++ } ++#endif ++ return SQLITE_OK; ++} ++ ++/* ++** Close a file. ++*/ ++int sqliteOsClose(OsFile *id){ ++#if OS_UNIX ++ sqliteOsUnlock(id); ++ if( id->dirfd>=0 ) close(id->dirfd); ++ id->dirfd = -1; ++ sqliteOsEnterMutex(); ++ if( id->pOpen->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 pOpen->aPending. It will be automatically closed when ++ ** the last lock is cleared. ++ */ ++ int *aNew; ++ struct openCnt *pOpen = id->pOpen; ++ pOpen->nPending++; ++ aNew = sqliteRealloc( pOpen->aPending, pOpen->nPending*sizeof(int) ); ++ if( aNew==0 ){ ++ /* If a malloc fails, just leak the file descriptor */ ++ }else{ ++ pOpen->aPending = aNew; ++ pOpen->aPending[pOpen->nPending-1] = id->fd; ++ } ++ }else{ ++ /* There are no outstanding locks so we can close the file immediately */ ++ close(id->fd); ++ } ++ releaseLockInfo(id->pLock); ++ releaseOpenCnt(id->pOpen); ++ sqliteOsLeaveMutex(); ++ TRACE2("CLOSE %-3d\n", id->fd); ++ OpenCounter(-1); ++ return SQLITE_OK; ++#endif ++#if OS_WIN ++ CloseHandle(id->h); ++ OpenCounter(-1); ++ return SQLITE_OK; ++#endif ++#if OS_MAC ++ if( id->refNumRF!=-1 ) ++ FSClose(id->refNumRF); ++# ifdef _LARGE_FILE ++ FSCloseFork(id->refNum); ++# else ++ FSClose(id->refNum); ++# endif ++ if( id->delOnClose ){ ++ unlink(id->pathToDel); ++ sqliteFree(id->pathToDel); ++ } ++ OpenCounter(-1); ++ return SQLITE_OK; ++#endif ++} ++ ++/* ++** Read data from a file into a buffer. Return SQLITE_OK if all ++** bytes were read successfully and SQLITE_IOERR if anything goes ++** wrong. ++*/ ++int sqliteOsRead(OsFile *id, void *pBuf, int amt){ ++#if OS_UNIX ++ int got; ++ SimulateIOError(SQLITE_IOERR); ++ TIMER_START; ++ got = read(id->fd, pBuf, amt); ++ TIMER_END; ++ TRACE4("READ %-3d %7d %d\n", id->fd, last_page, elapse); ++ SEEK(0); ++ /* if( got<0 ) got = 0; */ ++ if( got==amt ){ ++ return SQLITE_OK; ++ }else{ ++ return SQLITE_IOERR; ++ } ++#endif ++#if OS_WIN ++ DWORD got; ++ SimulateIOError(SQLITE_IOERR); ++ TRACE2("READ %d\n", last_page); ++ if( !ReadFile(id->h, pBuf, amt, &got, 0) ){ ++ got = 0; ++ } ++ if( got==(DWORD)amt ){ ++ return SQLITE_OK; ++ }else{ ++ return SQLITE_IOERR; ++ } ++#endif ++#if OS_MAC ++ int got; ++ SimulateIOError(SQLITE_IOERR); ++ TRACE2("READ %d\n", last_page); ++# ifdef _LARGE_FILE ++ FSReadFork(id->refNum, fsAtMark, 0, (ByteCount)amt, pBuf, (ByteCount*)&got); ++# else ++ got = amt; ++ FSRead(id->refNum, &got, pBuf); ++# endif ++ if( got==amt ){ ++ return SQLITE_OK; ++ }else{ ++ return SQLITE_IOERR; ++ } ++#endif ++} ++ ++/* ++** Write data from a buffer into a file. Return SQLITE_OK on success ++** or some other error code on failure. ++*/ ++int sqliteOsWrite(OsFile *id, const void *pBuf, int amt){ ++#if OS_UNIX ++ int wrote = 0; ++ SimulateIOError(SQLITE_IOERR); ++ TIMER_START; ++ while( amt>0 && (wrote = write(id->fd, pBuf, amt))>0 ){ ++ amt -= wrote; ++ pBuf = &((char*)pBuf)[wrote]; ++ } ++ TIMER_END; ++ TRACE4("WRITE %-3d %7d %d\n", id->fd, last_page, elapse); ++ SEEK(0); ++ if( amt>0 ){ ++ return SQLITE_FULL; ++ } ++ return SQLITE_OK; ++#endif ++#if OS_WIN ++ int rc; ++ DWORD wrote; ++ SimulateIOError(SQLITE_IOERR); ++ TRACE2("WRITE %d\n", last_page); ++ while( amt>0 && (rc = WriteFile(id->h, pBuf, amt, &wrote, 0))!=0 && wrote>0 ){ ++ amt -= wrote; ++ pBuf = &((char*)pBuf)[wrote]; ++ } ++ if( !rc || amt>(int)wrote ){ ++ return SQLITE_FULL; ++ } ++ return SQLITE_OK; ++#endif ++#if OS_MAC ++ OSErr oserr; ++ int wrote = 0; ++ SimulateIOError(SQLITE_IOERR); ++ TRACE2("WRITE %d\n", last_page); ++ while( amt>0 ){ ++# ifdef _LARGE_FILE ++ oserr = FSWriteFork(id->refNum, fsAtMark, 0, ++ (ByteCount)amt, pBuf, (ByteCount*)&wrote); ++# else ++ wrote = amt; ++ oserr = FSWrite(id->refNum, &wrote, pBuf); ++# endif ++ if( wrote == 0 || oserr != noErr) ++ break; ++ amt -= wrote; ++ pBuf = &((char*)pBuf)[wrote]; ++ } ++ if( oserr != noErr || amt>wrote ){ ++ return SQLITE_FULL; ++ } ++ return SQLITE_OK; ++#endif ++} ++ ++/* ++** Move the read/write pointer in a file. ++*/ ++int sqliteOsSeek(OsFile *id, off_t offset){ ++ SEEK(offset/1024 + 1); ++#if OS_UNIX ++ lseek(id->fd, offset, SEEK_SET); ++ return SQLITE_OK; ++#endif ++#if OS_WIN ++ { ++ LONG upperBits = offset>>32; ++ LONG lowerBits = offset & 0xffffffff; ++ DWORD rc; ++ rc = SetFilePointer(id->h, lowerBits, &upperBits, FILE_BEGIN); ++ /* TRACE3("SEEK rc=0x%x upper=0x%x\n", rc, upperBits); */ ++ } ++ return SQLITE_OK; ++#endif ++#if OS_MAC ++ { ++ off_t curSize; ++ if( sqliteOsFileSize(id, &curSize) != SQLITE_OK ){ ++ return SQLITE_IOERR; ++ } ++ if( offset >= curSize ){ ++ if( sqliteOsTruncate(id, offset+1) != SQLITE_OK ){ ++ return SQLITE_IOERR; ++ } ++ } ++# ifdef _LARGE_FILE ++ if( FSSetForkPosition(id->refNum, fsFromStart, offset) != noErr ){ ++# else ++ if( SetFPos(id->refNum, fsFromStart, offset) != noErr ){ ++# endif ++ return SQLITE_IOERR; ++ }else{ ++ return SQLITE_OK; ++ } ++ } ++#endif ++} ++ ++#ifdef SQLITE_NOSYNC ++# define fsync(X) 0 ++#endif ++ ++/* ++** Make sure all writes to a particular file are committed to disk. ++** ++** 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. ++*/ ++int sqliteOsSync(OsFile *id){ ++#if OS_UNIX ++ SimulateIOError(SQLITE_IOERR); ++ TRACE2("SYNC %-3d\n", id->fd); ++ if( fsync(id->fd) ){ ++ return SQLITE_IOERR; ++ }else{ ++ if( id->dirfd>=0 ){ ++ TRACE2("DIRSYNC %-3d\n", id->dirfd); ++ fsync(id->dirfd); ++ close(id->dirfd); /* Only need to sync once, so close the directory */ ++ id->dirfd = -1; /* when we are done. */ ++ } ++ return SQLITE_OK; ++ } ++#endif ++#if OS_WIN ++ if( FlushFileBuffers(id->h) ){ ++ return SQLITE_OK; ++ }else{ ++ return SQLITE_IOERR; ++ } ++#endif ++#if OS_MAC ++# ifdef _LARGE_FILE ++ if( FSFlushFork(id->refNum) != noErr ){ ++# else ++ ParamBlockRec params; ++ memset(¶ms, 0, sizeof(ParamBlockRec)); ++ params.ioParam.ioRefNum = id->refNum; ++ if( PBFlushFileSync(¶ms) != noErr ){ ++# endif ++ return SQLITE_IOERR; ++ }else{ ++ return SQLITE_OK; ++ } ++#endif ++} ++ ++/* ++** Truncate an open file to a specified size ++*/ ++int sqliteOsTruncate(OsFile *id, off_t nByte){ ++ SimulateIOError(SQLITE_IOERR); ++#if OS_UNIX ++ return ftruncate(id->fd, nByte)==0 ? SQLITE_OK : SQLITE_IOERR; ++#endif ++#if OS_WIN ++ { ++ LONG upperBits = nByte>>32; ++ SetFilePointer(id->h, nByte, &upperBits, FILE_BEGIN); ++ SetEndOfFile(id->h); ++ } ++ return SQLITE_OK; ++#endif ++#if OS_MAC ++# ifdef _LARGE_FILE ++ if( FSSetForkSize(id->refNum, fsFromStart, nByte) != noErr){ ++# else ++ if( SetEOF(id->refNum, nByte) != noErr ){ ++# endif ++ return SQLITE_IOERR; ++ }else{ ++ return SQLITE_OK; ++ } ++#endif ++} ++ ++/* ++** Determine the current size of a file in bytes ++*/ ++int sqliteOsFileSize(OsFile *id, off_t *pSize){ ++#if OS_UNIX ++ struct stat buf; ++ SimulateIOError(SQLITE_IOERR); ++ if( fstat(id->fd, &buf)!=0 ){ ++ return SQLITE_IOERR; ++ } ++ *pSize = buf.st_size; ++ return SQLITE_OK; ++#endif ++#if OS_WIN ++ DWORD upperBits, lowerBits; ++ SimulateIOError(SQLITE_IOERR); ++ lowerBits = GetFileSize(id->h, &upperBits); ++ *pSize = (((off_t)upperBits)<<32) + lowerBits; ++ return SQLITE_OK; ++#endif ++#if OS_MAC ++# ifdef _LARGE_FILE ++ if( FSGetForkSize(id->refNum, pSize) != noErr){ ++# else ++ if( GetEOF(id->refNum, pSize) != noErr ){ ++# endif ++ return SQLITE_IOERR; ++ }else{ ++ return SQLITE_OK; ++ } ++#endif ++} ++ ++#if OS_WIN ++/* ++** Return true (non-zero) if we are running under WinNT, Win2K or WinXP. ++** 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 win 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. ++*/ ++int isNT(void){ ++ static int osType = 0; /* 0=unknown 1=win95 2=winNT */ ++ if( osType==0 ){ ++ OSVERSIONINFO sInfo; ++ sInfo.dwOSVersionInfoSize = sizeof(sInfo); ++ GetVersionEx(&sInfo); ++ osType = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1; ++ } ++ return osType==2; ++} ++#endif ++ ++/* ++** Windows file locking notes: [similar issues apply to MacOS] ++** ++** 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. ++** (This is a design error on the part of Windows, but there is nothing ++** we can do about that.) So the region used for locking is at the ++** end of the file where it is unlikely to ever interfere with an ++** actual read attempt. ++** ++** A database read 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. ++** A database write lock is obtained by locking all bytes in the range. ++** There can only be one writer. ++** ++** A lock is obtained on the first byte of the lock range before acquiring ++** either a read lock or a write lock. This prevents two processes from ++** attempting to get a lock at a same time. The semantics of ++** sqliteOsReadLock() require that if there is already a write lock, that ++** lock is converted into a read lock atomically. The lock on the first ++** byte allows us to drop the old write lock and get the read lock without ++** another process jumping into the middle and messing us up. The same ++** argument applies to sqliteOsWriteLock(). ++** ++** 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. ++** ++** Note: On MacOS we use the resource fork for locking. ++** ++** The following #defines specify the range of bytes used for locking. ++** N_LOCKBYTE is the number of bytes available for doing the locking. ++** The first byte used to hold the lock while the lock is changing does ++** not count toward this number. FIRST_LOCKBYTE is the address of ++** the first byte in the range of bytes used for locking. ++*/ ++#define N_LOCKBYTE 10239 ++#if OS_MAC ++# define FIRST_LOCKBYTE (0x000fffff - N_LOCKBYTE) ++#else ++# define FIRST_LOCKBYTE (0xffffffff - N_LOCKBYTE) ++#endif ++ ++/* ++** Change the status of the lock on the file "id" to be a readlock. ++** If the file was write locked, then this reduces the lock to a read. ++** If the file was read locked, then this acquires a new read lock. ++** ++** Return SQLITE_OK on success and SQLITE_BUSY on failure. If this ++** library was compiled with large file support (LFS) but LFS is not ++** available on the host, then an SQLITE_NOLFS is returned. ++*/ ++int sqliteOsReadLock(OsFile *id){ ++#if OS_UNIX ++ int rc; ++ sqliteOsEnterMutex(); ++ if( id->pLock->cnt>0 ){ ++ if( !id->locked ){ ++ id->pLock->cnt++; ++ id->locked = 1; ++ id->pOpen->nLock++; ++ } ++ rc = SQLITE_OK; ++ }else if( id->locked || id->pLock->cnt==0 ){ ++ struct flock lock; ++ int s; ++ lock.l_type = F_RDLCK; ++ lock.l_whence = SEEK_SET; ++ lock.l_start = lock.l_len = 0L; ++ s = fcntl(id->fd, F_SETLK, &lock); ++ if( s!=0 ){ ++ rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY; ++ }else{ ++ rc = SQLITE_OK; ++ if( !id->locked ){ ++ id->pOpen->nLock++; ++ id->locked = 1; ++ } ++ id->pLock->cnt = 1; ++ } ++ }else{ ++ rc = SQLITE_BUSY; ++ } ++ sqliteOsLeaveMutex(); ++ return rc; ++#endif ++#if OS_WIN ++ int rc; ++ if( id->locked>0 ){ ++ rc = SQLITE_OK; ++ }else{ ++ int lk; ++ int res; ++ int cnt = 100; ++ sqliteRandomness(sizeof(lk), &lk); ++ lk = (lk & 0x7fffffff)%N_LOCKBYTE + 1; ++ while( cnt-->0 && (res = LockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0))==0 ){ ++ Sleep(1); ++ } ++ if( res ){ ++ UnlockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0); ++ if( isNT() ){ ++ OVERLAPPED ovlp; ++ ovlp.Offset = FIRST_LOCKBYTE+1; ++ ovlp.OffsetHigh = 0; ++ ovlp.hEvent = 0; ++ res = LockFileEx(id->h, LOCKFILE_FAIL_IMMEDIATELY, ++ 0, N_LOCKBYTE, 0, &ovlp); ++ }else{ ++ res = LockFile(id->h, FIRST_LOCKBYTE+lk, 0, 1, 0); ++ } ++ UnlockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0); ++ } ++ if( res ){ ++ id->locked = lk; ++ rc = SQLITE_OK; ++ }else{ ++ rc = SQLITE_BUSY; ++ } ++ } ++ return rc; ++#endif ++#if OS_MAC ++ int rc; ++ if( id->locked>0 || id->refNumRF == -1 ){ ++ rc = SQLITE_OK; ++ }else{ ++ int lk; ++ OSErr res; ++ int cnt = 5; ++ ParamBlockRec params; ++ sqliteRandomness(sizeof(lk), &lk); ++ lk = (lk & 0x7fffffff)%N_LOCKBYTE + 1; ++ memset(¶ms, 0, sizeof(params)); ++ params.ioParam.ioRefNum = id->refNumRF; ++ params.ioParam.ioPosMode = fsFromStart; ++ params.ioParam.ioPosOffset = FIRST_LOCKBYTE; ++ params.ioParam.ioReqCount = 1; ++ while( cnt-->0 && (res = PBLockRangeSync(¶ms))!=noErr ){ ++ UInt32 finalTicks; ++ Delay(1, &finalTicks); /* 1/60 sec */ ++ } ++ if( res == noErr ){ ++ params.ioParam.ioPosOffset = FIRST_LOCKBYTE+1; ++ params.ioParam.ioReqCount = N_LOCKBYTE; ++ PBUnlockRangeSync(¶ms); ++ params.ioParam.ioPosOffset = FIRST_LOCKBYTE+lk; ++ params.ioParam.ioReqCount = 1; ++ res = PBLockRangeSync(¶ms); ++ params.ioParam.ioPosOffset = FIRST_LOCKBYTE; ++ params.ioParam.ioReqCount = 1; ++ PBUnlockRangeSync(¶ms); ++ } ++ if( res == noErr ){ ++ id->locked = lk; ++ rc = SQLITE_OK; ++ }else{ ++ rc = SQLITE_BUSY; ++ } ++ } ++ return rc; ++#endif ++} ++ ++/* ++** Change the lock status to be an exclusive or write lock. Return ++** SQLITE_OK on success and SQLITE_BUSY on a failure. If this ++** library was compiled with large file support (LFS) but LFS is not ++** available on the host, then an SQLITE_NOLFS is returned. ++*/ ++int sqliteOsWriteLock(OsFile *id){ ++#if OS_UNIX ++ int rc; ++ sqliteOsEnterMutex(); ++ if( id->pLock->cnt==0 || (id->pLock->cnt==1 && id->locked==1) ){ ++ struct flock lock; ++ int s; ++ lock.l_type = F_WRLCK; ++ lock.l_whence = SEEK_SET; ++ lock.l_start = lock.l_len = 0L; ++ s = fcntl(id->fd, F_SETLK, &lock); ++ if( s!=0 ){ ++ rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY; ++ }else{ ++ rc = SQLITE_OK; ++ if( !id->locked ){ ++ id->pOpen->nLock++; ++ id->locked = 1; ++ } ++ id->pLock->cnt = -1; ++ } ++ }else{ ++ rc = SQLITE_BUSY; ++ } ++ sqliteOsLeaveMutex(); ++ return rc; ++#endif ++#if OS_WIN ++ int rc; ++ if( id->locked<0 ){ ++ rc = SQLITE_OK; ++ }else{ ++ int res; ++ int cnt = 100; ++ while( cnt-->0 && (res = LockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0))==0 ){ ++ Sleep(1); ++ } ++ if( res ){ ++ if( id->locked>0 ){ ++ if( isNT() ){ ++ UnlockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0); ++ }else{ ++ res = UnlockFile(id->h, FIRST_LOCKBYTE + id->locked, 0, 1, 0); ++ } ++ } ++ if( res ){ ++ res = LockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0); ++ }else{ ++ res = 0; ++ } ++ UnlockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0); ++ } ++ if( res ){ ++ id->locked = -1; ++ rc = SQLITE_OK; ++ }else{ ++ rc = SQLITE_BUSY; ++ } ++ } ++ return rc; ++#endif ++#if OS_MAC ++ int rc; ++ if( id->locked<0 || id->refNumRF == -1 ){ ++ rc = SQLITE_OK; ++ }else{ ++ OSErr res; ++ int cnt = 5; ++ ParamBlockRec params; ++ memset(¶ms, 0, sizeof(params)); ++ params.ioParam.ioRefNum = id->refNumRF; ++ params.ioParam.ioPosMode = fsFromStart; ++ params.ioParam.ioPosOffset = FIRST_LOCKBYTE; ++ params.ioParam.ioReqCount = 1; ++ while( cnt-->0 && (res = PBLockRangeSync(¶ms))!=noErr ){ ++ UInt32 finalTicks; ++ Delay(1, &finalTicks); /* 1/60 sec */ ++ } ++ if( res == noErr ){ ++ params.ioParam.ioPosOffset = FIRST_LOCKBYTE + id->locked; ++ params.ioParam.ioReqCount = 1; ++ if( id->locked==0 ++ || PBUnlockRangeSync(¶ms)==noErr ){ ++ params.ioParam.ioPosOffset = FIRST_LOCKBYTE+1; ++ params.ioParam.ioReqCount = N_LOCKBYTE; ++ res = PBLockRangeSync(¶ms); ++ }else{ ++ res = afpRangeNotLocked; ++ } ++ params.ioParam.ioPosOffset = FIRST_LOCKBYTE; ++ params.ioParam.ioReqCount = 1; ++ PBUnlockRangeSync(¶ms); ++ } ++ if( res == noErr ){ ++ id->locked = -1; ++ rc = SQLITE_OK; ++ }else{ ++ rc = SQLITE_BUSY; ++ } ++ } ++ return rc; ++#endif ++} ++ ++/* ++** Unlock the given file descriptor. If the file descriptor was ++** not previously locked, then this routine is a no-op. If this ++** library was compiled with large file support (LFS) but LFS is not ++** available on the host, then an SQLITE_NOLFS is returned. ++*/ ++int sqliteOsUnlock(OsFile *id){ ++#if OS_UNIX ++ int rc; ++ if( !id->locked ) return SQLITE_OK; ++ sqliteOsEnterMutex(); ++ assert( id->pLock->cnt!=0 ); ++ if( id->pLock->cnt>1 ){ ++ id->pLock->cnt--; ++ rc = SQLITE_OK; ++ }else{ ++ struct flock lock; ++ int s; ++ lock.l_type = F_UNLCK; ++ lock.l_whence = SEEK_SET; ++ lock.l_start = lock.l_len = 0L; ++ s = fcntl(id->fd, F_SETLK, &lock); ++ if( s!=0 ){ ++ rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY; ++ }else{ ++ rc = SQLITE_OK; ++ id->pLock->cnt = 0; ++ } ++ } ++ if( rc==SQLITE_OK ){ ++ /* 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. ++ */ ++ struct openCnt *pOpen = id->pOpen; ++ pOpen->nLock--; ++ assert( pOpen->nLock>=0 ); ++ if( pOpen->nLock==0 && pOpen->nPending>0 ){ ++ int i; ++ for(i=0; inPending; i++){ ++ close(pOpen->aPending[i]); ++ } ++ sqliteFree(pOpen->aPending); ++ pOpen->nPending = 0; ++ pOpen->aPending = 0; ++ } ++ } ++ sqliteOsLeaveMutex(); ++ id->locked = 0; ++ return rc; ++#endif ++#if OS_WIN ++ int rc; ++ if( id->locked==0 ){ ++ rc = SQLITE_OK; ++ }else if( isNT() || id->locked<0 ){ ++ UnlockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0); ++ rc = SQLITE_OK; ++ id->locked = 0; ++ }else{ ++ UnlockFile(id->h, FIRST_LOCKBYTE+id->locked, 0, 1, 0); ++ rc = SQLITE_OK; ++ id->locked = 0; ++ } ++ return rc; ++#endif ++#if OS_MAC ++ int rc; ++ ParamBlockRec params; ++ memset(¶ms, 0, sizeof(params)); ++ params.ioParam.ioRefNum = id->refNumRF; ++ params.ioParam.ioPosMode = fsFromStart; ++ if( id->locked==0 || id->refNumRF == -1 ){ ++ rc = SQLITE_OK; ++ }else if( id->locked<0 ){ ++ params.ioParam.ioPosOffset = FIRST_LOCKBYTE+1; ++ params.ioParam.ioReqCount = N_LOCKBYTE; ++ PBUnlockRangeSync(¶ms); ++ rc = SQLITE_OK; ++ id->locked = 0; ++ }else{ ++ params.ioParam.ioPosOffset = FIRST_LOCKBYTE+id->locked; ++ params.ioParam.ioReqCount = 1; ++ PBUnlockRangeSync(¶ms); ++ rc = SQLITE_OK; ++ id->locked = 0; ++ } ++ return rc; ++#endif ++} ++ ++/* ++** Get information to seed the random number generator. The seed ++** is written into the buffer zBuf[256]. The calling function must ++** supply a sufficiently large buffer. ++*/ ++int sqliteOsRandomSeed(char *zBuf){ ++ /* 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, 256); ++#if OS_UNIX && !defined(SQLITE_TEST) ++ { ++ int pid; ++ time((time_t*)zBuf); ++ pid = getpid(); ++ memcpy(&zBuf[sizeof(time_t)], &pid, sizeof(pid)); ++ } ++#endif ++#if OS_WIN && !defined(SQLITE_TEST) ++ GetSystemTime((LPSYSTEMTIME)zBuf); ++#endif ++#if OS_MAC ++ { ++ int pid; ++ Microseconds((UnsignedWide*)zBuf); ++ pid = getpid(); ++ memcpy(&zBuf[sizeof(UnsignedWide)], &pid, sizeof(pid)); ++ } ++#endif ++ return SQLITE_OK; ++} ++ ++/* ++** Sleep for a little while. Return the amount of time slept. ++*/ ++int sqliteOsSleep(int ms){ ++#if OS_UNIX ++#if defined(HAVE_USLEEP) && HAVE_USLEEP ++ usleep(ms*1000); ++ return ms; ++#else ++ sleep((ms+999)/1000); ++ return 1000*((ms+999)/1000); ++#endif ++#endif ++#if OS_WIN ++ Sleep(ms); ++ return ms; ++#endif ++#if OS_MAC ++ UInt32 finalTicks; ++ UInt32 ticks = (((UInt32)ms+16)*3)/50; /* 1/60 sec per tick */ ++ Delay(ticks, &finalTicks); ++ return (int)((ticks*50)/3); ++#endif ++} ++ ++/* ++** Static variables used for thread synchronization ++*/ ++static int inMutex = 0; ++#ifdef SQLITE_UNIX_THREADS ++ static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; ++#endif ++#ifdef SQLITE_W32_THREADS ++ static CRITICAL_SECTION cs; ++#endif ++#ifdef SQLITE_MACOS_MULTITASKING ++ static MPCriticalRegionID criticalRegion; ++#endif ++ ++/* ++** The following pair of routine implement mutual exclusion for ++** multi-threaded processes. Only a single thread is allowed to ++** executed code that is surrounded by EnterMutex() and LeaveMutex(). ++** ++** SQLite uses only a single Mutex. There is not much critical ++** code and what little there is executes quickly and without blocking. ++*/ ++void sqliteOsEnterMutex(){ ++#ifdef SQLITE_UNIX_THREADS ++ pthread_mutex_lock(&mutex); ++#endif ++#ifdef SQLITE_W32_THREADS ++ static int isInit = 0; ++ while( !isInit ){ ++ static long lock = 0; ++ if( InterlockedIncrement(&lock)==1 ){ ++ InitializeCriticalSection(&cs); ++ isInit = 1; ++ }else{ ++ Sleep(1); ++ } ++ } ++ EnterCriticalSection(&cs); ++#endif ++#ifdef SQLITE_MACOS_MULTITASKING ++ static volatile int notInit = 1; ++ if( notInit ){ ++ if( notInit == 2 ) /* as close as you can get to thread safe init */ ++ MPYield(); ++ else{ ++ notInit = 2; ++ MPCreateCriticalRegion(&criticalRegion); ++ notInit = 0; ++ } ++ } ++ MPEnterCriticalRegion(criticalRegion, kDurationForever); ++#endif ++ assert( !inMutex ); ++ inMutex = 1; ++} ++void sqliteOsLeaveMutex(){ ++ assert( inMutex ); ++ inMutex = 0; ++#ifdef SQLITE_UNIX_THREADS ++ pthread_mutex_unlock(&mutex); ++#endif ++#ifdef SQLITE_W32_THREADS ++ LeaveCriticalSection(&cs); ++#endif ++#ifdef SQLITE_MACOS_MULTITASKING ++ MPExitCriticalRegion(criticalRegion); ++#endif ++} ++ ++/* ++** Turn a relative pathname into a full pathname. Return a pointer ++** to the full pathname stored in space obtained from sqliteMalloc(). ++** The calling function is responsible for freeing this space once it ++** is no longer needed. ++*/ ++char *sqliteOsFullPathname(const char *zRelative){ ++#if OS_UNIX ++ char *zFull = 0; ++ if( zRelative[0]=='/' ){ ++ sqliteSetString(&zFull, zRelative, (char*)0); ++ }else{ ++ char zBuf[5000]; ++ zBuf[0] = 0; ++ sqliteSetString(&zFull, getcwd(zBuf, sizeof(zBuf)), "/", zRelative, ++ (char*)0); ++ } ++ return zFull; ++#endif ++#if OS_WIN ++ char *zNotUsed; ++ char *zFull; ++ int nByte; ++ nByte = GetFullPathName(zRelative, 0, 0, &zNotUsed) + 1; ++ zFull = sqliteMalloc( nByte ); ++ if( zFull==0 ) return 0; ++ GetFullPathName(zRelative, nByte, zFull, &zNotUsed); ++ return zFull; ++#endif ++#if OS_MAC ++ char *zFull = 0; ++ if( zRelative[0]==':' ){ ++ char zBuf[_MAX_PATH+1]; ++ sqliteSetString(&zFull, getcwd(zBuf, sizeof(zBuf)), &(zRelative[1]), ++ (char*)0); ++ }else{ ++ if( strchr(zRelative, ':') ){ ++ sqliteSetString(&zFull, zRelative, (char*)0); ++ }else{ ++ char zBuf[_MAX_PATH+1]; ++ sqliteSetString(&zFull, getcwd(zBuf, sizeof(zBuf)), zRelative, (char*)0); ++ } ++ } ++ return zFull; ++#endif ++} ++ ++/* ++** The following variable, if set to a non-zero value, becomes the result ++** returned from sqliteOsCurrentTime(). This is used for testing. ++*/ ++#ifdef SQLITE_TEST ++int sqlite_current_time = 0; ++#endif ++ ++/* ++** 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. ++*/ ++int sqliteOsCurrentTime(double *prNow){ ++#if OS_UNIX ++ time_t t; ++ time(&t); ++ *prNow = t/86400.0 + 2440587.5; ++#endif ++#if OS_WIN ++ FILETIME ft; ++ /* FILETIME structure is a 64-bit value representing the number of ++ 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5). ++ */ ++ double now; ++ GetSystemTimeAsFileTime( &ft ); ++ now = ((double)ft.dwHighDateTime) * 4294967296.0; ++ *prNow = (now + ft.dwLowDateTime)/864000000000.0 + 2305813.5; ++#endif ++#ifdef SQLITE_TEST ++ if( sqlite_current_time ){ ++ *prNow = sqlite_current_time/86400.0 + 2440587.5; ++ } ++#endif ++ return 0; ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/os.h +@@ -0,0 +1,191 @@ ++/* ++** 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. ++*/ ++#ifndef _SQLITE_OS_H_ ++#define _SQLITE_OS_H_ ++ ++/* ++** Helpful hint: To get this to compile on HP/UX, add -D_INCLUDE_POSIX_SOURCE ++** to the compiler command line. ++*/ ++ ++/* ++** 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. ++** ++** 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: RedHat 7.2) but you want your code to work ++** on an older machine (ex: RedHat 6.0). If you compile on RedHat 7.2 ++** without this option, LFS is enable. But LFS does not exist in the kernel ++** in RedHat 6.0, so the code won't work. Hence, for maximum binary ++** portability you should omit LFS. ++** ++** Similar is true for MacOS. LFS is only supported on MacOS 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 ++ ++/* ++** 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 -DTEMP_FILE_PREFIX=myprefix_ on the compiler command line. ++*/ ++#ifndef TEMP_FILE_PREFIX ++# define TEMP_FILE_PREFIX "sqlite_" ++#endif ++ ++/* ++** Figure out if we are dealing with Unix, Windows or MacOS. ++** ++** N.B. MacOS means Mac Classic (or Carbon). Treat Darwin (OS X) as Unix. ++** The MacOS build is designed to use CodeWarrior (tested with v8) ++*/ ++#ifndef OS_UNIX ++# ifndef OS_WIN ++# ifndef OS_MAC ++# if defined(__MACOS__) ++# define OS_MAC 1 ++# define OS_WIN 0 ++# define OS_UNIX 0 ++# elif defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__) ++# define OS_MAC 0 ++# define OS_WIN 1 ++# define OS_UNIX 0 ++# else ++# define OS_MAC 0 ++# define OS_WIN 0 ++# define OS_UNIX 1 ++# endif ++# else ++# define OS_WIN 0 ++# define OS_UNIX 0 ++# endif ++# else ++# define OS_MAC 0 ++# define OS_UNIX 0 ++# endif ++#else ++# define OS_MAC 0 ++# ifndef OS_WIN ++# define OS_WIN 0 ++# endif ++#endif ++ ++/* ++** A handle for an open file is stored in an OsFile object. ++*/ ++#if OS_UNIX ++# include ++# include ++# include ++# include ++ typedef struct OsFile OsFile; ++ struct OsFile { ++ struct openCnt *pOpen; /* Info about all open fd's on this inode */ ++ struct lockInfo *pLock; /* Info about locks on this inode */ ++ int fd; /* The file descriptor */ ++ int locked; /* True if this instance holds the lock */ ++ int dirfd; /* File descriptor for the directory */ ++ }; ++# define SQLITE_TEMPNAME_SIZE 200 ++# if defined(HAVE_USLEEP) && HAVE_USLEEP ++# define SQLITE_MIN_SLEEP_MS 1 ++# else ++# define SQLITE_MIN_SLEEP_MS 1000 ++# endif ++#endif ++ ++#if OS_WIN ++#include ++#include ++ typedef struct OsFile OsFile; ++ struct OsFile { ++ HANDLE h; /* Handle for accessing the file */ ++ int locked; /* 0: unlocked, <0: write lock, >0: read lock */ ++ }; ++# if defined(_MSC_VER) || defined(__BORLANDC__) ++ typedef __int64 off_t; ++# else ++# if !defined(_CYGWIN_TYPES_H) ++ typedef long long off_t; ++# if defined(__MINGW32__) ++# define _OFF_T_ ++# endif ++# endif ++# endif ++# define SQLITE_TEMPNAME_SIZE (MAX_PATH+50) ++# define SQLITE_MIN_SLEEP_MS 1 ++#endif ++ ++#if OS_MAC ++# include ++# include ++ typedef struct OsFile OsFile; ++ struct OsFile { ++ SInt16 refNum; /* Data fork/file reference number */ ++ SInt16 refNumRF; /* Resource fork reference number (for locking) */ ++ int locked; /* 0: unlocked, <0: write lock, >0: read lock */ ++ int delOnClose; /* True if file is to be deleted on close */ ++ char *pathToDel; /* Name of file to delete on close */ ++ }; ++# ifdef _LARGE_FILE ++ typedef SInt64 off_t; ++# else ++ typedef SInt32 off_t; ++# endif ++# define SQLITE_TEMPNAME_SIZE _MAX_PATH ++# define SQLITE_MIN_SLEEP_MS 17 ++#endif ++ ++int sqliteOsDelete(const char*); ++int sqliteOsFileExists(const char*); ++int sqliteOsFileRename(const char*, const char*); ++int sqliteOsOpenReadWrite(const char*, OsFile*, int*); ++int sqliteOsOpenExclusive(const char*, OsFile*, int); ++int sqliteOsOpenReadOnly(const char*, OsFile*); ++int sqliteOsOpenDirectory(const char*, OsFile*); ++int sqliteOsTempFileName(char*); ++int sqliteOsClose(OsFile*); ++int sqliteOsRead(OsFile*, void*, int amt); ++int sqliteOsWrite(OsFile*, const void*, int amt); ++int sqliteOsSeek(OsFile*, off_t offset); ++int sqliteOsSync(OsFile*); ++int sqliteOsTruncate(OsFile*, off_t size); ++int sqliteOsFileSize(OsFile*, off_t *pSize); ++int sqliteOsReadLock(OsFile*); ++int sqliteOsWriteLock(OsFile*); ++int sqliteOsUnlock(OsFile*); ++int sqliteOsRandomSeed(char*); ++int sqliteOsSleep(int ms); ++int sqliteOsCurrentTime(double*); ++void sqliteOsEnterMutex(void); ++void sqliteOsLeaveMutex(void); ++char *sqliteOsFullPathname(const char*); ++ ++ ++ ++#endif /* _SQLITE_OS_H_ */ +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/pager.c +@@ -0,0 +1,2220 @@ ++/* ++** 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. ++** ++** @(#) $Id$ ++*/ ++#include "os.h" /* Must be first to enable large file support */ ++#include "sqliteInt.h" ++#include "pager.h" ++#include ++#include ++ ++/* ++** Macros for troubleshooting. Normally turned off ++*/ ++#if 0 ++static Pager *mainPager = 0; ++#define SET_PAGER(X) if( mainPager==0 ) mainPager = (X) ++#define CLR_PAGER(X) if( mainPager==(X) ) mainPager = 0 ++#define TRACE1(X) if( pPager==mainPager ) fprintf(stderr,X) ++#define TRACE2(X,Y) if( pPager==mainPager ) fprintf(stderr,X,Y) ++#define TRACE3(X,Y,Z) if( pPager==mainPager ) fprintf(stderr,X,Y,Z) ++#else ++#define SET_PAGER(X) ++#define CLR_PAGER(X) ++#define TRACE1(X) ++#define TRACE2(X,Y) ++#define TRACE3(X,Y,Z) ++#endif ++ ++ ++/* ++** The page cache as a whole is always in one of the following ++** states: ++** ++** SQLITE_UNLOCK The page cache is not currently reading or ++** writing the database file. There is no ++** data held in memory. This is the initial ++** state. ++** ++** SQLITE_READLOCK The page cache is reading the database. ++** Writing is not permitted. There can be ++** multiple readers accessing the same database ++** file at the same time. ++** ++** SQLITE_WRITELOCK The page cache is writing the database. ++** Access is exclusive. No other processes or ++** threads can be reading or writing while one ++** process is writing. ++** ++** The page cache comes up in SQLITE_UNLOCK. The first time a ++** sqlite_page_get() occurs, the state transitions to SQLITE_READLOCK. ++** After all pages have been released using sqlite_page_unref(), ++** the state transitions back to SQLITE_UNLOCK. The first time ++** that sqlite_page_write() is called, the state transitions to ++** SQLITE_WRITELOCK. (Note that sqlite_page_write() can only be ++** called on an outstanding page which means that the pager must ++** be in SQLITE_READLOCK before it transitions to SQLITE_WRITELOCK.) ++** The sqlite_page_rollback() and sqlite_page_commit() functions ++** transition the state from SQLITE_WRITELOCK back to SQLITE_READLOCK. ++*/ ++#define SQLITE_UNLOCK 0 ++#define SQLITE_READLOCK 1 ++#define SQLITE_WRITELOCK 2 ++ ++ ++/* ++** Each in-memory image of a page begins with the following header. ++** This header is only visible to this pager module. The client ++** code that calls pager sees only the data that follows the header. ++** ++** Client code should call sqlitepager_write() on a page prior to making ++** any modifications to that page. The first time sqlitepager_write() ++** is called, the original page contents are written into the rollback ++** journal and PgHdr.inJournal and PgHdr.needSync are set. Later, once ++** the journal page has made it onto the disk surface, PgHdr.needSync ++** is cleared. The modified page cannot be written back into the original ++** database file until the journal pages has been synced to disk and the ++** PgHdr.needSync has been cleared. ++** ++** The PgHdr.dirty flag is set when sqlitepager_write() is called and ++** is cleared again when the page content is written back to the original ++** database file. ++*/ ++typedef struct PgHdr PgHdr; ++struct PgHdr { ++ Pager *pPager; /* The pager to which this page belongs */ ++ Pgno pgno; /* The page number for this page */ ++ PgHdr *pNextHash, *pPrevHash; /* Hash collision chain for PgHdr.pgno */ ++ int nRef; /* Number of users of this page */ ++ PgHdr *pNextFree, *pPrevFree; /* Freelist of pages where nRef==0 */ ++ PgHdr *pNextAll, *pPrevAll; /* A list of all pages */ ++ PgHdr *pNextCkpt, *pPrevCkpt; /* List of pages in the checkpoint journal */ ++ u8 inJournal; /* TRUE if has been written to journal */ ++ u8 inCkpt; /* TRUE if written to the checkpoint journal */ ++ u8 dirty; /* TRUE if we need to write back changes */ ++ u8 needSync; /* Sync journal before writing this page */ ++ u8 alwaysRollback; /* Disable dont_rollback() for this page */ ++ PgHdr *pDirty; /* Dirty pages sorted by PgHdr.pgno */ ++ /* SQLITE_PAGE_SIZE bytes of page data follow this header */ ++ /* Pager.nExtra bytes of local data follow the page data */ ++}; ++ ++ ++/* ++** A macro used for invoking the codec if there is one ++*/ ++#ifdef SQLITE_HAS_CODEC ++# define CODEC(P,D,N,X) if( P->xCodec ){ P->xCodec(P->pCodecArg,D,N,X); } ++#else ++# define CODEC(P,D,N,X) ++#endif ++ ++/* ++** Convert a pointer to a PgHdr into a pointer to its data ++** and back again. ++*/ ++#define PGHDR_TO_DATA(P) ((void*)(&(P)[1])) ++#define DATA_TO_PGHDR(D) (&((PgHdr*)(D))[-1]) ++#define PGHDR_TO_EXTRA(P) ((void*)&((char*)(&(P)[1]))[SQLITE_PAGE_SIZE]) ++ ++/* ++** How big to make the hash table used for locating in-memory pages ++** by page number. ++*/ ++#define N_PG_HASH 2048 ++ ++/* ++** Hash a page number ++*/ ++#define pager_hash(PN) ((PN)&(N_PG_HASH-1)) ++ ++/* ++** A open page cache is an instance of the following structure. ++*/ ++struct Pager { ++ char *zFilename; /* Name of the database file */ ++ char *zJournal; /* Name of the journal file */ ++ char *zDirectory; /* Directory hold database and journal files */ ++ OsFile fd, jfd; /* File descriptors for database and journal */ ++ OsFile cpfd; /* File descriptor for the checkpoint journal */ ++ int dbSize; /* Number of pages in the file */ ++ int origDbSize; /* dbSize before the current change */ ++ int ckptSize; /* Size of database (in pages) at ckpt_begin() */ ++ off_t ckptJSize; /* Size of journal at ckpt_begin() */ ++ int nRec; /* Number of pages written to the journal */ ++ u32 cksumInit; /* Quasi-random value added to every checksum */ ++ int ckptNRec; /* Number of records in the checkpoint journal */ ++ int nExtra; /* Add this many bytes to each in-memory page */ ++ void (*xDestructor)(void*); /* Call this routine when freeing pages */ ++ int nPage; /* Total number of in-memory pages */ ++ int nRef; /* Number of in-memory pages with PgHdr.nRef>0 */ ++ int mxPage; /* Maximum number of pages to hold in cache */ ++ int nHit, nMiss, nOvfl; /* Cache hits, missing, and LRU overflows */ ++ void (*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */ ++ void *pCodecArg; /* First argument to xCodec() */ ++ u8 journalOpen; /* True if journal file descriptors is valid */ ++ u8 journalStarted; /* True if header of journal is synced */ ++ u8 useJournal; /* Use a rollback journal on this file */ ++ u8 ckptOpen; /* True if the checkpoint journal is open */ ++ u8 ckptInUse; /* True we are in a checkpoint */ ++ u8 ckptAutoopen; /* Open ckpt journal when main journal is opened*/ ++ u8 noSync; /* Do not sync the journal if true */ ++ u8 fullSync; /* Do extra syncs of the journal for robustness */ ++ u8 state; /* SQLITE_UNLOCK, _READLOCK or _WRITELOCK */ ++ u8 errMask; /* One of several kinds of errors */ ++ u8 tempFile; /* zFilename is a temporary file */ ++ u8 readOnly; /* True for a read-only database */ ++ u8 needSync; /* True if an fsync() is needed on the journal */ ++ u8 dirtyFile; /* True if database file has changed in any way */ ++ u8 alwaysRollback; /* Disable dont_rollback() for all pages */ ++ u8 *aInJournal; /* One bit for each page in the database file */ ++ u8 *aInCkpt; /* One bit for each page in the database */ ++ PgHdr *pFirst, *pLast; /* List of free pages */ ++ PgHdr *pFirstSynced; /* First free page with PgHdr.needSync==0 */ ++ PgHdr *pAll; /* List of all pages */ ++ PgHdr *pCkpt; /* List of pages in the checkpoint journal */ ++ PgHdr *aHash[N_PG_HASH]; /* Hash table to map page number of PgHdr */ ++}; ++ ++/* ++** These are bits that can be set in Pager.errMask. ++*/ ++#define PAGER_ERR_FULL 0x01 /* a write() failed */ ++#define PAGER_ERR_MEM 0x02 /* malloc() failed */ ++#define PAGER_ERR_LOCK 0x04 /* error in the locking protocol */ ++#define PAGER_ERR_CORRUPT 0x08 /* database or journal corruption */ ++#define PAGER_ERR_DISK 0x10 /* general disk I/O error - bad hard drive? */ ++ ++/* ++** The journal file contains page records in the following ++** format. ++** ++** Actually, this structure is the complete page record for pager ++** formats less than 3. Beginning with format 3, this record is surrounded ++** by two checksums. ++*/ ++typedef struct PageRecord PageRecord; ++struct PageRecord { ++ Pgno pgno; /* The page number */ ++ char aData[SQLITE_PAGE_SIZE]; /* Original data for page pgno */ ++}; ++ ++/* ++** Journal files begin with the following magic string. The data ++** was obtained from /dev/random. It is used only as a sanity check. ++** ++** There are three journal formats (so far). The 1st journal format writes ++** 32-bit integers in the byte-order of the host machine. New ++** formats writes integers as big-endian. All new journals use the ++** new format, but we have to be able to read an older journal in order ++** to rollback journals created by older versions of the library. ++** ++** The 3rd journal format (added for 2.8.0) adds additional sanity ++** checking information to the journal. 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 3rd journal format consists ++** of a 32-bit checksum on each page of data. The checksum covers both ++** the page number and the SQLITE_PAGE_SIZE 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 aJournalMagic1[] = { ++ 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd4, ++}; ++static const unsigned char aJournalMagic2[] = { ++ 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd5, ++}; ++static const unsigned char aJournalMagic3[] = { ++ 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd6, ++}; ++#define JOURNAL_FORMAT_1 1 ++#define JOURNAL_FORMAT_2 2 ++#define JOURNAL_FORMAT_3 3 ++ ++/* ++** The following integer determines what format to use when creating ++** new primary journal files. By default we always use format 3. ++** When testing, we can set this value to older journal formats in order to ++** make sure that newer versions of the library are able to rollback older ++** journal files. ++** ++** Note that checkpoint journals always use format 2 and omit the header. ++*/ ++#ifdef SQLITE_TEST ++int journal_format = 3; ++#else ++# define journal_format 3 ++#endif ++ ++/* ++** The size of the header and of each page in the journal varies according ++** to which journal format is being used. The following macros figure out ++** the sizes based on format numbers. ++*/ ++#define JOURNAL_HDR_SZ(X) \ ++ (sizeof(aJournalMagic1) + sizeof(Pgno) + ((X)>=3)*2*sizeof(u32)) ++#define JOURNAL_PG_SZ(X) \ ++ (SQLITE_PAGE_SIZE + sizeof(Pgno) + ((X)>=3)*sizeof(u32)) ++ ++/* ++** Enable reference count tracking here: ++*/ ++#ifdef SQLITE_TEST ++ int pager_refinfo_enable = 0; ++ static void pager_refinfo(PgHdr *p){ ++ static int cnt = 0; ++ if( !pager_refinfo_enable ) return; ++ printf( ++ "REFCNT: %4d addr=0x%08x nRef=%d\n", ++ p->pgno, (int)PGHDR_TO_DATA(p), p->nRef ++ ); ++ cnt++; /* Something to set a breakpoint on */ ++ } ++# define REFINFO(X) pager_refinfo(X) ++#else ++# define REFINFO(X) ++#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. ++** ++** If the journal format is 2 or 3, read a big-endian integer. If the ++** journal format is 1, read an integer in the native byte-order of the ++** host machine. ++*/ ++static int read32bits(int format, OsFile *fd, u32 *pRes){ ++ u32 res; ++ int rc; ++ rc = sqliteOsRead(fd, &res, sizeof(res)); ++ if( rc==SQLITE_OK && format>JOURNAL_FORMAT_1 ){ ++ unsigned char ac[4]; ++ memcpy(ac, &res, 4); ++ res = (ac[0]<<24) | (ac[1]<<16) | (ac[2]<<8) | ac[3]; ++ } ++ *pRes = res; ++ return rc; ++} ++ ++/* ++** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK ++** on success or an error code is something goes wrong. ++** ++** If the journal format is 2 or 3, write the integer as 4 big-endian ++** bytes. If the journal format is 1, write the integer in the native ++** byte order. In normal operation, only formats 2 and 3 are used. ++** Journal format 1 is only used for testing. ++*/ ++static int write32bits(OsFile *fd, u32 val){ ++ unsigned char ac[4]; ++ if( journal_format<=1 ){ ++ return sqliteOsWrite(fd, &val, 4); ++ } ++ ac[0] = (val>>24) & 0xff; ++ ac[1] = (val>>16) & 0xff; ++ ac[2] = (val>>8) & 0xff; ++ ac[3] = val & 0xff; ++ return sqliteOsWrite(fd, ac, 4); ++} ++ ++/* ++** Write a 32-bit integer into a page header right before the ++** page data. This will overwrite the PgHdr.pDirty pointer. ++** ++** The integer is big-endian for formats 2 and 3 and native byte order ++** for journal format 1. ++*/ ++static void store32bits(u32 val, PgHdr *p, int offset){ ++ unsigned char *ac; ++ ac = &((unsigned char*)PGHDR_TO_DATA(p))[offset]; ++ if( journal_format<=1 ){ ++ memcpy(ac, &val, 4); ++ }else{ ++ ac[0] = (val>>24) & 0xff; ++ ac[1] = (val>>16) & 0xff; ++ ac[2] = (val>>8) & 0xff; ++ ac[3] = val & 0xff; ++ } ++} ++ ++ ++/* ++** Convert the bits in the pPager->errMask into an approprate ++** return code. ++*/ ++static int pager_errcode(Pager *pPager){ ++ int rc = SQLITE_OK; ++ if( pPager->errMask & PAGER_ERR_LOCK ) rc = SQLITE_PROTOCOL; ++ if( pPager->errMask & PAGER_ERR_DISK ) rc = SQLITE_IOERR; ++ if( pPager->errMask & PAGER_ERR_FULL ) rc = SQLITE_FULL; ++ if( pPager->errMask & PAGER_ERR_MEM ) rc = SQLITE_NOMEM; ++ if( pPager->errMask & PAGER_ERR_CORRUPT ) rc = SQLITE_CORRUPT; ++ return rc; ++} ++ ++/* ++** Add or remove a page from the list of all pages that are in the ++** checkpoint journal. ++** ++** The Pager keeps a separate list of pages that are currently in ++** the checkpoint journal. This helps the sqlitepager_ckpt_commit() ++** routine run MUCH faster for the common case where there are many ++** pages in memory but only a few are in the checkpoint journal. ++*/ ++static void page_add_to_ckpt_list(PgHdr *pPg){ ++ Pager *pPager = pPg->pPager; ++ if( pPg->inCkpt ) return; ++ assert( pPg->pPrevCkpt==0 && pPg->pNextCkpt==0 ); ++ pPg->pPrevCkpt = 0; ++ if( pPager->pCkpt ){ ++ pPager->pCkpt->pPrevCkpt = pPg; ++ } ++ pPg->pNextCkpt = pPager->pCkpt; ++ pPager->pCkpt = pPg; ++ pPg->inCkpt = 1; ++} ++static void page_remove_from_ckpt_list(PgHdr *pPg){ ++ if( !pPg->inCkpt ) return; ++ if( pPg->pPrevCkpt ){ ++ assert( pPg->pPrevCkpt->pNextCkpt==pPg ); ++ pPg->pPrevCkpt->pNextCkpt = pPg->pNextCkpt; ++ }else{ ++ assert( pPg->pPager->pCkpt==pPg ); ++ pPg->pPager->pCkpt = pPg->pNextCkpt; ++ } ++ if( pPg->pNextCkpt ){ ++ assert( pPg->pNextCkpt->pPrevCkpt==pPg ); ++ pPg->pNextCkpt->pPrevCkpt = pPg->pPrevCkpt; ++ } ++ pPg->pNextCkpt = 0; ++ pPg->pPrevCkpt = 0; ++ pPg->inCkpt = 0; ++} ++ ++/* ++** Find a page in the hash table given its page number. Return ++** a pointer to the page or NULL if not found. ++*/ ++static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){ ++ PgHdr *p = pPager->aHash[pager_hash(pgno)]; ++ while( p && p->pgno!=pgno ){ ++ p = p->pNextHash; ++ } ++ return p; ++} ++ ++/* ++** Unlock the database and clear the in-memory cache. This routine ++** sets the state of the pager back to what it was when it was first ++** opened. Any outstanding pages are invalidated and subsequent attempts ++** to access those pages will likely result in a coredump. ++*/ ++static void pager_reset(Pager *pPager){ ++ PgHdr *pPg, *pNext; ++ for(pPg=pPager->pAll; pPg; pPg=pNext){ ++ pNext = pPg->pNextAll; ++ sqliteFree(pPg); ++ } ++ pPager->pFirst = 0; ++ pPager->pFirstSynced = 0; ++ pPager->pLast = 0; ++ pPager->pAll = 0; ++ memset(pPager->aHash, 0, sizeof(pPager->aHash)); ++ pPager->nPage = 0; ++ if( pPager->state>=SQLITE_WRITELOCK ){ ++ sqlitepager_rollback(pPager); ++ } ++ sqliteOsUnlock(&pPager->fd); ++ pPager->state = SQLITE_UNLOCK; ++ pPager->dbSize = -1; ++ pPager->nRef = 0; ++ assert( pPager->journalOpen==0 ); ++} ++ ++/* ++** When this routine is called, the pager has the journal file open and ++** a write lock on the database. This routine releases the database ++** write lock and acquires a read lock in its place. The journal file ++** is deleted and closed. ++** ++** TODO: Consider keeping the journal file open for temporary databases. ++** This might give a performance improvement on windows where opening ++** a file is an expensive operation. ++*/ ++static int pager_unwritelock(Pager *pPager){ ++ int rc; ++ PgHdr *pPg; ++ if( pPager->stateckptOpen ){ ++ sqliteOsClose(&pPager->cpfd); ++ pPager->ckptOpen = 0; ++ } ++ if( pPager->journalOpen ){ ++ sqliteOsClose(&pPager->jfd); ++ pPager->journalOpen = 0; ++ sqliteOsDelete(pPager->zJournal); ++ sqliteFree( pPager->aInJournal ); ++ pPager->aInJournal = 0; ++ for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ ++ pPg->inJournal = 0; ++ pPg->dirty = 0; ++ pPg->needSync = 0; ++ } ++ }else{ ++ assert( pPager->dirtyFile==0 || pPager->useJournal==0 ); ++ } ++ rc = sqliteOsReadLock(&pPager->fd); ++ if( rc==SQLITE_OK ){ ++ pPager->state = SQLITE_READLOCK; ++ }else{ ++ /* This can only happen if a process does a BEGIN, then forks and the ++ ** child process does the COMMIT. Because of the semantics of unix ++ ** file locking, the unlock will fail. ++ */ ++ pPager->state = SQLITE_UNLOCK; ++ } ++ return rc; ++} ++ ++/* ++** Compute and return a checksum for the page of data. ++** ++** This is not a real checksum. It is really just the sum of the ++** random initial value and the page number. We considered do a checksum ++** of the database, but that was found to be too slow. ++*/ ++static u32 pager_cksum(Pager *pPager, Pgno pgno, const char *aData){ ++ u32 cksum = pPager->cksumInit + pgno; ++ return cksum; ++} ++ ++/* ++** Read a single page from the journal file opened on file descriptor ++** jfd. Playback this one page. ++** ++** There are three different journal formats. The format parameter determines ++** which format is used by the journal that is played back. ++*/ ++static int pager_playback_one_page(Pager *pPager, OsFile *jfd, int format){ ++ int rc; ++ PgHdr *pPg; /* An existing page in the cache */ ++ PageRecord pgRec; ++ u32 cksum; ++ ++ rc = read32bits(format, jfd, &pgRec.pgno); ++ if( rc!=SQLITE_OK ) return rc; ++ rc = sqliteOsRead(jfd, &pgRec.aData, sizeof(pgRec.aData)); ++ if( rc!=SQLITE_OK ) return rc; ++ ++ /* 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( pgRec.pgno==0 ){ ++ return SQLITE_DONE; ++ } ++ if( pgRec.pgno>(unsigned)pPager->dbSize ){ ++ return SQLITE_OK; ++ } ++ if( format>=JOURNAL_FORMAT_3 ){ ++ rc = read32bits(format, jfd, &cksum); ++ if( rc ) return rc; ++ if( pager_cksum(pPager, pgRec.pgno, pgRec.aData)!=cksum ){ ++ return SQLITE_DONE; ++ } ++ } ++ ++ /* Playback the page. Update the in-memory copy of the page ++ ** at the same time, if there is one. ++ */ ++ pPg = pager_lookup(pPager, pgRec.pgno); ++ TRACE2("PLAYBACK %d\n", pgRec.pgno); ++ sqliteOsSeek(&pPager->fd, (pgRec.pgno-1)*(off_t)SQLITE_PAGE_SIZE); ++ rc = sqliteOsWrite(&pPager->fd, pgRec.aData, SQLITE_PAGE_SIZE); ++ if( pPg ){ ++ /* No page should ever be 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. ++ */ ++ assert( pPg->nRef==0 || pPg->pgno==1 ); ++ memcpy(PGHDR_TO_DATA(pPg), pgRec.aData, SQLITE_PAGE_SIZE); ++ memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra); ++ pPg->dirty = 0; ++ pPg->needSync = 0; ++ CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3); ++ } ++ return rc; ++} ++ ++/* ++** 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: ++** ++** * 8 byte prefix. One of the aJournalMagic123 vectors defined ++** above. The format of the journal file is determined by which ++** of the three prefix vectors is seen. ++** * 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. This field appears ++** in format 3 only. ++** * 4 byte big-endian integer which is the initial value for the ++** sanity checksum. This field appears in format 3 only. ++** * 4 byte integer which is the number of pages to truncate the ++** database to during a rollback. ++** * Zero or more pages instances, each as follows: ++** + 4 byte page number. ++** + SQLITE_PAGE_SIZE bytes of data. ++** + 4 byte checksum (format 3 only) ++** ++** When we speak of the journal header, we mean the first 4 bullets above. ++** Each entry in the journal is an instance of the 5th bullet. Note that ++** bullets 2 and 3 only appear in format-3 journals. ++** ++** 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. ++** ++** Journal formats 1 and 2 do not have an nRec value in the header so we ++** have to compute nRec from the file size. This has risks (as described ++** above) which is why all persistent tables have been changed to use ++** format 3. ++** ++** If the file opened as the journal file is not a well-formed ++** journal file then the database will likely already be ++** corrupted, so the PAGER_ERR_CORRUPT bit is set in pPager->errMask ++** and SQLITE_CORRUPT is returned. If it all works, then this routine ++** returns SQLITE_OK. ++*/ ++static int pager_playback(Pager *pPager, int useJournalSize){ ++ off_t szJ; /* Size of the journal file in bytes */ ++ int nRec; /* Number of Records in the journal */ ++ int i; /* Loop counter */ ++ Pgno mxPg = 0; /* Size of the original file in pages */ ++ int format; /* Format of the journal file. */ ++ unsigned char aMagic[sizeof(aJournalMagic1)]; ++ int rc; ++ ++ /* Figure out how many records are in the journal. Abort early if ++ ** the journal is empty. ++ */ ++ assert( pPager->journalOpen ); ++ sqliteOsSeek(&pPager->jfd, 0); ++ rc = sqliteOsFileSize(&pPager->jfd, &szJ); ++ if( rc!=SQLITE_OK ){ ++ goto end_playback; ++ } ++ ++ /* If the journal file is too small to contain a complete header, ++ ** it must mean that the process that created the journal was just ++ ** beginning to write the journal file when it died. In that case, ++ ** the database file should have still been completely unchanged. ++ ** Nothing needs to be rolled back. We can safely ignore this journal. ++ */ ++ if( szJ < sizeof(aMagic)+sizeof(Pgno) ){ ++ goto end_playback; ++ } ++ ++ /* Read the beginning of the journal and truncate the ++ ** database file back to its original size. ++ */ ++ rc = sqliteOsRead(&pPager->jfd, aMagic, sizeof(aMagic)); ++ if( rc!=SQLITE_OK ){ ++ rc = SQLITE_PROTOCOL; ++ goto end_playback; ++ } ++ if( memcmp(aMagic, aJournalMagic3, sizeof(aMagic))==0 ){ ++ format = JOURNAL_FORMAT_3; ++ }else if( memcmp(aMagic, aJournalMagic2, sizeof(aMagic))==0 ){ ++ format = JOURNAL_FORMAT_2; ++ }else if( memcmp(aMagic, aJournalMagic1, sizeof(aMagic))==0 ){ ++ format = JOURNAL_FORMAT_1; ++ }else{ ++ rc = SQLITE_PROTOCOL; ++ goto end_playback; ++ } ++ if( format>=JOURNAL_FORMAT_3 ){ ++ if( szJ < sizeof(aMagic) + 3*sizeof(u32) ){ ++ /* Ignore the journal if it is too small to contain a complete ++ ** header. We already did this test once above, but at the prior ++ ** test, we did not know the journal format and so we had to assume ++ ** the smallest possible header. Now we know the header is bigger ++ ** than the minimum so we test again. ++ */ ++ goto end_playback; ++ } ++ rc = read32bits(format, &pPager->jfd, (u32*)&nRec); ++ if( rc ) goto end_playback; ++ rc = read32bits(format, &pPager->jfd, &pPager->cksumInit); ++ if( rc ) goto end_playback; ++ if( nRec==0xffffffff || useJournalSize ){ ++ nRec = (szJ - JOURNAL_HDR_SZ(3))/JOURNAL_PG_SZ(3); ++ } ++ }else{ ++ nRec = (szJ - JOURNAL_HDR_SZ(2))/JOURNAL_PG_SZ(2); ++ assert( nRec*JOURNAL_PG_SZ(2)+JOURNAL_HDR_SZ(2)==szJ ); ++ } ++ rc = read32bits(format, &pPager->jfd, &mxPg); ++ if( rc!=SQLITE_OK ){ ++ goto end_playback; ++ } ++ assert( pPager->origDbSize==0 || pPager->origDbSize==mxPg ); ++ rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)mxPg); ++ if( rc!=SQLITE_OK ){ ++ goto end_playback; ++ } ++ pPager->dbSize = mxPg; ++ ++ /* Copy original pages out of the journal and back into the database file. ++ */ ++ for(i=0; ijfd, format); ++ if( rc!=SQLITE_OK ){ ++ if( rc==SQLITE_DONE ){ ++ rc = SQLITE_OK; ++ } ++ break; ++ } ++ } ++ ++ /* Pages that have been written to the journal but never synced ++ ** where not restored by the loop above. We have to restore those ++ ** pages by reading them back from the original database. ++ */ ++ if( rc==SQLITE_OK ){ ++ PgHdr *pPg; ++ for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ ++ char zBuf[SQLITE_PAGE_SIZE]; ++ if( !pPg->dirty ) continue; ++ if( (int)pPg->pgno <= pPager->origDbSize ){ ++ sqliteOsSeek(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)(pPg->pgno-1)); ++ rc = sqliteOsRead(&pPager->fd, zBuf, SQLITE_PAGE_SIZE); ++ TRACE2("REFETCH %d\n", pPg->pgno); ++ CODEC(pPager, zBuf, pPg->pgno, 2); ++ if( rc ) break; ++ }else{ ++ memset(zBuf, 0, SQLITE_PAGE_SIZE); ++ } ++ if( pPg->nRef==0 || memcmp(zBuf, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE) ){ ++ memcpy(PGHDR_TO_DATA(pPg), zBuf, SQLITE_PAGE_SIZE); ++ memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra); ++ } ++ pPg->needSync = 0; ++ pPg->dirty = 0; ++ } ++ } ++ ++end_playback: ++ if( rc!=SQLITE_OK ){ ++ pager_unwritelock(pPager); ++ pPager->errMask |= PAGER_ERR_CORRUPT; ++ rc = SQLITE_CORRUPT; ++ }else{ ++ rc = pager_unwritelock(pPager); ++ } ++ return rc; ++} ++ ++/* ++** Playback the checkpoint journal. ++** ++** This is similar to playing back the transaction journal but with ++** a few extra twists. ++** ++** (1) The number of pages in the database file at the start of ++** the checkpoint is stored in pPager->ckptSize, not in the ++** journal file itself. ++** ++** (2) In addition to playing back the checkpoint journal, also ++** playback all pages of the transaction journal beginning ++** at offset pPager->ckptJSize. ++*/ ++static int pager_ckpt_playback(Pager *pPager){ ++ off_t szJ; /* Size of the full journal */ ++ int nRec; /* Number of Records */ ++ int i; /* Loop counter */ ++ int rc; ++ ++ /* Truncate the database back to its original size. ++ */ ++ rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)pPager->ckptSize); ++ pPager->dbSize = pPager->ckptSize; ++ ++ /* Figure out how many records are in the checkpoint journal. ++ */ ++ assert( pPager->ckptInUse && pPager->journalOpen ); ++ sqliteOsSeek(&pPager->cpfd, 0); ++ nRec = pPager->ckptNRec; ++ ++ /* Copy original pages out of the checkpoint journal and back into the ++ ** database file. Note that the checkpoint journal always uses format ++ ** 2 instead of format 3 since it does not need to be concerned with ++ ** power failures corrupting the journal and can thus omit the checksums. ++ */ ++ for(i=nRec-1; i>=0; i--){ ++ rc = pager_playback_one_page(pPager, &pPager->cpfd, 2); ++ assert( rc!=SQLITE_DONE ); ++ if( rc!=SQLITE_OK ) goto end_ckpt_playback; ++ } ++ ++ /* Figure out how many pages need to be copied out of the transaction ++ ** journal. ++ */ ++ rc = sqliteOsSeek(&pPager->jfd, pPager->ckptJSize); ++ if( rc!=SQLITE_OK ){ ++ goto end_ckpt_playback; ++ } ++ rc = sqliteOsFileSize(&pPager->jfd, &szJ); ++ if( rc!=SQLITE_OK ){ ++ goto end_ckpt_playback; ++ } ++ nRec = (szJ - pPager->ckptJSize)/JOURNAL_PG_SZ(journal_format); ++ for(i=nRec-1; i>=0; i--){ ++ rc = pager_playback_one_page(pPager, &pPager->jfd, journal_format); ++ if( rc!=SQLITE_OK ){ ++ assert( rc!=SQLITE_DONE ); ++ goto end_ckpt_playback; ++ } ++ } ++ ++end_ckpt_playback: ++ if( rc!=SQLITE_OK ){ ++ pPager->errMask |= PAGER_ERR_CORRUPT; ++ rc = SQLITE_CORRUPT; ++ } ++ return rc; ++} ++ ++/* ++** Change the maximum number of in-memory pages that are allowed. ++** ++** The maximum number is the absolute value of the mxPage parameter. ++** If mxPage is negative, the noSync flag is also set. noSync bypasses ++** calls to sqliteOsSync(). The pager runs much faster with noSync on, ++** but if the operating system crashes or there is an abrupt power ++** failure, the database file might be left in an inconsistent and ++** unrepairable state. ++*/ ++void sqlitepager_set_cachesize(Pager *pPager, int mxPage){ ++ if( mxPage>=0 ){ ++ pPager->noSync = pPager->tempFile; ++ if( pPager->noSync==0 ) pPager->needSync = 0; ++ }else{ ++ pPager->noSync = 1; ++ mxPage = -mxPage; ++ } ++ if( mxPage>10 ){ ++ pPager->mxPage = mxPage; ++ } ++} ++ ++/* ++** Adjust the robustness of the database to damage due to OS crashes ++** or power failures by changing the number of syncs()s when writing ++** the rollback journal. There are three levels: ++** ++** OFF sqliteOsSync() 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. ++** ++** Numeric values associated with these states are OFF==1, NORMAL=2, ++** and FULL=3. ++*/ ++void sqlitepager_set_safety_level(Pager *pPager, int level){ ++ pPager->noSync = level==1 || pPager->tempFile; ++ pPager->fullSync = level==3 && !pPager->tempFile; ++ if( pPager->noSync==0 ) pPager->needSync = 0; ++} ++ ++/* ++** Open a temporary file. Write the name of the file into zName ++** (zName must be at least SQLITE_TEMPNAME_SIZE bytes long.) Write ++** the file descriptor into *fd. 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. ++*/ ++static int sqlitepager_opentemp(char *zFile, OsFile *fd){ ++ int cnt = 8; ++ int rc; ++ do{ ++ cnt--; ++ sqliteOsTempFileName(zFile); ++ rc = sqliteOsOpenExclusive(zFile, fd, 1); ++ }while( cnt>0 && rc!=SQLITE_OK ); ++ return rc; ++} ++ ++/* ++** Create a new page cache and put a pointer to the page cache in *ppPager. ++** The file to be cached need not exist. The file is not locked until ++** the first call to sqlitepager_get() and is only held open until the ++** last page is released using sqlitepager_unref(). ++** ++** If zFilename is NULL then a randomly-named temporary file is created ++** and used as the file to be cached. The file will be deleted ++** automatically when it is closed. ++*/ ++int sqlitepager_open( ++ Pager **ppPager, /* Return the Pager structure here */ ++ const char *zFilename, /* Name of the database file to open */ ++ int mxPage, /* Max number of in-memory cache pages */ ++ int nExtra, /* Extra bytes append to each in-memory page */ ++ int useJournal /* TRUE to use a rollback journal on this file */ ++){ ++ Pager *pPager; ++ char *zFullPathname; ++ int nameLen; ++ OsFile fd; ++ int rc, i; ++ int tempFile; ++ int readOnly = 0; ++ char zTemp[SQLITE_TEMPNAME_SIZE]; ++ ++ *ppPager = 0; ++ if( sqlite_malloc_failed ){ ++ return SQLITE_NOMEM; ++ } ++ if( zFilename && zFilename[0] ){ ++ zFullPathname = sqliteOsFullPathname(zFilename); ++ rc = sqliteOsOpenReadWrite(zFullPathname, &fd, &readOnly); ++ tempFile = 0; ++ }else{ ++ rc = sqlitepager_opentemp(zTemp, &fd); ++ zFilename = zTemp; ++ zFullPathname = sqliteOsFullPathname(zFilename); ++ tempFile = 1; ++ } ++ if( sqlite_malloc_failed ){ ++ return SQLITE_NOMEM; ++ } ++ if( rc!=SQLITE_OK ){ ++ sqliteFree(zFullPathname); ++ return SQLITE_CANTOPEN; ++ } ++ nameLen = strlen(zFullPathname); ++ pPager = sqliteMalloc( sizeof(*pPager) + nameLen*3 + 30 ); ++ if( pPager==0 ){ ++ sqliteOsClose(&fd); ++ sqliteFree(zFullPathname); ++ return SQLITE_NOMEM; ++ } ++ SET_PAGER(pPager); ++ pPager->zFilename = (char*)&pPager[1]; ++ pPager->zDirectory = &pPager->zFilename[nameLen+1]; ++ pPager->zJournal = &pPager->zDirectory[nameLen+1]; ++ strcpy(pPager->zFilename, zFullPathname); ++ strcpy(pPager->zDirectory, zFullPathname); ++ for(i=nameLen; i>0 && pPager->zDirectory[i-1]!='/'; i--){} ++ if( i>0 ) pPager->zDirectory[i-1] = 0; ++ strcpy(pPager->zJournal, zFullPathname); ++ sqliteFree(zFullPathname); ++ strcpy(&pPager->zJournal[nameLen], "-journal"); ++ pPager->fd = fd; ++ pPager->journalOpen = 0; ++ pPager->useJournal = useJournal; ++ pPager->ckptOpen = 0; ++ pPager->ckptInUse = 0; ++ pPager->nRef = 0; ++ pPager->dbSize = -1; ++ pPager->ckptSize = 0; ++ pPager->ckptJSize = 0; ++ pPager->nPage = 0; ++ pPager->mxPage = mxPage>5 ? mxPage : 10; ++ pPager->state = SQLITE_UNLOCK; ++ pPager->errMask = 0; ++ pPager->tempFile = tempFile; ++ pPager->readOnly = readOnly; ++ pPager->needSync = 0; ++ pPager->noSync = pPager->tempFile || !useJournal; ++ pPager->pFirst = 0; ++ pPager->pFirstSynced = 0; ++ pPager->pLast = 0; ++ pPager->nExtra = nExtra; ++ memset(pPager->aHash, 0, sizeof(pPager->aHash)); ++ *ppPager = pPager; ++ return SQLITE_OK; ++} ++ ++/* ++** Set the destructor for this pager. If not NULL, the destructor is called ++** when the reference count on each page reaches zero. The destructor can ++** be used to clean up information in the extra segment appended to each page. ++** ++** The destructor is not called as a result sqlitepager_close(). ++** Destructors are only called by sqlitepager_unref(). ++*/ ++void sqlitepager_set_destructor(Pager *pPager, void (*xDesc)(void*)){ ++ pPager->xDestructor = xDesc; ++} ++ ++/* ++** Return the total number of pages in the disk file associated with ++** pPager. ++*/ ++int sqlitepager_pagecount(Pager *pPager){ ++ off_t n; ++ assert( pPager!=0 ); ++ if( pPager->dbSize>=0 ){ ++ return pPager->dbSize; ++ } ++ if( sqliteOsFileSize(&pPager->fd, &n)!=SQLITE_OK ){ ++ pPager->errMask |= PAGER_ERR_DISK; ++ return 0; ++ } ++ n /= SQLITE_PAGE_SIZE; ++ if( pPager->state!=SQLITE_UNLOCK ){ ++ pPager->dbSize = n; ++ } ++ return n; ++} ++ ++/* ++** Forward declaration ++*/ ++static int syncJournal(Pager*); ++ ++/* ++** Truncate the file to the number of pages specified. ++*/ ++int sqlitepager_truncate(Pager *pPager, Pgno nPage){ ++ int rc; ++ if( pPager->dbSize<0 ){ ++ sqlitepager_pagecount(pPager); ++ } ++ if( pPager->errMask!=0 ){ ++ rc = pager_errcode(pPager); ++ return rc; ++ } ++ if( nPage>=(unsigned)pPager->dbSize ){ ++ return SQLITE_OK; ++ } ++ syncJournal(pPager); ++ rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)nPage); ++ if( rc==SQLITE_OK ){ ++ pPager->dbSize = nPage; ++ } ++ return rc; ++} ++ ++/* ++** 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. ++*/ ++int sqlitepager_close(Pager *pPager){ ++ PgHdr *pPg, *pNext; ++ switch( pPager->state ){ ++ case SQLITE_WRITELOCK: { ++ sqlitepager_rollback(pPager); ++ sqliteOsUnlock(&pPager->fd); ++ assert( pPager->journalOpen==0 ); ++ break; ++ } ++ case SQLITE_READLOCK: { ++ sqliteOsUnlock(&pPager->fd); ++ break; ++ } ++ default: { ++ /* Do nothing */ ++ break; ++ } ++ } ++ for(pPg=pPager->pAll; pPg; pPg=pNext){ ++ pNext = pPg->pNextAll; ++ sqliteFree(pPg); ++ } ++ sqliteOsClose(&pPager->fd); ++ assert( pPager->journalOpen==0 ); ++ /* Temp files are automatically deleted by the OS ++ ** if( pPager->tempFile ){ ++ ** sqliteOsDelete(pPager->zFilename); ++ ** } ++ */ ++ CLR_PAGER(pPager); ++ if( pPager->zFilename!=(char*)&pPager[1] ){ ++ assert( 0 ); /* Cannot happen */ ++ sqliteFree(pPager->zFilename); ++ sqliteFree(pPager->zJournal); ++ sqliteFree(pPager->zDirectory); ++ } ++ sqliteFree(pPager); ++ return SQLITE_OK; ++} ++ ++/* ++** Return the page number for the given page data. ++*/ ++Pgno sqlitepager_pagenumber(void *pData){ ++ PgHdr *p = DATA_TO_PGHDR(pData); ++ return p->pgno; ++} ++ ++/* ++** Increment the reference count for a page. If the page is ++** currently on the freelist (the reference count is zero) then ++** remove it from the freelist. ++*/ ++#define page_ref(P) ((P)->nRef==0?_page_ref(P):(void)(P)->nRef++) ++static void _page_ref(PgHdr *pPg){ ++ if( pPg->nRef==0 ){ ++ /* The page is currently on the freelist. Remove it. */ ++ if( pPg==pPg->pPager->pFirstSynced ){ ++ PgHdr *p = pPg->pNextFree; ++ while( p && p->needSync ){ p = p->pNextFree; } ++ pPg->pPager->pFirstSynced = p; ++ } ++ if( pPg->pPrevFree ){ ++ pPg->pPrevFree->pNextFree = pPg->pNextFree; ++ }else{ ++ pPg->pPager->pFirst = pPg->pNextFree; ++ } ++ if( pPg->pNextFree ){ ++ pPg->pNextFree->pPrevFree = pPg->pPrevFree; ++ }else{ ++ pPg->pPager->pLast = pPg->pPrevFree; ++ } ++ pPg->pPager->nRef++; ++ } ++ pPg->nRef++; ++ REFINFO(pPg); ++} ++ ++/* ++** Increment the reference count for a page. The input pointer is ++** a reference to the page data. ++*/ ++int sqlitepager_ref(void *pData){ ++ PgHdr *pPg = DATA_TO_PGHDR(pData); ++ page_ref(pPg); ++ return SQLITE_OK; ++} ++ ++/* ++** 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. It is not safe to modify the original database file until after ++** the journal has been synced. If the original database is modified before ++** the journal is synced and a power failure occurs, the unsynced journal ++** data would be lost and we would be unable to completely rollback the ++** database changes. Database corruption would occur. ++** ++** This routine also updates the nRec field in the header of the journal. ++** (See comments on the pager_playback() routine for additional information.) ++** If the sync mode is FULL, two syncs will occur. First the whole journal ++** is synced, then the nRec field is updated, then a second sync occurs. ++** ++** For temporary databases, we do not care if we are able to rollback ++** after a power failure, so sync occurs. ++** ++** This routine clears the needSync field of every page current held in ++** memory. ++*/ ++static int syncJournal(Pager *pPager){ ++ PgHdr *pPg; ++ int rc = SQLITE_OK; ++ ++ /* Sync the journal before modifying the main database ++ ** (assuming there is a journal and it needs to be synced.) ++ */ ++ if( pPager->needSync ){ ++ if( !pPager->tempFile ){ ++ assert( pPager->journalOpen ); ++ /* assert( !pPager->noSync ); // noSync might be set if synchronous ++ ** was turned off after the transaction was started. Ticket #615 */ ++#ifndef NDEBUG ++ { ++ /* Make sure the pPager->nRec counter we are keeping agrees ++ ** with the nRec computed from the size of the journal file. ++ */ ++ off_t hdrSz, pgSz, jSz; ++ hdrSz = JOURNAL_HDR_SZ(journal_format); ++ pgSz = JOURNAL_PG_SZ(journal_format); ++ rc = sqliteOsFileSize(&pPager->jfd, &jSz); ++ if( rc!=0 ) return rc; ++ assert( pPager->nRec*pgSz+hdrSz==jSz ); ++ } ++#endif ++ if( journal_format>=3 ){ ++ /* Write the nRec value into the journal file header */ ++ off_t szJ; ++ if( pPager->fullSync ){ ++ TRACE1("SYNC\n"); ++ rc = sqliteOsSync(&pPager->jfd); ++ if( rc!=0 ) return rc; ++ } ++ sqliteOsSeek(&pPager->jfd, sizeof(aJournalMagic1)); ++ rc = write32bits(&pPager->jfd, pPager->nRec); ++ if( rc ) return rc; ++ szJ = JOURNAL_HDR_SZ(journal_format) + ++ pPager->nRec*JOURNAL_PG_SZ(journal_format); ++ sqliteOsSeek(&pPager->jfd, szJ); ++ } ++ TRACE1("SYNC\n"); ++ rc = sqliteOsSync(&pPager->jfd); ++ if( rc!=0 ) return rc; ++ pPager->journalStarted = 1; ++ } ++ pPager->needSync = 0; ++ ++ /* Erase the needSync flag from every page. ++ */ ++ for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ ++ pPg->needSync = 0; ++ } ++ pPager->pFirstSynced = pPager->pFirst; ++ } ++ ++#ifndef NDEBUG ++ /* If the Pager.needSync flag is clear then the PgHdr.needSync ++ ** flag must also be clear for all pages. Verify that this ++ ** invariant is true. ++ */ ++ else{ ++ for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ ++ assert( pPg->needSync==0 ); ++ } ++ assert( pPager->pFirstSynced==pPager->pFirst ); ++ } ++#endif ++ ++ return rc; ++} ++ ++/* ++** Given a list of pages (connected by the PgHdr.pDirty pointer) write ++** every one of those pages out to the database file and mark them all ++** as clean. ++*/ ++static int pager_write_pagelist(PgHdr *pList){ ++ Pager *pPager; ++ int rc; ++ ++ if( pList==0 ) return SQLITE_OK; ++ pPager = pList->pPager; ++ while( pList ){ ++ assert( pList->dirty ); ++ sqliteOsSeek(&pPager->fd, (pList->pgno-1)*(off_t)SQLITE_PAGE_SIZE); ++ CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6); ++ TRACE2("STORE %d\n", pList->pgno); ++ rc = sqliteOsWrite(&pPager->fd, PGHDR_TO_DATA(pList), SQLITE_PAGE_SIZE); ++ CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 0); ++ if( rc ) return rc; ++ pList->dirty = 0; ++ pList = pList->pDirty; ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** Collect every dirty page into a dirty list and ++** return a pointer to the head of that list. All pages are ++** collected even if they are still in use. ++*/ ++static PgHdr *pager_get_all_dirty_pages(Pager *pPager){ ++ PgHdr *p, *pList; ++ pList = 0; ++ for(p=pPager->pAll; p; p=p->pNextAll){ ++ if( p->dirty ){ ++ p->pDirty = pList; ++ pList = p; ++ } ++ } ++ return pList; ++} ++ ++/* ++** Acquire a page. ++** ++** A read lock on the disk file is obtained when the first page is acquired. ++** This read lock is dropped when the last page is released. ++** ++** A _get works for any page number greater than 0. If the database ++** file is smaller than the requested page, then no actual disk ++** read occurs and the memory image of the page is initialized to ++** all zeros. The extra data appended to a page is always initialized ++** to zeros the first time a page is loaded into memory. ++** ++** The acquisition might fail for several reasons. In all cases, ++** an appropriate error code is returned and *ppPage is set to NULL. ++** ++** See also sqlitepager_lookup(). 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. ++*/ ++int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){ ++ PgHdr *pPg; ++ int rc; ++ ++ /* Make sure we have not hit any critical errors. ++ */ ++ assert( pPager!=0 ); ++ assert( pgno!=0 ); ++ *ppPage = 0; ++ if( pPager->errMask & ~(PAGER_ERR_FULL) ){ ++ return pager_errcode(pPager); ++ } ++ ++ /* If this is the first page accessed, then get a read lock ++ ** on the database file. ++ */ ++ if( pPager->nRef==0 ){ ++ rc = sqliteOsReadLock(&pPager->fd); ++ if( rc!=SQLITE_OK ){ ++ return rc; ++ } ++ pPager->state = SQLITE_READLOCK; ++ ++ /* If a journal file exists, try to play it back. ++ */ ++ if( pPager->useJournal && sqliteOsFileExists(pPager->zJournal) ){ ++ int rc; ++ ++ /* Get a write lock on the database ++ */ ++ rc = sqliteOsWriteLock(&pPager->fd); ++ if( rc!=SQLITE_OK ){ ++ if( sqliteOsUnlock(&pPager->fd)!=SQLITE_OK ){ ++ /* This should never happen! */ ++ rc = SQLITE_INTERNAL; ++ } ++ return rc; ++ } ++ pPager->state = SQLITE_WRITELOCK; ++ ++ /* Open the journal for reading only. Return SQLITE_BUSY if ++ ** we are unable to open the journal file. ++ ** ++ ** The journal file does not need to be locked itself. The ++ ** journal file is never open unless the main database file holds ++ ** a write lock, so there is never any chance of two or more ++ ** processes opening the journal at the same time. ++ */ ++ rc = sqliteOsOpenReadOnly(pPager->zJournal, &pPager->jfd); ++ if( rc!=SQLITE_OK ){ ++ rc = sqliteOsUnlock(&pPager->fd); ++ assert( rc==SQLITE_OK ); ++ return SQLITE_BUSY; ++ } ++ pPager->journalOpen = 1; ++ pPager->journalStarted = 0; ++ ++ /* Playback and delete the journal. Drop the database write ++ ** lock and reacquire the read lock. ++ */ ++ rc = pager_playback(pPager, 0); ++ if( rc!=SQLITE_OK ){ ++ return rc; ++ } ++ } ++ pPg = 0; ++ }else{ ++ /* Search for page in cache */ ++ pPg = pager_lookup(pPager, pgno); ++ } ++ if( pPg==0 ){ ++ /* The requested page is not in the page cache. */ ++ int h; ++ pPager->nMiss++; ++ if( pPager->nPagemxPage || pPager->pFirst==0 ){ ++ /* Create a new page */ ++ pPg = sqliteMallocRaw( sizeof(*pPg) + SQLITE_PAGE_SIZE ++ + sizeof(u32) + pPager->nExtra ); ++ if( pPg==0 ){ ++ pager_unwritelock(pPager); ++ pPager->errMask |= PAGER_ERR_MEM; ++ return SQLITE_NOMEM; ++ } ++ memset(pPg, 0, sizeof(*pPg)); ++ pPg->pPager = pPager; ++ pPg->pNextAll = pPager->pAll; ++ if( pPager->pAll ){ ++ pPager->pAll->pPrevAll = pPg; ++ } ++ pPg->pPrevAll = 0; ++ pPager->pAll = pPg; ++ pPager->nPage++; ++ }else{ ++ /* Find a page to recycle. Try to locate a page that does not ++ ** require us to do an fsync() on the journal. ++ */ ++ pPg = pPager->pFirstSynced; ++ ++ /* If we could not find a page that does not require an fsync() ++ ** on the journal file then fsync the journal file. This is a ++ ** very slow operation, so we work hard to avoid it. But sometimes ++ ** it can't be helped. ++ */ ++ if( pPg==0 ){ ++ int rc = syncJournal(pPager); ++ if( rc!=0 ){ ++ sqlitepager_rollback(pPager); ++ return SQLITE_IOERR; ++ } ++ pPg = pPager->pFirst; ++ } ++ assert( pPg->nRef==0 ); ++ ++ /* Write the page to the database file if it is dirty. ++ */ ++ if( pPg->dirty ){ ++ assert( pPg->needSync==0 ); ++ pPg->pDirty = 0; ++ rc = pager_write_pagelist( pPg ); ++ if( rc!=SQLITE_OK ){ ++ sqlitepager_rollback(pPager); ++ return SQLITE_IOERR; ++ } ++ } ++ assert( pPg->dirty==0 ); ++ ++ /* If the page we are recycling is marked as alwaysRollback, then ++ ** set the global alwaysRollback flag, thus disabling the ++ ** sqlite_dont_rollback() optimization for the rest of this transaction. ++ ** It is necessary to do this because the page marked alwaysRollback ++ ** might be reloaded at a later time but at that point we won't remember ++ ** that is was marked alwaysRollback. This means that all pages must ++ ** be marked as alwaysRollback from here on out. ++ */ ++ if( pPg->alwaysRollback ){ ++ pPager->alwaysRollback = 1; ++ } ++ ++ /* Unlink the old page from the free list and the hash table ++ */ ++ if( pPg==pPager->pFirstSynced ){ ++ PgHdr *p = pPg->pNextFree; ++ while( p && p->needSync ){ p = p->pNextFree; } ++ pPager->pFirstSynced = p; ++ } ++ if( pPg->pPrevFree ){ ++ pPg->pPrevFree->pNextFree = pPg->pNextFree; ++ }else{ ++ assert( pPager->pFirst==pPg ); ++ pPager->pFirst = pPg->pNextFree; ++ } ++ if( pPg->pNextFree ){ ++ pPg->pNextFree->pPrevFree = pPg->pPrevFree; ++ }else{ ++ assert( pPager->pLast==pPg ); ++ pPager->pLast = pPg->pPrevFree; ++ } ++ pPg->pNextFree = pPg->pPrevFree = 0; ++ if( pPg->pNextHash ){ ++ pPg->pNextHash->pPrevHash = pPg->pPrevHash; ++ } ++ if( pPg->pPrevHash ){ ++ pPg->pPrevHash->pNextHash = pPg->pNextHash; ++ }else{ ++ h = pager_hash(pPg->pgno); ++ assert( pPager->aHash[h]==pPg ); ++ pPager->aHash[h] = pPg->pNextHash; ++ } ++ pPg->pNextHash = pPg->pPrevHash = 0; ++ pPager->nOvfl++; ++ } ++ pPg->pgno = pgno; ++ if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){ ++ sqliteCheckMemory(pPager->aInJournal, pgno/8); ++ assert( pPager->journalOpen ); ++ pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0; ++ pPg->needSync = 0; ++ }else{ ++ pPg->inJournal = 0; ++ pPg->needSync = 0; ++ } ++ if( pPager->aInCkpt && (int)pgno<=pPager->ckptSize ++ && (pPager->aInCkpt[pgno/8] & (1<<(pgno&7)))!=0 ){ ++ page_add_to_ckpt_list(pPg); ++ }else{ ++ page_remove_from_ckpt_list(pPg); ++ } ++ pPg->dirty = 0; ++ pPg->nRef = 1; ++ REFINFO(pPg); ++ pPager->nRef++; ++ h = pager_hash(pgno); ++ pPg->pNextHash = pPager->aHash[h]; ++ pPager->aHash[h] = pPg; ++ if( pPg->pNextHash ){ ++ assert( pPg->pNextHash->pPrevHash==0 ); ++ pPg->pNextHash->pPrevHash = pPg; ++ } ++ if( pPager->nExtra>0 ){ ++ memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra); ++ } ++ if( pPager->dbSize<0 ) sqlitepager_pagecount(pPager); ++ if( pPager->errMask!=0 ){ ++ sqlitepager_unref(PGHDR_TO_DATA(pPg)); ++ rc = pager_errcode(pPager); ++ return rc; ++ } ++ if( pPager->dbSize<(int)pgno ){ ++ memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE); ++ }else{ ++ int rc; ++ sqliteOsSeek(&pPager->fd, (pgno-1)*(off_t)SQLITE_PAGE_SIZE); ++ rc = sqliteOsRead(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE); ++ TRACE2("FETCH %d\n", pPg->pgno); ++ CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3); ++ if( rc!=SQLITE_OK ){ ++ off_t fileSize; ++ if( sqliteOsFileSize(&pPager->fd,&fileSize)!=SQLITE_OK ++ || fileSize>=pgno*SQLITE_PAGE_SIZE ){ ++ sqlitepager_unref(PGHDR_TO_DATA(pPg)); ++ return rc; ++ }else{ ++ memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE); ++ } ++ } ++ } ++ }else{ ++ /* The requested page is in the page cache. */ ++ pPager->nHit++; ++ page_ref(pPg); ++ } ++ *ppPage = PGHDR_TO_DATA(pPg); ++ return SQLITE_OK; ++} ++ ++/* ++** 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 sqlitepager_get(). The difference between this routine ++** and sqlitepager_get() 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. ++*/ ++void *sqlitepager_lookup(Pager *pPager, Pgno pgno){ ++ PgHdr *pPg; ++ ++ assert( pPager!=0 ); ++ assert( pgno!=0 ); ++ if( pPager->errMask & ~(PAGER_ERR_FULL) ){ ++ return 0; ++ } ++ /* if( pPager->nRef==0 ){ ++ ** return 0; ++ ** } ++ */ ++ pPg = pager_lookup(pPager, pgno); ++ if( pPg==0 ) return 0; ++ page_ref(pPg); ++ return PGHDR_TO_DATA(pPg); ++} ++ ++/* ++** Release a page. ++** ++** 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. ++*/ ++int sqlitepager_unref(void *pData){ ++ PgHdr *pPg; ++ ++ /* Decrement the reference count for this page ++ */ ++ pPg = DATA_TO_PGHDR(pData); ++ assert( pPg->nRef>0 ); ++ pPg->nRef--; ++ REFINFO(pPg); ++ ++ /* When the number of references to a page reach 0, call the ++ ** destructor and add the page to the freelist. ++ */ ++ if( pPg->nRef==0 ){ ++ Pager *pPager; ++ pPager = pPg->pPager; ++ pPg->pNextFree = 0; ++ pPg->pPrevFree = pPager->pLast; ++ pPager->pLast = pPg; ++ if( pPg->pPrevFree ){ ++ pPg->pPrevFree->pNextFree = pPg; ++ }else{ ++ pPager->pFirst = pPg; ++ } ++ if( pPg->needSync==0 && pPager->pFirstSynced==0 ){ ++ pPager->pFirstSynced = pPg; ++ } ++ if( pPager->xDestructor ){ ++ pPager->xDestructor(pData); ++ } ++ ++ /* When all pages reach the freelist, drop the read lock from ++ ** the database file. ++ */ ++ pPager->nRef--; ++ assert( pPager->nRef>=0 ); ++ if( pPager->nRef==0 ){ ++ pager_reset(pPager); ++ } ++ } ++ return SQLITE_OK; ++} ++ ++/* ++** Create a journal file for pPager. There should already be a write ++** lock on the database file when this routine is called. ++** ++** Return SQLITE_OK if everything. Return an error code and release the ++** write lock if anything goes wrong. ++*/ ++static int pager_open_journal(Pager *pPager){ ++ int rc; ++ assert( pPager->state==SQLITE_WRITELOCK ); ++ assert( pPager->journalOpen==0 ); ++ assert( pPager->useJournal ); ++ sqlitepager_pagecount(pPager); ++ pPager->aInJournal = sqliteMalloc( pPager->dbSize/8 + 1 ); ++ if( pPager->aInJournal==0 ){ ++ sqliteOsReadLock(&pPager->fd); ++ pPager->state = SQLITE_READLOCK; ++ return SQLITE_NOMEM; ++ } ++ rc = sqliteOsOpenExclusive(pPager->zJournal, &pPager->jfd,pPager->tempFile); ++ if( rc!=SQLITE_OK ){ ++ sqliteFree(pPager->aInJournal); ++ pPager->aInJournal = 0; ++ sqliteOsReadLock(&pPager->fd); ++ pPager->state = SQLITE_READLOCK; ++ return SQLITE_CANTOPEN; ++ } ++ sqliteOsOpenDirectory(pPager->zDirectory, &pPager->jfd); ++ pPager->journalOpen = 1; ++ pPager->journalStarted = 0; ++ pPager->needSync = 0; ++ pPager->alwaysRollback = 0; ++ pPager->nRec = 0; ++ if( pPager->errMask!=0 ){ ++ rc = pager_errcode(pPager); ++ return rc; ++ } ++ pPager->origDbSize = pPager->dbSize; ++ if( journal_format==JOURNAL_FORMAT_3 ){ ++ rc = sqliteOsWrite(&pPager->jfd, aJournalMagic3, sizeof(aJournalMagic3)); ++ if( rc==SQLITE_OK ){ ++ rc = write32bits(&pPager->jfd, pPager->noSync ? 0xffffffff : 0); ++ } ++ if( rc==SQLITE_OK ){ ++ sqliteRandomness(sizeof(pPager->cksumInit), &pPager->cksumInit); ++ rc = write32bits(&pPager->jfd, pPager->cksumInit); ++ } ++ }else if( journal_format==JOURNAL_FORMAT_2 ){ ++ rc = sqliteOsWrite(&pPager->jfd, aJournalMagic2, sizeof(aJournalMagic2)); ++ }else{ ++ assert( journal_format==JOURNAL_FORMAT_1 ); ++ rc = sqliteOsWrite(&pPager->jfd, aJournalMagic1, sizeof(aJournalMagic1)); ++ } ++ if( rc==SQLITE_OK ){ ++ rc = write32bits(&pPager->jfd, pPager->dbSize); ++ } ++ if( pPager->ckptAutoopen && rc==SQLITE_OK ){ ++ rc = sqlitepager_ckpt_begin(pPager); ++ } ++ if( rc!=SQLITE_OK ){ ++ rc = pager_unwritelock(pPager); ++ if( rc==SQLITE_OK ){ ++ rc = SQLITE_FULL; ++ } ++ } ++ return rc; ++} ++ ++/* ++** Acquire a write-lock on the database. The lock is removed when ++** the any of the following happen: ++** ++** * sqlitepager_commit() is called. ++** * sqlitepager_rollback() is called. ++** * sqlitepager_close() is called. ++** * sqlitepager_unref() is called to on every outstanding page. ++** ++** The parameter to this routine is a pointer to any open page of the ++** database file. Nothing changes about the page - it is used merely ++** to acquire a pointer to the Pager structure and as proof that there ++** is already a read-lock on the database. ++** ++** A journal file is opened if this is not a temporary file. For ++** temporary files, the opening of the journal file is deferred until ++** there is an actual need to write to the journal. ++** ++** If the database is already write-locked, this routine is a no-op. ++*/ ++int sqlitepager_begin(void *pData){ ++ PgHdr *pPg = DATA_TO_PGHDR(pData); ++ Pager *pPager = pPg->pPager; ++ int rc = SQLITE_OK; ++ assert( pPg->nRef>0 ); ++ assert( pPager->state!=SQLITE_UNLOCK ); ++ if( pPager->state==SQLITE_READLOCK ){ ++ assert( pPager->aInJournal==0 ); ++ rc = sqliteOsWriteLock(&pPager->fd); ++ if( rc!=SQLITE_OK ){ ++ return rc; ++ } ++ pPager->state = SQLITE_WRITELOCK; ++ pPager->dirtyFile = 0; ++ TRACE1("TRANSACTION\n"); ++ if( pPager->useJournal && !pPager->tempFile ){ ++ rc = pager_open_journal(pPager); ++ } ++ } ++ return rc; ++} ++ ++/* ++** Mark a data page as writeable. The page is written into the journal ++** if it is not there already. This routine must be called before making ++** changes to a page. ++** ++** The first time this routine is called, the pager creates a new ++** journal and acquires a write lock on the database. If the write ++** lock could not be acquired, this routine returns SQLITE_BUSY. The ++** calling routine must check for that return value and be careful not to ++** change any page data until this routine returns SQLITE_OK. ++** ++** If the journal file could not be written because the disk is full, ++** then this routine returns SQLITE_FULL and does an immediate rollback. ++** All subsequent write attempts also return SQLITE_FULL until there ++** is a call to sqlitepager_commit() or sqlitepager_rollback() to ++** reset. ++*/ ++int sqlitepager_write(void *pData){ ++ PgHdr *pPg = DATA_TO_PGHDR(pData); ++ Pager *pPager = pPg->pPager; ++ int rc = SQLITE_OK; ++ ++ /* Check for errors ++ */ ++ if( pPager->errMask ){ ++ return pager_errcode(pPager); ++ } ++ if( pPager->readOnly ){ ++ return SQLITE_PERM; ++ } ++ ++ /* Mark the page as dirty. If the page has already been written ++ ** to the journal then we can return right away. ++ */ ++ pPg->dirty = 1; ++ if( pPg->inJournal && (pPg->inCkpt || pPager->ckptInUse==0) ){ ++ pPager->dirtyFile = 1; ++ return SQLITE_OK; ++ } ++ ++ /* If we get this far, it means that the page needs to be ++ ** written to the transaction journal or the ckeckpoint journal ++ ** or both. ++ ** ++ ** First check to see that the transaction journal exists and ++ ** create it if it does not. ++ */ ++ assert( pPager->state!=SQLITE_UNLOCK ); ++ rc = sqlitepager_begin(pData); ++ if( rc!=SQLITE_OK ){ ++ return rc; ++ } ++ assert( pPager->state==SQLITE_WRITELOCK ); ++ if( !pPager->journalOpen && pPager->useJournal ){ ++ rc = pager_open_journal(pPager); ++ if( rc!=SQLITE_OK ) return rc; ++ } ++ assert( pPager->journalOpen || !pPager->useJournal ); ++ pPager->dirtyFile = 1; ++ ++ /* The transaction journal now exists and we have a write lock on the ++ ** main database file. Write the current page to the transaction ++ ** journal if it is not there already. ++ */ ++ if( !pPg->inJournal && pPager->useJournal ){ ++ if( (int)pPg->pgno <= pPager->origDbSize ){ ++ int szPg; ++ u32 saved; ++ if( journal_format>=JOURNAL_FORMAT_3 ){ ++ u32 cksum = pager_cksum(pPager, pPg->pgno, pData); ++ saved = *(u32*)PGHDR_TO_EXTRA(pPg); ++ store32bits(cksum, pPg, SQLITE_PAGE_SIZE); ++ szPg = SQLITE_PAGE_SIZE+8; ++ }else{ ++ szPg = SQLITE_PAGE_SIZE+4; ++ } ++ store32bits(pPg->pgno, pPg, -4); ++ CODEC(pPager, pData, pPg->pgno, 7); ++ rc = sqliteOsWrite(&pPager->jfd, &((char*)pData)[-4], szPg); ++ TRACE3("JOURNAL %d %d\n", pPg->pgno, pPg->needSync); ++ CODEC(pPager, pData, pPg->pgno, 0); ++ if( journal_format>=JOURNAL_FORMAT_3 ){ ++ *(u32*)PGHDR_TO_EXTRA(pPg) = saved; ++ } ++ if( rc!=SQLITE_OK ){ ++ sqlitepager_rollback(pPager); ++ pPager->errMask |= PAGER_ERR_FULL; ++ return rc; ++ } ++ pPager->nRec++; ++ assert( pPager->aInJournal!=0 ); ++ pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7); ++ pPg->needSync = !pPager->noSync; ++ pPg->inJournal = 1; ++ if( pPager->ckptInUse ){ ++ pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7); ++ page_add_to_ckpt_list(pPg); ++ } ++ }else{ ++ pPg->needSync = !pPager->journalStarted && !pPager->noSync; ++ TRACE3("APPEND %d %d\n", pPg->pgno, pPg->needSync); ++ } ++ if( pPg->needSync ){ ++ pPager->needSync = 1; ++ } ++ } ++ ++ /* If the checkpoint journal is open and the page is not in it, ++ ** then write the current page to the checkpoint journal. Note that ++ ** the checkpoint journal always uses the simplier format 2 that lacks ++ ** checksums. The header is also omitted from the checkpoint journal. ++ */ ++ if( pPager->ckptInUse && !pPg->inCkpt && (int)pPg->pgno<=pPager->ckptSize ){ ++ assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize ); ++ store32bits(pPg->pgno, pPg, -4); ++ CODEC(pPager, pData, pPg->pgno, 7); ++ rc = sqliteOsWrite(&pPager->cpfd, &((char*)pData)[-4], SQLITE_PAGE_SIZE+4); ++ TRACE2("CKPT-JOURNAL %d\n", pPg->pgno); ++ CODEC(pPager, pData, pPg->pgno, 0); ++ if( rc!=SQLITE_OK ){ ++ sqlitepager_rollback(pPager); ++ pPager->errMask |= PAGER_ERR_FULL; ++ return rc; ++ } ++ pPager->ckptNRec++; ++ assert( pPager->aInCkpt!=0 ); ++ pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7); ++ page_add_to_ckpt_list(pPg); ++ } ++ ++ /* Update the database size and return. ++ */ ++ if( pPager->dbSize<(int)pPg->pgno ){ ++ pPager->dbSize = pPg->pgno; ++ } ++ return rc; ++} ++ ++/* ++** Return TRUE if the page given in the argument was previously passed ++** to sqlitepager_write(). In other words, return TRUE if it is ok ++** to change the content of the page. ++*/ ++int sqlitepager_iswriteable(void *pData){ ++ PgHdr *pPg = DATA_TO_PGHDR(pData); ++ return pPg->dirty; ++} ++ ++/* ++** Replace the content of a single page with the information in the third ++** argument. ++*/ ++int sqlitepager_overwrite(Pager *pPager, Pgno pgno, void *pData){ ++ void *pPage; ++ int rc; ++ ++ rc = sqlitepager_get(pPager, pgno, &pPage); ++ if( rc==SQLITE_OK ){ ++ rc = sqlitepager_write(pPage); ++ if( rc==SQLITE_OK ){ ++ memcpy(pPage, pData, SQLITE_PAGE_SIZE); ++ } ++ sqlitepager_unref(pPage); ++ } ++ return rc; ++} ++ ++/* ++** A call to this routine tells the pager that it is not necessary to ++** write the information on page "pgno" back to the disk, even though ++** that page might be marked as dirty. ++** ++** 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, together with the ++** sqlitepager_dont_rollback() below, more than double the speed ++** of large INSERT operations and quadruple the speed of large DELETEs. ++** ++** When this routine is called, set the alwaysRollback flag to true. ++** Subsequent calls to sqlitepager_dont_rollback() for the same page ++** will thereafter be ignored. This is necessary to avoid a problem ++** where a page with data is added to the freelist during one part of ++** a transaction then removed from the freelist during a later part ++** of the same transaction and reused for some other purpose. When it ++** is first added to the freelist, this routine is called. When reused, ++** the dont_rollback() routine is called. But because the page contains ++** critical data, we still need to be sure it gets rolled back in spite ++** of the dont_rollback() call. ++*/ ++void sqlitepager_dont_write(Pager *pPager, Pgno pgno){ ++ PgHdr *pPg; ++ ++ pPg = pager_lookup(pPager, pgno); ++ pPg->alwaysRollback = 1; ++ if( pPg && pPg->dirty && !pPager->ckptInUse ){ ++ if( pPager->dbSize==(int)pPg->pgno && pPager->origDbSizedbSize ){ ++ /* If this pages is the last page in the file and the file has grown ++ ** during the current transaction, then do NOT mark the page as clean. ++ ** When the database file grows, we must make sure that the last page ++ ** gets written at least once so that the disk file will be the correct ++ ** size. If you do not write this page and the size of the file ++ ** on the disk ends up being too small, that can lead to database ++ ** corruption during the next transaction. ++ */ ++ }else{ ++ TRACE2("DONT_WRITE %d\n", pgno); ++ pPg->dirty = 0; ++ } ++ } ++} ++ ++/* ++** A call to this routine tells the pager that if a rollback occurs, ++** it is not necessary to restore the data on the given page. This ++** means that the pager does not have to record the given page in the ++** rollback journal. ++*/ ++void sqlitepager_dont_rollback(void *pData){ ++ PgHdr *pPg = DATA_TO_PGHDR(pData); ++ Pager *pPager = pPg->pPager; ++ ++ if( pPager->state!=SQLITE_WRITELOCK || pPager->journalOpen==0 ) return; ++ if( pPg->alwaysRollback || pPager->alwaysRollback ) return; ++ if( !pPg->inJournal && (int)pPg->pgno <= pPager->origDbSize ){ ++ assert( pPager->aInJournal!=0 ); ++ pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7); ++ pPg->inJournal = 1; ++ if( pPager->ckptInUse ){ ++ pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7); ++ page_add_to_ckpt_list(pPg); ++ } ++ TRACE2("DONT_ROLLBACK %d\n", pPg->pgno); ++ } ++ if( pPager->ckptInUse && !pPg->inCkpt && (int)pPg->pgno<=pPager->ckptSize ){ ++ assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize ); ++ assert( pPager->aInCkpt!=0 ); ++ pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7); ++ page_add_to_ckpt_list(pPg); ++ } ++} ++ ++/* ++** Commit all changes to the database and release the write lock. ++** ++** If the commit fails for any reason, a rollback attempt is made ++** and an error code is returned. If the commit worked, SQLITE_OK ++** is returned. ++*/ ++int sqlitepager_commit(Pager *pPager){ ++ int rc; ++ PgHdr *pPg; ++ ++ if( pPager->errMask==PAGER_ERR_FULL ){ ++ rc = sqlitepager_rollback(pPager); ++ if( rc==SQLITE_OK ){ ++ rc = SQLITE_FULL; ++ } ++ return rc; ++ } ++ if( pPager->errMask!=0 ){ ++ rc = pager_errcode(pPager); ++ return rc; ++ } ++ if( pPager->state!=SQLITE_WRITELOCK ){ ++ return SQLITE_ERROR; ++ } ++ TRACE1("COMMIT\n"); ++ if( pPager->dirtyFile==0 ){ ++ /* Exit early (without doing the time-consuming sqliteOsSync() calls) ++ ** if there have been no changes to the database file. */ ++ assert( pPager->needSync==0 ); ++ rc = pager_unwritelock(pPager); ++ pPager->dbSize = -1; ++ return rc; ++ } ++ assert( pPager->journalOpen ); ++ rc = syncJournal(pPager); ++ if( rc!=SQLITE_OK ){ ++ goto commit_abort; ++ } ++ pPg = pager_get_all_dirty_pages(pPager); ++ if( pPg ){ ++ rc = pager_write_pagelist(pPg); ++ if( rc || (!pPager->noSync && sqliteOsSync(&pPager->fd)!=SQLITE_OK) ){ ++ goto commit_abort; ++ } ++ } ++ rc = pager_unwritelock(pPager); ++ pPager->dbSize = -1; ++ return rc; ++ ++ /* Jump here if anything goes wrong during the commit process. ++ */ ++commit_abort: ++ rc = sqlitepager_rollback(pPager); ++ if( rc==SQLITE_OK ){ ++ rc = SQLITE_FULL; ++ } ++ return rc; ++} ++ ++/* ++** Rollback all changes. The database falls back to read-only mode. ++** All in-memory cache pages revert to their original data contents. ++** The journal is deleted. ++** ++** This routine cannot fail unless some other process is not following ++** the correct locking protocol (SQLITE_PROTOCOL) or unless some other ++** process is writing trash into the journal file (SQLITE_CORRUPT) or ++** unless a prior malloc() failed (SQLITE_NOMEM). Appropriate error ++** codes are returned for all these occasions. Otherwise, ++** SQLITE_OK is returned. ++*/ ++int sqlitepager_rollback(Pager *pPager){ ++ int rc; ++ TRACE1("ROLLBACK\n"); ++ if( !pPager->dirtyFile || !pPager->journalOpen ){ ++ rc = pager_unwritelock(pPager); ++ pPager->dbSize = -1; ++ return rc; ++ } ++ ++ if( pPager->errMask!=0 && pPager->errMask!=PAGER_ERR_FULL ){ ++ if( pPager->state>=SQLITE_WRITELOCK ){ ++ pager_playback(pPager, 1); ++ } ++ return pager_errcode(pPager); ++ } ++ if( pPager->state!=SQLITE_WRITELOCK ){ ++ return SQLITE_OK; ++ } ++ rc = pager_playback(pPager, 1); ++ if( rc!=SQLITE_OK ){ ++ rc = SQLITE_CORRUPT; ++ pPager->errMask |= PAGER_ERR_CORRUPT; ++ } ++ pPager->dbSize = -1; ++ return rc; ++} ++ ++/* ++** Return TRUE if the database file is opened read-only. Return FALSE ++** if the database is (in theory) writable. ++*/ ++int sqlitepager_isreadonly(Pager *pPager){ ++ return pPager->readOnly; ++} ++ ++/* ++** This routine is used for testing and analysis only. ++*/ ++int *sqlitepager_stats(Pager *pPager){ ++ static int a[9]; ++ a[0] = pPager->nRef; ++ a[1] = pPager->nPage; ++ a[2] = pPager->mxPage; ++ a[3] = pPager->dbSize; ++ a[4] = pPager->state; ++ a[5] = pPager->errMask; ++ a[6] = pPager->nHit; ++ a[7] = pPager->nMiss; ++ a[8] = pPager->nOvfl; ++ return a; ++} ++ ++/* ++** Set the checkpoint. ++** ++** This routine should be called with the transaction journal already ++** open. A new checkpoint journal is created that can be used to rollback ++** changes of a single SQL command within a larger transaction. ++*/ ++int sqlitepager_ckpt_begin(Pager *pPager){ ++ int rc; ++ char zTemp[SQLITE_TEMPNAME_SIZE]; ++ if( !pPager->journalOpen ){ ++ pPager->ckptAutoopen = 1; ++ return SQLITE_OK; ++ } ++ assert( pPager->journalOpen ); ++ assert( !pPager->ckptInUse ); ++ pPager->aInCkpt = sqliteMalloc( pPager->dbSize/8 + 1 ); ++ if( pPager->aInCkpt==0 ){ ++ sqliteOsReadLock(&pPager->fd); ++ return SQLITE_NOMEM; ++ } ++#ifndef NDEBUG ++ rc = sqliteOsFileSize(&pPager->jfd, &pPager->ckptJSize); ++ if( rc ) goto ckpt_begin_failed; ++ assert( pPager->ckptJSize == ++ pPager->nRec*JOURNAL_PG_SZ(journal_format)+JOURNAL_HDR_SZ(journal_format) ); ++#endif ++ pPager->ckptJSize = pPager->nRec*JOURNAL_PG_SZ(journal_format) ++ + JOURNAL_HDR_SZ(journal_format); ++ pPager->ckptSize = pPager->dbSize; ++ if( !pPager->ckptOpen ){ ++ rc = sqlitepager_opentemp(zTemp, &pPager->cpfd); ++ if( rc ) goto ckpt_begin_failed; ++ pPager->ckptOpen = 1; ++ pPager->ckptNRec = 0; ++ } ++ pPager->ckptInUse = 1; ++ return SQLITE_OK; ++ ++ckpt_begin_failed: ++ if( pPager->aInCkpt ){ ++ sqliteFree(pPager->aInCkpt); ++ pPager->aInCkpt = 0; ++ } ++ return rc; ++} ++ ++/* ++** Commit a checkpoint. ++*/ ++int sqlitepager_ckpt_commit(Pager *pPager){ ++ if( pPager->ckptInUse ){ ++ PgHdr *pPg, *pNext; ++ sqliteOsSeek(&pPager->cpfd, 0); ++ /* sqliteOsTruncate(&pPager->cpfd, 0); */ ++ pPager->ckptNRec = 0; ++ pPager->ckptInUse = 0; ++ sqliteFree( pPager->aInCkpt ); ++ pPager->aInCkpt = 0; ++ for(pPg=pPager->pCkpt; pPg; pPg=pNext){ ++ pNext = pPg->pNextCkpt; ++ assert( pPg->inCkpt ); ++ pPg->inCkpt = 0; ++ pPg->pPrevCkpt = pPg->pNextCkpt = 0; ++ } ++ pPager->pCkpt = 0; ++ } ++ pPager->ckptAutoopen = 0; ++ return SQLITE_OK; ++} ++ ++/* ++** Rollback a checkpoint. ++*/ ++int sqlitepager_ckpt_rollback(Pager *pPager){ ++ int rc; ++ if( pPager->ckptInUse ){ ++ rc = pager_ckpt_playback(pPager); ++ sqlitepager_ckpt_commit(pPager); ++ }else{ ++ rc = SQLITE_OK; ++ } ++ pPager->ckptAutoopen = 0; ++ return rc; ++} ++ ++/* ++** Return the full pathname of the database file. ++*/ ++const char *sqlitepager_filename(Pager *pPager){ ++ return pPager->zFilename; ++} ++ ++/* ++** Set the codec for this pager ++*/ ++void sqlitepager_set_codec( ++ Pager *pPager, ++ void (*xCodec)(void*,void*,Pgno,int), ++ void *pCodecArg ++){ ++ pPager->xCodec = xCodec; ++ pPager->pCodecArg = pCodecArg; ++} ++ ++#ifdef SQLITE_TEST ++/* ++** Print a listing of all referenced pages and their ref count. ++*/ ++void sqlitepager_refdump(Pager *pPager){ ++ PgHdr *pPg; ++ for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ ++ if( pPg->nRef<=0 ) continue; ++ printf("PAGE %3d addr=0x%08x nRef=%d\n", ++ pPg->pgno, (int)PGHDR_TO_DATA(pPg), pPg->nRef); ++ } ++} ++#endif +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/pager.h +@@ -0,0 +1,107 @@ ++/* ++** 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. ++** ++** @(#) $Id$ ++*/ ++ ++/* ++** The size of one page ++** ++** You can change this value to another (reasonable) value you want. ++** It need not be a power of two, though the interface to the disk ++** will likely be faster if it is. ++** ++** Experiments show that a page size of 1024 gives the best speed ++** for common usages. The speed differences for different sizes ++** such as 512, 2048, 4096, an so forth, is minimal. Note, however, ++** that changing the page size results in a completely imcompatible ++** file format. ++*/ ++#ifndef SQLITE_PAGE_SIZE ++#define SQLITE_PAGE_SIZE 1024 ++#endif ++ ++/* ++** Number of extra bytes of data allocated at the end of each page and ++** stored on disk but not used by the higher level btree layer. Changing ++** this value results in a completely incompatible file format. ++*/ ++#ifndef SQLITE_PAGE_RESERVE ++#define SQLITE_PAGE_RESERVE 0 ++#endif ++ ++/* ++** The total number of usable bytes stored on disk for each page. ++** The usable bytes come at the beginning of the page and the reserve ++** bytes come at the end. ++*/ ++#define SQLITE_USABLE_SIZE (SQLITE_PAGE_SIZE-SQLITE_PAGE_RESERVE) ++ ++/* ++** Maximum number of pages in one database. (This is a limitation of ++** imposed by 4GB files size limits.) ++*/ ++#define SQLITE_MAX_PAGE 1073741823 ++ ++/* ++** 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 unsigned int Pgno; ++ ++/* ++** Each open file is managed by a separate instance of the "Pager" structure. ++*/ ++typedef struct Pager Pager; ++ ++/* ++** See source code comments for a detailed description of the following ++** routines: ++*/ ++int sqlitepager_open(Pager **ppPager, const char *zFilename, ++ int nPage, int nExtra, int useJournal); ++void sqlitepager_set_destructor(Pager*, void(*)(void*)); ++void sqlitepager_set_cachesize(Pager*, int); ++int sqlitepager_close(Pager *pPager); ++int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage); ++void *sqlitepager_lookup(Pager *pPager, Pgno pgno); ++int sqlitepager_ref(void*); ++int sqlitepager_unref(void*); ++Pgno sqlitepager_pagenumber(void*); ++int sqlitepager_write(void*); ++int sqlitepager_iswriteable(void*); ++int sqlitepager_overwrite(Pager *pPager, Pgno pgno, void*); ++int sqlitepager_pagecount(Pager*); ++int sqlitepager_truncate(Pager*,Pgno); ++int sqlitepager_begin(void*); ++int sqlitepager_commit(Pager*); ++int sqlitepager_rollback(Pager*); ++int sqlitepager_isreadonly(Pager*); ++int sqlitepager_ckpt_begin(Pager*); ++int sqlitepager_ckpt_commit(Pager*); ++int sqlitepager_ckpt_rollback(Pager*); ++void sqlitepager_dont_rollback(void*); ++void sqlitepager_dont_write(Pager*, Pgno); ++int *sqlitepager_stats(Pager*); ++void sqlitepager_set_safety_level(Pager*,int); ++const char *sqlitepager_filename(Pager*); ++int sqlitepager_rename(Pager*, const char *zNewName); ++void sqlitepager_set_codec(Pager*,void(*)(void*,void*,Pgno,int),void*); ++ ++#ifdef SQLITE_TEST ++void sqlitepager_refdump(Pager*); ++int pager_refinfo_enable; ++int journal_format; ++#endif +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/parse.c +@@ -0,0 +1,3355 @@ ++/* Driver template for the LEMON parser generator. ++** The author disclaims copyright to this source code. ++*/ ++/* First off, code is included that follows the "include" declaration ++** in the input grammar file. */ ++#include ++#line 33 "ext/sqlite/libsqlite/src/parse.y" ++ ++#include "sqliteInt.h" ++#include "parse.h" ++ ++/* ++** An instance of this structure holds information about the ++** LIMIT clause of a SELECT statement. ++*/ ++struct LimitVal { ++ int limit; /* The LIMIT value. -1 if there is no limit */ ++ int offset; /* The OFFSET. 0 if there is none */ ++}; ++ ++/* ++** 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; }; ++ ++#line 33 "ext/sqlite/libsqlite/src/parse.c" ++/* 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. ++** sqliteParserTOKENTYPE 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 sqliteParserTOKENTYPE. 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() ++** sqliteParserARG_SDECL A static variable declaration for the %extra_argument ++** sqliteParserARG_PDECL A parameter declaration for the %extra_argument ++** sqliteParserARG_STORE Code to store %extra_argument into yypParser ++** sqliteParserARG_FETCH Code to extract %extra_argument from yypParser ++** YYNSTATE the combined number of states. ++** YYNRULE the number of rules in the grammar ++** YYERRORSYMBOL is the code number of the error symbol. If not ++** defined, then do no error processing. ++*/ ++#define YYCODETYPE unsigned char ++#define YYNOCODE 221 ++#define YYACTIONTYPE unsigned short int ++#define sqliteParserTOKENTYPE Token ++typedef union { ++ int yyinit; ++ sqliteParserTOKENTYPE yy0; ++ TriggerStep * yy19; ++ struct LimitVal yy124; ++ Select* yy179; ++ Expr * yy182; ++ Expr* yy242; ++ struct TrigEvent yy290; ++ SrcList* yy307; ++ IdList* yy320; ++ ExprList* yy322; ++ int yy372; ++ struct {int value; int mask;} yy407; ++} YYMINORTYPE; ++#ifndef YYSTACKDEPTH ++#define YYSTACKDEPTH 100 ++#endif ++#define sqliteParserARG_SDECL Parse *pParse; ++#define sqliteParserARG_PDECL ,Parse *pParse ++#define sqliteParserARG_FETCH Parse *pParse = yypParser->pParse ++#define sqliteParserARG_STORE yypParser->pParse = pParse ++#define YYNSTATE 563 ++#define YYNRULE 293 ++#define YYFALLBACK 1 ++#define YY_NO_ACTION (YYNSTATE+YYNRULE+2) ++#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1) ++#define YY_ERROR_ACTION (YYNSTATE+YYNRULE) ++ ++/* 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 < YYNSTATE Shift N. That is, push the lookahead ++** token onto the stack and goto state N. ++** ++** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE. ++** ++** N == YYNSTATE+YYNRULE A syntax error has occurred. ++** ++** N == YYNSTATE+YYNRULE+1 The parser accepts its input. ++** ++** N == YYNSTATE+YYNRULE+2 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 (1090) ++static const YYACTIONTYPE yy_action[] = { ++ /* 0 */ 186, 561, 483, 69, 67, 70, 68, 64, 63, 62, ++ /* 10 */ 61, 58, 57, 56, 55, 54, 53, 181, 180, 179, ++ /* 20 */ 514, 421, 334, 420, 468, 515, 64, 63, 62, 61, ++ /* 30 */ 58, 57, 56, 55, 54, 53, 9, 423, 422, 71, ++ /* 40 */ 72, 129, 65, 66, 513, 510, 305, 52, 138, 69, ++ /* 50 */ 67, 70, 68, 64, 63, 62, 61, 58, 57, 56, ++ /* 60 */ 55, 54, 53, 448, 469, 175, 482, 514, 470, 344, ++ /* 70 */ 342, 36, 515, 58, 57, 56, 55, 54, 53, 8, ++ /* 80 */ 341, 281, 285, 307, 437, 178, 71, 72, 129, 65, ++ /* 90 */ 66, 513, 510, 305, 52, 138, 69, 67, 70, 68, ++ /* 100 */ 64, 63, 62, 61, 58, 57, 56, 55, 54, 53, ++ /* 110 */ 130, 362, 360, 508, 507, 267, 551, 436, 298, 297, ++ /* 120 */ 369, 368, 50, 128, 543, 29, 266, 449, 537, 447, ++ /* 130 */ 591, 528, 442, 441, 187, 132, 514, 536, 47, 48, ++ /* 140 */ 472, 515, 122, 427, 331, 409, 49, 371, 370, 518, ++ /* 150 */ 328, 363, 517, 520, 45, 71, 72, 129, 65, 66, ++ /* 160 */ 513, 510, 305, 52, 138, 69, 67, 70, 68, 64, ++ /* 170 */ 63, 62, 61, 58, 57, 56, 55, 54, 53, 185, ++ /* 180 */ 550, 549, 512, 175, 467, 516, 18, 344, 342, 36, ++ /* 190 */ 544, 175, 320, 230, 231, 344, 342, 36, 341, 56, ++ /* 200 */ 55, 54, 53, 212, 531, 514, 341, 551, 3, 213, ++ /* 210 */ 515, 2, 551, 73, 7, 551, 184, 132, 551, 172, ++ /* 220 */ 551, 309, 348, 42, 71, 72, 129, 65, 66, 513, ++ /* 230 */ 510, 305, 52, 138, 69, 67, 70, 68, 64, 63, ++ /* 240 */ 62, 61, 58, 57, 56, 55, 54, 53, 243, 197, ++ /* 250 */ 282, 358, 268, 373, 264, 372, 183, 241, 436, 169, ++ /* 260 */ 356, 171, 269, 240, 471, 426, 29, 446, 506, 514, ++ /* 270 */ 445, 550, 549, 494, 515, 354, 550, 549, 359, 550, ++ /* 280 */ 549, 144, 550, 549, 550, 549, 592, 309, 71, 72, ++ /* 290 */ 129, 65, 66, 513, 510, 305, 52, 138, 69, 67, ++ /* 300 */ 70, 68, 64, 63, 62, 61, 58, 57, 56, 55, ++ /* 310 */ 54, 53, 514, 857, 82, 377, 1, 515, 268, 373, ++ /* 320 */ 264, 372, 183, 241, 362, 12, 508, 507, 500, 240, ++ /* 330 */ 17, 71, 72, 129, 65, 66, 513, 510, 305, 52, ++ /* 340 */ 138, 69, 67, 70, 68, 64, 63, 62, 61, 58, ++ /* 350 */ 57, 56, 55, 54, 53, 362, 182, 508, 507, 514, ++ /* 360 */ 362, 527, 508, 507, 515, 563, 429, 463, 182, 444, ++ /* 370 */ 375, 338, 443, 430, 379, 378, 593, 156, 71, 72, ++ /* 380 */ 129, 65, 66, 513, 510, 305, 52, 138, 69, 67, ++ /* 390 */ 70, 68, 64, 63, 62, 61, 58, 57, 56, 55, ++ /* 400 */ 54, 53, 514, 526, 542, 450, 534, 515, 286, 493, ++ /* 410 */ 453, 17, 478, 240, 80, 11, 533, 153, 194, 155, ++ /* 420 */ 286, 71, 51, 129, 65, 66, 513, 510, 305, 52, ++ /* 430 */ 138, 69, 67, 70, 68, 64, 63, 62, 61, 58, ++ /* 440 */ 57, 56, 55, 54, 53, 514, 195, 466, 160, 17, ++ /* 450 */ 515, 454, 490, 80, 459, 440, 460, 176, 239, 238, ++ /* 460 */ 80, 80, 562, 1, 71, 40, 129, 65, 66, 513, ++ /* 470 */ 510, 305, 52, 138, 69, 67, 70, 68, 64, 63, ++ /* 480 */ 62, 61, 58, 57, 56, 55, 54, 53, 514, 365, ++ /* 490 */ 154, 19, 339, 515, 80, 232, 405, 80, 165, 404, ++ /* 500 */ 193, 32, 396, 13, 32, 86, 414, 108, 72, 129, ++ /* 510 */ 65, 66, 513, 510, 305, 52, 138, 69, 67, 70, ++ /* 520 */ 68, 64, 63, 62, 61, 58, 57, 56, 55, 54, ++ /* 530 */ 53, 514, 551, 365, 483, 192, 515, 488, 323, 207, ++ /* 540 */ 366, 249, 177, 186, 87, 483, 483, 46, 38, 44, ++ /* 550 */ 458, 108, 129, 65, 66, 513, 510, 305, 52, 138, ++ /* 560 */ 69, 67, 70, 68, 64, 63, 62, 61, 58, 57, ++ /* 570 */ 56, 55, 54, 53, 274, 457, 272, 271, 270, 23, ++ /* 580 */ 8, 551, 211, 412, 307, 257, 365, 385, 201, 31, ++ /* 590 */ 217, 388, 141, 205, 387, 219, 550, 549, 482, 511, ++ /* 600 */ 215, 376, 560, 134, 90, 477, 214, 514, 392, 482, ++ /* 610 */ 482, 152, 515, 360, 203, 212, 409, 531, 800, 284, ++ /* 620 */ 365, 145, 505, 50, 300, 365, 365, 173, 321, 212, ++ /* 630 */ 487, 137, 135, 8, 41, 136, 531, 307, 93, 47, ++ /* 640 */ 48, 346, 316, 106, 106, 550, 549, 49, 371, 370, ++ /* 650 */ 518, 509, 531, 517, 520, 504, 531, 531, 162, 495, ++ /* 660 */ 170, 317, 503, 319, 223, 231, 360, 551, 502, 283, ++ /* 670 */ 162, 207, 557, 486, 212, 191, 50, 10, 289, 304, ++ /* 680 */ 303, 556, 207, 531, 8, 531, 516, 18, 307, 498, ++ /* 690 */ 498, 189, 47, 48, 393, 531, 555, 28, 302, 554, ++ /* 700 */ 49, 371, 370, 518, 484, 480, 517, 520, 322, 299, ++ /* 710 */ 553, 418, 365, 323, 17, 365, 365, 360, 416, 207, ++ /* 720 */ 322, 417, 207, 418, 327, 212, 480, 50, 207, 326, ++ /* 730 */ 106, 550, 549, 106, 105, 247, 407, 475, 332, 516, ++ /* 740 */ 18, 326, 365, 47, 48, 207, 295, 365, 475, 294, ++ /* 750 */ 158, 49, 371, 370, 518, 293, 473, 517, 520, 485, ++ /* 760 */ 106, 391, 390, 202, 148, 93, 351, 480, 204, 301, ++ /* 770 */ 333, 190, 291, 541, 60, 531, 498, 252, 453, 498, ++ /* 780 */ 365, 365, 290, 365, 501, 475, 365, 79, 475, 531, ++ /* 790 */ 516, 18, 379, 378, 475, 365, 465, 245, 89, 112, ++ /* 800 */ 365, 109, 365, 131, 121, 288, 499, 365, 365, 439, ++ /* 810 */ 365, 475, 365, 120, 365, 365, 343, 365, 119, 365, ++ /* 820 */ 118, 365, 365, 365, 365, 117, 116, 365, 126, 365, ++ /* 830 */ 125, 365, 124, 123, 365, 115, 365, 114, 431, 140, ++ /* 840 */ 139, 255, 254, 365, 365, 253, 365, 280, 365, 107, ++ /* 850 */ 365, 365, 113, 365, 111, 26, 365, 365, 365, 365, ++ /* 860 */ 365, 279, 278, 365, 277, 365, 92, 365, 104, 103, ++ /* 870 */ 365, 91, 365, 365, 102, 101, 110, 100, 99, 347, ++ /* 880 */ 25, 98, 340, 30, 24, 97, 266, 174, 96, 85, ++ /* 890 */ 95, 94, 166, 292, 78, 165, 415, 14, 163, 60, ++ /* 900 */ 164, 22, 6, 408, 5, 77, 34, 33, 159, 16, ++ /* 910 */ 157, 151, 75, 149, 15, 146, 313, 312, 395, 384, ++ /* 920 */ 143, 20, 60, 206, 21, 273, 198, 559, 375, 548, ++ /* 930 */ 547, 546, 374, 4, 540, 539, 538, 308, 535, 532, ++ /* 940 */ 530, 212, 261, 38, 260, 352, 259, 39, 258, 367, ++ /* 950 */ 529, 196, 210, 256, 521, 522, 53, 53, 209, 43, ++ /* 960 */ 496, 188, 492, 208, 256, 81, 246, 37, 479, 349, ++ /* 970 */ 244, 37, 474, 464, 276, 27, 452, 451, 433, 432, ++ /* 980 */ 275, 235, 234, 335, 424, 35, 329, 413, 410, 127, ++ /* 990 */ 161, 84, 76, 403, 38, 400, 188, 399, 224, 398, ++ /* 1000 */ 38, 150, 318, 220, 83, 147, 315, 200, 381, 383, ++ /* 1010 */ 199, 142, 545, 265, 88, 262, 523, 361, 491, 476, ++ /* 1020 */ 463, 406, 397, 287, 389, 386, 310, 382, 552, 74, ++ /* 1030 */ 306, 525, 524, 364, 519, 357, 355, 353, 497, 489, ++ /* 1040 */ 481, 263, 242, 462, 461, 456, 455, 438, 296, 345, ++ /* 1050 */ 434, 237, 425, 337, 168, 167, 336, 236, 419, 330, ++ /* 1060 */ 233, 325, 324, 229, 228, 402, 401, 227, 226, 225, ++ /* 1070 */ 222, 221, 218, 314, 394, 311, 216, 380, 251, 250, ++ /* 1080 */ 133, 350, 248, 364, 558, 59, 435, 411, 428, 212, ++}; ++static const YYCODETYPE yy_lookahead[] = { ++ /* 0 */ 21, 9, 23, 70, 71, 72, 73, 74, 75, 76, ++ /* 10 */ 77, 78, 79, 80, 81, 82, 83, 100, 101, 102, ++ /* 20 */ 41, 100, 101, 102, 20, 46, 74, 75, 76, 77, ++ /* 30 */ 78, 79, 80, 81, 82, 83, 19, 55, 56, 60, ++ /* 40 */ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, ++ /* 50 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, ++ /* 60 */ 81, 82, 83, 23, 108, 90, 87, 41, 112, 94, ++ /* 70 */ 95, 96, 46, 78, 79, 80, 81, 82, 83, 19, ++ /* 80 */ 105, 149, 143, 23, 152, 153, 60, 61, 62, 63, ++ /* 90 */ 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, ++ /* 100 */ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, ++ /* 110 */ 31, 107, 52, 109, 110, 93, 23, 140, 78, 79, ++ /* 120 */ 78, 79, 62, 22, 147, 148, 104, 87, 34, 89, ++ /* 130 */ 113, 89, 92, 93, 183, 184, 41, 43, 78, 79, ++ /* 140 */ 80, 46, 165, 166, 205, 53, 86, 87, 88, 89, ++ /* 150 */ 211, 62, 92, 93, 128, 60, 61, 62, 63, 64, ++ /* 160 */ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, ++ /* 170 */ 75, 76, 77, 78, 79, 80, 81, 82, 83, 146, ++ /* 180 */ 87, 88, 93, 90, 20, 125, 126, 94, 95, 96, ++ /* 190 */ 20, 90, 100, 101, 102, 94, 95, 96, 105, 80, ++ /* 200 */ 81, 82, 83, 111, 171, 41, 105, 23, 19, 48, ++ /* 210 */ 46, 19, 23, 19, 19, 23, 183, 184, 23, 17, ++ /* 220 */ 23, 62, 189, 128, 60, 61, 62, 63, 64, 65, ++ /* 230 */ 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, ++ /* 240 */ 76, 77, 78, 79, 80, 81, 82, 83, 20, 90, ++ /* 250 */ 91, 15, 93, 94, 95, 96, 97, 98, 140, 57, ++ /* 260 */ 24, 59, 144, 104, 80, 147, 148, 89, 20, 41, ++ /* 270 */ 92, 87, 88, 20, 46, 39, 87, 88, 42, 87, ++ /* 280 */ 88, 19, 87, 88, 87, 88, 113, 62, 60, 61, ++ /* 290 */ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, ++ /* 300 */ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, ++ /* 310 */ 82, 83, 41, 132, 133, 134, 135, 46, 93, 94, ++ /* 320 */ 95, 96, 97, 98, 107, 63, 109, 110, 20, 104, ++ /* 330 */ 22, 60, 61, 62, 63, 64, 65, 66, 67, 68, ++ /* 340 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, ++ /* 350 */ 79, 80, 81, 82, 83, 107, 47, 109, 110, 41, ++ /* 360 */ 107, 89, 109, 110, 46, 0, 161, 162, 47, 89, ++ /* 370 */ 99, 62, 92, 168, 9, 10, 113, 17, 60, 61, ++ /* 380 */ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, ++ /* 390 */ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, ++ /* 400 */ 82, 83, 41, 89, 155, 156, 26, 46, 99, 20, ++ /* 410 */ 161, 22, 20, 104, 22, 118, 36, 57, 22, 59, ++ /* 420 */ 99, 60, 61, 62, 63, 64, 65, 66, 67, 68, ++ /* 430 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, ++ /* 440 */ 79, 80, 81, 82, 83, 41, 50, 20, 22, 22, ++ /* 450 */ 46, 20, 22, 22, 91, 20, 93, 22, 20, 20, ++ /* 460 */ 22, 22, 134, 135, 60, 61, 62, 63, 64, 65, ++ /* 470 */ 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, ++ /* 480 */ 76, 77, 78, 79, 80, 81, 82, 83, 41, 140, ++ /* 490 */ 130, 22, 20, 46, 22, 20, 20, 22, 22, 20, ++ /* 500 */ 113, 22, 20, 19, 22, 21, 18, 158, 61, 62, ++ /* 510 */ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ++ /* 520 */ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, ++ /* 530 */ 83, 41, 23, 140, 23, 113, 46, 22, 140, 140, ++ /* 540 */ 191, 192, 19, 21, 114, 23, 23, 127, 122, 129, ++ /* 550 */ 29, 158, 62, 63, 64, 65, 66, 67, 68, 69, ++ /* 560 */ 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, ++ /* 570 */ 80, 81, 82, 83, 11, 54, 13, 14, 15, 16, ++ /* 580 */ 19, 23, 174, 95, 23, 192, 140, 78, 79, 181, ++ /* 590 */ 27, 89, 146, 195, 92, 32, 87, 88, 87, 93, ++ /* 600 */ 37, 136, 137, 88, 158, 206, 141, 41, 99, 87, ++ /* 610 */ 87, 146, 46, 52, 51, 111, 53, 171, 130, 19, ++ /* 620 */ 140, 58, 14, 62, 103, 140, 140, 146, 124, 111, ++ /* 630 */ 115, 146, 146, 19, 68, 69, 171, 23, 158, 78, ++ /* 640 */ 79, 80, 124, 158, 158, 87, 88, 86, 87, 88, ++ /* 650 */ 89, 108, 171, 92, 93, 20, 171, 171, 146, 93, ++ /* 660 */ 146, 196, 20, 100, 101, 102, 52, 23, 20, 106, ++ /* 670 */ 146, 140, 15, 115, 111, 22, 62, 118, 198, 194, ++ /* 680 */ 194, 24, 140, 171, 19, 171, 125, 126, 23, 204, ++ /* 690 */ 204, 22, 78, 79, 140, 171, 39, 19, 167, 42, ++ /* 700 */ 86, 87, 88, 89, 115, 152, 92, 93, 196, 167, ++ /* 710 */ 53, 140, 140, 140, 22, 140, 140, 52, 25, 140, ++ /* 720 */ 196, 28, 140, 140, 212, 111, 152, 62, 140, 217, ++ /* 730 */ 158, 87, 88, 158, 158, 182, 212, 206, 45, 125, ++ /* 740 */ 126, 217, 140, 78, 79, 140, 167, 140, 206, 167, ++ /* 750 */ 146, 86, 87, 88, 89, 167, 182, 92, 93, 115, ++ /* 760 */ 158, 207, 208, 209, 146, 158, 194, 152, 195, 194, ++ /* 770 */ 199, 22, 167, 156, 200, 171, 204, 201, 161, 204, ++ /* 780 */ 140, 140, 199, 140, 20, 206, 140, 20, 206, 171, ++ /* 790 */ 125, 126, 9, 10, 206, 140, 20, 182, 158, 158, ++ /* 800 */ 140, 158, 140, 113, 158, 198, 204, 140, 140, 20, ++ /* 810 */ 140, 206, 140, 158, 140, 140, 48, 140, 158, 140, ++ /* 820 */ 158, 140, 140, 140, 140, 158, 158, 140, 158, 140, ++ /* 830 */ 158, 140, 158, 158, 140, 158, 140, 158, 139, 158, ++ /* 840 */ 158, 158, 158, 140, 140, 158, 140, 158, 140, 158, ++ /* 850 */ 140, 140, 158, 140, 158, 19, 140, 140, 140, 140, ++ /* 860 */ 140, 158, 158, 140, 158, 140, 158, 140, 158, 158, ++ /* 870 */ 140, 158, 140, 140, 158, 158, 158, 158, 158, 140, ++ /* 880 */ 19, 158, 48, 158, 19, 158, 104, 97, 158, 21, ++ /* 890 */ 158, 158, 99, 38, 49, 22, 49, 158, 99, 200, ++ /* 900 */ 130, 19, 11, 14, 9, 103, 63, 63, 123, 19, ++ /* 910 */ 114, 114, 103, 123, 19, 114, 116, 35, 87, 20, ++ /* 920 */ 21, 150, 200, 160, 160, 138, 12, 139, 99, 138, ++ /* 930 */ 138, 138, 145, 22, 139, 139, 164, 44, 139, 139, ++ /* 940 */ 171, 111, 176, 122, 177, 119, 178, 120, 179, 117, ++ /* 950 */ 180, 121, 193, 98, 151, 23, 83, 83, 202, 127, ++ /* 960 */ 186, 113, 186, 193, 98, 186, 187, 99, 188, 116, ++ /* 970 */ 187, 99, 188, 139, 159, 19, 151, 164, 139, 139, ++ /* 980 */ 159, 186, 215, 40, 216, 127, 186, 139, 169, 60, ++ /* 990 */ 169, 197, 19, 176, 122, 186, 113, 186, 186, 176, ++ /* 1000 */ 122, 169, 186, 186, 197, 169, 186, 218, 33, 219, ++ /* 1010 */ 116, 218, 142, 157, 173, 175, 157, 203, 157, 157, ++ /* 1020 */ 162, 176, 176, 152, 210, 210, 152, 152, 140, 140, ++ /* 1030 */ 154, 154, 154, 140, 140, 140, 140, 140, 140, 185, ++ /* 1040 */ 140, 172, 140, 140, 163, 163, 163, 152, 154, 154, ++ /* 1050 */ 140, 140, 140, 140, 140, 213, 214, 140, 140, 140, ++ /* 1060 */ 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, ++ /* 1070 */ 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, ++ /* 1080 */ 140, 140, 140, 140, 170, 200, 166, 170, 166, 111, ++}; ++#define YY_SHIFT_USE_DFLT (-84) ++#define YY_SHIFT_COUNT (376) ++#define YY_SHIFT_MIN (-83) ++#define YY_SHIFT_MAX (978) ++static const short yy_shift_ofst[] = { ++ /* 0 */ 783, 563, 614, 614, 93, 92, 92, 978, 614, 561, ++ /* 10 */ 665, 665, 509, 197, -21, 665, 665, 665, 665, 665, ++ /* 20 */ 159, 309, 197, 488, 197, 197, 197, 197, 197, 511, ++ /* 30 */ 271, 60, 665, 665, 665, 665, 665, 665, 665, 665, ++ /* 40 */ 665, 665, 665, 665, 665, 665, 665, 665, 665, 665, ++ /* 50 */ 665, 665, 665, 665, 665, 665, 665, 665, 665, 665, ++ /* 60 */ 665, 665, 665, 665, 665, 665, 665, 665, 665, 665, ++ /* 70 */ 665, 665, 665, 665, 225, 197, 197, 197, 197, 522, ++ /* 80 */ 197, 522, 365, 518, 504, 978, 978, -84, -84, 228, ++ /* 90 */ 164, 95, 26, 318, 318, 318, 318, 318, 318, 318, ++ /* 100 */ 318, 404, 318, 318, 318, 318, 318, 361, 318, 447, ++ /* 110 */ 490, 490, 490, -67, -67, -67, -67, -67, -48, -48, ++ /* 120 */ -48, -48, 101, -5, -5, -5, -5, 657, -25, 566, ++ /* 130 */ 657, 184, 195, 644, 558, 253, 192, 248, 189, 119, ++ /* 140 */ 119, 4, 197, 197, 197, 197, 197, 197, 217, 197, ++ /* 150 */ 197, 197, 217, 197, 197, 197, 197, 197, 217, 197, ++ /* 160 */ 197, 197, 217, 197, 197, 197, 197, -79, 693, 197, ++ /* 170 */ 217, 197, 197, 217, 197, 197, 42, 42, 523, 521, ++ /* 180 */ 521, 521, 197, 197, 515, 217, 197, 515, 197, 197, ++ /* 190 */ 197, 197, 197, 197, 42, 42, 42, 197, 197, 511, ++ /* 200 */ 511, 502, 502, 511, 426, 426, 321, 380, 380, 420, ++ /* 210 */ 380, 430, -44, 380, 484, 975, 894, 975, 883, 929, ++ /* 220 */ 973, 883, 883, 929, 878, 883, 883, 883, 872, 973, ++ /* 230 */ 929, 929, 829, 848, 858, 943, 848, 956, 829, 829, ++ /* 240 */ 893, 932, 956, 829, 853, 872, 853, 868, 848, 866, ++ /* 250 */ 848, 848, 832, 874, 874, 873, 932, 855, 830, 832, ++ /* 260 */ 827, 826, 821, 830, 829, 829, 893, 829, 829, 911, ++ /* 270 */ 914, 914, 914, 829, 914, -84, -84, -84, -84, -84, ++ /* 280 */ -84, -84, 40, 360, 236, 202, -83, 262, 482, 479, ++ /* 290 */ 476, 475, -18, 472, 439, 438, 435, 280, 178, 431, ++ /* 300 */ 363, 427, 392, 389, 308, 89, 396, 17, 94, 22, ++ /* 310 */ 899, 899, 831, 882, 800, 801, 895, 790, 809, 797, ++ /* 320 */ 796, 890, 785, 844, 843, 802, 895, 889, 891, 882, ++ /* 330 */ 799, 770, 847, 873, 845, 855, 793, 868, 782, 790, ++ /* 340 */ 865, 834, 861, 836, 768, 789, 776, 690, 767, 678, ++ /* 350 */ 589, 692, 559, 764, 669, 648, 749, 642, 653, 635, ++ /* 360 */ 600, 608, 543, 506, 422, 387, 469, 297, 314, 272, ++ /* 370 */ 263, 173, 194, 161, 170, 79, -8, ++}; ++#define YY_REDUCE_USE_DFLT (-69) ++#define YY_REDUCE_COUNT (281) ++#define YY_REDUCE_MIN (-68) ++#define YY_REDUCE_MAX (943) ++static const short yy_reduce_ofst[] = { ++ /* 0 */ 181, 465, 486, 485, -23, 524, 512, 33, 446, 575, ++ /* 10 */ 572, 349, 554, 118, 574, 607, 480, 602, 576, 393, ++ /* 20 */ 249, 205, 605, -61, 588, 582, 579, 542, 531, -68, ++ /* 30 */ 699, 739, 733, 732, 730, 727, 725, 723, 720, 719, ++ /* 40 */ 718, 717, 716, 713, 711, 710, 708, 706, 704, 703, ++ /* 50 */ 696, 694, 691, 689, 687, 684, 683, 682, 681, 679, ++ /* 60 */ 677, 675, 674, 672, 670, 668, 667, 662, 660, 655, ++ /* 70 */ 646, 643, 641, 640, 617, 573, 583, 398, 571, 615, ++ /* 80 */ 399, 553, 328, 618, 604, 514, 481, -49, 408, 722, ++ /* 90 */ 722, 722, 722, 722, 722, 722, 722, 722, 722, 722, ++ /* 100 */ 722, 722, 722, 722, 722, 722, 722, 722, 722, 722, ++ /* 110 */ 722, 722, 722, 722, 722, 722, 722, 722, 722, 722, ++ /* 120 */ 722, 722, 922, 722, 722, 722, 722, 917, 920, 885, ++ /* 130 */ 914, 943, 942, 941, 940, 869, 939, 869, 938, 722, ++ /* 140 */ 722, 869, 937, 936, 935, 934, 933, 932, 869, 931, ++ /* 150 */ 930, 929, 869, 928, 927, 926, 925, 924, 869, 923, ++ /* 160 */ 922, 921, 869, 920, 919, 918, 917, 842, 842, 914, ++ /* 170 */ 869, 913, 912, 869, 911, 910, 895, 894, 895, 883, ++ /* 180 */ 882, 881, 903, 902, 854, 869, 900, 854, 898, 897, ++ /* 190 */ 896, 895, 894, 893, 878, 877, 876, 889, 888, 875, ++ /* 200 */ 874, 815, 814, 871, 846, 845, 858, 862, 861, 814, ++ /* 210 */ 859, 840, 841, 856, 870, 793, 790, 789, 820, 836, ++ /* 220 */ 807, 817, 816, 832, 823, 812, 811, 809, 817, 794, ++ /* 230 */ 821, 819, 848, 800, 768, 767, 795, 821, 840, 839, ++ /* 240 */ 813, 825, 815, 834, 784, 783, 780, 779, 779, 770, ++ /* 250 */ 776, 774, 756, 722, 722, 722, 803, 759, 770, 769, ++ /* 260 */ 768, 767, 766, 769, 800, 799, 772, 796, 795, 787, ++ /* 270 */ 793, 792, 791, 788, 787, 764, 763, 722, 722, 722, ++ /* 280 */ 722, 771, ++}; ++static const YYACTIONTYPE yy_default[] = { ++ /* 0 */ 570, 856, 797, 797, 856, 839, 839, 685, 856, 797, ++ /* 10 */ 797, 856, 822, 856, 681, 856, 856, 797, 793, 856, ++ /* 20 */ 586, 649, 856, 581, 856, 856, 856, 856, 856, 594, ++ /* 30 */ 651, 856, 856, 856, 856, 856, 856, 856, 856, 856, ++ /* 40 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856, ++ /* 50 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856, ++ /* 60 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856, ++ /* 70 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 681, ++ /* 80 */ 856, 681, 570, 856, 856, 856, 856, 685, 675, 856, ++ /* 90 */ 856, 856, 856, 730, 729, 724, 723, 837, 697, 721, ++ /* 100 */ 714, 856, 789, 790, 788, 792, 796, 856, 705, 748, ++ /* 110 */ 780, 774, 747, 779, 760, 759, 754, 753, 752, 751, ++ /* 120 */ 750, 749, 640, 758, 757, 756, 755, 856, 856, 856, ++ /* 130 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 764, ++ /* 140 */ 763, 856, 856, 856, 856, 809, 856, 856, 726, 856, ++ /* 150 */ 856, 856, 663, 856, 856, 856, 856, 856, 842, 856, ++ /* 160 */ 856, 856, 844, 856, 856, 856, 856, 856, 828, 856, ++ /* 170 */ 661, 856, 856, 583, 856, 856, 856, 856, 595, 856, ++ /* 180 */ 856, 856, 856, 856, 689, 688, 856, 683, 856, 856, ++ /* 190 */ 856, 856, 856, 856, 856, 856, 856, 856, 573, 856, ++ /* 200 */ 856, 856, 856, 856, 720, 720, 621, 708, 708, 791, ++ /* 210 */ 708, 682, 673, 708, 856, 854, 852, 854, 690, 653, ++ /* 220 */ 731, 690, 690, 653, 720, 690, 690, 690, 720, 731, ++ /* 230 */ 653, 653, 651, 690, 836, 833, 690, 801, 651, 651, ++ /* 240 */ 636, 856, 801, 651, 700, 698, 700, 698, 690, 709, ++ /* 250 */ 690, 690, 856, 767, 766, 765, 856, 709, 715, 701, ++ /* 260 */ 713, 711, 720, 856, 651, 651, 636, 651, 651, 639, ++ /* 270 */ 572, 572, 572, 651, 572, 624, 624, 777, 776, 775, ++ /* 280 */ 768, 604, 856, 856, 856, 856, 856, 816, 856, 856, ++ /* 290 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856, ++ /* 300 */ 856, 856, 856, 856, 856, 856, 716, 737, 856, 856, ++ /* 310 */ 856, 856, 856, 856, 808, 856, 856, 856, 856, 856, ++ /* 320 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856, ++ /* 330 */ 856, 856, 856, 832, 831, 856, 856, 856, 856, 856, ++ /* 340 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856, ++ /* 350 */ 856, 712, 856, 856, 856, 856, 856, 856, 856, 856, ++ /* 360 */ 856, 856, 666, 856, 739, 856, 702, 856, 856, 856, ++ /* 370 */ 738, 743, 856, 856, 856, 856, 856, 565, 569, 567, ++ /* 380 */ 855, 853, 851, 850, 815, 821, 818, 820, 819, 817, ++ /* 390 */ 814, 813, 812, 811, 810, 807, 725, 722, 719, 849, ++ /* 400 */ 806, 662, 660, 843, 841, 732, 840, 838, 823, 728, ++ /* 410 */ 727, 654, 799, 798, 580, 827, 826, 825, 734, 733, ++ /* 420 */ 830, 829, 835, 834, 824, 579, 585, 643, 642, 650, ++ /* 430 */ 648, 647, 646, 645, 644, 641, 587, 598, 599, 597, ++ /* 440 */ 596, 615, 612, 614, 611, 613, 610, 609, 608, 607, ++ /* 450 */ 606, 635, 623, 622, 802, 629, 628, 633, 632, 631, ++ /* 460 */ 630, 627, 626, 625, 620, 746, 745, 735, 778, 672, ++ /* 470 */ 671, 678, 677, 676, 687, 804, 805, 803, 699, 686, ++ /* 480 */ 680, 679, 590, 589, 696, 695, 694, 693, 692, 684, ++ /* 490 */ 674, 704, 786, 783, 784, 772, 785, 691, 795, 794, ++ /* 500 */ 781, 848, 847, 846, 845, 787, 782, 669, 668, 667, ++ /* 510 */ 771, 773, 770, 769, 762, 761, 744, 742, 741, 740, ++ /* 520 */ 736, 710, 588, 703, 718, 717, 602, 601, 600, 670, ++ /* 530 */ 665, 664, 619, 707, 706, 618, 638, 637, 634, 617, ++ /* 540 */ 616, 605, 603, 584, 582, 578, 577, 576, 575, 593, ++ /* 550 */ 592, 591, 574, 659, 658, 657, 656, 655, 652, 571, ++ /* 560 */ 568, 566, 564, ++}; ++ ++/* 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, /* END_OF_FILE => nothing */ ++ 0, /* ILLEGAL => nothing */ ++ 0, /* SPACE => nothing */ ++ 0, /* UNCLOSED_STRING => nothing */ ++ 0, /* COMMENT => nothing */ ++ 0, /* FUNCTION => nothing */ ++ 0, /* COLUMN => nothing */ ++ 0, /* AGG_FUNCTION => nothing */ ++ 0, /* SEMI => nothing */ ++ 23, /* EXPLAIN => ID */ ++ 23, /* BEGIN => ID */ ++ 0, /* TRANSACTION => nothing */ ++ 0, /* COMMIT => nothing */ ++ 23, /* END => ID */ ++ 0, /* ROLLBACK => nothing */ ++ 0, /* CREATE => nothing */ ++ 0, /* TABLE => nothing */ ++ 23, /* TEMP => ID */ ++ 0, /* LP => nothing */ ++ 0, /* RP => nothing */ ++ 0, /* AS => nothing */ ++ 0, /* COMMA => nothing */ ++ 0, /* ID => nothing */ ++ 23, /* ABORT => ID */ ++ 23, /* AFTER => ID */ ++ 23, /* ASC => ID */ ++ 23, /* ATTACH => ID */ ++ 23, /* BEFORE => ID */ ++ 23, /* CASCADE => ID */ ++ 23, /* CLUSTER => ID */ ++ 23, /* CONFLICT => ID */ ++ 23, /* COPY => ID */ ++ 23, /* DATABASE => ID */ ++ 23, /* DEFERRED => ID */ ++ 23, /* DELIMITERS => ID */ ++ 23, /* DESC => ID */ ++ 23, /* DETACH => ID */ ++ 23, /* EACH => ID */ ++ 23, /* FAIL => ID */ ++ 23, /* FOR => ID */ ++ 23, /* GLOB => ID */ ++ 23, /* IGNORE => ID */ ++ 23, /* IMMEDIATE => ID */ ++ 23, /* INITIALLY => ID */ ++ 23, /* INSTEAD => ID */ ++ 23, /* LIKE => ID */ ++ 23, /* MATCH => ID */ ++ 23, /* KEY => ID */ ++ 23, /* OF => ID */ ++ 23, /* OFFSET => ID */ ++ 23, /* PRAGMA => ID */ ++ 23, /* RAISE => ID */ ++ 23, /* REPLACE => ID */ ++ 23, /* RESTRICT => ID */ ++ 23, /* ROW => ID */ ++ 23, /* STATEMENT => ID */ ++ 23, /* TRIGGER => ID */ ++ 23, /* VACUUM => ID */ ++ 23, /* VIEW => 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. ++*/ ++struct yyStackEntry { ++ YYACTIONTYPE stateno; /* The state-number */ ++ 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 */ ++ sqliteParserARG_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. ++*/ ++void sqliteParserTrace(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[] = { ++ "$", "END_OF_FILE", "ILLEGAL", "SPACE", ++ "UNCLOSED_STRING", "COMMENT", "FUNCTION", "COLUMN", ++ "AGG_FUNCTION", "SEMI", "EXPLAIN", "BEGIN", ++ "TRANSACTION", "COMMIT", "END", "ROLLBACK", ++ "CREATE", "TABLE", "TEMP", "LP", ++ "RP", "AS", "COMMA", "ID", ++ "ABORT", "AFTER", "ASC", "ATTACH", ++ "BEFORE", "CASCADE", "CLUSTER", "CONFLICT", ++ "COPY", "DATABASE", "DEFERRED", "DELIMITERS", ++ "DESC", "DETACH", "EACH", "FAIL", ++ "FOR", "GLOB", "IGNORE", "IMMEDIATE", ++ "INITIALLY", "INSTEAD", "LIKE", "MATCH", ++ "KEY", "OF", "OFFSET", "PRAGMA", ++ "RAISE", "REPLACE", "RESTRICT", "ROW", ++ "STATEMENT", "TRIGGER", "VACUUM", "VIEW", ++ "OR", "AND", "NOT", "EQ", ++ "NE", "ISNULL", "NOTNULL", "IS", ++ "BETWEEN", "IN", "GT", "GE", ++ "LT", "LE", "BITAND", "BITOR", ++ "LSHIFT", "RSHIFT", "PLUS", "MINUS", ++ "STAR", "SLASH", "REM", "CONCAT", ++ "UMINUS", "UPLUS", "BITNOT", "STRING", ++ "JOIN_KW", "INTEGER", "CONSTRAINT", "DEFAULT", ++ "FLOAT", "NULL", "PRIMARY", "UNIQUE", ++ "CHECK", "REFERENCES", "COLLATE", "ON", ++ "DELETE", "UPDATE", "INSERT", "SET", ++ "DEFERRABLE", "FOREIGN", "DROP", "UNION", ++ "ALL", "INTERSECT", "EXCEPT", "SELECT", ++ "DISTINCT", "DOT", "FROM", "JOIN", ++ "USING", "ORDER", "BY", "GROUP", ++ "HAVING", "LIMIT", "WHERE", "INTO", ++ "VALUES", "VARIABLE", "CASE", "WHEN", ++ "THEN", "ELSE", "INDEX", "error", ++ "input", "cmdlist", "ecmd", "explain", ++ "cmdx", "cmd", "trans_opt", "onconf", ++ "nm", "create_table", "create_table_args", "temp", ++ "columnlist", "conslist_opt", "select", "column", ++ "columnid", "type", "carglist", "id", ++ "ids", "typename", "signed", "carg", ++ "ccons", "sortorder", "expr", "idxlist_opt", ++ "refargs", "defer_subclause", "refarg", "refact", ++ "init_deferred_pred_opt", "conslist", "tcons", "idxlist", ++ "defer_subclause_opt", "orconf", "resolvetype", "oneselect", ++ "multiselect_op", "distinct", "selcollist", "from", ++ "where_opt", "groupby_opt", "having_opt", "orderby_opt", ++ "limit_opt", "sclp", "as", "seltablist", ++ "stl_prefix", "joinop", "dbnm", "on_opt", ++ "using_opt", "seltablist_paren", "joinop2", "sortlist", ++ "sortitem", "collate", "exprlist", "setlist", ++ "insert_cmd", "inscollist_opt", "itemlist", "inscollist", ++ "likeop", "case_operand", "case_exprlist", "case_else", ++ "expritem", "uniqueflag", "idxitem", "plus_num", ++ "minus_num", "plus_opt", "number", "trigger_decl", ++ "trigger_cmd_list", "trigger_time", "trigger_event", "foreach_clause", ++ "when_clause", "trigger_cmd", "database_kw_opt", "key_opt", ++}; ++#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 ::= explain cmdx SEMI", ++ /* 4 */ "ecmd ::= SEMI", ++ /* 5 */ "cmdx ::= cmd", ++ /* 6 */ "explain ::= EXPLAIN", ++ /* 7 */ "explain ::=", ++ /* 8 */ "cmd ::= BEGIN trans_opt onconf", ++ /* 9 */ "trans_opt ::=", ++ /* 10 */ "trans_opt ::= TRANSACTION", ++ /* 11 */ "trans_opt ::= TRANSACTION nm", ++ /* 12 */ "cmd ::= COMMIT trans_opt", ++ /* 13 */ "cmd ::= END trans_opt", ++ /* 14 */ "cmd ::= ROLLBACK trans_opt", ++ /* 15 */ "cmd ::= create_table create_table_args", ++ /* 16 */ "create_table ::= CREATE temp TABLE nm", ++ /* 17 */ "temp ::= TEMP", ++ /* 18 */ "temp ::=", ++ /* 19 */ "create_table_args ::= LP columnlist conslist_opt RP", ++ /* 20 */ "create_table_args ::= AS select", ++ /* 21 */ "columnlist ::= columnlist COMMA column", ++ /* 22 */ "columnlist ::= column", ++ /* 23 */ "column ::= columnid type carglist", ++ /* 24 */ "columnid ::= nm", ++ /* 25 */ "id ::= ID", ++ /* 26 */ "ids ::= ID", ++ /* 27 */ "ids ::= STRING", ++ /* 28 */ "nm ::= ID", ++ /* 29 */ "nm ::= STRING", ++ /* 30 */ "nm ::= JOIN_KW", ++ /* 31 */ "type ::=", ++ /* 32 */ "type ::= typename", ++ /* 33 */ "type ::= typename LP signed RP", ++ /* 34 */ "type ::= typename LP signed COMMA signed RP", ++ /* 35 */ "typename ::= ids", ++ /* 36 */ "typename ::= typename ids", ++ /* 37 */ "signed ::= INTEGER", ++ /* 38 */ "signed ::= PLUS INTEGER", ++ /* 39 */ "signed ::= MINUS INTEGER", ++ /* 40 */ "carglist ::= carglist carg", ++ /* 41 */ "carglist ::=", ++ /* 42 */ "carg ::= CONSTRAINT nm ccons", ++ /* 43 */ "carg ::= ccons", ++ /* 44 */ "carg ::= DEFAULT STRING", ++ /* 45 */ "carg ::= DEFAULT ID", ++ /* 46 */ "carg ::= DEFAULT INTEGER", ++ /* 47 */ "carg ::= DEFAULT PLUS INTEGER", ++ /* 48 */ "carg ::= DEFAULT MINUS INTEGER", ++ /* 49 */ "carg ::= DEFAULT FLOAT", ++ /* 50 */ "carg ::= DEFAULT PLUS FLOAT", ++ /* 51 */ "carg ::= DEFAULT MINUS FLOAT", ++ /* 52 */ "carg ::= DEFAULT NULL", ++ /* 53 */ "ccons ::= NULL onconf", ++ /* 54 */ "ccons ::= NOT NULL onconf", ++ /* 55 */ "ccons ::= PRIMARY KEY sortorder onconf", ++ /* 56 */ "ccons ::= UNIQUE onconf", ++ /* 57 */ "ccons ::= CHECK LP expr RP onconf", ++ /* 58 */ "ccons ::= REFERENCES nm idxlist_opt refargs", ++ /* 59 */ "ccons ::= defer_subclause", ++ /* 60 */ "ccons ::= COLLATE id", ++ /* 61 */ "refargs ::=", ++ /* 62 */ "refargs ::= refargs refarg", ++ /* 63 */ "refarg ::= MATCH nm", ++ /* 64 */ "refarg ::= ON DELETE refact", ++ /* 65 */ "refarg ::= ON UPDATE refact", ++ /* 66 */ "refarg ::= ON INSERT refact", ++ /* 67 */ "refact ::= SET NULL", ++ /* 68 */ "refact ::= SET DEFAULT", ++ /* 69 */ "refact ::= CASCADE", ++ /* 70 */ "refact ::= RESTRICT", ++ /* 71 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt", ++ /* 72 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt", ++ /* 73 */ "init_deferred_pred_opt ::=", ++ /* 74 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED", ++ /* 75 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE", ++ /* 76 */ "conslist_opt ::=", ++ /* 77 */ "conslist_opt ::= COMMA conslist", ++ /* 78 */ "conslist ::= conslist COMMA tcons", ++ /* 79 */ "conslist ::= conslist tcons", ++ /* 80 */ "conslist ::= tcons", ++ /* 81 */ "tcons ::= CONSTRAINT nm", ++ /* 82 */ "tcons ::= PRIMARY KEY LP idxlist RP onconf", ++ /* 83 */ "tcons ::= UNIQUE LP idxlist RP onconf", ++ /* 84 */ "tcons ::= CHECK expr onconf", ++ /* 85 */ "tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt", ++ /* 86 */ "defer_subclause_opt ::=", ++ /* 87 */ "defer_subclause_opt ::= defer_subclause", ++ /* 88 */ "onconf ::=", ++ /* 89 */ "onconf ::= ON CONFLICT resolvetype", ++ /* 90 */ "orconf ::=", ++ /* 91 */ "orconf ::= OR resolvetype", ++ /* 92 */ "resolvetype ::= ROLLBACK", ++ /* 93 */ "resolvetype ::= ABORT", ++ /* 94 */ "resolvetype ::= FAIL", ++ /* 95 */ "resolvetype ::= IGNORE", ++ /* 96 */ "resolvetype ::= REPLACE", ++ /* 97 */ "cmd ::= DROP TABLE nm", ++ /* 98 */ "cmd ::= CREATE temp VIEW nm AS select", ++ /* 99 */ "cmd ::= DROP VIEW nm", ++ /* 100 */ "cmd ::= select", ++ /* 101 */ "select ::= oneselect", ++ /* 102 */ "select ::= select multiselect_op oneselect", ++ /* 103 */ "multiselect_op ::= UNION", ++ /* 104 */ "multiselect_op ::= UNION ALL", ++ /* 105 */ "multiselect_op ::= INTERSECT", ++ /* 106 */ "multiselect_op ::= EXCEPT", ++ /* 107 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt", ++ /* 108 */ "distinct ::= DISTINCT", ++ /* 109 */ "distinct ::= ALL", ++ /* 110 */ "distinct ::=", ++ /* 111 */ "sclp ::= selcollist COMMA", ++ /* 112 */ "sclp ::=", ++ /* 113 */ "selcollist ::= sclp expr as", ++ /* 114 */ "selcollist ::= sclp STAR", ++ /* 115 */ "selcollist ::= sclp nm DOT STAR", ++ /* 116 */ "as ::= AS nm", ++ /* 117 */ "as ::= ids", ++ /* 118 */ "as ::=", ++ /* 119 */ "from ::=", ++ /* 120 */ "from ::= FROM seltablist", ++ /* 121 */ "stl_prefix ::= seltablist joinop", ++ /* 122 */ "stl_prefix ::=", ++ /* 123 */ "seltablist ::= stl_prefix nm dbnm as on_opt using_opt", ++ /* 124 */ "seltablist ::= stl_prefix LP seltablist_paren RP as on_opt using_opt", ++ /* 125 */ "seltablist_paren ::= select", ++ /* 126 */ "seltablist_paren ::= seltablist", ++ /* 127 */ "dbnm ::=", ++ /* 128 */ "dbnm ::= DOT nm", ++ /* 129 */ "joinop ::= COMMA", ++ /* 130 */ "joinop ::= JOIN", ++ /* 131 */ "joinop ::= JOIN_KW JOIN", ++ /* 132 */ "joinop ::= JOIN_KW nm JOIN", ++ /* 133 */ "joinop ::= JOIN_KW nm nm JOIN", ++ /* 134 */ "on_opt ::= ON expr", ++ /* 135 */ "on_opt ::=", ++ /* 136 */ "using_opt ::= USING LP idxlist RP", ++ /* 137 */ "using_opt ::=", ++ /* 138 */ "orderby_opt ::=", ++ /* 139 */ "orderby_opt ::= ORDER BY sortlist", ++ /* 140 */ "sortlist ::= sortlist COMMA sortitem collate sortorder", ++ /* 141 */ "sortlist ::= sortitem collate sortorder", ++ /* 142 */ "sortitem ::= expr", ++ /* 143 */ "sortorder ::= ASC", ++ /* 144 */ "sortorder ::= DESC", ++ /* 145 */ "sortorder ::=", ++ /* 146 */ "collate ::=", ++ /* 147 */ "collate ::= COLLATE id", ++ /* 148 */ "groupby_opt ::=", ++ /* 149 */ "groupby_opt ::= GROUP BY exprlist", ++ /* 150 */ "having_opt ::=", ++ /* 151 */ "having_opt ::= HAVING expr", ++ /* 152 */ "limit_opt ::=", ++ /* 153 */ "limit_opt ::= LIMIT signed", ++ /* 154 */ "limit_opt ::= LIMIT signed OFFSET signed", ++ /* 155 */ "limit_opt ::= LIMIT signed COMMA signed", ++ /* 156 */ "cmd ::= DELETE FROM nm dbnm where_opt", ++ /* 157 */ "where_opt ::=", ++ /* 158 */ "where_opt ::= WHERE expr", ++ /* 159 */ "cmd ::= UPDATE orconf nm dbnm SET setlist where_opt", ++ /* 160 */ "setlist ::= setlist COMMA nm EQ expr", ++ /* 161 */ "setlist ::= nm EQ expr", ++ /* 162 */ "cmd ::= insert_cmd INTO nm dbnm inscollist_opt VALUES LP itemlist RP", ++ /* 163 */ "cmd ::= insert_cmd INTO nm dbnm inscollist_opt select", ++ /* 164 */ "insert_cmd ::= INSERT orconf", ++ /* 165 */ "insert_cmd ::= REPLACE", ++ /* 166 */ "itemlist ::= itemlist COMMA expr", ++ /* 167 */ "itemlist ::= expr", ++ /* 168 */ "inscollist_opt ::=", ++ /* 169 */ "inscollist_opt ::= LP inscollist RP", ++ /* 170 */ "inscollist ::= inscollist COMMA nm", ++ /* 171 */ "inscollist ::= nm", ++ /* 172 */ "expr ::= LP expr RP", ++ /* 173 */ "expr ::= NULL", ++ /* 174 */ "expr ::= ID", ++ /* 175 */ "expr ::= JOIN_KW", ++ /* 176 */ "expr ::= nm DOT nm", ++ /* 177 */ "expr ::= nm DOT nm DOT nm", ++ /* 178 */ "expr ::= INTEGER", ++ /* 179 */ "expr ::= FLOAT", ++ /* 180 */ "expr ::= STRING", ++ /* 181 */ "expr ::= VARIABLE", ++ /* 182 */ "expr ::= ID LP exprlist RP", ++ /* 183 */ "expr ::= ID LP STAR RP", ++ /* 184 */ "expr ::= expr AND expr", ++ /* 185 */ "expr ::= expr OR expr", ++ /* 186 */ "expr ::= expr LT expr", ++ /* 187 */ "expr ::= expr GT expr", ++ /* 188 */ "expr ::= expr LE expr", ++ /* 189 */ "expr ::= expr GE expr", ++ /* 190 */ "expr ::= expr NE expr", ++ /* 191 */ "expr ::= expr EQ expr", ++ /* 192 */ "expr ::= expr BITAND expr", ++ /* 193 */ "expr ::= expr BITOR expr", ++ /* 194 */ "expr ::= expr LSHIFT expr", ++ /* 195 */ "expr ::= expr RSHIFT expr", ++ /* 196 */ "expr ::= expr likeop expr", ++ /* 197 */ "expr ::= expr NOT likeop expr", ++ /* 198 */ "likeop ::= LIKE", ++ /* 199 */ "likeop ::= GLOB", ++ /* 200 */ "expr ::= expr PLUS expr", ++ /* 201 */ "expr ::= expr MINUS expr", ++ /* 202 */ "expr ::= expr STAR expr", ++ /* 203 */ "expr ::= expr SLASH expr", ++ /* 204 */ "expr ::= expr REM expr", ++ /* 205 */ "expr ::= expr CONCAT expr", ++ /* 206 */ "expr ::= expr ISNULL", ++ /* 207 */ "expr ::= expr IS NULL", ++ /* 208 */ "expr ::= expr NOTNULL", ++ /* 209 */ "expr ::= expr NOT NULL", ++ /* 210 */ "expr ::= expr IS NOT NULL", ++ /* 211 */ "expr ::= NOT expr", ++ /* 212 */ "expr ::= BITNOT expr", ++ /* 213 */ "expr ::= MINUS expr", ++ /* 214 */ "expr ::= PLUS expr", ++ /* 215 */ "expr ::= LP select RP", ++ /* 216 */ "expr ::= expr BETWEEN expr AND expr", ++ /* 217 */ "expr ::= expr NOT BETWEEN expr AND expr", ++ /* 218 */ "expr ::= expr IN LP exprlist RP", ++ /* 219 */ "expr ::= expr IN LP select RP", ++ /* 220 */ "expr ::= expr NOT IN LP exprlist RP", ++ /* 221 */ "expr ::= expr NOT IN LP select RP", ++ /* 222 */ "expr ::= expr IN nm dbnm", ++ /* 223 */ "expr ::= expr NOT IN nm dbnm", ++ /* 224 */ "expr ::= CASE case_operand case_exprlist case_else END", ++ /* 225 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", ++ /* 226 */ "case_exprlist ::= WHEN expr THEN expr", ++ /* 227 */ "case_else ::= ELSE expr", ++ /* 228 */ "case_else ::=", ++ /* 229 */ "case_operand ::= expr", ++ /* 230 */ "case_operand ::=", ++ /* 231 */ "exprlist ::= exprlist COMMA expritem", ++ /* 232 */ "exprlist ::= expritem", ++ /* 233 */ "expritem ::= expr", ++ /* 234 */ "expritem ::=", ++ /* 235 */ "cmd ::= CREATE uniqueflag INDEX nm ON nm dbnm LP idxlist RP onconf", ++ /* 236 */ "uniqueflag ::= UNIQUE", ++ /* 237 */ "uniqueflag ::=", ++ /* 238 */ "idxlist_opt ::=", ++ /* 239 */ "idxlist_opt ::= LP idxlist RP", ++ /* 240 */ "idxlist ::= idxlist COMMA idxitem", ++ /* 241 */ "idxlist ::= idxitem", ++ /* 242 */ "idxitem ::= nm sortorder", ++ /* 243 */ "cmd ::= DROP INDEX nm dbnm", ++ /* 244 */ "cmd ::= COPY orconf nm dbnm FROM nm USING DELIMITERS STRING", ++ /* 245 */ "cmd ::= COPY orconf nm dbnm FROM nm", ++ /* 246 */ "cmd ::= VACUUM", ++ /* 247 */ "cmd ::= VACUUM nm", ++ /* 248 */ "cmd ::= PRAGMA ids EQ nm", ++ /* 249 */ "cmd ::= PRAGMA ids EQ ON", ++ /* 250 */ "cmd ::= PRAGMA ids EQ plus_num", ++ /* 251 */ "cmd ::= PRAGMA ids EQ minus_num", ++ /* 252 */ "cmd ::= PRAGMA ids LP nm RP", ++ /* 253 */ "cmd ::= PRAGMA ids", ++ /* 254 */ "plus_num ::= plus_opt number", ++ /* 255 */ "minus_num ::= MINUS number", ++ /* 256 */ "number ::= INTEGER", ++ /* 257 */ "number ::= FLOAT", ++ /* 258 */ "plus_opt ::= PLUS", ++ /* 259 */ "plus_opt ::=", ++ /* 260 */ "cmd ::= CREATE trigger_decl BEGIN trigger_cmd_list END", ++ /* 261 */ "trigger_decl ::= temp TRIGGER nm trigger_time trigger_event ON nm dbnm foreach_clause when_clause", ++ /* 262 */ "trigger_time ::= BEFORE", ++ /* 263 */ "trigger_time ::= AFTER", ++ /* 264 */ "trigger_time ::= INSTEAD OF", ++ /* 265 */ "trigger_time ::=", ++ /* 266 */ "trigger_event ::= DELETE", ++ /* 267 */ "trigger_event ::= INSERT", ++ /* 268 */ "trigger_event ::= UPDATE", ++ /* 269 */ "trigger_event ::= UPDATE OF inscollist", ++ /* 270 */ "foreach_clause ::=", ++ /* 271 */ "foreach_clause ::= FOR EACH ROW", ++ /* 272 */ "foreach_clause ::= FOR EACH STATEMENT", ++ /* 273 */ "when_clause ::=", ++ /* 274 */ "when_clause ::= WHEN expr", ++ /* 275 */ "trigger_cmd_list ::= trigger_cmd SEMI trigger_cmd_list", ++ /* 276 */ "trigger_cmd_list ::=", ++ /* 277 */ "trigger_cmd ::= UPDATE orconf nm SET setlist where_opt", ++ /* 278 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt VALUES LP itemlist RP", ++ /* 279 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt select", ++ /* 280 */ "trigger_cmd ::= DELETE FROM nm where_opt", ++ /* 281 */ "trigger_cmd ::= select", ++ /* 282 */ "expr ::= RAISE LP IGNORE RP", ++ /* 283 */ "expr ::= RAISE LP ROLLBACK COMMA nm RP", ++ /* 284 */ "expr ::= RAISE LP ABORT COMMA nm RP", ++ /* 285 */ "expr ::= RAISE LP FAIL COMMA nm RP", ++ /* 286 */ "cmd ::= DROP TRIGGER nm dbnm", ++ /* 287 */ "cmd ::= ATTACH database_kw_opt ids AS nm key_opt", ++ /* 288 */ "key_opt ::= USING ids", ++ /* 289 */ "key_opt ::=", ++ /* 290 */ "database_kw_opt ::= DATABASE", ++ /* 291 */ "database_kw_opt ::=", ++ /* 292 */ "cmd ::= DETACH database_kw_opt nm", ++}; ++#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 sqliteParser and sqliteParserFree. ++*/ ++void *sqliteParserAlloc(void *(*mallocProc)(size_t)){ ++ yyParser *pParser; ++ pParser = (yyParser*)(*mallocProc)( (size_t)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 */ ++){ ++ sqliteParserARG_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 146: /* select */ ++ case 171: /* oneselect */ ++ case 189: /* seltablist_paren */ ++{ ++#line 286 "ext/sqlite/libsqlite/src/parse.y" ++sqliteSelectDelete((yypminor->yy179)); ++#line 1131 "ext/sqlite/libsqlite/src/parse.c" ++} ++ break; ++ case 158: /* expr */ ++ case 176: /* where_opt */ ++ case 178: /* having_opt */ ++ case 187: /* on_opt */ ++ case 192: /* sortitem */ ++ case 204: /* expritem */ ++{ ++#line 533 "ext/sqlite/libsqlite/src/parse.y" ++sqliteExprDelete((yypminor->yy242)); ++#line 1143 "ext/sqlite/libsqlite/src/parse.c" ++} ++ break; ++ case 159: /* idxlist_opt */ ++ case 167: /* idxlist */ ++ case 188: /* using_opt */ ++ case 197: /* inscollist_opt */ ++ case 199: /* inscollist */ ++{ ++#line 746 "ext/sqlite/libsqlite/src/parse.y" ++sqliteIdListDelete((yypminor->yy320)); ++#line 1154 "ext/sqlite/libsqlite/src/parse.c" ++} ++ break; ++ case 174: /* selcollist */ ++ case 177: /* groupby_opt */ ++ case 179: /* orderby_opt */ ++ case 181: /* sclp */ ++ case 191: /* sortlist */ ++ case 194: /* exprlist */ ++ case 195: /* setlist */ ++ case 198: /* itemlist */ ++ case 202: /* case_exprlist */ ++{ ++#line 322 "ext/sqlite/libsqlite/src/parse.y" ++sqliteExprListDelete((yypminor->yy322)); ++#line 1169 "ext/sqlite/libsqlite/src/parse.c" ++} ++ break; ++ case 175: /* from */ ++ case 183: /* seltablist */ ++ case 184: /* stl_prefix */ ++{ ++#line 353 "ext/sqlite/libsqlite/src/parse.y" ++sqliteSrcListDelete((yypminor->yy307)); ++#line 1178 "ext/sqlite/libsqlite/src/parse.c" ++} ++ break; ++ case 212: /* trigger_cmd_list */ ++ case 217: /* trigger_cmd */ ++{ ++#line 828 "ext/sqlite/libsqlite/src/parse.y" ++sqliteDeleteTriggerStep((yypminor->yy19)); ++#line 1186 "ext/sqlite/libsqlite/src/parse.c" ++} ++ break; ++ case 214: /* trigger_event */ ++{ ++#line 812 "ext/sqlite/libsqlite/src/parse.y" ++sqliteIdListDelete((yypminor->yy290).b); ++#line 1193 "ext/sqlite/libsqlite/src/parse.c" ++} ++ 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]; ++ ++ if( pParser->yyidx<0 ) return 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 sqliteParserAlloc. ++**
  • A pointer to a function used to reclaim memory obtained ++** from malloc. ++**
++*/ ++void sqliteParserFree( ++ void *p, /* The parser to be deleted */ ++ void (*freeProc)(void*) /* Function used to reclaim memory */ ++){ ++ yyParser *pParser = (yyParser*)p; ++ if( 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 ++int sqliteParserStackPeak(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_SHIFT_COUNT ++ || (i = yy_shift_ofst[stateno])==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 */ ++ sqliteParserARG_STORE; /* Suppress warning about unused %extra_argument var */ ++} ++ ++/* ++** Perform a shift action. ++*/ ++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; ++#ifndef NDEBUG ++ if( yyTraceFILE && yypParser->yyidx>0 ){ ++ int i; ++ fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState); ++ fprintf(yyTraceFILE,"%sStack:",yyTracePrompt); ++ for(i=1; i<=yypParser->yyidx; i++) ++ fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]); ++ fprintf(yyTraceFILE,"\n"); ++ } ++#endif ++} ++ ++/* 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[] = { ++ { 132, 1 }, ++ { 133, 2 }, ++ { 133, 1 }, ++ { 134, 3 }, ++ { 134, 1 }, ++ { 136, 1 }, ++ { 135, 1 }, ++ { 135, 0 }, ++ { 137, 3 }, ++ { 138, 0 }, ++ { 138, 1 }, ++ { 138, 2 }, ++ { 137, 2 }, ++ { 137, 2 }, ++ { 137, 2 }, ++ { 137, 2 }, ++ { 141, 4 }, ++ { 143, 1 }, ++ { 143, 0 }, ++ { 142, 4 }, ++ { 142, 2 }, ++ { 144, 3 }, ++ { 144, 1 }, ++ { 147, 3 }, ++ { 148, 1 }, ++ { 151, 1 }, ++ { 152, 1 }, ++ { 152, 1 }, ++ { 140, 1 }, ++ { 140, 1 }, ++ { 140, 1 }, ++ { 149, 0 }, ++ { 149, 1 }, ++ { 149, 4 }, ++ { 149, 6 }, ++ { 153, 1 }, ++ { 153, 2 }, ++ { 154, 1 }, ++ { 154, 2 }, ++ { 154, 2 }, ++ { 150, 2 }, ++ { 150, 0 }, ++ { 155, 3 }, ++ { 155, 1 }, ++ { 155, 2 }, ++ { 155, 2 }, ++ { 155, 2 }, ++ { 155, 3 }, ++ { 155, 3 }, ++ { 155, 2 }, ++ { 155, 3 }, ++ { 155, 3 }, ++ { 155, 2 }, ++ { 156, 2 }, ++ { 156, 3 }, ++ { 156, 4 }, ++ { 156, 2 }, ++ { 156, 5 }, ++ { 156, 4 }, ++ { 156, 1 }, ++ { 156, 2 }, ++ { 160, 0 }, ++ { 160, 2 }, ++ { 162, 2 }, ++ { 162, 3 }, ++ { 162, 3 }, ++ { 162, 3 }, ++ { 163, 2 }, ++ { 163, 2 }, ++ { 163, 1 }, ++ { 163, 1 }, ++ { 161, 3 }, ++ { 161, 2 }, ++ { 164, 0 }, ++ { 164, 2 }, ++ { 164, 2 }, ++ { 145, 0 }, ++ { 145, 2 }, ++ { 165, 3 }, ++ { 165, 2 }, ++ { 165, 1 }, ++ { 166, 2 }, ++ { 166, 6 }, ++ { 166, 5 }, ++ { 166, 3 }, ++ { 166, 10 }, ++ { 168, 0 }, ++ { 168, 1 }, ++ { 139, 0 }, ++ { 139, 3 }, ++ { 169, 0 }, ++ { 169, 2 }, ++ { 170, 1 }, ++ { 170, 1 }, ++ { 170, 1 }, ++ { 170, 1 }, ++ { 170, 1 }, ++ { 137, 3 }, ++ { 137, 6 }, ++ { 137, 3 }, ++ { 137, 1 }, ++ { 146, 1 }, ++ { 146, 3 }, ++ { 172, 1 }, ++ { 172, 2 }, ++ { 172, 1 }, ++ { 172, 1 }, ++ { 171, 9 }, ++ { 173, 1 }, ++ { 173, 1 }, ++ { 173, 0 }, ++ { 181, 2 }, ++ { 181, 0 }, ++ { 174, 3 }, ++ { 174, 2 }, ++ { 174, 4 }, ++ { 182, 2 }, ++ { 182, 1 }, ++ { 182, 0 }, ++ { 175, 0 }, ++ { 175, 2 }, ++ { 184, 2 }, ++ { 184, 0 }, ++ { 183, 6 }, ++ { 183, 7 }, ++ { 189, 1 }, ++ { 189, 1 }, ++ { 186, 0 }, ++ { 186, 2 }, ++ { 185, 1 }, ++ { 185, 1 }, ++ { 185, 2 }, ++ { 185, 3 }, ++ { 185, 4 }, ++ { 187, 2 }, ++ { 187, 0 }, ++ { 188, 4 }, ++ { 188, 0 }, ++ { 179, 0 }, ++ { 179, 3 }, ++ { 191, 5 }, ++ { 191, 3 }, ++ { 192, 1 }, ++ { 157, 1 }, ++ { 157, 1 }, ++ { 157, 0 }, ++ { 193, 0 }, ++ { 193, 2 }, ++ { 177, 0 }, ++ { 177, 3 }, ++ { 178, 0 }, ++ { 178, 2 }, ++ { 180, 0 }, ++ { 180, 2 }, ++ { 180, 4 }, ++ { 180, 4 }, ++ { 137, 5 }, ++ { 176, 0 }, ++ { 176, 2 }, ++ { 137, 7 }, ++ { 195, 5 }, ++ { 195, 3 }, ++ { 137, 9 }, ++ { 137, 6 }, ++ { 196, 2 }, ++ { 196, 1 }, ++ { 198, 3 }, ++ { 198, 1 }, ++ { 197, 0 }, ++ { 197, 3 }, ++ { 199, 3 }, ++ { 199, 1 }, ++ { 158, 3 }, ++ { 158, 1 }, ++ { 158, 1 }, ++ { 158, 1 }, ++ { 158, 3 }, ++ { 158, 5 }, ++ { 158, 1 }, ++ { 158, 1 }, ++ { 158, 1 }, ++ { 158, 1 }, ++ { 158, 4 }, ++ { 158, 4 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 4 }, ++ { 200, 1 }, ++ { 200, 1 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 3 }, ++ { 158, 2 }, ++ { 158, 3 }, ++ { 158, 2 }, ++ { 158, 3 }, ++ { 158, 4 }, ++ { 158, 2 }, ++ { 158, 2 }, ++ { 158, 2 }, ++ { 158, 2 }, ++ { 158, 3 }, ++ { 158, 5 }, ++ { 158, 6 }, ++ { 158, 5 }, ++ { 158, 5 }, ++ { 158, 6 }, ++ { 158, 6 }, ++ { 158, 4 }, ++ { 158, 5 }, ++ { 158, 5 }, ++ { 202, 5 }, ++ { 202, 4 }, ++ { 203, 2 }, ++ { 203, 0 }, ++ { 201, 1 }, ++ { 201, 0 }, ++ { 194, 3 }, ++ { 194, 1 }, ++ { 204, 1 }, ++ { 204, 0 }, ++ { 137, 11 }, ++ { 205, 1 }, ++ { 205, 0 }, ++ { 159, 0 }, ++ { 159, 3 }, ++ { 167, 3 }, ++ { 167, 1 }, ++ { 206, 2 }, ++ { 137, 4 }, ++ { 137, 9 }, ++ { 137, 6 }, ++ { 137, 1 }, ++ { 137, 2 }, ++ { 137, 4 }, ++ { 137, 4 }, ++ { 137, 4 }, ++ { 137, 4 }, ++ { 137, 5 }, ++ { 137, 2 }, ++ { 207, 2 }, ++ { 208, 2 }, ++ { 210, 1 }, ++ { 210, 1 }, ++ { 209, 1 }, ++ { 209, 0 }, ++ { 137, 5 }, ++ { 211, 10 }, ++ { 213, 1 }, ++ { 213, 1 }, ++ { 213, 2 }, ++ { 213, 0 }, ++ { 214, 1 }, ++ { 214, 1 }, ++ { 214, 1 }, ++ { 214, 3 }, ++ { 215, 0 }, ++ { 215, 3 }, ++ { 215, 3 }, ++ { 216, 0 }, ++ { 216, 2 }, ++ { 212, 3 }, ++ { 212, 0 }, ++ { 217, 6 }, ++ { 217, 8 }, ++ { 217, 5 }, ++ { 217, 4 }, ++ { 217, 1 }, ++ { 158, 4 }, ++ { 158, 6 }, ++ { 158, 6 }, ++ { 158, 6 }, ++ { 137, 4 }, ++ { 137, 6 }, ++ { 219, 2 }, ++ { 219, 0 }, ++ { 218, 1 }, ++ { 218, 0 }, ++ { 137, 3 }, ++}; ++ ++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 */ ++ sqliteParserARG_FETCH; ++ yymsp = &yypParser->yystack[yypParser->yyidx]; ++#ifndef NDEBUG ++ if( yyTraceFILE && yyruleno>=0 ++ && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ ++ fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt, ++ yyRuleName[yyruleno]); ++ } ++#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: /* cmdx ::= cmd */ ++#line 72 "ext/sqlite/libsqlite/src/parse.y" ++{ sqliteExec(pParse); } ++#line 1781 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 6: /* explain ::= EXPLAIN */ ++#line 73 "ext/sqlite/libsqlite/src/parse.y" ++{ sqliteBeginParse(pParse, 1); } ++#line 1786 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 7: /* explain ::= */ ++#line 74 "ext/sqlite/libsqlite/src/parse.y" ++{ sqliteBeginParse(pParse, 0); } ++#line 1791 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 8: /* cmd ::= BEGIN trans_opt onconf */ ++#line 79 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteBeginTransaction(pParse,yymsp[0].minor.yy372);} ++#line 1796 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 12: /* cmd ::= COMMIT trans_opt */ ++ case 13: /* cmd ::= END trans_opt */ yytestcase(yyruleno==13); ++#line 83 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteCommitTransaction(pParse);} ++#line 1802 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 14: /* cmd ::= ROLLBACK trans_opt */ ++#line 85 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteRollbackTransaction(pParse);} ++#line 1807 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 16: /* create_table ::= CREATE temp TABLE nm */ ++#line 90 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteStartTable(pParse,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0,yymsp[-2].minor.yy372,0); ++} ++#line 1814 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 17: /* temp ::= TEMP */ ++ case 74: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ yytestcase(yyruleno==74); ++ case 108: /* distinct ::= DISTINCT */ yytestcase(yyruleno==108); ++#line 94 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = 1;} ++#line 1821 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 18: /* temp ::= */ ++ case 73: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==73); ++ case 75: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ yytestcase(yyruleno==75); ++ case 86: /* defer_subclause_opt ::= */ yytestcase(yyruleno==86); ++ case 109: /* distinct ::= ALL */ yytestcase(yyruleno==109); ++ case 110: /* distinct ::= */ yytestcase(yyruleno==110); ++#line 95 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = 0;} ++#line 1831 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 19: /* create_table_args ::= LP columnlist conslist_opt RP */ ++#line 96 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteEndTable(pParse,&yymsp[0].minor.yy0,0); ++} ++#line 1838 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 20: /* create_table_args ::= AS select */ ++#line 99 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteEndTable(pParse,0,yymsp[0].minor.yy179); ++ sqliteSelectDelete(yymsp[0].minor.yy179); ++} ++#line 1846 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 24: /* columnid ::= nm */ ++#line 111 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteAddColumn(pParse,&yymsp[0].minor.yy0);} ++#line 1851 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 25: /* id ::= ID */ ++ case 26: /* ids ::= ID */ yytestcase(yyruleno==26); ++ case 27: /* ids ::= STRING */ yytestcase(yyruleno==27); ++ case 28: /* nm ::= ID */ yytestcase(yyruleno==28); ++ case 29: /* nm ::= STRING */ yytestcase(yyruleno==29); ++ case 30: /* nm ::= JOIN_KW */ yytestcase(yyruleno==30); ++ case 35: /* typename ::= ids */ yytestcase(yyruleno==35); ++ case 128: /* dbnm ::= DOT nm */ yytestcase(yyruleno==128); ++ case 254: /* plus_num ::= plus_opt number */ yytestcase(yyruleno==254); ++ case 255: /* minus_num ::= MINUS number */ yytestcase(yyruleno==255); ++ case 256: /* number ::= INTEGER */ yytestcase(yyruleno==256); ++ case 257: /* number ::= FLOAT */ yytestcase(yyruleno==257); ++#line 117 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy0 = yymsp[0].minor.yy0;} ++#line 1867 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 32: /* type ::= typename */ ++#line 160 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteAddColumnType(pParse,&yymsp[0].minor.yy0,&yymsp[0].minor.yy0);} ++#line 1872 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 33: /* type ::= typename LP signed RP */ ++#line 161 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteAddColumnType(pParse,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);} ++#line 1877 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 34: /* type ::= typename LP signed COMMA signed RP */ ++#line 163 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteAddColumnType(pParse,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);} ++#line 1882 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 36: /* typename ::= typename ids */ ++ case 242: /* idxitem ::= nm sortorder */ yytestcase(yyruleno==242); ++#line 166 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy0 = yymsp[-1].minor.yy0;} ++#line 1888 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 37: /* signed ::= INTEGER */ ++ case 38: /* signed ::= PLUS INTEGER */ yytestcase(yyruleno==38); ++#line 168 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = atoi(yymsp[0].minor.yy0.z); } ++#line 1894 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 39: /* signed ::= MINUS INTEGER */ ++#line 170 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = -atoi(yymsp[0].minor.yy0.z); } ++#line 1899 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 44: /* carg ::= DEFAULT STRING */ ++ case 45: /* carg ::= DEFAULT ID */ yytestcase(yyruleno==45); ++ case 46: /* carg ::= DEFAULT INTEGER */ yytestcase(yyruleno==46); ++ case 47: /* carg ::= DEFAULT PLUS INTEGER */ yytestcase(yyruleno==47); ++ case 49: /* carg ::= DEFAULT FLOAT */ yytestcase(yyruleno==49); ++ case 50: /* carg ::= DEFAULT PLUS FLOAT */ yytestcase(yyruleno==50); ++#line 175 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,0);} ++#line 1909 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 48: /* carg ::= DEFAULT MINUS INTEGER */ ++ case 51: /* carg ::= DEFAULT MINUS FLOAT */ yytestcase(yyruleno==51); ++#line 179 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,1);} ++#line 1915 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 54: /* ccons ::= NOT NULL onconf */ ++#line 189 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteAddNotNull(pParse, yymsp[0].minor.yy372);} ++#line 1920 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 55: /* ccons ::= PRIMARY KEY sortorder onconf */ ++#line 190 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteAddPrimaryKey(pParse,0,yymsp[0].minor.yy372);} ++#line 1925 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 56: /* ccons ::= UNIQUE onconf */ ++#line 191 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteCreateIndex(pParse,0,0,0,yymsp[0].minor.yy372,0,0);} ++#line 1930 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 57: /* ccons ::= CHECK LP expr RP onconf */ ++#line 192 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yy_destructor(yypParser,158,&yymsp[-2].minor); ++} ++#line 1937 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 58: /* ccons ::= REFERENCES nm idxlist_opt refargs */ ++#line 194 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteCreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy320,yymsp[0].minor.yy372);} ++#line 1942 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 59: /* ccons ::= defer_subclause */ ++#line 195 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteDeferForeignKey(pParse,yymsp[0].minor.yy372);} ++#line 1947 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 60: /* ccons ::= COLLATE id */ ++#line 196 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteAddCollateType(pParse, sqliteCollateType(yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n)); ++} ++#line 1954 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 61: /* refargs ::= */ ++#line 206 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_Restrict * 0x010101; } ++#line 1959 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 62: /* refargs ::= refargs refarg */ ++#line 207 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = (yymsp[-1].minor.yy372 & yymsp[0].minor.yy407.mask) | yymsp[0].minor.yy407.value; } ++#line 1964 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 63: /* refarg ::= MATCH nm */ ++#line 209 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy407.value = 0; yygotominor.yy407.mask = 0x000000; } ++#line 1969 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 64: /* refarg ::= ON DELETE refact */ ++#line 210 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy407.value = yymsp[0].minor.yy372; yygotominor.yy407.mask = 0x0000ff; } ++#line 1974 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 65: /* refarg ::= ON UPDATE refact */ ++#line 211 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy407.value = yymsp[0].minor.yy372<<8; yygotominor.yy407.mask = 0x00ff00; } ++#line 1979 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 66: /* refarg ::= ON INSERT refact */ ++#line 212 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy407.value = yymsp[0].minor.yy372<<16; yygotominor.yy407.mask = 0xff0000; } ++#line 1984 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 67: /* refact ::= SET NULL */ ++#line 214 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_SetNull; } ++#line 1989 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 68: /* refact ::= SET DEFAULT */ ++#line 215 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_SetDflt; } ++#line 1994 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 69: /* refact ::= CASCADE */ ++#line 216 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_Cascade; } ++#line 1999 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 70: /* refact ::= RESTRICT */ ++#line 217 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_Restrict; } ++#line 2004 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 71: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ ++ case 72: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ yytestcase(yyruleno==72); ++ case 87: /* defer_subclause_opt ::= defer_subclause */ yytestcase(yyruleno==87); ++ case 164: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==164); ++#line 219 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = yymsp[0].minor.yy372;} ++#line 2012 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 82: /* tcons ::= PRIMARY KEY LP idxlist RP onconf */ ++#line 236 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteAddPrimaryKey(pParse,yymsp[-2].minor.yy320,yymsp[0].minor.yy372);} ++#line 2017 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 83: /* tcons ::= UNIQUE LP idxlist RP onconf */ ++#line 238 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteCreateIndex(pParse,0,0,yymsp[-2].minor.yy320,yymsp[0].minor.yy372,0,0);} ++#line 2022 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 84: /* tcons ::= CHECK expr onconf */ ++#line 239 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yy_destructor(yypParser,158,&yymsp[-1].minor); ++} ++#line 2029 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 85: /* tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt */ ++#line 241 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteCreateForeignKey(pParse, yymsp[-6].minor.yy320, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy320, yymsp[-1].minor.yy372); ++ sqliteDeferForeignKey(pParse, yymsp[0].minor.yy372); ++} ++#line 2037 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 88: /* onconf ::= */ ++ case 90: /* orconf ::= */ yytestcase(yyruleno==90); ++#line 255 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_Default; } ++#line 2043 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 89: /* onconf ::= ON CONFLICT resolvetype */ ++ case 91: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==91); ++#line 256 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = yymsp[0].minor.yy372; } ++#line 2049 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 92: /* resolvetype ::= ROLLBACK */ ++#line 259 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_Rollback; } ++#line 2054 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 93: /* resolvetype ::= ABORT */ ++ case 236: /* uniqueflag ::= UNIQUE */ yytestcase(yyruleno==236); ++#line 260 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_Abort; } ++#line 2060 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 94: /* resolvetype ::= FAIL */ ++#line 261 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_Fail; } ++#line 2065 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 95: /* resolvetype ::= IGNORE */ ++#line 262 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_Ignore; } ++#line 2070 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 96: /* resolvetype ::= REPLACE */ ++#line 263 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_Replace; } ++#line 2075 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 97: /* cmd ::= DROP TABLE nm */ ++#line 267 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteDropTable(pParse,&yymsp[0].minor.yy0,0);} ++#line 2080 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 98: /* cmd ::= CREATE temp VIEW nm AS select */ ++#line 271 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteCreateView(pParse, &yymsp[-5].minor.yy0, &yymsp[-2].minor.yy0, yymsp[0].minor.yy179, yymsp[-4].minor.yy372); ++} ++#line 2087 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 99: /* cmd ::= DROP VIEW nm */ ++#line 274 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteDropTable(pParse, &yymsp[0].minor.yy0, 1); ++} ++#line 2094 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 100: /* cmd ::= select */ ++#line 280 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteSelect(pParse, yymsp[0].minor.yy179, SRT_Callback, 0, 0, 0, 0); ++ sqliteSelectDelete(yymsp[0].minor.yy179); ++} ++#line 2102 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 101: /* select ::= oneselect */ ++ case 125: /* seltablist_paren ::= select */ yytestcase(yyruleno==125); ++#line 290 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy179 = yymsp[0].minor.yy179;} ++#line 2108 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 102: /* select ::= select multiselect_op oneselect */ ++#line 291 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ if( yymsp[0].minor.yy179 ){ ++ yymsp[0].minor.yy179->op = yymsp[-1].minor.yy372; ++ yymsp[0].minor.yy179->pPrior = yymsp[-2].minor.yy179; ++ } ++ yygotominor.yy179 = yymsp[0].minor.yy179; ++} ++#line 2119 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 103: /* multiselect_op ::= UNION */ ++#line 299 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = TK_UNION;} ++#line 2124 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 104: /* multiselect_op ::= UNION ALL */ ++#line 300 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = TK_ALL;} ++#line 2129 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 105: /* multiselect_op ::= INTERSECT */ ++#line 301 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = TK_INTERSECT;} ++#line 2134 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 106: /* multiselect_op ::= EXCEPT */ ++#line 302 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = TK_EXCEPT;} ++#line 2139 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 107: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ ++#line 304 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy179 = sqliteSelectNew(yymsp[-6].minor.yy322,yymsp[-5].minor.yy307,yymsp[-4].minor.yy242,yymsp[-3].minor.yy322,yymsp[-2].minor.yy242,yymsp[-1].minor.yy322,yymsp[-7].minor.yy372,yymsp[0].minor.yy124.limit,yymsp[0].minor.yy124.offset); ++} ++#line 2146 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 111: /* sclp ::= selcollist COMMA */ ++#line 325 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy322 = yymsp[-1].minor.yy322;} ++#line 2151 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 112: /* sclp ::= */ ++ case 138: /* orderby_opt ::= */ yytestcase(yyruleno==138); ++ case 148: /* groupby_opt ::= */ yytestcase(yyruleno==148); ++#line 326 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy322 = 0;} ++#line 2158 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 113: /* selcollist ::= sclp expr as */ ++#line 327 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy322 = sqliteExprListAppend(yymsp[-2].minor.yy322,yymsp[-1].minor.yy242,yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0); ++} ++#line 2165 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 114: /* selcollist ::= sclp STAR */ ++#line 330 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy322 = sqliteExprListAppend(yymsp[-1].minor.yy322, sqliteExpr(TK_ALL, 0, 0, 0), 0); ++} ++#line 2172 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 115: /* selcollist ::= sclp nm DOT STAR */ ++#line 333 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ Expr *pRight = sqliteExpr(TK_ALL, 0, 0, 0); ++ Expr *pLeft = sqliteExpr(TK_ID, 0, 0, &yymsp[-2].minor.yy0); ++ yygotominor.yy322 = sqliteExprListAppend(yymsp[-3].minor.yy322, sqliteExpr(TK_DOT, pLeft, pRight, 0), 0); ++} ++#line 2181 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 116: /* as ::= AS nm */ ++ case 117: /* as ::= ids */ yytestcase(yyruleno==117); ++ case 288: /* key_opt ::= USING ids */ yytestcase(yyruleno==288); ++#line 343 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy0 = yymsp[0].minor.yy0; } ++#line 2188 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 118: /* as ::= */ ++#line 345 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy0.n = 0; } ++#line 2193 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 119: /* from ::= */ ++#line 357 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy307 = sqliteMalloc(sizeof(*yygotominor.yy307));} ++#line 2198 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 120: /* from ::= FROM seltablist */ ++#line 358 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy307 = yymsp[0].minor.yy307;} ++#line 2203 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 121: /* stl_prefix ::= seltablist joinop */ ++#line 363 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy307 = yymsp[-1].minor.yy307; ++ if( yygotominor.yy307 && yygotominor.yy307->nSrc>0 ) yygotominor.yy307->a[yygotominor.yy307->nSrc-1].jointype = yymsp[0].minor.yy372; ++} ++#line 2211 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 122: /* stl_prefix ::= */ ++#line 367 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy307 = 0;} ++#line 2216 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 123: /* seltablist ::= stl_prefix nm dbnm as on_opt using_opt */ ++#line 368 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy307 = sqliteSrcListAppend(yymsp[-5].minor.yy307,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0); ++ if( yymsp[-2].minor.yy0.n ) sqliteSrcListAddAlias(yygotominor.yy307,&yymsp[-2].minor.yy0); ++ if( yymsp[-1].minor.yy242 ){ ++ if( yygotominor.yy307 && yygotominor.yy307->nSrc>1 ){ yygotominor.yy307->a[yygotominor.yy307->nSrc-2].pOn = yymsp[-1].minor.yy242; } ++ else { sqliteExprDelete(yymsp[-1].minor.yy242); } ++ } ++ if( yymsp[0].minor.yy320 ){ ++ if( yygotominor.yy307 && yygotominor.yy307->nSrc>1 ){ yygotominor.yy307->a[yygotominor.yy307->nSrc-2].pUsing = yymsp[0].minor.yy320; } ++ else { sqliteIdListDelete(yymsp[0].minor.yy320); } ++ } ++} ++#line 2232 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 124: /* seltablist ::= stl_prefix LP seltablist_paren RP as on_opt using_opt */ ++#line 381 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy307 = sqliteSrcListAppend(yymsp[-6].minor.yy307,0,0); ++ yygotominor.yy307->a[yygotominor.yy307->nSrc-1].pSelect = yymsp[-4].minor.yy179; ++ if( yymsp[-2].minor.yy0.n ) sqliteSrcListAddAlias(yygotominor.yy307,&yymsp[-2].minor.yy0); ++ if( yymsp[-1].minor.yy242 ){ ++ if( yygotominor.yy307 && yygotominor.yy307->nSrc>1 ){ yygotominor.yy307->a[yygotominor.yy307->nSrc-2].pOn = yymsp[-1].minor.yy242; } ++ else { sqliteExprDelete(yymsp[-1].minor.yy242); } ++ } ++ if( yymsp[0].minor.yy320 ){ ++ if( yygotominor.yy307 && yygotominor.yy307->nSrc>1 ){ yygotominor.yy307->a[yygotominor.yy307->nSrc-2].pUsing = yymsp[0].minor.yy320; } ++ else { sqliteIdListDelete(yymsp[0].minor.yy320); } ++ } ++} ++#line 2249 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 126: /* seltablist_paren ::= seltablist */ ++#line 402 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy179 = sqliteSelectNew(0,yymsp[0].minor.yy307,0,0,0,0,0,-1,0); ++} ++#line 2256 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 127: /* dbnm ::= */ ++#line 407 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy0.z=0; yygotominor.yy0.n=0;} ++#line 2261 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 129: /* joinop ::= COMMA */ ++ case 130: /* joinop ::= JOIN */ yytestcase(yyruleno==130); ++#line 412 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = JT_INNER; } ++#line 2267 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 131: /* joinop ::= JOIN_KW JOIN */ ++#line 414 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = sqliteJoinType(pParse,&yymsp[-1].minor.yy0,0,0); } ++#line 2272 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 132: /* joinop ::= JOIN_KW nm JOIN */ ++#line 415 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = sqliteJoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); } ++#line 2277 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 133: /* joinop ::= JOIN_KW nm nm JOIN */ ++#line 417 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = sqliteJoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); } ++#line 2282 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 134: /* on_opt ::= ON expr */ ++ case 142: /* sortitem ::= expr */ yytestcase(yyruleno==142); ++ case 151: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==151); ++ case 158: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==158); ++ case 227: /* case_else ::= ELSE expr */ yytestcase(yyruleno==227); ++ case 229: /* case_operand ::= expr */ yytestcase(yyruleno==229); ++ case 233: /* expritem ::= expr */ yytestcase(yyruleno==233); ++#line 421 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = yymsp[0].minor.yy242;} ++#line 2293 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 135: /* on_opt ::= */ ++ case 150: /* having_opt ::= */ yytestcase(yyruleno==150); ++ case 157: /* where_opt ::= */ yytestcase(yyruleno==157); ++ case 228: /* case_else ::= */ yytestcase(yyruleno==228); ++ case 230: /* case_operand ::= */ yytestcase(yyruleno==230); ++ case 234: /* expritem ::= */ yytestcase(yyruleno==234); ++#line 422 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = 0;} ++#line 2303 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 136: /* using_opt ::= USING LP idxlist RP */ ++ case 169: /* inscollist_opt ::= LP inscollist RP */ yytestcase(yyruleno==169); ++ case 239: /* idxlist_opt ::= LP idxlist RP */ yytestcase(yyruleno==239); ++#line 426 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy320 = yymsp[-1].minor.yy320;} ++#line 2310 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 137: /* using_opt ::= */ ++ case 168: /* inscollist_opt ::= */ yytestcase(yyruleno==168); ++ case 238: /* idxlist_opt ::= */ yytestcase(yyruleno==238); ++#line 427 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy320 = 0;} ++#line 2317 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 139: /* orderby_opt ::= ORDER BY sortlist */ ++ case 149: /* groupby_opt ::= GROUP BY exprlist */ yytestcase(yyruleno==149); ++#line 438 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy322 = yymsp[0].minor.yy322;} ++#line 2323 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 140: /* sortlist ::= sortlist COMMA sortitem collate sortorder */ ++#line 439 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy322 = sqliteExprListAppend(yymsp[-4].minor.yy322,yymsp[-2].minor.yy242,0); ++ if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = yymsp[-1].minor.yy372+yymsp[0].minor.yy372; ++} ++#line 2331 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 141: /* sortlist ::= sortitem collate sortorder */ ++#line 443 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy322 = sqliteExprListAppend(0,yymsp[-2].minor.yy242,0); ++ if( yygotominor.yy322 ) yygotominor.yy322->a[0].sortOrder = yymsp[-1].minor.yy372+yymsp[0].minor.yy372; ++} ++#line 2339 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 143: /* sortorder ::= ASC */ ++ case 145: /* sortorder ::= */ yytestcase(yyruleno==145); ++#line 452 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = SQLITE_SO_ASC;} ++#line 2345 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 144: /* sortorder ::= DESC */ ++#line 453 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = SQLITE_SO_DESC;} ++#line 2350 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 146: /* collate ::= */ ++#line 455 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = SQLITE_SO_UNK;} ++#line 2355 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 147: /* collate ::= COLLATE id */ ++#line 456 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = sqliteCollateType(yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);} ++#line 2360 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 152: /* limit_opt ::= */ ++#line 469 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy124.limit = -1; yygotominor.yy124.offset = 0;} ++#line 2365 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 153: /* limit_opt ::= LIMIT signed */ ++#line 470 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy124.limit = yymsp[0].minor.yy372; yygotominor.yy124.offset = 0;} ++#line 2370 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 154: /* limit_opt ::= LIMIT signed OFFSET signed */ ++#line 472 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy124.limit = yymsp[-2].minor.yy372; yygotominor.yy124.offset = yymsp[0].minor.yy372;} ++#line 2375 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 155: /* limit_opt ::= LIMIT signed COMMA signed */ ++#line 474 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy124.limit = yymsp[0].minor.yy372; yygotominor.yy124.offset = yymsp[-2].minor.yy372;} ++#line 2380 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 156: /* cmd ::= DELETE FROM nm dbnm where_opt */ ++#line 478 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteDeleteFrom(pParse, sqliteSrcListAppend(0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0), yymsp[0].minor.yy242); ++} ++#line 2387 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 159: /* cmd ::= UPDATE orconf nm dbnm SET setlist where_opt */ ++#line 494 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteUpdate(pParse,sqliteSrcListAppend(0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0),yymsp[-1].minor.yy322,yymsp[0].minor.yy242,yymsp[-5].minor.yy372);} ++#line 2392 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 160: /* setlist ::= setlist COMMA nm EQ expr */ ++#line 497 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy322 = sqliteExprListAppend(yymsp[-4].minor.yy322,yymsp[0].minor.yy242,&yymsp[-2].minor.yy0);} ++#line 2397 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 161: /* setlist ::= nm EQ expr */ ++#line 498 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy322 = sqliteExprListAppend(0,yymsp[0].minor.yy242,&yymsp[-2].minor.yy0);} ++#line 2402 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 162: /* cmd ::= insert_cmd INTO nm dbnm inscollist_opt VALUES LP itemlist RP */ ++#line 504 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteInsert(pParse, sqliteSrcListAppend(0,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0), yymsp[-1].minor.yy322, 0, yymsp[-4].minor.yy320, yymsp[-8].minor.yy372);} ++#line 2407 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 163: /* cmd ::= insert_cmd INTO nm dbnm inscollist_opt select */ ++#line 506 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteInsert(pParse, sqliteSrcListAppend(0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0), 0, yymsp[0].minor.yy179, yymsp[-1].minor.yy320, yymsp[-5].minor.yy372);} ++#line 2412 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 165: /* insert_cmd ::= REPLACE */ ++#line 510 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = OE_Replace;} ++#line 2417 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 166: /* itemlist ::= itemlist COMMA expr */ ++ case 231: /* exprlist ::= exprlist COMMA expritem */ yytestcase(yyruleno==231); ++#line 516 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy322 = sqliteExprListAppend(yymsp[-2].minor.yy322,yymsp[0].minor.yy242,0);} ++#line 2423 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 167: /* itemlist ::= expr */ ++ case 232: /* exprlist ::= expritem */ yytestcase(yyruleno==232); ++#line 517 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy322 = sqliteExprListAppend(0,yymsp[0].minor.yy242,0);} ++#line 2429 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 170: /* inscollist ::= inscollist COMMA nm */ ++ case 240: /* idxlist ::= idxlist COMMA idxitem */ yytestcase(yyruleno==240); ++#line 526 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy320 = sqliteIdListAppend(yymsp[-2].minor.yy320,&yymsp[0].minor.yy0);} ++#line 2435 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 171: /* inscollist ::= nm */ ++ case 241: /* idxlist ::= idxitem */ yytestcase(yyruleno==241); ++#line 527 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy320 = sqliteIdListAppend(0,&yymsp[0].minor.yy0);} ++#line 2441 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 172: /* expr ::= LP expr RP */ ++#line 535 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = yymsp[-1].minor.yy242; sqliteExprSpan(yygotominor.yy242,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); } ++#line 2446 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 173: /* expr ::= NULL */ ++#line 536 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_NULL, 0, 0, &yymsp[0].minor.yy0);} ++#line 2451 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 174: /* expr ::= ID */ ++ case 175: /* expr ::= JOIN_KW */ yytestcase(yyruleno==175); ++#line 537 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_ID, 0, 0, &yymsp[0].minor.yy0);} ++#line 2457 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 176: /* expr ::= nm DOT nm */ ++#line 539 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &yymsp[-2].minor.yy0); ++ Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &yymsp[0].minor.yy0); ++ yygotominor.yy242 = sqliteExpr(TK_DOT, temp1, temp2, 0); ++} ++#line 2466 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 177: /* expr ::= nm DOT nm DOT nm */ ++#line 544 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &yymsp[-4].minor.yy0); ++ Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &yymsp[-2].minor.yy0); ++ Expr *temp3 = sqliteExpr(TK_ID, 0, 0, &yymsp[0].minor.yy0); ++ Expr *temp4 = sqliteExpr(TK_DOT, temp2, temp3, 0); ++ yygotominor.yy242 = sqliteExpr(TK_DOT, temp1, temp4, 0); ++} ++#line 2477 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 178: /* expr ::= INTEGER */ ++#line 551 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_INTEGER, 0, 0, &yymsp[0].minor.yy0);} ++#line 2482 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 179: /* expr ::= FLOAT */ ++#line 552 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_FLOAT, 0, 0, &yymsp[0].minor.yy0);} ++#line 2487 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 180: /* expr ::= STRING */ ++#line 553 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_STRING, 0, 0, &yymsp[0].minor.yy0);} ++#line 2492 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 181: /* expr ::= VARIABLE */ ++#line 554 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_VARIABLE, 0, 0, &yymsp[0].minor.yy0); ++ if( yygotominor.yy242 ) yygotominor.yy242->iTable = ++pParse->nVar; ++} ++#line 2500 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 182: /* expr ::= ID LP exprlist RP */ ++#line 558 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExprFunction(yymsp[-1].minor.yy322, &yymsp[-3].minor.yy0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); ++} ++#line 2508 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 183: /* expr ::= ID LP STAR RP */ ++#line 562 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExprFunction(0, &yymsp[-3].minor.yy0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); ++} ++#line 2516 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 184: /* expr ::= expr AND expr */ ++#line 566 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_AND, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2521 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 185: /* expr ::= expr OR expr */ ++#line 567 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_OR, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2526 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 186: /* expr ::= expr LT expr */ ++#line 568 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_LT, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2531 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 187: /* expr ::= expr GT expr */ ++#line 569 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_GT, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2536 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 188: /* expr ::= expr LE expr */ ++#line 570 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_LE, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2541 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 189: /* expr ::= expr GE expr */ ++#line 571 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_GE, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2546 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 190: /* expr ::= expr NE expr */ ++#line 572 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_NE, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2551 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 191: /* expr ::= expr EQ expr */ ++#line 573 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_EQ, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2556 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 192: /* expr ::= expr BITAND expr */ ++#line 574 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_BITAND, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2561 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 193: /* expr ::= expr BITOR expr */ ++#line 575 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_BITOR, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2566 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 194: /* expr ::= expr LSHIFT expr */ ++#line 576 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_LSHIFT, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2571 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 195: /* expr ::= expr RSHIFT expr */ ++#line 577 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_RSHIFT, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2576 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 196: /* expr ::= expr likeop expr */ ++#line 578 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ ExprList *pList = sqliteExprListAppend(0, yymsp[0].minor.yy242, 0); ++ pList = sqliteExprListAppend(pList, yymsp[-2].minor.yy242, 0); ++ yygotominor.yy242 = sqliteExprFunction(pList, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->op = yymsp[-1].minor.yy372; ++ sqliteExprSpan(yygotominor.yy242, &yymsp[-2].minor.yy242->span, &yymsp[0].minor.yy242->span); ++} ++#line 2587 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 197: /* expr ::= expr NOT likeop expr */ ++#line 585 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ ExprList *pList = sqliteExprListAppend(0, yymsp[0].minor.yy242, 0); ++ pList = sqliteExprListAppend(pList, yymsp[-3].minor.yy242, 0); ++ yygotominor.yy242 = sqliteExprFunction(pList, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->op = yymsp[-1].minor.yy372; ++ yygotominor.yy242 = sqliteExpr(TK_NOT, yygotominor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-3].minor.yy242->span,&yymsp[0].minor.yy242->span); ++} ++#line 2599 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 198: /* likeop ::= LIKE */ ++#line 594 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = TK_LIKE;} ++#line 2604 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 199: /* likeop ::= GLOB */ ++#line 595 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy372 = TK_GLOB;} ++#line 2609 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 200: /* expr ::= expr PLUS expr */ ++#line 596 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_PLUS, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2614 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 201: /* expr ::= expr MINUS expr */ ++#line 597 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_MINUS, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2619 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 202: /* expr ::= expr STAR expr */ ++#line 598 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_STAR, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2624 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 203: /* expr ::= expr SLASH expr */ ++#line 599 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_SLASH, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2629 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 204: /* expr ::= expr REM expr */ ++#line 600 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_REM, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2634 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 205: /* expr ::= expr CONCAT expr */ ++#line 601 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy242 = sqliteExpr(TK_CONCAT, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} ++#line 2639 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 206: /* expr ::= expr ISNULL */ ++#line 602 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_ISNULL, yymsp[-1].minor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-1].minor.yy242->span,&yymsp[0].minor.yy0); ++} ++#line 2647 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 207: /* expr ::= expr IS NULL */ ++#line 606 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_ISNULL, yymsp[-2].minor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-2].minor.yy242->span,&yymsp[0].minor.yy0); ++} ++#line 2655 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 208: /* expr ::= expr NOTNULL */ ++#line 610 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_NOTNULL, yymsp[-1].minor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-1].minor.yy242->span,&yymsp[0].minor.yy0); ++} ++#line 2663 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 209: /* expr ::= expr NOT NULL */ ++#line 614 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_NOTNULL, yymsp[-2].minor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-2].minor.yy242->span,&yymsp[0].minor.yy0); ++} ++#line 2671 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 210: /* expr ::= expr IS NOT NULL */ ++#line 618 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_NOTNULL, yymsp[-3].minor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-3].minor.yy242->span,&yymsp[0].minor.yy0); ++} ++#line 2679 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 211: /* expr ::= NOT expr */ ++#line 622 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_NOT, yymsp[0].minor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy242->span); ++} ++#line 2687 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 212: /* expr ::= BITNOT expr */ ++#line 626 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_BITNOT, yymsp[0].minor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy242->span); ++} ++#line 2695 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 213: /* expr ::= MINUS expr */ ++#line 630 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_UMINUS, yymsp[0].minor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy242->span); ++} ++#line 2703 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 214: /* expr ::= PLUS expr */ ++#line 634 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_UPLUS, yymsp[0].minor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy242->span); ++} ++#line 2711 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 215: /* expr ::= LP select RP */ ++#line 638 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_SELECT, 0, 0, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->pSelect = yymsp[-1].minor.yy179; ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); ++} ++#line 2720 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 216: /* expr ::= expr BETWEEN expr AND expr */ ++#line 643 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ ExprList *pList = sqliteExprListAppend(0, yymsp[-2].minor.yy242, 0); ++ pList = sqliteExprListAppend(pList, yymsp[0].minor.yy242, 0); ++ yygotominor.yy242 = sqliteExpr(TK_BETWEEN, yymsp[-4].minor.yy242, 0, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->pList = pList; ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-4].minor.yy242->span,&yymsp[0].minor.yy242->span); ++} ++#line 2731 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 217: /* expr ::= expr NOT BETWEEN expr AND expr */ ++#line 650 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ ExprList *pList = sqliteExprListAppend(0, yymsp[-2].minor.yy242, 0); ++ pList = sqliteExprListAppend(pList, yymsp[0].minor.yy242, 0); ++ yygotominor.yy242 = sqliteExpr(TK_BETWEEN, yymsp[-5].minor.yy242, 0, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->pList = pList; ++ yygotominor.yy242 = sqliteExpr(TK_NOT, yygotominor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-5].minor.yy242->span,&yymsp[0].minor.yy242->span); ++} ++#line 2743 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 218: /* expr ::= expr IN LP exprlist RP */ ++#line 658 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_IN, yymsp[-4].minor.yy242, 0, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->pList = yymsp[-1].minor.yy322; ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-4].minor.yy242->span,&yymsp[0].minor.yy0); ++} ++#line 2752 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 219: /* expr ::= expr IN LP select RP */ ++#line 663 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_IN, yymsp[-4].minor.yy242, 0, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->pSelect = yymsp[-1].minor.yy179; ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-4].minor.yy242->span,&yymsp[0].minor.yy0); ++} ++#line 2761 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 220: /* expr ::= expr NOT IN LP exprlist RP */ ++#line 668 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_IN, yymsp[-5].minor.yy242, 0, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->pList = yymsp[-1].minor.yy322; ++ yygotominor.yy242 = sqliteExpr(TK_NOT, yygotominor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-5].minor.yy242->span,&yymsp[0].minor.yy0); ++} ++#line 2771 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 221: /* expr ::= expr NOT IN LP select RP */ ++#line 674 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_IN, yymsp[-5].minor.yy242, 0, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->pSelect = yymsp[-1].minor.yy179; ++ yygotominor.yy242 = sqliteExpr(TK_NOT, yygotominor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-5].minor.yy242->span,&yymsp[0].minor.yy0); ++} ++#line 2781 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 222: /* expr ::= expr IN nm dbnm */ ++#line 680 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ SrcList *pSrc = sqliteSrcListAppend(0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); ++ yygotominor.yy242 = sqliteExpr(TK_IN, yymsp[-3].minor.yy242, 0, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->pSelect = sqliteSelectNew(0,pSrc,0,0,0,0,0,-1,0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-3].minor.yy242->span,yymsp[0].minor.yy0.z?&yymsp[0].minor.yy0:&yymsp[-1].minor.yy0); ++} ++#line 2791 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 223: /* expr ::= expr NOT IN nm dbnm */ ++#line 686 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ SrcList *pSrc = sqliteSrcListAppend(0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); ++ yygotominor.yy242 = sqliteExpr(TK_IN, yymsp[-4].minor.yy242, 0, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->pSelect = sqliteSelectNew(0,pSrc,0,0,0,0,0,-1,0); ++ yygotominor.yy242 = sqliteExpr(TK_NOT, yygotominor.yy242, 0, 0); ++ sqliteExprSpan(yygotominor.yy242,&yymsp[-4].minor.yy242->span,yymsp[0].minor.yy0.z?&yymsp[0].minor.yy0:&yymsp[-1].minor.yy0); ++} ++#line 2802 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 224: /* expr ::= CASE case_operand case_exprlist case_else END */ ++#line 696 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_CASE, yymsp[-3].minor.yy242, yymsp[-1].minor.yy242, 0); ++ if( yygotominor.yy242 ) yygotominor.yy242->pList = yymsp[-2].minor.yy322; ++ sqliteExprSpan(yygotominor.yy242, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0); ++} ++#line 2811 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 225: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */ ++#line 703 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy322 = sqliteExprListAppend(yymsp[-4].minor.yy322, yymsp[-2].minor.yy242, 0); ++ yygotominor.yy322 = sqliteExprListAppend(yygotominor.yy322, yymsp[0].minor.yy242, 0); ++} ++#line 2819 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 226: /* case_exprlist ::= WHEN expr THEN expr */ ++#line 707 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy322 = sqliteExprListAppend(0, yymsp[-2].minor.yy242, 0); ++ yygotominor.yy322 = sqliteExprListAppend(yygotominor.yy322, yymsp[0].minor.yy242, 0); ++} ++#line 2827 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 235: /* cmd ::= CREATE uniqueflag INDEX nm ON nm dbnm LP idxlist RP onconf */ ++#line 732 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ SrcList *pSrc = sqliteSrcListAppend(0, &yymsp[-5].minor.yy0, &yymsp[-4].minor.yy0); ++ if( yymsp[-9].minor.yy372!=OE_None ) yymsp[-9].minor.yy372 = yymsp[0].minor.yy372; ++ if( yymsp[-9].minor.yy372==OE_Default) yymsp[-9].minor.yy372 = OE_Abort; ++ sqliteCreateIndex(pParse, &yymsp[-7].minor.yy0, pSrc, yymsp[-2].minor.yy320, yymsp[-9].minor.yy372, &yymsp[-10].minor.yy0, &yymsp[-1].minor.yy0); ++} ++#line 2837 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 237: /* uniqueflag ::= */ ++#line 741 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = OE_None; } ++#line 2842 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 243: /* cmd ::= DROP INDEX nm dbnm */ ++#line 758 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteDropIndex(pParse, sqliteSrcListAppend(0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0)); ++} ++#line 2849 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 244: /* cmd ::= COPY orconf nm dbnm FROM nm USING DELIMITERS STRING */ ++#line 766 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteCopy(pParse,sqliteSrcListAppend(0,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0),&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0,yymsp[-7].minor.yy372);} ++#line 2854 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 245: /* cmd ::= COPY orconf nm dbnm FROM nm */ ++#line 768 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteCopy(pParse,sqliteSrcListAppend(0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0),&yymsp[0].minor.yy0,0,yymsp[-4].minor.yy372);} ++#line 2859 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 246: /* cmd ::= VACUUM */ ++#line 772 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteVacuum(pParse,0);} ++#line 2864 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 247: /* cmd ::= VACUUM nm */ ++#line 773 "ext/sqlite/libsqlite/src/parse.y" ++{sqliteVacuum(pParse,&yymsp[0].minor.yy0);} ++#line 2869 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 248: /* cmd ::= PRAGMA ids EQ nm */ ++ case 249: /* cmd ::= PRAGMA ids EQ ON */ yytestcase(yyruleno==249); ++ case 250: /* cmd ::= PRAGMA ids EQ plus_num */ yytestcase(yyruleno==250); ++#line 777 "ext/sqlite/libsqlite/src/parse.y" ++{sqlitePragma(pParse,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);} ++#line 2876 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 251: /* cmd ::= PRAGMA ids EQ minus_num */ ++#line 780 "ext/sqlite/libsqlite/src/parse.y" ++{sqlitePragma(pParse,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);} ++#line 2881 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 252: /* cmd ::= PRAGMA ids LP nm RP */ ++#line 781 "ext/sqlite/libsqlite/src/parse.y" ++{sqlitePragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);} ++#line 2886 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 253: /* cmd ::= PRAGMA ids */ ++#line 782 "ext/sqlite/libsqlite/src/parse.y" ++{sqlitePragma(pParse,&yymsp[0].minor.yy0,&yymsp[0].minor.yy0,0);} ++#line 2891 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 260: /* cmd ::= CREATE trigger_decl BEGIN trigger_cmd_list END */ ++#line 792 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ Token all; ++ all.z = yymsp[-4].minor.yy0.z; ++ all.n = (yymsp[0].minor.yy0.z - yymsp[-4].minor.yy0.z) + yymsp[0].minor.yy0.n; ++ sqliteFinishTrigger(pParse, yymsp[-1].minor.yy19, &all); ++} ++#line 2901 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 261: /* trigger_decl ::= temp TRIGGER nm trigger_time trigger_event ON nm dbnm foreach_clause when_clause */ ++#line 800 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ SrcList *pTab = sqliteSrcListAppend(0, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0); ++ sqliteBeginTrigger(pParse, &yymsp[-7].minor.yy0, yymsp[-6].minor.yy372, yymsp[-5].minor.yy290.a, yymsp[-5].minor.yy290.b, pTab, yymsp[-1].minor.yy372, yymsp[0].minor.yy182, yymsp[-9].minor.yy372); ++} ++#line 2909 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 262: /* trigger_time ::= BEFORE */ ++ case 265: /* trigger_time ::= */ yytestcase(yyruleno==265); ++#line 806 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = TK_BEFORE; } ++#line 2915 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 263: /* trigger_time ::= AFTER */ ++#line 807 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = TK_AFTER; } ++#line 2920 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 264: /* trigger_time ::= INSTEAD OF */ ++#line 808 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = TK_INSTEAD;} ++#line 2925 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 266: /* trigger_event ::= DELETE */ ++#line 813 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy290.a = TK_DELETE; yygotominor.yy290.b = 0; } ++#line 2930 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 267: /* trigger_event ::= INSERT */ ++#line 814 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy290.a = TK_INSERT; yygotominor.yy290.b = 0; } ++#line 2935 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 268: /* trigger_event ::= UPDATE */ ++#line 815 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy290.a = TK_UPDATE; yygotominor.yy290.b = 0;} ++#line 2940 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 269: /* trigger_event ::= UPDATE OF inscollist */ ++#line 816 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy290.a = TK_UPDATE; yygotominor.yy290.b = yymsp[0].minor.yy320; } ++#line 2945 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 270: /* foreach_clause ::= */ ++ case 271: /* foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==271); ++#line 819 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = TK_ROW; } ++#line 2951 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 272: /* foreach_clause ::= FOR EACH STATEMENT */ ++#line 821 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy372 = TK_STATEMENT; } ++#line 2956 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 273: /* when_clause ::= */ ++#line 824 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy182 = 0; } ++#line 2961 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 274: /* when_clause ::= WHEN expr */ ++#line 825 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy182 = yymsp[0].minor.yy242; } ++#line 2966 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 275: /* trigger_cmd_list ::= trigger_cmd SEMI trigger_cmd_list */ ++#line 829 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yymsp[-2].minor.yy19->pNext = yymsp[0].minor.yy19; ++ yygotominor.yy19 = yymsp[-2].minor.yy19; ++} ++#line 2974 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 276: /* trigger_cmd_list ::= */ ++#line 833 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy19 = 0; } ++#line 2979 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 277: /* trigger_cmd ::= UPDATE orconf nm SET setlist where_opt */ ++#line 839 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy19 = sqliteTriggerUpdateStep(&yymsp[-3].minor.yy0, yymsp[-1].minor.yy322, yymsp[0].minor.yy242, yymsp[-4].minor.yy372); } ++#line 2984 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 278: /* trigger_cmd ::= insert_cmd INTO nm inscollist_opt VALUES LP itemlist RP */ ++#line 844 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy19 = sqliteTriggerInsertStep(&yymsp[-5].minor.yy0, yymsp[-4].minor.yy320, yymsp[-1].minor.yy322, 0, yymsp[-7].minor.yy372);} ++#line 2989 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 279: /* trigger_cmd ::= insert_cmd INTO nm inscollist_opt select */ ++#line 847 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy19 = sqliteTriggerInsertStep(&yymsp[-2].minor.yy0, yymsp[-1].minor.yy320, 0, yymsp[0].minor.yy179, yymsp[-4].minor.yy372);} ++#line 2994 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 280: /* trigger_cmd ::= DELETE FROM nm where_opt */ ++#line 851 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy19 = sqliteTriggerDeleteStep(&yymsp[-1].minor.yy0, yymsp[0].minor.yy242);} ++#line 2999 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 281: /* trigger_cmd ::= select */ ++#line 854 "ext/sqlite/libsqlite/src/parse.y" ++{yygotominor.yy19 = sqliteTriggerSelectStep(yymsp[0].minor.yy179); } ++#line 3004 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 282: /* expr ::= RAISE LP IGNORE RP */ ++#line 857 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_RAISE, 0, 0, 0); ++ yygotominor.yy242->iColumn = OE_Ignore; ++ sqliteExprSpan(yygotominor.yy242, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0); ++} ++#line 3013 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 283: /* expr ::= RAISE LP ROLLBACK COMMA nm RP */ ++#line 862 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_RAISE, 0, 0, &yymsp[-1].minor.yy0); ++ yygotominor.yy242->iColumn = OE_Rollback; ++ sqliteExprSpan(yygotominor.yy242, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0); ++} ++#line 3022 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 284: /* expr ::= RAISE LP ABORT COMMA nm RP */ ++#line 867 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_RAISE, 0, 0, &yymsp[-1].minor.yy0); ++ yygotominor.yy242->iColumn = OE_Abort; ++ sqliteExprSpan(yygotominor.yy242, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0); ++} ++#line 3031 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 285: /* expr ::= RAISE LP FAIL COMMA nm RP */ ++#line 872 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ yygotominor.yy242 = sqliteExpr(TK_RAISE, 0, 0, &yymsp[-1].minor.yy0); ++ yygotominor.yy242->iColumn = OE_Fail; ++ sqliteExprSpan(yygotominor.yy242, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0); ++} ++#line 3040 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 286: /* cmd ::= DROP TRIGGER nm dbnm */ ++#line 879 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteDropTrigger(pParse,sqliteSrcListAppend(0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0)); ++} ++#line 3047 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 287: /* cmd ::= ATTACH database_kw_opt ids AS nm key_opt */ ++#line 884 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteAttach(pParse, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); ++} ++#line 3054 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 289: /* key_opt ::= */ ++#line 889 "ext/sqlite/libsqlite/src/parse.y" ++{ yygotominor.yy0.z = 0; yygotominor.yy0.n = 0; } ++#line 3059 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ case 292: /* cmd ::= DETACH database_kw_opt nm */ ++#line 895 "ext/sqlite/libsqlite/src/parse.y" ++{ ++ sqliteDetach(pParse, &yymsp[0].minor.yy0); ++} ++#line 3066 "ext/sqlite/libsqlite/src/parse.c" ++ break; ++ default: ++ /* (0) input ::= cmdlist */ yytestcase(yyruleno==0); ++ /* (1) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==1); ++ /* (2) cmdlist ::= ecmd */ yytestcase(yyruleno==2); ++ /* (3) ecmd ::= explain cmdx SEMI */ yytestcase(yyruleno==3); ++ /* (4) ecmd ::= SEMI */ yytestcase(yyruleno==4); ++ /* (9) trans_opt ::= */ yytestcase(yyruleno==9); ++ /* (10) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==10); ++ /* (11) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==11); ++ /* (15) cmd ::= create_table create_table_args */ yytestcase(yyruleno==15); ++ /* (21) columnlist ::= columnlist COMMA column */ yytestcase(yyruleno==21); ++ /* (22) columnlist ::= column */ yytestcase(yyruleno==22); ++ /* (23) column ::= columnid type carglist */ yytestcase(yyruleno==23); ++ /* (31) type ::= */ yytestcase(yyruleno==31); ++ /* (40) carglist ::= carglist carg */ yytestcase(yyruleno==40); ++ /* (41) carglist ::= */ yytestcase(yyruleno==41); ++ /* (42) carg ::= CONSTRAINT nm ccons */ yytestcase(yyruleno==42); ++ /* (43) carg ::= ccons */ yytestcase(yyruleno==43); ++ /* (52) carg ::= DEFAULT NULL */ yytestcase(yyruleno==52); ++ /* (53) ccons ::= NULL onconf */ yytestcase(yyruleno==53); ++ /* (76) conslist_opt ::= */ yytestcase(yyruleno==76); ++ /* (77) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==77); ++ /* (78) conslist ::= conslist COMMA tcons */ yytestcase(yyruleno==78); ++ /* (79) conslist ::= conslist tcons */ yytestcase(yyruleno==79); ++ /* (80) conslist ::= tcons */ yytestcase(yyruleno==80); ++ /* (81) tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==81); ++ /* (258) plus_opt ::= PLUS */ yytestcase(yyruleno==258); ++ /* (259) plus_opt ::= */ yytestcase(yyruleno==259); ++ /* (290) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==290); ++ /* (291) database_kw_opt ::= */ yytestcase(yyruleno==291); ++ break; ++ }; ++ yygoto = yyRuleInfo[yyruleno].lhs; ++ yysize = yyRuleInfo[yyruleno].nrhs; ++ yypParser->yyidx -= yysize; ++ yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto); ++ if( yyact < YYNSTATE ){ ++#ifdef NDEBUG ++ /* If we are not debugging and 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; ++ }else ++#endif ++ { ++ yy_shift(yypParser,yyact,yygoto,&yygotominor); ++ } ++ }else{ ++ assert( yyact == YYNSTATE + YYNRULE + 1 ); ++ yy_accept(yypParser); ++ } ++} ++ ++/* ++** The following code executes when the parse fails ++*/ ++#ifndef YYNOERRORRECOVERY ++static void yy_parse_failed( ++ yyParser *yypParser /* The parser */ ++){ ++ sqliteParserARG_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 */ ++ sqliteParserARG_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 */ ++){ ++ sqliteParserARG_FETCH; ++#define TOKEN (yyminor.yy0) ++#line 23 "ext/sqlite/libsqlite/src/parse.y" ++ ++ if( pParse->zErrMsg==0 ){ ++ if( TOKEN.z[0] ){ ++ sqliteErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); ++ }else{ ++ sqliteErrorMsg(pParse, "incomplete SQL statement"); ++ } ++ } ++#line 3166 "ext/sqlite/libsqlite/src/parse.c" ++ sqliteParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ ++} ++ ++/* ++** The following is executed when the parser accepts ++*/ ++static void yy_accept( ++ yyParser *yypParser /* The parser */ ++){ ++ sqliteParserARG_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 */ ++ sqliteParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ ++} ++ ++/* The main parser program. ++** The first argument is a pointer to a structure obtained from ++** "sqliteParserAlloc" 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. ++*/ ++void sqliteParser( ++ void *yyp, /* The parser */ ++ int yymajor, /* The major token code number */ ++ sqliteParserTOKENTYPE yyminor /* The value for the token */ ++ sqliteParserARG_PDECL /* Optional %extra_argument parameter */ ++){ ++ YYMINORTYPE yyminorunion; ++ int yyact; /* The parser action. */ ++ int yyendofinput; /* True if we are at the end of input */ ++#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; ++ yyendofinput = (yymajor==0); ++ sqliteParserARG_STORE; ++ ++#ifndef NDEBUG ++ if( yyTraceFILE ){ ++ fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]); ++ } ++#endif ++ ++ do{ ++ yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor); ++ if( yyactyyerrcnt--; ++ yymajor = YYNOCODE; ++ }else if( yyact < YYNSTATE + YYNRULE ){ ++ yy_reduce(yypParser,yyact-YYNSTATE); ++ }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)) >= YYNSTATE ++ ){ ++ 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 ); ++ return; ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/parse.h +@@ -0,0 +1,130 @@ ++#define TK_END_OF_FILE 1 ++#define TK_ILLEGAL 2 ++#define TK_SPACE 3 ++#define TK_UNCLOSED_STRING 4 ++#define TK_COMMENT 5 ++#define TK_FUNCTION 6 ++#define TK_COLUMN 7 ++#define TK_AGG_FUNCTION 8 ++#define TK_SEMI 9 ++#define TK_EXPLAIN 10 ++#define TK_BEGIN 11 ++#define TK_TRANSACTION 12 ++#define TK_COMMIT 13 ++#define TK_END 14 ++#define TK_ROLLBACK 15 ++#define TK_CREATE 16 ++#define TK_TABLE 17 ++#define TK_TEMP 18 ++#define TK_LP 19 ++#define TK_RP 20 ++#define TK_AS 21 ++#define TK_COMMA 22 ++#define TK_ID 23 ++#define TK_ABORT 24 ++#define TK_AFTER 25 ++#define TK_ASC 26 ++#define TK_ATTACH 27 ++#define TK_BEFORE 28 ++#define TK_CASCADE 29 ++#define TK_CLUSTER 30 ++#define TK_CONFLICT 31 ++#define TK_COPY 32 ++#define TK_DATABASE 33 ++#define TK_DEFERRED 34 ++#define TK_DELIMITERS 35 ++#define TK_DESC 36 ++#define TK_DETACH 37 ++#define TK_EACH 38 ++#define TK_FAIL 39 ++#define TK_FOR 40 ++#define TK_GLOB 41 ++#define TK_IGNORE 42 ++#define TK_IMMEDIATE 43 ++#define TK_INITIALLY 44 ++#define TK_INSTEAD 45 ++#define TK_LIKE 46 ++#define TK_MATCH 47 ++#define TK_KEY 48 ++#define TK_OF 49 ++#define TK_OFFSET 50 ++#define TK_PRAGMA 51 ++#define TK_RAISE 52 ++#define TK_REPLACE 53 ++#define TK_RESTRICT 54 ++#define TK_ROW 55 ++#define TK_STATEMENT 56 ++#define TK_TRIGGER 57 ++#define TK_VACUUM 58 ++#define TK_VIEW 59 ++#define TK_OR 60 ++#define TK_AND 61 ++#define TK_NOT 62 ++#define TK_EQ 63 ++#define TK_NE 64 ++#define TK_ISNULL 65 ++#define TK_NOTNULL 66 ++#define TK_IS 67 ++#define TK_BETWEEN 68 ++#define TK_IN 69 ++#define TK_GT 70 ++#define TK_GE 71 ++#define TK_LT 72 ++#define TK_LE 73 ++#define TK_BITAND 74 ++#define TK_BITOR 75 ++#define TK_LSHIFT 76 ++#define TK_RSHIFT 77 ++#define TK_PLUS 78 ++#define TK_MINUS 79 ++#define TK_STAR 80 ++#define TK_SLASH 81 ++#define TK_REM 82 ++#define TK_CONCAT 83 ++#define TK_UMINUS 84 ++#define TK_UPLUS 85 ++#define TK_BITNOT 86 ++#define TK_STRING 87 ++#define TK_JOIN_KW 88 ++#define TK_INTEGER 89 ++#define TK_CONSTRAINT 90 ++#define TK_DEFAULT 91 ++#define TK_FLOAT 92 ++#define TK_NULL 93 ++#define TK_PRIMARY 94 ++#define TK_UNIQUE 95 ++#define TK_CHECK 96 ++#define TK_REFERENCES 97 ++#define TK_COLLATE 98 ++#define TK_ON 99 ++#define TK_DELETE 100 ++#define TK_UPDATE 101 ++#define TK_INSERT 102 ++#define TK_SET 103 ++#define TK_DEFERRABLE 104 ++#define TK_FOREIGN 105 ++#define TK_DROP 106 ++#define TK_UNION 107 ++#define TK_ALL 108 ++#define TK_INTERSECT 109 ++#define TK_EXCEPT 110 ++#define TK_SELECT 111 ++#define TK_DISTINCT 112 ++#define TK_DOT 113 ++#define TK_FROM 114 ++#define TK_JOIN 115 ++#define TK_USING 116 ++#define TK_ORDER 117 ++#define TK_BY 118 ++#define TK_GROUP 119 ++#define TK_HAVING 120 ++#define TK_LIMIT 121 ++#define TK_WHERE 122 ++#define TK_INTO 123 ++#define TK_VALUES 124 ++#define TK_VARIABLE 125 ++#define TK_CASE 126 ++#define TK_WHEN 127 ++#define TK_THEN 128 ++#define TK_ELSE 129 ++#define TK_INDEX 130 +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/parse.y +@@ -0,0 +1,897 @@ ++/* ++** 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 SQLite's grammar for SQL. Process this file ++** using the lemon parser generator to generate C code that runs ++** the parser. Lemon will also generate a header file containing ++** numeric codes for all of the tokens. ++** ++** @(#) $Id$ ++*/ ++%token_prefix TK_ ++%token_type {Token} ++%default_type {Token} ++%extra_argument {Parse *pParse} ++%syntax_error { ++ if( pParse->zErrMsg==0 ){ ++ if( TOKEN.z[0] ){ ++ sqliteErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); ++ }else{ ++ sqliteErrorMsg(pParse, "incomplete SQL statement"); ++ } ++ } ++} ++%name sqliteParser ++%include { ++#include "sqliteInt.h" ++#include "parse.h" ++ ++/* ++** An instance of this structure holds information about the ++** LIMIT clause of a SELECT statement. ++*/ ++struct LimitVal { ++ int limit; /* The LIMIT value. -1 if there is no limit */ ++ int offset; /* The OFFSET. 0 if there is none */ ++}; ++ ++/* ++** 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; }; ++ ++} // end %include ++ ++// These are extra tokens used by the lexer but never seen by the ++// parser. We put them in a rule so that the parser generator will ++// add them to the parse.h output file. ++// ++%nonassoc END_OF_FILE ILLEGAL SPACE UNCLOSED_STRING COMMENT FUNCTION ++ COLUMN AGG_FUNCTION. ++ ++// Input is a single SQL command ++input ::= cmdlist. ++cmdlist ::= cmdlist ecmd. ++cmdlist ::= ecmd. ++ecmd ::= explain cmdx SEMI. ++ecmd ::= SEMI. ++cmdx ::= cmd. { sqliteExec(pParse); } ++explain ::= EXPLAIN. { sqliteBeginParse(pParse, 1); } ++explain ::= . { sqliteBeginParse(pParse, 0); } ++ ++///////////////////// Begin and end transactions. //////////////////////////// ++// ++ ++cmd ::= BEGIN trans_opt onconf(R). {sqliteBeginTransaction(pParse,R);} ++trans_opt ::= . ++trans_opt ::= TRANSACTION. ++trans_opt ::= TRANSACTION nm. ++cmd ::= COMMIT trans_opt. {sqliteCommitTransaction(pParse);} ++cmd ::= END trans_opt. {sqliteCommitTransaction(pParse);} ++cmd ::= ROLLBACK trans_opt. {sqliteRollbackTransaction(pParse);} ++ ++///////////////////// The CREATE TABLE statement //////////////////////////// ++// ++cmd ::= create_table create_table_args. ++create_table ::= CREATE(X) temp(T) TABLE nm(Y). { ++ sqliteStartTable(pParse,&X,&Y,T,0); ++} ++%type temp {int} ++temp(A) ::= TEMP. {A = 1;} ++temp(A) ::= . {A = 0;} ++create_table_args ::= LP columnlist conslist_opt RP(X). { ++ sqliteEndTable(pParse,&X,0); ++} ++create_table_args ::= AS select(S). { ++ sqliteEndTable(pParse,0,S); ++ sqliteSelectDelete(S); ++} ++columnlist ::= columnlist COMMA column. ++columnlist ::= column. ++ ++// About the only information used for a column is the name of the ++// column. The type is always just "text". But the code will accept ++// an elaborate typename. Perhaps someday we'll do something with it. ++// ++column ::= columnid type carglist. ++columnid ::= nm(X). {sqliteAddColumn(pParse,&X);} ++ ++// An IDENTIFIER can be a generic identifier, or one of several ++// keywords. Any non-standard keyword can also be an identifier. ++// ++%type id {Token} ++id(A) ::= ID(X). {A = X;} ++ ++// The following directive causes tokens ABORT, AFTER, ASC, etc. to ++// fallback to ID if they will not parse as their original value. ++// This obviates the need for the "id" nonterminal. ++// ++%fallback ID ++ ABORT AFTER ASC ATTACH BEFORE BEGIN CASCADE CLUSTER CONFLICT ++ COPY DATABASE DEFERRED DELIMITERS DESC DETACH EACH END EXPLAIN FAIL FOR ++ GLOB IGNORE IMMEDIATE INITIALLY INSTEAD LIKE MATCH KEY ++ OF OFFSET PRAGMA RAISE REPLACE RESTRICT ROW STATEMENT ++ TEMP TRIGGER VACUUM VIEW. ++ ++// Define operator precedence early so that this is the first occurance ++// of the operator tokens in the grammer. Keeping the operators together ++// causes them to be assigned integer values that are close together, ++// which keeps parser tables smaller. ++// ++%left OR. ++%left AND. ++%right NOT. ++%left EQ NE ISNULL NOTNULL IS LIKE GLOB BETWEEN IN. ++%left GT GE LT LE. ++%left BITAND BITOR LSHIFT RSHIFT. ++%left PLUS MINUS. ++%left STAR SLASH REM. ++%left CONCAT. ++%right UMINUS UPLUS BITNOT. ++ ++// And "ids" is an identifer-or-string. ++// ++%type ids {Token} ++ids(A) ::= ID(X). {A = X;} ++ids(A) ::= STRING(X). {A = X;} ++ ++// The name of a column or table can be any of the following: ++// ++%type nm {Token} ++nm(A) ::= ID(X). {A = X;} ++nm(A) ::= STRING(X). {A = X;} ++nm(A) ::= JOIN_KW(X). {A = X;} ++ ++type ::= . ++type ::= typename(X). {sqliteAddColumnType(pParse,&X,&X);} ++type ::= typename(X) LP signed RP(Y). {sqliteAddColumnType(pParse,&X,&Y);} ++type ::= typename(X) LP signed COMMA signed RP(Y). ++ {sqliteAddColumnType(pParse,&X,&Y);} ++%type typename {Token} ++typename(A) ::= ids(X). {A = X;} ++typename(A) ::= typename(X) ids. {A = X;} ++%type signed {int} ++signed(A) ::= INTEGER(X). { A = atoi(X.z); } ++signed(A) ::= PLUS INTEGER(X). { A = atoi(X.z); } ++signed(A) ::= MINUS INTEGER(X). { A = -atoi(X.z); } ++carglist ::= carglist carg. ++carglist ::= . ++carg ::= CONSTRAINT nm ccons. ++carg ::= ccons. ++carg ::= DEFAULT STRING(X). {sqliteAddDefaultValue(pParse,&X,0);} ++carg ::= DEFAULT ID(X). {sqliteAddDefaultValue(pParse,&X,0);} ++carg ::= DEFAULT INTEGER(X). {sqliteAddDefaultValue(pParse,&X,0);} ++carg ::= DEFAULT PLUS INTEGER(X). {sqliteAddDefaultValue(pParse,&X,0);} ++carg ::= DEFAULT MINUS INTEGER(X). {sqliteAddDefaultValue(pParse,&X,1);} ++carg ::= DEFAULT FLOAT(X). {sqliteAddDefaultValue(pParse,&X,0);} ++carg ::= DEFAULT PLUS FLOAT(X). {sqliteAddDefaultValue(pParse,&X,0);} ++carg ::= DEFAULT MINUS FLOAT(X). {sqliteAddDefaultValue(pParse,&X,1);} ++carg ::= DEFAULT NULL. ++ ++// In addition to the type name, we also care about the primary key and ++// UNIQUE constraints. ++// ++ccons ::= NULL onconf. ++ccons ::= NOT NULL onconf(R). {sqliteAddNotNull(pParse, R);} ++ccons ::= PRIMARY KEY sortorder onconf(R). {sqliteAddPrimaryKey(pParse,0,R);} ++ccons ::= UNIQUE onconf(R). {sqliteCreateIndex(pParse,0,0,0,R,0,0);} ++ccons ::= CHECK LP expr RP onconf. ++ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R). ++ {sqliteCreateForeignKey(pParse,0,&T,TA,R);} ++ccons ::= defer_subclause(D). {sqliteDeferForeignKey(pParse,D);} ++ccons ::= COLLATE id(C). { ++ sqliteAddCollateType(pParse, sqliteCollateType(C.z, C.n)); ++} ++ ++// The next group of rules parses the arguments to a REFERENCES clause ++// that determine if the referential integrity checking is deferred or ++// or immediate and which determine what action to take if a ref-integ ++// check fails. ++// ++%type refargs {int} ++refargs(A) ::= . { A = OE_Restrict * 0x010101; } ++refargs(A) ::= refargs(X) refarg(Y). { A = (X & Y.mask) | Y.value; } ++%type refarg {struct {int value; int mask;}} ++refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; } ++refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; } ++refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; } ++refarg(A) ::= ON INSERT refact(X). { A.value = X<<16; A.mask = 0xff0000; } ++%type refact {int} ++refact(A) ::= SET NULL. { A = OE_SetNull; } ++refact(A) ::= SET DEFAULT. { A = OE_SetDflt; } ++refact(A) ::= CASCADE. { A = OE_Cascade; } ++refact(A) ::= RESTRICT. { A = OE_Restrict; } ++%type defer_subclause {int} ++defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt(X). {A = X;} ++defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X). {A = X;} ++%type init_deferred_pred_opt {int} ++init_deferred_pred_opt(A) ::= . {A = 0;} ++init_deferred_pred_opt(A) ::= INITIALLY DEFERRED. {A = 1;} ++init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE. {A = 0;} ++ ++// For the time being, the only constraint we care about is the primary ++// key and UNIQUE. Both create indices. ++// ++conslist_opt ::= . ++conslist_opt ::= COMMA conslist. ++conslist ::= conslist COMMA tcons. ++conslist ::= conslist tcons. ++conslist ::= tcons. ++tcons ::= CONSTRAINT nm. ++tcons ::= PRIMARY KEY LP idxlist(X) RP onconf(R). ++ {sqliteAddPrimaryKey(pParse,X,R);} ++tcons ::= UNIQUE LP idxlist(X) RP onconf(R). ++ {sqliteCreateIndex(pParse,0,0,X,R,0,0);} ++tcons ::= CHECK expr onconf. ++tcons ::= FOREIGN KEY LP idxlist(FA) RP ++ REFERENCES nm(T) idxlist_opt(TA) refargs(R) defer_subclause_opt(D). { ++ sqliteCreateForeignKey(pParse, FA, &T, TA, R); ++ sqliteDeferForeignKey(pParse, D); ++} ++%type defer_subclause_opt {int} ++defer_subclause_opt(A) ::= . {A = 0;} ++defer_subclause_opt(A) ::= defer_subclause(X). {A = X;} ++ ++// The following is a non-standard extension that allows us to declare the ++// default behavior when there is a constraint conflict. ++// ++%type onconf {int} ++%type orconf {int} ++%type resolvetype {int} ++onconf(A) ::= . { A = OE_Default; } ++onconf(A) ::= ON CONFLICT resolvetype(X). { A = X; } ++orconf(A) ::= . { A = OE_Default; } ++orconf(A) ::= OR resolvetype(X). { A = X; } ++resolvetype(A) ::= ROLLBACK. { A = OE_Rollback; } ++resolvetype(A) ::= ABORT. { A = OE_Abort; } ++resolvetype(A) ::= FAIL. { A = OE_Fail; } ++resolvetype(A) ::= IGNORE. { A = OE_Ignore; } ++resolvetype(A) ::= REPLACE. { A = OE_Replace; } ++ ++////////////////////////// The DROP TABLE ///////////////////////////////////// ++// ++cmd ::= DROP TABLE nm(X). {sqliteDropTable(pParse,&X,0);} ++ ++///////////////////// The CREATE VIEW statement ///////////////////////////// ++// ++cmd ::= CREATE(X) temp(T) VIEW nm(Y) AS select(S). { ++ sqliteCreateView(pParse, &X, &Y, S, T); ++} ++cmd ::= DROP VIEW nm(X). { ++ sqliteDropTable(pParse, &X, 1); ++} ++ ++//////////////////////// The SELECT statement ///////////////////////////////// ++// ++cmd ::= select(X). { ++ sqliteSelect(pParse, X, SRT_Callback, 0, 0, 0, 0); ++ sqliteSelectDelete(X); ++} ++ ++%type select {Select*} ++%destructor select {sqliteSelectDelete($$);} ++%type oneselect {Select*} ++%destructor oneselect {sqliteSelectDelete($$);} ++ ++select(A) ::= oneselect(X). {A = X;} ++select(A) ::= select(X) multiselect_op(Y) oneselect(Z). { ++ if( Z ){ ++ Z->op = Y; ++ Z->pPrior = X; ++ } ++ A = Z; ++} ++%type multiselect_op {int} ++multiselect_op(A) ::= UNION. {A = TK_UNION;} ++multiselect_op(A) ::= UNION ALL. {A = TK_ALL;} ++multiselect_op(A) ::= INTERSECT. {A = TK_INTERSECT;} ++multiselect_op(A) ::= EXCEPT. {A = TK_EXCEPT;} ++oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y) ++ groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). { ++ A = sqliteSelectNew(W,X,Y,P,Q,Z,D,L.limit,L.offset); ++} ++ ++// The "distinct" nonterminal is true (1) if the DISTINCT keyword is ++// present and false (0) if it is not. ++// ++%type distinct {int} ++distinct(A) ::= DISTINCT. {A = 1;} ++distinct(A) ::= ALL. {A = 0;} ++distinct(A) ::= . {A = 0;} ++ ++// selcollist is a list of expressions that are to become the return ++// values of the SELECT statement. The "*" in statements like ++// "SELECT * FROM ..." is encoded as a special expression with an ++// opcode of TK_ALL. ++// ++%type selcollist {ExprList*} ++%destructor selcollist {sqliteExprListDelete($$);} ++%type sclp {ExprList*} ++%destructor sclp {sqliteExprListDelete($$);} ++sclp(A) ::= selcollist(X) COMMA. {A = X;} ++sclp(A) ::= . {A = 0;} ++selcollist(A) ::= sclp(P) expr(X) as(Y). { ++ A = sqliteExprListAppend(P,X,Y.n?&Y:0); ++} ++selcollist(A) ::= sclp(P) STAR. { ++ A = sqliteExprListAppend(P, sqliteExpr(TK_ALL, 0, 0, 0), 0); ++} ++selcollist(A) ::= sclp(P) nm(X) DOT STAR. { ++ Expr *pRight = sqliteExpr(TK_ALL, 0, 0, 0); ++ Expr *pLeft = sqliteExpr(TK_ID, 0, 0, &X); ++ A = sqliteExprListAppend(P, sqliteExpr(TK_DOT, pLeft, pRight, 0), 0); ++} ++ ++// An option "AS " phrase that can follow one of the expressions that ++// define the result set, or one of the tables in the FROM clause. ++// ++%type as {Token} ++as(X) ::= AS nm(Y). { X = Y; } ++as(X) ::= ids(Y). { X = Y; } ++as(X) ::= . { X.n = 0; } ++ ++ ++%type seltablist {SrcList*} ++%destructor seltablist {sqliteSrcListDelete($$);} ++%type stl_prefix {SrcList*} ++%destructor stl_prefix {sqliteSrcListDelete($$);} ++%type from {SrcList*} ++%destructor from {sqliteSrcListDelete($$);} ++ ++// A complete FROM clause. ++// ++from(A) ::= . {A = sqliteMalloc(sizeof(*A));} ++from(A) ::= FROM seltablist(X). {A = X;} ++ ++// "seltablist" is a "Select Table List" - the content of the FROM clause ++// in a SELECT statement. "stl_prefix" is a prefix of this list. ++// ++stl_prefix(A) ::= seltablist(X) joinop(Y). { ++ A = X; ++ if( A && A->nSrc>0 ) A->a[A->nSrc-1].jointype = Y; ++} ++stl_prefix(A) ::= . {A = 0;} ++seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) on_opt(N) using_opt(U). { ++ A = sqliteSrcListAppend(X,&Y,&D); ++ if( Z.n ) sqliteSrcListAddAlias(A,&Z); ++ if( N ){ ++ if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pOn = N; } ++ else { sqliteExprDelete(N); } ++ } ++ if( U ){ ++ if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pUsing = U; } ++ else { sqliteIdListDelete(U); } ++ } ++} ++seltablist(A) ::= stl_prefix(X) LP seltablist_paren(S) RP ++ as(Z) on_opt(N) using_opt(U). { ++ A = sqliteSrcListAppend(X,0,0); ++ A->a[A->nSrc-1].pSelect = S; ++ if( Z.n ) sqliteSrcListAddAlias(A,&Z); ++ if( N ){ ++ if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pOn = N; } ++ else { sqliteExprDelete(N); } ++ } ++ if( U ){ ++ if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pUsing = U; } ++ else { sqliteIdListDelete(U); } ++ } ++} ++ ++// A seltablist_paren nonterminal represents anything in a FROM that ++// is contained inside parentheses. This can be either a subquery or ++// a grouping of table and subqueries. ++// ++%type seltablist_paren {Select*} ++%destructor seltablist_paren {sqliteSelectDelete($$);} ++seltablist_paren(A) ::= select(S). {A = S;} ++seltablist_paren(A) ::= seltablist(F). { ++ A = sqliteSelectNew(0,F,0,0,0,0,0,-1,0); ++} ++ ++%type dbnm {Token} ++dbnm(A) ::= . {A.z=0; A.n=0;} ++dbnm(A) ::= DOT nm(X). {A = X;} ++ ++%type joinop {int} ++%type joinop2 {int} ++joinop(X) ::= COMMA. { X = JT_INNER; } ++joinop(X) ::= JOIN. { X = JT_INNER; } ++joinop(X) ::= JOIN_KW(A) JOIN. { X = sqliteJoinType(pParse,&A,0,0); } ++joinop(X) ::= JOIN_KW(A) nm(B) JOIN. { X = sqliteJoinType(pParse,&A,&B,0); } ++joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN. ++ { X = sqliteJoinType(pParse,&A,&B,&C); } ++ ++%type on_opt {Expr*} ++%destructor on_opt {sqliteExprDelete($$);} ++on_opt(N) ::= ON expr(E). {N = E;} ++on_opt(N) ::= . {N = 0;} ++ ++%type using_opt {IdList*} ++%destructor using_opt {sqliteIdListDelete($$);} ++using_opt(U) ::= USING LP idxlist(L) RP. {U = L;} ++using_opt(U) ::= . {U = 0;} ++ ++ ++%type orderby_opt {ExprList*} ++%destructor orderby_opt {sqliteExprListDelete($$);} ++%type sortlist {ExprList*} ++%destructor sortlist {sqliteExprListDelete($$);} ++%type sortitem {Expr*} ++%destructor sortitem {sqliteExprDelete($$);} ++ ++orderby_opt(A) ::= . {A = 0;} ++orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;} ++sortlist(A) ::= sortlist(X) COMMA sortitem(Y) collate(C) sortorder(Z). { ++ A = sqliteExprListAppend(X,Y,0); ++ if( A ) A->a[A->nExpr-1].sortOrder = C+Z; ++} ++sortlist(A) ::= sortitem(Y) collate(C) sortorder(Z). { ++ A = sqliteExprListAppend(0,Y,0); ++ if( A ) A->a[0].sortOrder = C+Z; ++} ++sortitem(A) ::= expr(X). {A = X;} ++ ++%type sortorder {int} ++%type collate {int} ++ ++sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;} ++sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;} ++sortorder(A) ::= . {A = SQLITE_SO_ASC;} ++collate(C) ::= . {C = SQLITE_SO_UNK;} ++collate(C) ::= COLLATE id(X). {C = sqliteCollateType(X.z, X.n);} ++ ++%type groupby_opt {ExprList*} ++%destructor groupby_opt {sqliteExprListDelete($$);} ++groupby_opt(A) ::= . {A = 0;} ++groupby_opt(A) ::= GROUP BY exprlist(X). {A = X;} ++ ++%type having_opt {Expr*} ++%destructor having_opt {sqliteExprDelete($$);} ++having_opt(A) ::= . {A = 0;} ++having_opt(A) ::= HAVING expr(X). {A = X;} ++ ++%type limit_opt {struct LimitVal} ++limit_opt(A) ::= . {A.limit = -1; A.offset = 0;} ++limit_opt(A) ::= LIMIT signed(X). {A.limit = X; A.offset = 0;} ++limit_opt(A) ::= LIMIT signed(X) OFFSET signed(Y). ++ {A.limit = X; A.offset = Y;} ++limit_opt(A) ::= LIMIT signed(X) COMMA signed(Y). ++ {A.limit = Y; A.offset = X;} ++ ++/////////////////////////// The DELETE statement ///////////////////////////// ++// ++cmd ::= DELETE FROM nm(X) dbnm(D) where_opt(Y). { ++ sqliteDeleteFrom(pParse, sqliteSrcListAppend(0,&X,&D), Y); ++} ++ ++%type where_opt {Expr*} ++%destructor where_opt {sqliteExprDelete($$);} ++ ++where_opt(A) ::= . {A = 0;} ++where_opt(A) ::= WHERE expr(X). {A = X;} ++ ++%type setlist {ExprList*} ++%destructor setlist {sqliteExprListDelete($$);} ++ ++////////////////////////// The UPDATE command //////////////////////////////// ++// ++cmd ::= UPDATE orconf(R) nm(X) dbnm(D) SET setlist(Y) where_opt(Z). ++ {sqliteUpdate(pParse,sqliteSrcListAppend(0,&X,&D),Y,Z,R);} ++ ++setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y). ++ {A = sqliteExprListAppend(Z,Y,&X);} ++setlist(A) ::= nm(X) EQ expr(Y). {A = sqliteExprListAppend(0,Y,&X);} ++ ++////////////////////////// The INSERT command ///////////////////////////////// ++// ++cmd ::= insert_cmd(R) INTO nm(X) dbnm(D) inscollist_opt(F) ++ VALUES LP itemlist(Y) RP. ++ {sqliteInsert(pParse, sqliteSrcListAppend(0,&X,&D), Y, 0, F, R);} ++cmd ::= insert_cmd(R) INTO nm(X) dbnm(D) inscollist_opt(F) select(S). ++ {sqliteInsert(pParse, sqliteSrcListAppend(0,&X,&D), 0, S, F, R);} ++ ++%type insert_cmd {int} ++insert_cmd(A) ::= INSERT orconf(R). {A = R;} ++insert_cmd(A) ::= REPLACE. {A = OE_Replace;} ++ ++ ++%type itemlist {ExprList*} ++%destructor itemlist {sqliteExprListDelete($$);} ++ ++itemlist(A) ::= itemlist(X) COMMA expr(Y). {A = sqliteExprListAppend(X,Y,0);} ++itemlist(A) ::= expr(X). {A = sqliteExprListAppend(0,X,0);} ++ ++%type inscollist_opt {IdList*} ++%destructor inscollist_opt {sqliteIdListDelete($$);} ++%type inscollist {IdList*} ++%destructor inscollist {sqliteIdListDelete($$);} ++ ++inscollist_opt(A) ::= . {A = 0;} ++inscollist_opt(A) ::= LP inscollist(X) RP. {A = X;} ++inscollist(A) ::= inscollist(X) COMMA nm(Y). {A = sqliteIdListAppend(X,&Y);} ++inscollist(A) ::= nm(Y). {A = sqliteIdListAppend(0,&Y);} ++ ++/////////////////////////// Expression Processing ///////////////////////////// ++// ++ ++%type expr {Expr*} ++%destructor expr {sqliteExprDelete($$);} ++ ++expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqliteExprSpan(A,&B,&E); } ++expr(A) ::= NULL(X). {A = sqliteExpr(TK_NULL, 0, 0, &X);} ++expr(A) ::= ID(X). {A = sqliteExpr(TK_ID, 0, 0, &X);} ++expr(A) ::= JOIN_KW(X). {A = sqliteExpr(TK_ID, 0, 0, &X);} ++expr(A) ::= nm(X) DOT nm(Y). { ++ Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X); ++ Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y); ++ A = sqliteExpr(TK_DOT, temp1, temp2, 0); ++} ++expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). { ++ Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X); ++ Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y); ++ Expr *temp3 = sqliteExpr(TK_ID, 0, 0, &Z); ++ Expr *temp4 = sqliteExpr(TK_DOT, temp2, temp3, 0); ++ A = sqliteExpr(TK_DOT, temp1, temp4, 0); ++} ++expr(A) ::= INTEGER(X). {A = sqliteExpr(TK_INTEGER, 0, 0, &X);} ++expr(A) ::= FLOAT(X). {A = sqliteExpr(TK_FLOAT, 0, 0, &X);} ++expr(A) ::= STRING(X). {A = sqliteExpr(TK_STRING, 0, 0, &X);} ++expr(A) ::= VARIABLE(X). { ++ A = sqliteExpr(TK_VARIABLE, 0, 0, &X); ++ if( A ) A->iTable = ++pParse->nVar; ++} ++expr(A) ::= ID(X) LP exprlist(Y) RP(E). { ++ A = sqliteExprFunction(Y, &X); ++ sqliteExprSpan(A,&X,&E); ++} ++expr(A) ::= ID(X) LP STAR RP(E). { ++ A = sqliteExprFunction(0, &X); ++ sqliteExprSpan(A,&X,&E); ++} ++expr(A) ::= expr(X) AND expr(Y). {A = sqliteExpr(TK_AND, X, Y, 0);} ++expr(A) ::= expr(X) OR expr(Y). {A = sqliteExpr(TK_OR, X, Y, 0);} ++expr(A) ::= expr(X) LT expr(Y). {A = sqliteExpr(TK_LT, X, Y, 0);} ++expr(A) ::= expr(X) GT expr(Y). {A = sqliteExpr(TK_GT, X, Y, 0);} ++expr(A) ::= expr(X) LE expr(Y). {A = sqliteExpr(TK_LE, X, Y, 0);} ++expr(A) ::= expr(X) GE expr(Y). {A = sqliteExpr(TK_GE, X, Y, 0);} ++expr(A) ::= expr(X) NE expr(Y). {A = sqliteExpr(TK_NE, X, Y, 0);} ++expr(A) ::= expr(X) EQ expr(Y). {A = sqliteExpr(TK_EQ, X, Y, 0);} ++expr(A) ::= expr(X) BITAND expr(Y). {A = sqliteExpr(TK_BITAND, X, Y, 0);} ++expr(A) ::= expr(X) BITOR expr(Y). {A = sqliteExpr(TK_BITOR, X, Y, 0);} ++expr(A) ::= expr(X) LSHIFT expr(Y). {A = sqliteExpr(TK_LSHIFT, X, Y, 0);} ++expr(A) ::= expr(X) RSHIFT expr(Y). {A = sqliteExpr(TK_RSHIFT, X, Y, 0);} ++expr(A) ::= expr(X) likeop(OP) expr(Y). [LIKE] { ++ ExprList *pList = sqliteExprListAppend(0, Y, 0); ++ pList = sqliteExprListAppend(pList, X, 0); ++ A = sqliteExprFunction(pList, 0); ++ if( A ) A->op = OP; ++ sqliteExprSpan(A, &X->span, &Y->span); ++} ++expr(A) ::= expr(X) NOT likeop(OP) expr(Y). [LIKE] { ++ ExprList *pList = sqliteExprListAppend(0, Y, 0); ++ pList = sqliteExprListAppend(pList, X, 0); ++ A = sqliteExprFunction(pList, 0); ++ if( A ) A->op = OP; ++ A = sqliteExpr(TK_NOT, A, 0, 0); ++ sqliteExprSpan(A,&X->span,&Y->span); ++} ++%type likeop {int} ++likeop(A) ::= LIKE. {A = TK_LIKE;} ++likeop(A) ::= GLOB. {A = TK_GLOB;} ++expr(A) ::= expr(X) PLUS expr(Y). {A = sqliteExpr(TK_PLUS, X, Y, 0);} ++expr(A) ::= expr(X) MINUS expr(Y). {A = sqliteExpr(TK_MINUS, X, Y, 0);} ++expr(A) ::= expr(X) STAR expr(Y). {A = sqliteExpr(TK_STAR, X, Y, 0);} ++expr(A) ::= expr(X) SLASH expr(Y). {A = sqliteExpr(TK_SLASH, X, Y, 0);} ++expr(A) ::= expr(X) REM expr(Y). {A = sqliteExpr(TK_REM, X, Y, 0);} ++expr(A) ::= expr(X) CONCAT expr(Y). {A = sqliteExpr(TK_CONCAT, X, Y, 0);} ++expr(A) ::= expr(X) ISNULL(E). { ++ A = sqliteExpr(TK_ISNULL, X, 0, 0); ++ sqliteExprSpan(A,&X->span,&E); ++} ++expr(A) ::= expr(X) IS NULL(E). { ++ A = sqliteExpr(TK_ISNULL, X, 0, 0); ++ sqliteExprSpan(A,&X->span,&E); ++} ++expr(A) ::= expr(X) NOTNULL(E). { ++ A = sqliteExpr(TK_NOTNULL, X, 0, 0); ++ sqliteExprSpan(A,&X->span,&E); ++} ++expr(A) ::= expr(X) NOT NULL(E). { ++ A = sqliteExpr(TK_NOTNULL, X, 0, 0); ++ sqliteExprSpan(A,&X->span,&E); ++} ++expr(A) ::= expr(X) IS NOT NULL(E). { ++ A = sqliteExpr(TK_NOTNULL, X, 0, 0); ++ sqliteExprSpan(A,&X->span,&E); ++} ++expr(A) ::= NOT(B) expr(X). { ++ A = sqliteExpr(TK_NOT, X, 0, 0); ++ sqliteExprSpan(A,&B,&X->span); ++} ++expr(A) ::= BITNOT(B) expr(X). { ++ A = sqliteExpr(TK_BITNOT, X, 0, 0); ++ sqliteExprSpan(A,&B,&X->span); ++} ++expr(A) ::= MINUS(B) expr(X). [UMINUS] { ++ A = sqliteExpr(TK_UMINUS, X, 0, 0); ++ sqliteExprSpan(A,&B,&X->span); ++} ++expr(A) ::= PLUS(B) expr(X). [UPLUS] { ++ A = sqliteExpr(TK_UPLUS, X, 0, 0); ++ sqliteExprSpan(A,&B,&X->span); ++} ++expr(A) ::= LP(B) select(X) RP(E). { ++ A = sqliteExpr(TK_SELECT, 0, 0, 0); ++ if( A ) A->pSelect = X; ++ sqliteExprSpan(A,&B,&E); ++} ++expr(A) ::= expr(W) BETWEEN expr(X) AND expr(Y). { ++ ExprList *pList = sqliteExprListAppend(0, X, 0); ++ pList = sqliteExprListAppend(pList, Y, 0); ++ A = sqliteExpr(TK_BETWEEN, W, 0, 0); ++ if( A ) A->pList = pList; ++ sqliteExprSpan(A,&W->span,&Y->span); ++} ++expr(A) ::= expr(W) NOT BETWEEN expr(X) AND expr(Y). { ++ ExprList *pList = sqliteExprListAppend(0, X, 0); ++ pList = sqliteExprListAppend(pList, Y, 0); ++ A = sqliteExpr(TK_BETWEEN, W, 0, 0); ++ if( A ) A->pList = pList; ++ A = sqliteExpr(TK_NOT, A, 0, 0); ++ sqliteExprSpan(A,&W->span,&Y->span); ++} ++expr(A) ::= expr(X) IN LP exprlist(Y) RP(E). { ++ A = sqliteExpr(TK_IN, X, 0, 0); ++ if( A ) A->pList = Y; ++ sqliteExprSpan(A,&X->span,&E); ++} ++expr(A) ::= expr(X) IN LP select(Y) RP(E). { ++ A = sqliteExpr(TK_IN, X, 0, 0); ++ if( A ) A->pSelect = Y; ++ sqliteExprSpan(A,&X->span,&E); ++} ++expr(A) ::= expr(X) NOT IN LP exprlist(Y) RP(E). { ++ A = sqliteExpr(TK_IN, X, 0, 0); ++ if( A ) A->pList = Y; ++ A = sqliteExpr(TK_NOT, A, 0, 0); ++ sqliteExprSpan(A,&X->span,&E); ++} ++expr(A) ::= expr(X) NOT IN LP select(Y) RP(E). { ++ A = sqliteExpr(TK_IN, X, 0, 0); ++ if( A ) A->pSelect = Y; ++ A = sqliteExpr(TK_NOT, A, 0, 0); ++ sqliteExprSpan(A,&X->span,&E); ++} ++expr(A) ::= expr(X) IN nm(Y) dbnm(D). { ++ SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D); ++ A = sqliteExpr(TK_IN, X, 0, 0); ++ if( A ) A->pSelect = sqliteSelectNew(0,pSrc,0,0,0,0,0,-1,0); ++ sqliteExprSpan(A,&X->span,D.z?&D:&Y); ++} ++expr(A) ::= expr(X) NOT IN nm(Y) dbnm(D). { ++ SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D); ++ A = sqliteExpr(TK_IN, X, 0, 0); ++ if( A ) A->pSelect = sqliteSelectNew(0,pSrc,0,0,0,0,0,-1,0); ++ A = sqliteExpr(TK_NOT, A, 0, 0); ++ sqliteExprSpan(A,&X->span,D.z?&D:&Y); ++} ++ ++ ++/* CASE expressions */ ++expr(A) ::= CASE(C) case_operand(X) case_exprlist(Y) case_else(Z) END(E). { ++ A = sqliteExpr(TK_CASE, X, Z, 0); ++ if( A ) A->pList = Y; ++ sqliteExprSpan(A, &C, &E); ++} ++%type case_exprlist {ExprList*} ++%destructor case_exprlist {sqliteExprListDelete($$);} ++case_exprlist(A) ::= case_exprlist(X) WHEN expr(Y) THEN expr(Z). { ++ A = sqliteExprListAppend(X, Y, 0); ++ A = sqliteExprListAppend(A, Z, 0); ++} ++case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). { ++ A = sqliteExprListAppend(0, Y, 0); ++ A = sqliteExprListAppend(A, Z, 0); ++} ++%type case_else {Expr*} ++case_else(A) ::= ELSE expr(X). {A = X;} ++case_else(A) ::= . {A = 0;} ++%type case_operand {Expr*} ++case_operand(A) ::= expr(X). {A = X;} ++case_operand(A) ::= . {A = 0;} ++ ++%type exprlist {ExprList*} ++%destructor exprlist {sqliteExprListDelete($$);} ++%type expritem {Expr*} ++%destructor expritem {sqliteExprDelete($$);} ++ ++exprlist(A) ::= exprlist(X) COMMA expritem(Y). ++ {A = sqliteExprListAppend(X,Y,0);} ++exprlist(A) ::= expritem(X). {A = sqliteExprListAppend(0,X,0);} ++expritem(A) ::= expr(X). {A = X;} ++expritem(A) ::= . {A = 0;} ++ ++///////////////////////////// The CREATE INDEX command /////////////////////// ++// ++cmd ::= CREATE(S) uniqueflag(U) INDEX nm(X) ++ ON nm(Y) dbnm(D) LP idxlist(Z) RP(E) onconf(R). { ++ SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D); ++ if( U!=OE_None ) U = R; ++ if( U==OE_Default) U = OE_Abort; ++ sqliteCreateIndex(pParse, &X, pSrc, Z, U, &S, &E); ++} ++ ++%type uniqueflag {int} ++uniqueflag(A) ::= UNIQUE. { A = OE_Abort; } ++uniqueflag(A) ::= . { A = OE_None; } ++ ++%type idxlist {IdList*} ++%destructor idxlist {sqliteIdListDelete($$);} ++%type idxlist_opt {IdList*} ++%destructor idxlist_opt {sqliteIdListDelete($$);} ++%type idxitem {Token} ++ ++idxlist_opt(A) ::= . {A = 0;} ++idxlist_opt(A) ::= LP idxlist(X) RP. {A = X;} ++idxlist(A) ::= idxlist(X) COMMA idxitem(Y). {A = sqliteIdListAppend(X,&Y);} ++idxlist(A) ::= idxitem(Y). {A = sqliteIdListAppend(0,&Y);} ++idxitem(A) ::= nm(X) sortorder. {A = X;} ++ ++///////////////////////////// The DROP INDEX command ///////////////////////// ++// ++ ++cmd ::= DROP INDEX nm(X) dbnm(Y). { ++ sqliteDropIndex(pParse, sqliteSrcListAppend(0,&X,&Y)); ++} ++ ++ ++///////////////////////////// The COPY command /////////////////////////////// ++// ++cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y) USING DELIMITERS STRING(Z). ++ {sqliteCopy(pParse,sqliteSrcListAppend(0,&X,&D),&Y,&Z,R);} ++cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y). ++ {sqliteCopy(pParse,sqliteSrcListAppend(0,&X,&D),&Y,0,R);} ++ ++///////////////////////////// The VACUUM command ///////////////////////////// ++// ++cmd ::= VACUUM. {sqliteVacuum(pParse,0);} ++cmd ::= VACUUM nm(X). {sqliteVacuum(pParse,&X);} ++ ++///////////////////////////// The PRAGMA command ///////////////////////////// ++// ++cmd ::= PRAGMA ids(X) EQ nm(Y). {sqlitePragma(pParse,&X,&Y,0);} ++cmd ::= PRAGMA ids(X) EQ ON(Y). {sqlitePragma(pParse,&X,&Y,0);} ++cmd ::= PRAGMA ids(X) EQ plus_num(Y). {sqlitePragma(pParse,&X,&Y,0);} ++cmd ::= PRAGMA ids(X) EQ minus_num(Y). {sqlitePragma(pParse,&X,&Y,1);} ++cmd ::= PRAGMA ids(X) LP nm(Y) RP. {sqlitePragma(pParse,&X,&Y,0);} ++cmd ::= PRAGMA ids(X). {sqlitePragma(pParse,&X,&X,0);} ++plus_num(A) ::= plus_opt number(X). {A = X;} ++minus_num(A) ::= MINUS number(X). {A = X;} ++number(A) ::= INTEGER(X). {A = X;} ++number(A) ::= FLOAT(X). {A = X;} ++plus_opt ::= PLUS. ++plus_opt ::= . ++ ++//////////////////////////// The CREATE TRIGGER command ///////////////////// ++ ++cmd ::= CREATE(A) trigger_decl BEGIN trigger_cmd_list(S) END(Z). { ++ Token all; ++ all.z = A.z; ++ all.n = (Z.z - A.z) + Z.n; ++ sqliteFinishTrigger(pParse, S, &all); ++} ++ ++trigger_decl ::= temp(T) TRIGGER nm(B) trigger_time(C) trigger_event(D) ++ ON nm(E) dbnm(DB) foreach_clause(F) when_clause(G). { ++ SrcList *pTab = sqliteSrcListAppend(0, &E, &DB); ++ sqliteBeginTrigger(pParse, &B, C, D.a, D.b, pTab, F, G, T); ++} ++ ++%type trigger_time {int} ++trigger_time(A) ::= BEFORE. { A = TK_BEFORE; } ++trigger_time(A) ::= AFTER. { A = TK_AFTER; } ++trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;} ++trigger_time(A) ::= . { A = TK_BEFORE; } ++ ++%type trigger_event {struct TrigEvent} ++%destructor trigger_event {sqliteIdListDelete($$.b);} ++trigger_event(A) ::= DELETE. { A.a = TK_DELETE; A.b = 0; } ++trigger_event(A) ::= INSERT. { A.a = TK_INSERT; A.b = 0; } ++trigger_event(A) ::= UPDATE. { A.a = TK_UPDATE; A.b = 0;} ++trigger_event(A) ::= UPDATE OF inscollist(X). {A.a = TK_UPDATE; A.b = X; } ++ ++%type foreach_clause {int} ++foreach_clause(A) ::= . { A = TK_ROW; } ++foreach_clause(A) ::= FOR EACH ROW. { A = TK_ROW; } ++foreach_clause(A) ::= FOR EACH STATEMENT. { A = TK_STATEMENT; } ++ ++%type when_clause {Expr *} ++when_clause(A) ::= . { A = 0; } ++when_clause(A) ::= WHEN expr(X). { A = X; } ++ ++%type trigger_cmd_list {TriggerStep *} ++%destructor trigger_cmd_list {sqliteDeleteTriggerStep($$);} ++trigger_cmd_list(A) ::= trigger_cmd(X) SEMI trigger_cmd_list(Y). { ++ X->pNext = Y; ++ A = X; ++} ++trigger_cmd_list(A) ::= . { A = 0; } ++ ++%type trigger_cmd {TriggerStep *} ++%destructor trigger_cmd {sqliteDeleteTriggerStep($$);} ++// UPDATE ++trigger_cmd(A) ::= UPDATE orconf(R) nm(X) SET setlist(Y) where_opt(Z). ++ { A = sqliteTriggerUpdateStep(&X, Y, Z, R); } ++ ++// INSERT ++trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) ++ VALUES LP itemlist(Y) RP. ++{A = sqliteTriggerInsertStep(&X, F, Y, 0, R);} ++ ++trigger_cmd(A) ::= insert_cmd(R) INTO nm(X) inscollist_opt(F) select(S). ++ {A = sqliteTriggerInsertStep(&X, F, 0, S, R);} ++ ++// DELETE ++trigger_cmd(A) ::= DELETE FROM nm(X) where_opt(Y). ++ {A = sqliteTriggerDeleteStep(&X, Y);} ++ ++// SELECT ++trigger_cmd(A) ::= select(X). {A = sqliteTriggerSelectStep(X); } ++ ++// The special RAISE expression that may occur in trigger programs ++expr(A) ::= RAISE(X) LP IGNORE RP(Y). { ++ A = sqliteExpr(TK_RAISE, 0, 0, 0); ++ A->iColumn = OE_Ignore; ++ sqliteExprSpan(A, &X, &Y); ++} ++expr(A) ::= RAISE(X) LP ROLLBACK COMMA nm(Z) RP(Y). { ++ A = sqliteExpr(TK_RAISE, 0, 0, &Z); ++ A->iColumn = OE_Rollback; ++ sqliteExprSpan(A, &X, &Y); ++} ++expr(A) ::= RAISE(X) LP ABORT COMMA nm(Z) RP(Y). { ++ A = sqliteExpr(TK_RAISE, 0, 0, &Z); ++ A->iColumn = OE_Abort; ++ sqliteExprSpan(A, &X, &Y); ++} ++expr(A) ::= RAISE(X) LP FAIL COMMA nm(Z) RP(Y). { ++ A = sqliteExpr(TK_RAISE, 0, 0, &Z); ++ A->iColumn = OE_Fail; ++ sqliteExprSpan(A, &X, &Y); ++} ++ ++//////////////////////// DROP TRIGGER statement ////////////////////////////// ++cmd ::= DROP TRIGGER nm(X) dbnm(D). { ++ sqliteDropTrigger(pParse,sqliteSrcListAppend(0,&X,&D)); ++} ++ ++//////////////////////// ATTACH DATABASE file AS name ///////////////////////// ++cmd ::= ATTACH database_kw_opt ids(F) AS nm(D) key_opt(K). { ++ sqliteAttach(pParse, &F, &D, &K); ++} ++%type key_opt {Token} ++key_opt(A) ::= USING ids(X). { A = X; } ++key_opt(A) ::= . { A.z = 0; A.n = 0; } ++ ++database_kw_opt ::= DATABASE. ++database_kw_opt ::= . ++ ++//////////////////////// DETACH DATABASE name ///////////////////////////////// ++cmd ::= DETACH database_kw_opt nm(D). { ++ sqliteDetach(pParse, &D); ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/pragma.c +@@ -0,0 +1,712 @@ ++/* ++** 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. ++** ++** $Id$ ++*/ ++#include "sqliteInt.h" ++#include ++ ++/* ++** Interpret the given string as a boolean value. ++*/ ++static int getBoolean(const char *z){ ++ static char *azTrue[] = { "yes", "on", "true" }; ++ int i; ++ if( z[0]==0 ) return 0; ++ if( isdigit(z[0]) || (z[0]=='-' && isdigit(z[1])) ){ ++ return atoi(z); ++ } ++ for(i=0; i='0' && z[0]<='2' ){ ++ return z[0] - '0'; ++ }else if( sqliteStrICmp(z, "file")==0 ){ ++ return 1; ++ }else if( sqliteStrICmp(z, "memory")==0 ){ ++ return 2; ++ }else{ ++ return 0; ++ } ++} ++ ++/* ++** If the TEMP database is open, close it and mark the database schema ++** as needing reloading. This must be done when using the TEMP_STORE ++** or DEFAULT_TEMP_STORE pragmas. ++*/ ++static int changeTempStorage(Parse *pParse, const char *zStorageType){ ++ int ts = getTempStore(zStorageType); ++ sqlite *db = pParse->db; ++ if( db->temp_store==ts ) return SQLITE_OK; ++ if( db->aDb[1].pBt!=0 ){ ++ if( db->flags & SQLITE_InTrans ){ ++ sqliteErrorMsg(pParse, "temporary storage cannot be changed " ++ "from within a transaction"); ++ return SQLITE_ERROR; ++ } ++ sqliteBtreeClose(db->aDb[1].pBt); ++ db->aDb[1].pBt = 0; ++ sqliteResetInternalSchema(db, 0); ++ } ++ db->temp_store = ts; ++ return SQLITE_OK; ++} ++ ++/* ++** Check to see if zRight and zLeft refer to a pragma that queries ++** or changes one of the flags in db->flags. Return 1 if so and 0 if not. ++** Also, implement the pragma. ++*/ ++static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){ ++ static const struct { ++ const char *zName; /* Name of the pragma */ ++ int mask; /* Mask for the db->flags value */ ++ } aPragma[] = { ++ { "vdbe_trace", SQLITE_VdbeTrace }, ++ { "full_column_names", SQLITE_FullColNames }, ++ { "short_column_names", SQLITE_ShortColNames }, ++ { "show_datatypes", SQLITE_ReportTypes }, ++ { "count_changes", SQLITE_CountRows }, ++ { "empty_result_callbacks", SQLITE_NullCallback }, ++ }; ++ int i; ++ for(i=0; idb; ++ Vdbe *v; ++ if( strcmp(zLeft,zRight)==0 && (v = sqliteGetVdbe(pParse))!=0 ){ ++ sqliteVdbeOp3(v, OP_ColumnName, 0, 1, aPragma[i].zName, P3_STATIC); ++ sqliteVdbeOp3(v, OP_ColumnName, 1, 0, "boolean", P3_STATIC); ++ sqliteVdbeCode(v, OP_Integer, (db->flags & aPragma[i].mask)!=0, 0, ++ OP_Callback, 1, 0, ++ 0); ++ }else if( getBoolean(zRight) ){ ++ db->flags |= aPragma[i].mask; ++ }else{ ++ db->flags &= ~aPragma[i].mask; ++ } ++ return 1; ++ } ++ } ++ return 0; ++} ++ ++/* ++** Process a pragma statement. ++** ++** Pragmas are of this form: ++** ++** PRAGMA 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. ++*/ ++void sqlitePragma(Parse *pParse, Token *pLeft, Token *pRight, int minusFlag){ ++ char *zLeft = 0; ++ char *zRight = 0; ++ sqlite *db = pParse->db; ++ Vdbe *v = sqliteGetVdbe(pParse); ++ if( v==0 ) return; ++ ++ zLeft = sqliteStrNDup(pLeft->z, pLeft->n); ++ sqliteDequote(zLeft); ++ if( minusFlag ){ ++ zRight = 0; ++ sqliteSetNString(&zRight, "-", 1, pRight->z, pRight->n, 0); ++ }else{ ++ zRight = sqliteStrNDup(pRight->z, pRight->n); ++ sqliteDequote(zRight); ++ } ++ if( sqliteAuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, 0) ){ ++ sqliteFree(zLeft); ++ sqliteFree(zRight); ++ return; ++ } ++ ++ /* ++ ** PRAGMA default_cache_size ++ ** PRAGMA 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. ++ ** ++ ** The default cache size is stored in meta-value 2 of page 1 of the ++ ** database file. The cache size is actually the absolute value of ++ ** this memory location. The sign of meta-value 2 determines the ++ ** synchronous setting. A negative value means synchronous is off ++ ** and a positive value means synchronous is on. ++ */ ++ if( sqliteStrICmp(zLeft,"default_cache_size")==0 ){ ++ static VdbeOpList getCacheSize[] = { ++ { OP_ReadCookie, 0, 2, 0}, ++ { OP_AbsValue, 0, 0, 0}, ++ { OP_Dup, 0, 0, 0}, ++ { OP_Integer, 0, 0, 0}, ++ { OP_Ne, 0, 6, 0}, ++ { OP_Integer, 0, 0, 0}, /* 5 */ ++ { OP_ColumnName, 0, 1, "cache_size"}, ++ { OP_Callback, 1, 0, 0}, ++ }; ++ int addr; ++ if( pRight->z==pLeft->z ){ ++ addr = sqliteVdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize); ++ sqliteVdbeChangeP1(v, addr+5, MAX_PAGES); ++ }else{ ++ int size = atoi(zRight); ++ if( size<0 ) size = -size; ++ sqliteBeginWriteOperation(pParse, 0, 0); ++ sqliteVdbeAddOp(v, OP_Integer, size, 0); ++ sqliteVdbeAddOp(v, OP_ReadCookie, 0, 2); ++ addr = sqliteVdbeAddOp(v, OP_Integer, 0, 0); ++ sqliteVdbeAddOp(v, OP_Ge, 0, addr+3); ++ sqliteVdbeAddOp(v, OP_Negative, 0, 0); ++ sqliteVdbeAddOp(v, OP_SetCookie, 0, 2); ++ sqliteEndWriteOperation(pParse); ++ db->cache_size = db->cache_size<0 ? -size : size; ++ sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size); ++ } ++ }else ++ ++ /* ++ ** PRAGMA cache_size ++ ** PRAGMA cache_size=N ++ ** ++ ** The first form reports the current local setting for the ++ ** page cache size. The local setting can be different from ++ ** the persistent cache size value that is stored in the database ++ ** file itself. The value returned is the maximum number of ++ ** pages in the page cache. The second form sets the local ++ ** page cache size value. It does not change the persistent ++ ** cache size stored on the disk so the cache size will revert ++ ** to its default value when the database is closed and reopened. ++ ** N should be a positive integer. ++ */ ++ if( sqliteStrICmp(zLeft,"cache_size")==0 ){ ++ static VdbeOpList getCacheSize[] = { ++ { OP_ColumnName, 0, 1, "cache_size"}, ++ { OP_Callback, 1, 0, 0}, ++ }; ++ if( pRight->z==pLeft->z ){ ++ int size = db->cache_size;; ++ if( size<0 ) size = -size; ++ sqliteVdbeAddOp(v, OP_Integer, size, 0); ++ sqliteVdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize); ++ }else{ ++ int size = atoi(zRight); ++ if( size<0 ) size = -size; ++ if( db->cache_size<0 ) size = -size; ++ db->cache_size = size; ++ sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size); ++ } ++ }else ++ ++ /* ++ ** PRAGMA default_synchronous ++ ** PRAGMA default_synchronous=ON|OFF|NORMAL|FULL ++ ** ++ ** The first form returns the persistent value of the "synchronous" setting ++ ** that is stored in the database. This is the synchronous setting that ++ ** is used whenever the database is opened unless overridden by a separate ++ ** "synchronous" pragma. The second form changes the persistent and the ++ ** local synchronous setting to the value given. ++ ** ++ ** If synchronous is OFF, SQLite does not attempt any fsync() systems calls ++ ** to make sure data is committed to disk. Write operations are very fast, ++ ** but a power failure can leave the database in an inconsistent state. ++ ** If synchronous is ON or NORMAL, SQLite will do an fsync() system call to ++ ** make sure data is being written to disk. The risk of corruption due to ++ ** a power loss in this mode is negligible but non-zero. If synchronous ++ ** is FULL, extra fsync()s occur to reduce the risk of corruption to near ++ ** zero, but with a write performance penalty. The default mode is NORMAL. ++ */ ++ if( sqliteStrICmp(zLeft,"default_synchronous")==0 ){ ++ static VdbeOpList getSync[] = { ++ { OP_ColumnName, 0, 1, "synchronous"}, ++ { OP_ReadCookie, 0, 3, 0}, ++ { OP_Dup, 0, 0, 0}, ++ { OP_If, 0, 0, 0}, /* 3 */ ++ { OP_ReadCookie, 0, 2, 0}, ++ { OP_Integer, 0, 0, 0}, ++ { OP_Lt, 0, 5, 0}, ++ { OP_AddImm, 1, 0, 0}, ++ { OP_Callback, 1, 0, 0}, ++ { OP_Halt, 0, 0, 0}, ++ { OP_AddImm, -1, 0, 0}, /* 10 */ ++ { OP_Callback, 1, 0, 0} ++ }; ++ if( pRight->z==pLeft->z ){ ++ int addr = sqliteVdbeAddOpList(v, ArraySize(getSync), getSync); ++ sqliteVdbeChangeP2(v, addr+3, addr+10); ++ }else{ ++ int addr; ++ int size = db->cache_size; ++ if( size<0 ) size = -size; ++ sqliteBeginWriteOperation(pParse, 0, 0); ++ sqliteVdbeAddOp(v, OP_ReadCookie, 0, 2); ++ sqliteVdbeAddOp(v, OP_Dup, 0, 0); ++ addr = sqliteVdbeAddOp(v, OP_Integer, 0, 0); ++ sqliteVdbeAddOp(v, OP_Ne, 0, addr+3); ++ sqliteVdbeAddOp(v, OP_AddImm, MAX_PAGES, 0); ++ sqliteVdbeAddOp(v, OP_AbsValue, 0, 0); ++ db->safety_level = getSafetyLevel(zRight)+1; ++ if( db->safety_level==1 ){ ++ sqliteVdbeAddOp(v, OP_Negative, 0, 0); ++ size = -size; ++ } ++ sqliteVdbeAddOp(v, OP_SetCookie, 0, 2); ++ sqliteVdbeAddOp(v, OP_Integer, db->safety_level, 0); ++ sqliteVdbeAddOp(v, OP_SetCookie, 0, 3); ++ sqliteEndWriteOperation(pParse); ++ db->cache_size = size; ++ sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size); ++ sqliteBtreeSetSafetyLevel(db->aDb[0].pBt, db->safety_level); ++ } ++ }else ++ ++ /* ++ ** PRAGMA synchronous ++ ** PRAGMA 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. ++ */ ++ if( sqliteStrICmp(zLeft,"synchronous")==0 ){ ++ static VdbeOpList getSync[] = { ++ { OP_ColumnName, 0, 1, "synchronous"}, ++ { OP_Callback, 1, 0, 0}, ++ }; ++ if( pRight->z==pLeft->z ){ ++ sqliteVdbeAddOp(v, OP_Integer, db->safety_level-1, 0); ++ sqliteVdbeAddOpList(v, ArraySize(getSync), getSync); ++ }else{ ++ int size = db->cache_size; ++ if( size<0 ) size = -size; ++ db->safety_level = getSafetyLevel(zRight)+1; ++ if( db->safety_level==1 ) size = -size; ++ db->cache_size = size; ++ sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size); ++ sqliteBtreeSetSafetyLevel(db->aDb[0].pBt, db->safety_level); ++ } ++ }else ++ ++#ifndef NDEBUG ++ if( sqliteStrICmp(zLeft, "trigger_overhead_test")==0 ){ ++ if( getBoolean(zRight) ){ ++ always_code_trigger_setup = 1; ++ }else{ ++ always_code_trigger_setup = 0; ++ } ++ }else ++#endif ++ ++ if( flagPragma(pParse, zLeft, zRight) ){ ++ /* The flagPragma() call also generates any necessary code */ ++ }else ++ ++ if( sqliteStrICmp(zLeft, "table_info")==0 ){ ++ Table *pTab; ++ pTab = sqliteFindTable(db, zRight, 0); ++ if( pTab ){ ++ static VdbeOpList tableInfoPreface[] = { ++ { OP_ColumnName, 0, 0, "cid"}, ++ { OP_ColumnName, 1, 0, "name"}, ++ { OP_ColumnName, 2, 0, "type"}, ++ { OP_ColumnName, 3, 0, "notnull"}, ++ { OP_ColumnName, 4, 0, "dflt_value"}, ++ { OP_ColumnName, 5, 1, "pk"}, ++ }; ++ int i; ++ sqliteVdbeAddOpList(v, ArraySize(tableInfoPreface), tableInfoPreface); ++ sqliteViewGetColumnNames(pParse, pTab); ++ for(i=0; inCol; i++){ ++ sqliteVdbeAddOp(v, OP_Integer, i, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zName, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, ++ pTab->aCol[i].zType ? pTab->aCol[i].zType : "numeric", 0); ++ sqliteVdbeAddOp(v, OP_Integer, pTab->aCol[i].notNull, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, ++ pTab->aCol[i].zDflt, P3_STATIC); ++ sqliteVdbeAddOp(v, OP_Integer, pTab->aCol[i].isPrimKey, 0); ++ sqliteVdbeAddOp(v, OP_Callback, 6, 0); ++ } ++ } ++ }else ++ ++ if( sqliteStrICmp(zLeft, "index_info")==0 ){ ++ Index *pIdx; ++ Table *pTab; ++ pIdx = sqliteFindIndex(db, zRight, 0); ++ if( pIdx ){ ++ static VdbeOpList tableInfoPreface[] = { ++ { OP_ColumnName, 0, 0, "seqno"}, ++ { OP_ColumnName, 1, 0, "cid"}, ++ { OP_ColumnName, 2, 1, "name"}, ++ }; ++ int i; ++ pTab = pIdx->pTable; ++ sqliteVdbeAddOpList(v, ArraySize(tableInfoPreface), tableInfoPreface); ++ for(i=0; inColumn; i++){ ++ int cnum = pIdx->aiColumn[i]; ++ sqliteVdbeAddOp(v, OP_Integer, i, 0); ++ sqliteVdbeAddOp(v, OP_Integer, cnum, 0); ++ assert( pTab->nCol>cnum ); ++ sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[cnum].zName, 0); ++ sqliteVdbeAddOp(v, OP_Callback, 3, 0); ++ } ++ } ++ }else ++ ++ if( sqliteStrICmp(zLeft, "index_list")==0 ){ ++ Index *pIdx; ++ Table *pTab; ++ pTab = sqliteFindTable(db, zRight, 0); ++ if( pTab ){ ++ v = sqliteGetVdbe(pParse); ++ pIdx = pTab->pIndex; ++ } ++ if( pTab && pIdx ){ ++ int i = 0; ++ static VdbeOpList indexListPreface[] = { ++ { OP_ColumnName, 0, 0, "seq"}, ++ { OP_ColumnName, 1, 0, "name"}, ++ { OP_ColumnName, 2, 1, "unique"}, ++ }; ++ ++ sqliteVdbeAddOpList(v, ArraySize(indexListPreface), indexListPreface); ++ while(pIdx){ ++ sqliteVdbeAddOp(v, OP_Integer, i, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, pIdx->zName, 0); ++ sqliteVdbeAddOp(v, OP_Integer, pIdx->onError!=OE_None, 0); ++ sqliteVdbeAddOp(v, OP_Callback, 3, 0); ++ ++i; ++ pIdx = pIdx->pNext; ++ } ++ } ++ }else ++ ++ if( sqliteStrICmp(zLeft, "foreign_key_list")==0 ){ ++ FKey *pFK; ++ Table *pTab; ++ pTab = sqliteFindTable(db, zRight, 0); ++ if( pTab ){ ++ v = sqliteGetVdbe(pParse); ++ pFK = pTab->pFKey; ++ } ++ if( pTab && pFK ){ ++ int i = 0; ++ static VdbeOpList indexListPreface[] = { ++ { OP_ColumnName, 0, 0, "id"}, ++ { OP_ColumnName, 1, 0, "seq"}, ++ { OP_ColumnName, 2, 0, "table"}, ++ { OP_ColumnName, 3, 0, "from"}, ++ { OP_ColumnName, 4, 1, "to"}, ++ }; ++ ++ sqliteVdbeAddOpList(v, ArraySize(indexListPreface), indexListPreface); ++ while(pFK){ ++ int j; ++ for(j=0; jnCol; j++){ ++ sqliteVdbeAddOp(v, OP_Integer, i, 0); ++ sqliteVdbeAddOp(v, OP_Integer, j, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, pFK->zTo, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, ++ pTab->aCol[pFK->aCol[j].iFrom].zName, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, pFK->aCol[j].zCol, 0); ++ sqliteVdbeAddOp(v, OP_Callback, 5, 0); ++ } ++ ++i; ++ pFK = pFK->pNextFrom; ++ } ++ } ++ }else ++ ++ if( sqliteStrICmp(zLeft, "database_list")==0 ){ ++ int i; ++ static VdbeOpList indexListPreface[] = { ++ { OP_ColumnName, 0, 0, "seq"}, ++ { OP_ColumnName, 1, 0, "name"}, ++ { OP_ColumnName, 2, 1, "file"}, ++ }; ++ ++ sqliteVdbeAddOpList(v, ArraySize(indexListPreface), indexListPreface); ++ for(i=0; inDb; i++){ ++ if( db->aDb[i].pBt==0 ) continue; ++ assert( db->aDb[i].zName!=0 ); ++ sqliteVdbeAddOp(v, OP_Integer, i, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, db->aDb[i].zName, 0); ++ sqliteVdbeOp3(v, OP_String, 0, 0, ++ sqliteBtreeGetFilename(db->aDb[i].pBt), 0); ++ sqliteVdbeAddOp(v, OP_Callback, 3, 0); ++ } ++ }else ++ ++ ++ /* ++ ** 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 ++ */ ++ if( sqliteStrICmp(zLeft, "temp_store")==0 ){ ++ static VdbeOpList getTmpDbLoc[] = { ++ { OP_ColumnName, 0, 1, "temp_store"}, ++ { OP_Callback, 1, 0, 0}, ++ }; ++ if( pRight->z==pLeft->z ){ ++ sqliteVdbeAddOp(v, OP_Integer, db->temp_store, 0); ++ sqliteVdbeAddOpList(v, ArraySize(getTmpDbLoc), getTmpDbLoc); ++ }else{ ++ changeTempStorage(pParse, zRight); ++ } ++ }else ++ ++ /* ++ ** PRAGMA default_temp_store ++ ** PRAGMA default_temp_store = "default"|"memory"|"file" ++ ** ++ ** Return or set the value of the persistent temp_store flag. Any ++ ** change does not take effect until the next time the database is ++ ** opened. ++ ** ++ ** Note that it is possible for the library compile-time options to ++ ** override this setting ++ */ ++ if( sqliteStrICmp(zLeft, "default_temp_store")==0 ){ ++ static VdbeOpList getTmpDbLoc[] = { ++ { OP_ColumnName, 0, 1, "temp_store"}, ++ { OP_ReadCookie, 0, 5, 0}, ++ { OP_Callback, 1, 0, 0}}; ++ if( pRight->z==pLeft->z ){ ++ sqliteVdbeAddOpList(v, ArraySize(getTmpDbLoc), getTmpDbLoc); ++ }else{ ++ sqliteBeginWriteOperation(pParse, 0, 0); ++ sqliteVdbeAddOp(v, OP_Integer, getTempStore(zRight), 0); ++ sqliteVdbeAddOp(v, OP_SetCookie, 0, 5); ++ sqliteEndWriteOperation(pParse); ++ } ++ }else ++ ++#ifndef NDEBUG ++ if( sqliteStrICmp(zLeft, "parser_trace")==0 ){ ++ extern void sqliteParserTrace(FILE*, char *); ++ if( getBoolean(zRight) ){ ++ sqliteParserTrace(stdout, "parser: "); ++ }else{ ++ sqliteParserTrace(0, 0); ++ } ++ }else ++#endif ++ ++ if( sqliteStrICmp(zLeft, "integrity_check")==0 ){ ++ int i, j, addr; ++ ++ /* Code that initializes the integrity check program. Set the ++ ** error count 0 ++ */ ++ static VdbeOpList initCode[] = { ++ { OP_Integer, 0, 0, 0}, ++ { OP_MemStore, 0, 1, 0}, ++ { OP_ColumnName, 0, 1, "integrity_check"}, ++ }; ++ ++ /* Code to do an BTree integrity check on a single database file. ++ */ ++ static VdbeOpList checkDb[] = { ++ { OP_SetInsert, 0, 0, "2"}, ++ { OP_Integer, 0, 0, 0}, /* 1 */ ++ { OP_OpenRead, 0, 2, 0}, ++ { OP_Rewind, 0, 7, 0}, /* 3 */ ++ { OP_Column, 0, 3, 0}, /* 4 */ ++ { OP_SetInsert, 0, 0, 0}, ++ { OP_Next, 0, 4, 0}, /* 6 */ ++ { OP_IntegrityCk, 0, 0, 0}, /* 7 */ ++ { OP_Dup, 0, 1, 0}, ++ { OP_String, 0, 0, "ok"}, ++ { OP_StrEq, 0, 12, 0}, /* 10 */ ++ { OP_MemIncr, 0, 0, 0}, ++ { OP_String, 0, 0, "*** in database "}, ++ { OP_String, 0, 0, 0}, /* 13 */ ++ { OP_String, 0, 0, " ***\n"}, ++ { OP_Pull, 3, 0, 0}, ++ { OP_Concat, 4, 1, 0}, ++ { OP_Callback, 1, 0, 0}, ++ }; ++ ++ /* 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 VdbeOpList endCode[] = { ++ { OP_MemLoad, 0, 0, 0}, ++ { OP_Integer, 0, 0, 0}, ++ { OP_Ne, 0, 0, 0}, /* 2 */ ++ { OP_String, 0, 0, "ok"}, ++ { OP_Callback, 1, 0, 0}, ++ }; ++ ++ /* Initialize the VDBE program */ ++ sqliteVdbeAddOpList(v, ArraySize(initCode), initCode); ++ ++ /* Do an integrity check on each database file */ ++ for(i=0; inDb; i++){ ++ HashElem *x; ++ ++ /* Do an integrity check of the B-Tree ++ */ ++ addr = sqliteVdbeAddOpList(v, ArraySize(checkDb), checkDb); ++ sqliteVdbeChangeP1(v, addr+1, i); ++ sqliteVdbeChangeP2(v, addr+3, addr+7); ++ sqliteVdbeChangeP2(v, addr+6, addr+4); ++ sqliteVdbeChangeP2(v, addr+7, i); ++ sqliteVdbeChangeP2(v, addr+10, addr+ArraySize(checkDb)); ++ sqliteVdbeChangeP3(v, addr+13, db->aDb[i].zName, P3_STATIC); ++ ++ /* Make sure all the indices are constructed correctly. ++ */ ++ sqliteCodeVerifySchema(pParse, i); ++ for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){ ++ Table *pTab = sqliteHashData(x); ++ Index *pIdx; ++ int loopTop; ++ ++ if( pTab->pIndex==0 ) continue; ++ sqliteVdbeAddOp(v, OP_Integer, i, 0); ++ sqliteVdbeOp3(v, OP_OpenRead, 1, pTab->tnum, pTab->zName, 0); ++ for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ ++ if( pIdx->tnum==0 ) continue; ++ sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0); ++ sqliteVdbeOp3(v, OP_OpenRead, j+2, pIdx->tnum, pIdx->zName, 0); ++ } ++ sqliteVdbeAddOp(v, OP_Integer, 0, 0); ++ sqliteVdbeAddOp(v, OP_MemStore, 1, 1); ++ loopTop = sqliteVdbeAddOp(v, OP_Rewind, 1, 0); ++ sqliteVdbeAddOp(v, OP_MemIncr, 1, 0); ++ for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ ++ int k, jmp2; ++ static VdbeOpList idxErr[] = { ++ { OP_MemIncr, 0, 0, 0}, ++ { OP_String, 0, 0, "rowid "}, ++ { OP_Recno, 1, 0, 0}, ++ { OP_String, 0, 0, " missing from index "}, ++ { OP_String, 0, 0, 0}, /* 4 */ ++ { OP_Concat, 4, 0, 0}, ++ { OP_Callback, 1, 0, 0}, ++ }; ++ sqliteVdbeAddOp(v, OP_Recno, 1, 0); ++ for(k=0; knColumn; k++){ ++ int idx = pIdx->aiColumn[k]; ++ if( idx==pTab->iPKey ){ ++ sqliteVdbeAddOp(v, OP_Recno, 1, 0); ++ }else{ ++ sqliteVdbeAddOp(v, OP_Column, 1, idx); ++ } ++ } ++ sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0); ++ if( db->file_format>=4 ) sqliteAddIdxKeyType(v, pIdx); ++ jmp2 = sqliteVdbeAddOp(v, OP_Found, j+2, 0); ++ addr = sqliteVdbeAddOpList(v, ArraySize(idxErr), idxErr); ++ sqliteVdbeChangeP3(v, addr+4, pIdx->zName, P3_STATIC); ++ sqliteVdbeChangeP2(v, jmp2, sqliteVdbeCurrentAddr(v)); ++ } ++ sqliteVdbeAddOp(v, OP_Next, 1, loopTop+1); ++ sqliteVdbeChangeP2(v, loopTop, sqliteVdbeCurrentAddr(v)); ++ for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ ++ static VdbeOpList cntIdx[] = { ++ { OP_Integer, 0, 0, 0}, ++ { OP_MemStore, 2, 1, 0}, ++ { OP_Rewind, 0, 0, 0}, /* 2 */ ++ { OP_MemIncr, 2, 0, 0}, ++ { OP_Next, 0, 0, 0}, /* 4 */ ++ { OP_MemLoad, 1, 0, 0}, ++ { OP_MemLoad, 2, 0, 0}, ++ { OP_Eq, 0, 0, 0}, /* 7 */ ++ { OP_MemIncr, 0, 0, 0}, ++ { OP_String, 0, 0, "wrong # of entries in index "}, ++ { OP_String, 0, 0, 0}, /* 10 */ ++ { OP_Concat, 2, 0, 0}, ++ { OP_Callback, 1, 0, 0}, ++ }; ++ if( pIdx->tnum==0 ) continue; ++ addr = sqliteVdbeAddOpList(v, ArraySize(cntIdx), cntIdx); ++ sqliteVdbeChangeP1(v, addr+2, j+2); ++ sqliteVdbeChangeP2(v, addr+2, addr+5); ++ sqliteVdbeChangeP1(v, addr+4, j+2); ++ sqliteVdbeChangeP2(v, addr+4, addr+3); ++ sqliteVdbeChangeP2(v, addr+7, addr+ArraySize(cntIdx)); ++ sqliteVdbeChangeP3(v, addr+10, pIdx->zName, P3_STATIC); ++ } ++ } ++ } ++ addr = sqliteVdbeAddOpList(v, ArraySize(endCode), endCode); ++ sqliteVdbeChangeP2(v, addr+2, addr+ArraySize(endCode)); ++ }else ++ ++ {} ++ sqliteFree(zLeft); ++ sqliteFree(zRight); ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/printf.c +@@ -0,0 +1,858 @@ ++/* ++** The "printf" code that follows dates from the 1980's. It is in ++** the public domain. The original comments are included here for ++** completeness. They are very out-of-date but might be useful as ++** an historical reference. Most of the "enhancements" have been backed ++** out so that the functionality is now the same as standard printf(). ++** ++************************************************************************** ++** ++** The following modules is an enhanced replacement for the "printf" subroutines ++** found in the standard C library. The following enhancements are ++** supported: ++** ++** + Additional functions. The standard set of "printf" functions ++** includes printf, fprintf, sprintf, vprintf, vfprintf, and ++** vsprintf. This module adds the following: ++** ++** * snprintf -- Works like sprintf, but has an extra argument ++** which is the size of the buffer written to. ++** ++** * mprintf -- Similar to sprintf. Writes output to memory ++** obtained from malloc. ++** ++** * xprintf -- Calls a function to dispose of output. ++** ++** * nprintf -- No output, but returns the number of characters ++** that would have been output by printf. ++** ++** * A v- version (ex: vsnprintf) of every function is also ++** supplied. ++** ++** + A few extensions to the formatting notation are supported: ++** ++** * The "=" flag (similar to "-") causes the output to be ++** be centered in the appropriately sized field. ++** ++** * The %b field outputs an integer in binary notation. ++** ++** * The %c field now accepts a precision. The character output ++** is repeated by the number of times the precision specifies. ++** ++** * The %' field works like %c, but takes as its character the ++** next character of the format string, instead of the next ++** argument. For example, printf("%.78'-") prints 78 minus ++** signs, the same as printf("%.78c",'-'). ++** ++** + When compiled using GCC on a SPARC, this version of printf is ++** faster than the library printf for SUN OS 4.1. ++** ++** + All functions are fully reentrant. ++** ++*/ ++#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 */ ++#define etERROR 10 /* Used to indicate no such conversion type */ ++/* The rest are extensions, not normally found in printf() */ ++#define etCHARLIT 11 /* Literal characters. %' */ ++#define etSQLESCAPE 12 /* Strings with '\'' doubled. %q */ ++#define etSQLESCAPE2 13 /* Strings with '\'' doubled and enclosed in '', ++ NULL pointers replaced by SQL NULL. %Q */ ++#define etTOKEN 14 /* a pointer to a Token structure */ ++#define etSRCLIST 15 /* a pointer to a SrcList */ ++ ++ ++/* ++** 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 */ ++ char *charset; /* The character set for conversion */ ++ char *prefix; /* Prefix on non-zero values in alt format */ ++} 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 */ ++ ++ ++/* ++** The following table is searched linearly, so it is good to put the ++** most frequently used conversion types first. ++*/ ++static et_info fmtinfo[] = { ++ { 'd', 10, 1, etRADIX, "0123456789", 0 }, ++ { 's', 0, 0, etSTRING, 0, 0 }, ++ { 'z', 0, 2, etDYNSTRING, 0, 0 }, ++ { 'q', 0, 0, etSQLESCAPE, 0, 0 }, ++ { 'Q', 0, 0, etSQLESCAPE2, 0, 0 }, ++ { 'c', 0, 0, etCHARX, 0, 0 }, ++ { 'o', 8, 0, etRADIX, "01234567", "0" }, ++ { 'u', 10, 0, etRADIX, "0123456789", 0 }, ++ { 'x', 16, 0, etRADIX, "0123456789abcdef", "x0" }, ++ { 'X', 16, 0, etRADIX, "0123456789ABCDEF", "X0" }, ++ { 'f', 0, 1, etFLOAT, 0, 0 }, ++ { 'e', 0, 1, etEXP, "e", 0 }, ++ { 'E', 0, 1, etEXP, "E", 0 }, ++ { 'g', 0, 1, etGENERIC, "e", 0 }, ++ { 'G', 0, 1, etGENERIC, "E", 0 }, ++ { 'i', 10, 1, etRADIX, "0123456789", 0 }, ++ { 'n', 0, 0, etSIZE, 0, 0 }, ++ { '%', 0, 0, etPERCENT, 0, 0 }, ++ { 'p', 10, 0, etRADIX, "0123456789", 0 }, ++ { 'T', 0, 2, etTOKEN, 0, 0 }, ++ { 'S', 0, 2, etSRCLIST, 0, 0 }, ++}; ++#define etNINFO (sizeof(fmtinfo)/sizeof(fmtinfo[0])) ++ ++/* ++** If NOFLOATINGPOINT is defined, then none of the floating point ++** conversions will work. ++*/ ++#ifndef etNOFLOATINGPOINT ++/* ++** "*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 int et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){ ++ int digit; ++ LONGDOUBLE_TYPE d; ++ if( (*cnt)++ >= 16 ) return '0'; ++ digit = (int)*val; ++ d = digit; ++ digit += '0'; ++ *val = (*val - d)*10.0; ++ return digit; ++} ++#endif ++ ++#define etBUFSIZE 1000 /* Size of the output buffer */ ++ ++/* ++** The root program. All variations call this core. ++** ++** INPUTS: ++** func This is a pointer to a function taking three arguments ++** 1. A pointer to anything. Same as the "arg" parameter. ++** 2. A pointer to the list of characters to be output ++** (Note, this list is NOT null terminated.) ++** 3. An integer number of characters to be output. ++** (Note: This number might be zero.) ++** ++** arg This is the pointer to anything which will be passed as the ++** first argument to "func". Use it for whatever you like. ++** ++** fmt This is the format string, as in the usual print. ++** ++** ap This is a pointer to a list of arguments. Same as in ++** vfprint. ++** ++** OUTPUTS: ++** The return value is the total number of characters sent to ++** the function "func". Returns -1 on a error. ++** ++** Note that the order in which automatic variables are declared below ++** seems to make a big difference in determining how fast this beast ++** will run. ++*/ ++static int vxprintf( ++ void (*func)(void*,const char*,int), /* Consumer of text */ ++ void *arg, /* First argument to the consumer */ ++ int useExtended, /* Allow extended %-conversions */ ++ 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 count; /* Total number of characters output */ ++ 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_zeropad; /* True if field width constant starts with zero */ ++ etByte flag_long; /* True if "l" flag is present */ ++ unsigned long longvalue; /* Value for integer types */ ++ LONGDOUBLE_TYPE realvalue; /* Value for real types */ ++ et_info *infop; /* Pointer to the appropriate info structure */ ++ char buf[etBUFSIZE]; /* Conversion buffer */ ++ char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */ ++ etByte errorflag = 0; /* True if an error is encountered */ ++ etByte xtype; /* Conversion paradigm */ ++ char *zExtra; /* Extra memory used for etTCLESCAPE conversions */ ++ static char spaces[] = " "; ++#define etSPACESIZE (sizeof(spaces)-1) ++#ifndef etNOFLOATINGPOINT ++ int exp; /* exponent of real numbers */ ++ 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 */ ++ etByte flag_exp; /* True to force display of the exponent */ ++ int nsd; /* Number of significant digits returned */ ++#endif ++ ++ func(arg,"",0); ++ count = length = 0; ++ bufpt = 0; ++ for(; (c=(*fmt))!=0; ++fmt){ ++ if( c!='%' ){ ++ int amt; ++ bufpt = (char *)fmt; ++ amt = 1; ++ while( (c=(*++fmt))!='%' && c!=0 ) amt++; ++ (*func)(arg,bufpt,amt); ++ count += amt; ++ if( c==0 ) break; ++ } ++ if( (c=(*++fmt))==0 ){ ++ errorflag = 1; ++ (*func)(arg,"%",1); ++ count++; ++ break; ++ } ++ /* Find out what flags are present */ ++ flag_leftjustify = flag_plussign = flag_blanksign = ++ flag_alternateform = flag_zeropad = 0; ++ do{ ++ switch( c ){ ++ case '-': flag_leftjustify = 1; c = 0; break; ++ case '+': flag_plussign = 1; c = 0; break; ++ case ' ': flag_blanksign = 1; c = 0; break; ++ case '#': flag_alternateform = 1; c = 0; break; ++ case '0': flag_zeropad = 1; c = 0; break; ++ default: break; ++ } ++ }while( c==0 && (c=(*++fmt))!=0 ); ++ /* Get the field width */ ++ width = 0; ++ if( c=='*' ){ ++ width = va_arg(ap,int); ++ if( width<0 ){ ++ flag_leftjustify = 1; ++ width = -width; ++ } ++ c = *++fmt; ++ }else{ ++ while( c>='0' && c<='9' ){ ++ width = width*10 + c - '0'; ++ c = *++fmt; ++ } ++ } ++ if( width > etBUFSIZE-10 ){ ++ width = etBUFSIZE-10; ++ } ++ /* Get the precision */ ++ if( c=='.' ){ ++ precision = 0; ++ c = *++fmt; ++ if( c=='*' ){ ++ precision = va_arg(ap,int); ++ if( precision<0 ) precision = -precision; ++ c = *++fmt; ++ }else{ ++ while( c>='0' && c<='9' ){ ++ precision = precision*10 + c - '0'; ++ c = *++fmt; ++ } ++ } ++ /* Limit the precision to prevent overflowing buf[] during conversion */ ++ if( precision>etBUFSIZE-40 ) precision = etBUFSIZE-40; ++ }else{ ++ precision = -1; ++ } ++ /* Get the conversion type modifier */ ++ if( c=='l' ){ ++ flag_long = 1; ++ c = *++fmt; ++ }else{ ++ flag_long = 0; ++ } ++ /* Fetch the info entry for the field */ ++ infop = 0; ++ xtype = etERROR; ++ for(idx=0; idxflags & FLAG_INTERN)==0 ){ ++ xtype = infop->type; ++ } ++ break; ++ } ++ } ++ zExtra = 0; ++ ++ /* ++ ** At this point, variables are initialized as follows: ++ ** ++ ** flag_alternateform 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_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 etRADIX: ++ if( flag_long ) longvalue = va_arg(ap,long); ++ else longvalue = va_arg(ap,int); ++#if 1 ++ /* For the format %#x, the value zero is printed "0" not "0x0". ++ ** I think this is stupid. */ ++ if( longvalue==0 ) flag_alternateform = 0; ++#else ++ /* More sensible: turn off the prefix for octal (to prevent "00"), ++ ** but leave the prefix for hex. */ ++ if( longvalue==0 && infop->base==8 ) flag_alternateform = 0; ++#endif ++ if( infop->flags & FLAG_SIGNED ){ ++ if( *(long*)&longvalue<0 ){ ++ longvalue = -*(long*)&longvalue; ++ prefix = '-'; ++ }else if( flag_plussign ) prefix = '+'; ++ else if( flag_blanksign ) prefix = ' '; ++ else prefix = 0; ++ }else prefix = 0; ++ if( flag_zeropad && precisioncharset; ++ base = infop->base; ++ do{ /* Convert to ascii */ ++ *(--bufpt) = cset[longvalue%base]; ++ longvalue = longvalue/base; ++ }while( longvalue>0 ); ++ } ++ length = &buf[etBUFSIZE-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" */ ++ char *pre, x; ++ pre = infop->prefix; ++ if( *bufpt!=pre[0] ){ ++ for(pre=infop->prefix; (x=(*pre))!=0; pre++) *(--bufpt) = x; ++ } ++ } ++ length = &buf[etBUFSIZE-1]-bufpt; ++ break; ++ case etFLOAT: ++ case etEXP: ++ case etGENERIC: ++ realvalue = va_arg(ap,double); ++#ifndef etNOFLOATINGPOINT ++ if( precision<0 ) precision = 6; /* Set default precision */ ++ if( precision>etBUFSIZE-10 ) precision = etBUFSIZE-10; ++ if( realvalue<0.0 ){ ++ realvalue = -realvalue; ++ prefix = '-'; ++ }else{ ++ if( flag_plussign ) prefix = '+'; ++ else if( flag_blanksign ) prefix = ' '; ++ else prefix = 0; ++ } ++ if( infop->type==etGENERIC && precision>0 ) precision--; ++ rounder = 0.0; ++#if 0 ++ /* Rounding works like BSD when the constant 0.4999 is used. Wierd! */ ++ for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1); ++#else ++ /* It makes more sense to use 0.5 */ ++ for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1); ++#endif ++ if( infop->type==etFLOAT ) realvalue += rounder; ++ /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */ ++ exp = 0; ++ if( realvalue>0.0 ){ ++ while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; } ++ while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; } ++ while( realvalue<1e-8 && exp>=-350 ){ realvalue *= 1e8; exp-=8; } ++ while( realvalue<1.0 && exp>=-350 ){ realvalue *= 10.0; exp--; } ++ if( exp>350 || exp<-350 ){ ++ bufpt = "NaN"; ++ length = 3; ++ break; ++ } ++ } ++ bufpt = buf; ++ /* ++ ** If the field type is etGENERIC, then convert to either etEXP ++ ** or etFLOAT, as appropriate. ++ */ ++ flag_exp = xtype==etEXP; ++ 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 = 0; ++ } ++ /* ++ ** The "exp+precision" test causes output to be of type etEXP if ++ ** the precision is too large to fit in buf[]. ++ */ ++ nsd = 0; ++ if( xtype==etFLOAT && exp+precision0 || flag_alternateform); ++ if( prefix ) *(bufpt++) = prefix; /* Sign */ ++ if( exp<0 ) *(bufpt++) = '0'; /* Digits before "." */ ++ else for(; exp>=0; exp--) *(bufpt++) = et_getdigit(&realvalue,&nsd); ++ if( flag_dp ) *(bufpt++) = '.'; /* The decimal point */ ++ for(exp++; exp<0 && precision>0; precision--, exp++){ ++ *(bufpt++) = '0'; ++ } ++ while( (precision--)>0 ) *(bufpt++) = et_getdigit(&realvalue,&nsd); ++ *(bufpt--) = 0; /* Null terminate */ ++ if( flag_rtz && flag_dp ){ /* Remove trailing zeros and "." */ ++ while( bufpt>=buf && *bufpt=='0' ) *(bufpt--) = 0; ++ if( bufpt>=buf && *bufpt=='.' ) *(bufpt--) = 0; ++ } ++ bufpt++; /* point to next free slot */ ++ }else{ /* etEXP or etGENERIC */ ++ flag_dp = (precision>0 || flag_alternateform); ++ if( prefix ) *(bufpt++) = prefix; /* Sign */ ++ *(bufpt++) = et_getdigit(&realvalue,&nsd); /* First digit */ ++ if( flag_dp ) *(bufpt++) = '.'; /* Decimal point */ ++ while( (precision--)>0 ) *(bufpt++) = et_getdigit(&realvalue,&nsd); ++ bufpt--; /* point to last digit */ ++ if( flag_rtz && flag_dp ){ /* Remove tail zeros */ ++ while( bufpt>=buf && *bufpt=='0' ) *(bufpt--) = 0; ++ if( bufpt>=buf && *bufpt=='.' ) *(bufpt--) = 0; ++ } ++ bufpt++; /* point to next free slot */ ++ if( exp || flag_exp ){ ++ *(bufpt++) = infop->charset[0]; ++ if( exp<0 ){ *(bufpt++) = '-'; exp = -exp; } /* sign of exp */ ++ else { *(bufpt++) = '+'; } ++ if( exp>=100 ){ ++ *(bufpt++) = (exp/100)+'0'; /* 100's digit */ ++ exp %= 100; ++ } ++ *(bufpt++) = exp/10+'0'; /* 10's digit */ ++ *(bufpt++) = exp%10+'0'; /* 1's digit */ ++ } ++ } ++ /* 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 = bufpt-buf; ++ bufpt = buf; ++ ++ /* 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 ++ break; ++ case etSIZE: ++ *(va_arg(ap,int*)) = count; ++ length = width = 0; ++ break; ++ case etPERCENT: ++ buf[0] = '%'; ++ bufpt = buf; ++ length = 1; ++ break; ++ case etCHARLIT: ++ case etCHARX: ++ c = buf[0] = (xtype==etCHARX ? va_arg(ap,int) : *++fmt); ++ if( precision>=0 ){ ++ for(idx=1; idx=0 && precisionetBUFSIZE ){ ++ bufpt = zExtra = sqliteMalloc( n ); ++ if( bufpt==0 ) return -1; ++ }else{ ++ bufpt = buf; ++ } ++ j = 0; ++ if( !isnull && xtype==etSQLESCAPE2 ) bufpt[j++] = '\''; ++ for(i=0; (c=arg[i])!=0; i++){ ++ bufpt[j++] = c; ++ if( c=='\'' ) bufpt[j++] = c; ++ } ++ if( !isnull && xtype==etSQLESCAPE2 ) bufpt[j++] = '\''; ++ bufpt[j] = 0; ++ length = j; ++ if( precision>=0 && precisionz, 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( k>=0 && knSrc ); ++ if( pItem->zDatabase && pItem->zDatabase[0] ){ ++ (*func)(arg, pItem->zDatabase, strlen(pItem->zDatabase)); ++ (*func)(arg, ".", 1); ++ } ++ (*func)(arg, pItem->zName, strlen(pItem->zName)); ++ length = width = 0; ++ break; ++ } ++ case etERROR: ++ buf[0] = '%'; ++ buf[1] = c; ++ errorflag = 0; ++ idx = 1+(c!=0); ++ (*func)(arg,"%",idx); ++ count += idx; ++ if( c==0 ) fmt--; ++ break; ++ }/* 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. ++ */ ++ if( !flag_leftjustify ){ ++ register int nspace; ++ nspace = width-length; ++ if( nspace>0 ){ ++ count += nspace; ++ while( nspace>=etSPACESIZE ){ ++ (*func)(arg,spaces,etSPACESIZE); ++ nspace -= etSPACESIZE; ++ } ++ if( nspace>0 ) (*func)(arg,spaces,nspace); ++ } ++ } ++ if( length>0 ){ ++ (*func)(arg,bufpt,length); ++ count += length; ++ } ++ if( flag_leftjustify ){ ++ register int nspace; ++ nspace = width-length; ++ if( nspace>0 ){ ++ count += nspace; ++ while( nspace>=etSPACESIZE ){ ++ (*func)(arg,spaces,etSPACESIZE); ++ nspace -= etSPACESIZE; ++ } ++ if( nspace>0 ) (*func)(arg,spaces,nspace); ++ } ++ } ++ if( zExtra ){ ++ sqliteFree(zExtra); ++ } ++ }/* End for loop over the format string */ ++ return errorflag ? -1 : count; ++} /* End of function */ ++ ++ ++/* This structure is used to store state information about the ++** write to memory that is currently in progress. ++*/ ++struct sgMprintf { ++ char *zBase; /* A base allocation */ ++ char *zText; /* The string collected so far */ ++ int nChar; /* Length of the string so far */ ++ int nTotal; /* Output size if unconstrained */ ++ int nAlloc; /* Amount of space allocated in zText */ ++ void *(*xRealloc)(void*,int); /* Function used to realloc memory */ ++}; ++ ++/* ++** This function implements the callback from vxprintf. ++** ++** This routine add nNewChar characters of text in zNewText to ++** the sgMprintf structure pointed to by "arg". ++*/ ++static void mout(void *arg, const char *zNewText, int nNewChar){ ++ struct sgMprintf *pM = (struct sgMprintf*)arg; ++ pM->nTotal += nNewChar; ++ if( pM->nChar + nNewChar + 1 > pM->nAlloc ){ ++ if( pM->xRealloc==0 ){ ++ nNewChar = pM->nAlloc - pM->nChar - 1; ++ }else{ ++ pM->nAlloc = pM->nChar + nNewChar*2 + 1; ++ if( pM->zText==pM->zBase ){ ++ pM->zText = pM->xRealloc(0, pM->nAlloc); ++ if( pM->zText && pM->nChar ){ ++ memcpy(pM->zText, pM->zBase, pM->nChar); ++ } ++ }else{ ++ pM->zText = pM->xRealloc(pM->zText, pM->nAlloc); ++ } ++ } ++ } ++ if( pM->zText ){ ++ if( nNewChar>0 ){ ++ memcpy(&pM->zText[pM->nChar], zNewText, nNewChar); ++ pM->nChar += nNewChar; ++ } ++ pM->zText[pM->nChar] = 0; ++ } ++} ++ ++/* ++** This routine is a wrapper around xprintf() that invokes mout() as ++** the consumer. ++*/ ++static char *base_vprintf( ++ void *(*xRealloc)(void*,int), /* Routine to realloc memory. May be NULL */ ++ int useInternal, /* Use internal %-conversions if true */ ++ char *zInitBuf, /* Initially write here, before mallocing */ ++ int nInitBuf, /* Size of zInitBuf[] */ ++ const char *zFormat, /* format string */ ++ va_list ap /* arguments */ ++){ ++ struct sgMprintf sM; ++ sM.zBase = sM.zText = zInitBuf; ++ sM.nChar = sM.nTotal = 0; ++ sM.nAlloc = nInitBuf; ++ sM.xRealloc = xRealloc; ++ vxprintf(mout, &sM, useInternal, zFormat, ap); ++ if( xRealloc ){ ++ if( sM.zText==sM.zBase ){ ++ sM.zText = xRealloc(0, sM.nChar+1); ++ memcpy(sM.zText, sM.zBase, sM.nChar+1); ++ }else if( sM.nAlloc>sM.nChar+10 ){ ++ sM.zText = xRealloc(sM.zText, sM.nChar+1); ++ } ++ } ++ return sM.zText; ++} ++ ++/* ++** Realloc that is a real function, not a macro. ++*/ ++static void *printf_realloc(void *old, int size){ ++ return sqliteRealloc(old,size); ++} ++ ++/* ++** Print into memory obtained from sqliteMalloc(). Use the internal ++** %-conversion extensions. ++*/ ++char *sqliteVMPrintf(const char *zFormat, va_list ap){ ++ char zBase[1000]; ++ return base_vprintf(printf_realloc, 1, zBase, sizeof(zBase), zFormat, ap); ++} ++ ++/* ++** Print into memory obtained from sqliteMalloc(). Use the internal ++** %-conversion extensions. ++*/ ++char *sqliteMPrintf(const char *zFormat, ...){ ++ va_list ap; ++ char *z; ++ char zBase[1000]; ++ va_start(ap, zFormat); ++ z = base_vprintf(printf_realloc, 1, zBase, sizeof(zBase), zFormat, ap); ++ va_end(ap); ++ return z; ++} ++ ++/* ++** Print into memory obtained from malloc(). Do not use the internal ++** %-conversion extensions. This routine is for use by external users. ++*/ ++char *sqlite_mprintf(const char *zFormat, ...){ ++ va_list ap; ++ char *z; ++ char zBuf[200]; ++ ++ va_start(ap,zFormat); ++ z = base_vprintf((void*(*)(void*,int))realloc, 0, ++ zBuf, sizeof(zBuf), zFormat, ap); ++ va_end(ap); ++ return z; ++} ++ ++/* This is the varargs version of sqlite_mprintf. ++*/ ++char *sqlite_vmprintf(const char *zFormat, va_list ap){ ++ char zBuf[200]; ++ return base_vprintf((void*(*)(void*,int))realloc, 0, ++ zBuf, sizeof(zBuf), zFormat, ap); ++} ++ ++/* ++** sqlite_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. ++*/ ++char *sqlite_snprintf(int n, char *zBuf, const char *zFormat, ...){ ++ char *z; ++ va_list ap; ++ ++ va_start(ap,zFormat); ++ z = base_vprintf(0, 0, zBuf, n, zFormat, ap); ++ va_end(ap); ++ return z; ++} ++ ++/* ++** The following four routines implement the varargs versions of the ++** sqlite_exec() and sqlite_get_table() interfaces. See the sqlite.h ++** header files for a more detailed description of how these interfaces ++** work. ++** ++** These routines are all just simple wrappers. ++*/ ++int sqlite_exec_printf( ++ sqlite *db, /* An open database */ ++ const char *sqlFormat, /* printf-style format string for the SQL */ ++ sqlite_callback xCallback, /* Callback function */ ++ void *pArg, /* 1st argument to callback function */ ++ char **errmsg, /* Error msg written here */ ++ ... /* Arguments to the format string. */ ++){ ++ va_list ap; ++ int rc; ++ ++ va_start(ap, errmsg); ++ rc = sqlite_exec_vprintf(db, sqlFormat, xCallback, pArg, errmsg, ap); ++ va_end(ap); ++ return rc; ++} ++int sqlite_exec_vprintf( ++ sqlite *db, /* An open database */ ++ const char *sqlFormat, /* printf-style format string for the SQL */ ++ sqlite_callback xCallback, /* Callback function */ ++ void *pArg, /* 1st argument to callback function */ ++ char **errmsg, /* Error msg written here */ ++ va_list ap /* Arguments to the format string. */ ++){ ++ char *zSql; ++ int rc; ++ ++ zSql = sqlite_vmprintf(sqlFormat, ap); ++ rc = sqlite_exec(db, zSql, xCallback, pArg, errmsg); ++ free(zSql); ++ return rc; ++} ++int sqlite_get_table_printf( ++ sqlite *db, /* An open database */ ++ const char *sqlFormat, /* printf-style format string for the SQL */ ++ char ***resultp, /* Result written to a char *[] that this points to */ ++ int *nrow, /* Number of result rows written here */ ++ int *ncol, /* Number of result columns written here */ ++ char **errmsg, /* Error msg written here */ ++ ... /* Arguments to the format string */ ++){ ++ va_list ap; ++ int rc; ++ ++ va_start(ap, errmsg); ++ rc = sqlite_get_table_vprintf(db, sqlFormat, resultp, nrow, ncol, errmsg, ap); ++ va_end(ap); ++ return rc; ++} ++int sqlite_get_table_vprintf( ++ sqlite *db, /* An open database */ ++ const char *sqlFormat, /* printf-style format string for the SQL */ ++ char ***resultp, /* Result written to a char *[] that this points to */ ++ int *nrow, /* Number of result rows written here */ ++ int *ncolumn, /* Number of result columns written here */ ++ char **errmsg, /* Error msg written here */ ++ va_list ap /* Arguments to the format string */ ++){ ++ char *zSql; ++ int rc; ++ ++ zSql = sqlite_vmprintf(sqlFormat, ap); ++ rc = sqlite_get_table(db, zSql, resultp, nrow, ncolumn, errmsg); ++ free(zSql); ++ return rc; ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/random.c +@@ -0,0 +1,97 @@ ++/* ++** 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. ++** ++** $Id$ ++*/ ++#include "sqliteInt.h" ++#include "os.h" ++ ++ ++/* ++** Get a single 8-bit random value from the RC4 PRNG. The Mutex ++** must be held while executing this routine. ++** ++** Why not just use a library random generator like lrand48() for this? ++** Because the OP_NewRecno opcode in the VDBE depends on having a very ++** good source of random numbers. The lrand48() library function may ++** well be good enough. But maybe not. Or maybe lrand48() has some ++** subtle problems on some systems that could cause problems. It is hard ++** to know. To minimize the risk of problems due to bad lrand48() ++** implementations, SQLite uses this random number generator based ++** on RC4, which we know works very well. ++*/ ++static int randomByte(){ ++ unsigned char t; ++ ++ /* All threads share a single random number generator. ++ ** This structure is the current state of the generator. ++ */ ++ static struct { ++ unsigned char isInit; /* True if initialized */ ++ unsigned char i, j; /* State variables */ ++ unsigned char s[256]; /* State variables */ ++ } prng; ++ ++ /* 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( !prng.isInit ){ ++ int i; ++ char k[256]; ++ prng.j = 0; ++ prng.i = 0; ++ sqliteOsRandomSeed(k); ++ for(i=0; i<256; i++){ ++ prng.s[i] = i; ++ } ++ for(i=0; i<256; i++){ ++ prng.j += prng.s[i] + k[i]; ++ t = prng.s[prng.j]; ++ prng.s[prng.j] = prng.s[i]; ++ prng.s[i] = t; ++ } ++ prng.isInit = 1; ++ } ++ ++ /* Generate and return single random byte ++ */ ++ prng.i++; ++ t = prng.s[prng.i]; ++ prng.j += t; ++ prng.s[prng.i] = prng.s[prng.j]; ++ prng.s[prng.j] = t; ++ t += prng.s[prng.i]; ++ return prng.s[t]; ++} ++ ++/* ++** Return N random bytes. ++*/ ++void sqliteRandomness(int N, void *pBuf){ ++ unsigned char *zBuf = pBuf; ++ sqliteOsEnterMutex(); ++ while( N-- ){ ++ *(zBuf++) = randomByte(); ++ } ++ sqliteOsLeaveMutex(); ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/select.c +@@ -0,0 +1,2434 @@ ++/* ++** 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. ++** ++** $Id$ ++*/ ++#include "sqliteInt.h" ++ ++ ++/* ++** Allocate a new Select structure and return a pointer to that ++** structure. ++*/ ++Select *sqliteSelectNew( ++ 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 */ ++ int isDistinct, /* true if the DISTINCT keyword is present */ ++ int nLimit, /* LIMIT value. -1 means not used */ ++ int nOffset /* OFFSET value. 0 means no offset */ ++){ ++ Select *pNew; ++ pNew = sqliteMalloc( sizeof(*pNew) ); ++ if( pNew==0 ){ ++ sqliteExprListDelete(pEList); ++ sqliteSrcListDelete(pSrc); ++ sqliteExprDelete(pWhere); ++ sqliteExprListDelete(pGroupBy); ++ sqliteExprDelete(pHaving); ++ sqliteExprListDelete(pOrderBy); ++ }else{ ++ if( pEList==0 ){ ++ pEList = sqliteExprListAppend(0, sqliteExpr(TK_ALL,0,0,0), 0); ++ } ++ pNew->pEList = pEList; ++ pNew->pSrc = pSrc; ++ pNew->pWhere = pWhere; ++ pNew->pGroupBy = pGroupBy; ++ pNew->pHaving = pHaving; ++ pNew->pOrderBy = pOrderBy; ++ pNew->isDistinct = isDistinct; ++ pNew->op = TK_SELECT; ++ pNew->nLimit = nLimit; ++ pNew->nOffset = nOffset; ++ pNew->iLimit = -1; ++ pNew->iOffset = -1; ++ } ++ return pNew; ++} ++ ++/* ++** Given 1 to 3 identifiers preceeding 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_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. ++*/ ++int sqliteJoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ ++ int jointype = 0; ++ Token *apAll[3]; ++ Token *p; ++ static struct { ++ const char *zKeyword; ++ int nChar; ++ int code; ++ } keywords[] = { ++ { "natural", 7, JT_NATURAL }, ++ { "left", 4, JT_LEFT|JT_OUTER }, ++ { "right", 5, JT_RIGHT|JT_OUTER }, ++ { "full", 4, JT_LEFT|JT_RIGHT|JT_OUTER }, ++ { "outer", 5, JT_OUTER }, ++ { "inner", 5, JT_INNER }, ++ { "cross", 5, JT_INNER }, ++ }; ++ 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==keywords[j].nChar ++ && sqliteStrNICmp(p->z, keywords[j].zKeyword, p->n)==0 ){ ++ jointype |= keywords[j].code; ++ break; ++ } ++ } ++ if( j>=sizeof(keywords)/sizeof(keywords[0]) ){ ++ jointype |= JT_ERROR; ++ break; ++ } ++ } ++ if( ++ (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) || ++ (jointype & JT_ERROR)!=0 ++ ){ ++ static Token dummy = { 0, 0 }; ++ char *zSp1 = " ", *zSp2 = " "; ++ if( pB==0 ){ pB = &dummy; zSp1 = 0; } ++ if( pC==0 ){ pC = &dummy; zSp2 = 0; } ++ sqliteSetNString(&pParse->zErrMsg, "unknown or unsupported join type: ", 0, ++ pA->z, pA->n, zSp1, 1, pB->z, pB->n, zSp2, 1, pC->z, pC->n, 0); ++ pParse->nErr++; ++ jointype = JT_INNER; ++ }else if( jointype & JT_RIGHT ){ ++ sqliteErrorMsg(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( sqliteStrICmp(pTab->aCol[i].zName, zCol)==0 ) return i; ++ } ++ return -1; ++} ++ ++/* ++** Add a term to the WHERE expression in *ppExpr that requires the ++** zCol column to be equal in the two tables pTab1 and pTab2. ++*/ ++static void addWhereTerm( ++ const char *zCol, /* Name of the column */ ++ const Table *pTab1, /* First table */ ++ const Table *pTab2, /* Second table */ ++ Expr **ppExpr /* Add the equality term to this expression */ ++){ ++ Token dummy; ++ Expr *pE1a, *pE1b, *pE1c; ++ Expr *pE2a, *pE2b, *pE2c; ++ Expr *pE; ++ ++ dummy.z = zCol; ++ dummy.n = strlen(zCol); ++ dummy.dyn = 0; ++ pE1a = sqliteExpr(TK_ID, 0, 0, &dummy); ++ pE2a = sqliteExpr(TK_ID, 0, 0, &dummy); ++ dummy.z = pTab1->zName; ++ dummy.n = strlen(dummy.z); ++ pE1b = sqliteExpr(TK_ID, 0, 0, &dummy); ++ dummy.z = pTab2->zName; ++ dummy.n = strlen(dummy.z); ++ pE2b = sqliteExpr(TK_ID, 0, 0, &dummy); ++ pE1c = sqliteExpr(TK_DOT, pE1b, pE1a, 0); ++ pE2c = sqliteExpr(TK_DOT, pE2b, pE2a, 0); ++ pE = sqliteExpr(TK_EQ, pE1c, pE2c, 0); ++ ExprSetProperty(pE, EP_FromJoin); ++ if( *ppExpr ){ ++ *ppExpr = sqliteExpr(TK_AND, *ppExpr, pE, 0); ++ }else{ ++ *ppExpr = pE; ++ } ++} ++ ++/* ++** Set the EP_FromJoin property on all terms of the given 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. ++*/ ++static void setJoinExpr(Expr *p){ ++ while( p ){ ++ ExprSetProperty(p, EP_FromJoin); ++ setJoinExpr(p->pLeft); ++ 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. ++** ++** This routine returns the number of errors encountered. ++*/ ++static int sqliteProcessJoin(Parse *pParse, Select *p){ ++ SrcList *pSrc; ++ int i, j; ++ pSrc = p->pSrc; ++ for(i=0; inSrc-1; i++){ ++ struct SrcList_item *pTerm = &pSrc->a[i]; ++ struct SrcList_item *pOther = &pSrc->a[i+1]; ++ ++ if( pTerm->pTab==0 || pOther->pTab==0 ) continue; ++ ++ /* When the NATURAL keyword is present, add WHERE clause terms for ++ ** every column that the two tables have in common. ++ */ ++ if( pTerm->jointype & JT_NATURAL ){ ++ Table *pTab; ++ if( pTerm->pOn || pTerm->pUsing ){ ++ sqliteErrorMsg(pParse, "a NATURAL join may not have " ++ "an ON or USING clause", 0); ++ return 1; ++ } ++ pTab = pTerm->pTab; ++ for(j=0; jnCol; j++){ ++ if( columnIndex(pOther->pTab, pTab->aCol[j].zName)>=0 ){ ++ addWhereTerm(pTab->aCol[j].zName, pTab, pOther->pTab, &p->pWhere); ++ } ++ } ++ } ++ ++ /* Disallow both ON and USING clauses in the same join ++ */ ++ if( pTerm->pOn && pTerm->pUsing ){ ++ sqliteErrorMsg(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 ++ ** and AND operator. ++ */ ++ if( pTerm->pOn ){ ++ setJoinExpr(pTerm->pOn); ++ if( p->pWhere==0 ){ ++ p->pWhere = pTerm->pOn; ++ }else{ ++ p->pWhere = sqliteExpr(TK_AND, p->pWhere, pTerm->pOn, 0); ++ } ++ pTerm->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( pTerm->pUsing ){ ++ IdList *pList; ++ int j; ++ assert( inSrc-1 ); ++ pList = pTerm->pUsing; ++ for(j=0; jnId; j++){ ++ if( columnIndex(pTerm->pTab, pList->a[j].zName)<0 || ++ columnIndex(pOther->pTab, pList->a[j].zName)<0 ){ ++ sqliteErrorMsg(pParse, "cannot join using column %s - column " ++ "not present in both tables", pList->a[j].zName); ++ return 1; ++ } ++ addWhereTerm(pList->a[j].zName, pTerm->pTab, pOther->pTab, &p->pWhere); ++ } ++ } ++ } ++ return 0; ++} ++ ++/* ++** Delete the given Select structure and all of its substructures. ++*/ ++void sqliteSelectDelete(Select *p){ ++ if( p==0 ) return; ++ sqliteExprListDelete(p->pEList); ++ sqliteSrcListDelete(p->pSrc); ++ sqliteExprDelete(p->pWhere); ++ sqliteExprListDelete(p->pGroupBy); ++ sqliteExprDelete(p->pHaving); ++ sqliteExprListDelete(p->pOrderBy); ++ sqliteSelectDelete(p->pPrior); ++ sqliteFree(p->zSelect); ++ sqliteFree(p); ++} ++ ++/* ++** Delete the aggregate information from the parse structure. ++*/ ++static void sqliteAggregateInfoReset(Parse *pParse){ ++ sqliteFree(pParse->aAgg); ++ pParse->aAgg = 0; ++ pParse->nAgg = 0; ++ pParse->useAgg = 0; ++} ++ ++/* ++** Insert code into "v" that will push the record on the top of the ++** stack into the sorter. ++*/ ++static void pushOntoSorter(Parse *pParse, Vdbe *v, ExprList *pOrderBy){ ++ char *zSortOrder; ++ int i; ++ zSortOrder = sqliteMalloc( pOrderBy->nExpr + 1 ); ++ if( zSortOrder==0 ) return; ++ for(i=0; inExpr; i++){ ++ int order = pOrderBy->a[i].sortOrder; ++ int type; ++ int c; ++ if( (order & SQLITE_SO_TYPEMASK)==SQLITE_SO_TEXT ){ ++ type = SQLITE_SO_TEXT; ++ }else if( (order & SQLITE_SO_TYPEMASK)==SQLITE_SO_NUM ){ ++ type = SQLITE_SO_NUM; ++ }else if( pParse->db->file_format>=4 ){ ++ type = sqliteExprType(pOrderBy->a[i].pExpr); ++ }else{ ++ type = SQLITE_SO_NUM; ++ } ++ if( (order & SQLITE_SO_DIRMASK)==SQLITE_SO_ASC ){ ++ c = type==SQLITE_SO_TEXT ? 'A' : '+'; ++ }else{ ++ c = type==SQLITE_SO_TEXT ? 'D' : '-'; ++ } ++ zSortOrder[i] = c; ++ sqliteExprCode(pParse, pOrderBy->a[i].pExpr); ++ } ++ zSortOrder[pOrderBy->nExpr] = 0; ++ sqliteVdbeOp3(v, OP_SortMakeKey, pOrderBy->nExpr, 0, zSortOrder, P3_DYNAMIC); ++ sqliteVdbeAddOp(v, OP_SortPut, 0, 0); ++} ++ ++/* ++** This routine adds a P3 argument to the last VDBE opcode that was ++** inserted. The P3 argument added is a string suitable for the ++** OP_MakeKey or OP_MakeIdxKey opcodes. The string consists of ++** characters 't' or 'n' depending on whether or not the various ++** fields of the key to be generated should be treated as numeric ++** or as text. See the OP_MakeKey and OP_MakeIdxKey opcode ++** documentation for additional information about the P3 string. ++** See also the sqliteAddIdxKeyType() routine. ++*/ ++void sqliteAddKeyType(Vdbe *v, ExprList *pEList){ ++ int nColumn = pEList->nExpr; ++ char *zType = sqliteMalloc( nColumn+1 ); ++ int i; ++ if( zType==0 ) return; ++ for(i=0; ia[i].pExpr)==SQLITE_SO_NUM ? 'n' : 't'; ++ } ++ zType[i] = 0; ++ sqliteVdbeChangeP3(v, -1, zType, P3_DYNAMIC); ++} ++ ++/* ++** Add code to implement the OFFSET and LIMIT ++*/ ++static void codeLimiter( ++ Vdbe *v, /* Generate code into this VM */ ++ Select *p, /* The SELECT statement being coded */ ++ int iContinue, /* Jump here to skip the current record */ ++ int iBreak, /* Jump here to end the loop */ ++ int nPop /* Number of times to pop stack when jumping */ ++){ ++ if( p->iOffset>=0 ){ ++ int addr = sqliteVdbeCurrentAddr(v) + 2; ++ if( nPop>0 ) addr++; ++ sqliteVdbeAddOp(v, OP_MemIncr, p->iOffset, addr); ++ if( nPop>0 ){ ++ sqliteVdbeAddOp(v, OP_Pop, nPop, 0); ++ } ++ sqliteVdbeAddOp(v, OP_Goto, 0, iContinue); ++ } ++ if( p->iLimit>=0 ){ ++ sqliteVdbeAddOp(v, OP_MemIncr, p->iLimit, iBreak); ++ } ++} ++ ++/* ++** This routine generates the code for the inside of the inner loop ++** of a SELECT. ++** ++** If srcTab and nColumn are both zero, then the pEList expressions ++** are evaluated in order to get the data for this row. If nColumn>0 ++** then data is pulled from srcTab and pEList is used only to get the ++** datatypes for each column. ++*/ ++static int 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 */ ++ int nColumn, /* Number of columns in the source table */ ++ ExprList *pOrderBy, /* If not NULL, sort results using this key */ ++ int distinct, /* If >=0, make sure results are distinct */ ++ int eDest, /* How to dispose of the results */ ++ int iParm, /* An argument to the disposal method */ ++ 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 */ ++ ++ if( v==0 ) return 0; ++ assert( pEList!=0 ); ++ ++ /* If there was a LIMIT clause on the SELECT statement, then do the check ++ ** to see if this row should be output. ++ */ ++ hasDistinct = distinct>=0 && pEList && pEList->nExpr>0; ++ if( pOrderBy==0 && !hasDistinct ){ ++ codeLimiter(v, p, iContinue, iBreak, 0); ++ } ++ ++ /* Pull the requested columns. ++ */ ++ if( nColumn>0 ){ ++ for(i=0; inExpr; ++ for(i=0; inExpr; i++){ ++ sqliteExprCode(pParse, pEList->a[i].pExpr); ++ } ++ } ++ ++ /* 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 ){ ++#if NULL_ALWAYS_DISTINCT ++ sqliteVdbeAddOp(v, OP_IsNull, -pEList->nExpr, sqliteVdbeCurrentAddr(v)+7); ++#endif ++ sqliteVdbeAddOp(v, OP_MakeKey, pEList->nExpr, 1); ++ if( pParse->db->file_format>=4 ) sqliteAddKeyType(v, pEList); ++ sqliteVdbeAddOp(v, OP_Distinct, distinct, sqliteVdbeCurrentAddr(v)+3); ++ sqliteVdbeAddOp(v, OP_Pop, pEList->nExpr+1, 0); ++ sqliteVdbeAddOp(v, OP_Goto, 0, iContinue); ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ sqliteVdbeAddOp(v, OP_PutStrKey, distinct, 0); ++ if( pOrderBy==0 ){ ++ codeLimiter(v, p, iContinue, iBreak, nColumn); ++ } ++ } ++ ++ switch( eDest ){ ++ /* In this mode, write each query result to the key of the temporary ++ ** table iParm. ++ */ ++ case SRT_Union: { ++ sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, NULL_ALWAYS_DISTINCT); ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ sqliteVdbeAddOp(v, OP_PutStrKey, iParm, 0); ++ break; ++ } ++ ++ /* Store the result as data using a unique key. ++ */ ++ case SRT_Table: ++ case SRT_TempTable: { ++ sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, 0); ++ if( pOrderBy ){ ++ pushOntoSorter(pParse, v, pOrderBy); ++ }else{ ++ sqliteVdbeAddOp(v, OP_NewRecno, iParm, 0); ++ sqliteVdbeAddOp(v, OP_Pull, 1, 0); ++ sqliteVdbeAddOp(v, OP_PutIntKey, iParm, 0); ++ } ++ 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: { ++ int addr; ++ addr = sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, NULL_ALWAYS_DISTINCT); ++ sqliteVdbeAddOp(v, OP_NotFound, iParm, addr+3); ++ sqliteVdbeAddOp(v, OP_Delete, iParm, 0); ++ break; ++ } ++ ++ /* 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 addr1 = sqliteVdbeCurrentAddr(v); ++ int addr2; ++ assert( nColumn==1 ); ++ sqliteVdbeAddOp(v, OP_NotNull, -1, addr1+3); ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ addr2 = sqliteVdbeAddOp(v, OP_Goto, 0, 0); ++ if( pOrderBy ){ ++ pushOntoSorter(pParse, v, pOrderBy); ++ }else{ ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ sqliteVdbeAddOp(v, OP_PutStrKey, iParm, 0); ++ } ++ sqliteVdbeChangeP2(v, addr2, sqliteVdbeCurrentAddr(v)); ++ 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( nColumn==1 ); ++ if( pOrderBy ){ ++ pushOntoSorter(pParse, v, pOrderBy); ++ }else{ ++ sqliteVdbeAddOp(v, OP_MemStore, iParm, 1); ++ sqliteVdbeAddOp(v, OP_Goto, 0, iBreak); ++ } ++ break; ++ } ++ ++ /* Send the data to the callback function. ++ */ ++ case SRT_Callback: ++ case SRT_Sorter: { ++ if( pOrderBy ){ ++ sqliteVdbeAddOp(v, OP_SortMakeRec, nColumn, 0); ++ pushOntoSorter(pParse, v, pOrderBy); ++ }else{ ++ assert( eDest==SRT_Callback ); ++ sqliteVdbeAddOp(v, OP_Callback, nColumn, 0); ++ } ++ break; ++ } ++ ++ /* Invoke a subroutine to handle the results. The subroutine itself ++ ** is responsible for popping the results off of the stack. ++ */ ++ case SRT_Subroutine: { ++ if( pOrderBy ){ ++ sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, 0); ++ pushOntoSorter(pParse, v, pOrderBy); ++ }else{ ++ sqliteVdbeAddOp(v, OP_Gosub, 0, iParm); ++ } ++ break; ++ } ++ ++ /* 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 ); ++ sqliteVdbeAddOp(v, OP_Pop, nColumn, 0); ++ break; ++ } ++ } ++ return 0; ++} ++ ++/* ++** 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( ++ Select *p, /* The SELECT statement */ ++ Vdbe *v, /* Generate code into this VDBE */ ++ int nColumn, /* Number of columns of data */ ++ int eDest, /* Write the sorted results here */ ++ int iParm /* Optional parameter associated with eDest */ ++){ ++ int end1 = sqliteVdbeMakeLabel(v); ++ int end2 = sqliteVdbeMakeLabel(v); ++ int addr; ++ if( eDest==SRT_Sorter ) return; ++ sqliteVdbeAddOp(v, OP_Sort, 0, 0); ++ addr = sqliteVdbeAddOp(v, OP_SortNext, 0, end1); ++ codeLimiter(v, p, addr, end2, 1); ++ switch( eDest ){ ++ case SRT_Callback: { ++ sqliteVdbeAddOp(v, OP_SortCallback, nColumn, 0); ++ break; ++ } ++ case SRT_Table: ++ case SRT_TempTable: { ++ sqliteVdbeAddOp(v, OP_NewRecno, iParm, 0); ++ sqliteVdbeAddOp(v, OP_Pull, 1, 0); ++ sqliteVdbeAddOp(v, OP_PutIntKey, iParm, 0); ++ break; ++ } ++ case SRT_Set: { ++ assert( nColumn==1 ); ++ sqliteVdbeAddOp(v, OP_NotNull, -1, sqliteVdbeCurrentAddr(v)+3); ++ sqliteVdbeAddOp(v, OP_Pop, 1, 0); ++ sqliteVdbeAddOp(v, OP_Goto, 0, sqliteVdbeCurrentAddr(v)+3); ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ sqliteVdbeAddOp(v, OP_PutStrKey, iParm, 0); ++ break; ++ } ++ case SRT_Mem: { ++ assert( nColumn==1 ); ++ sqliteVdbeAddOp(v, OP_MemStore, iParm, 1); ++ sqliteVdbeAddOp(v, OP_Goto, 0, end1); ++ break; ++ } ++ case SRT_Subroutine: { ++ int i; ++ for(i=0; ipVdbe; ++ int i, j; ++ for(i=0; inExpr; i++){ ++ Expr *p = pEList->a[i].pExpr; ++ char *zType = 0; ++ if( p==0 ) continue; ++ if( p->op==TK_COLUMN && pTabList ){ ++ Table *pTab; ++ int iCol = p->iColumn; ++ for(j=0; jnSrc && pTabList->a[j].iCursor!=p->iTable; j++){} ++ assert( jnSrc ); ++ pTab = pTabList->a[j].pTab; ++ if( iCol<0 ) iCol = pTab->iPKey; ++ assert( iCol==-1 || (iCol>=0 && iColnCol) ); ++ if( iCol<0 ){ ++ zType = "INTEGER"; ++ }else{ ++ zType = pTab->aCol[iCol].zType; ++ } ++ }else{ ++ if( sqliteExprType(p)==SQLITE_SO_TEXT ){ ++ zType = "TEXT"; ++ }else{ ++ zType = "NUMERIC"; ++ } ++ } ++ sqliteVdbeOp3(v, OP_ColumnName, i + pEList->nExpr, 0, zType, 0); ++ } ++} ++ ++/* ++** 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; ++ sqlite *db = pParse->db; ++ int fullNames, shortNames; ++ ++ assert( v!=0 ); ++ if( pParse->colNamesSet || v==0 || sqlite_malloc_failed ) return; ++ pParse->colNamesSet = 1; ++ fullNames = (db->flags & SQLITE_FullColNames)!=0; ++ shortNames = (db->flags & SQLITE_ShortColNames)!=0; ++ for(i=0; inExpr; i++){ ++ Expr *p; ++ int p2 = i==pEList->nExpr-1; ++ p = pEList->a[i].pExpr; ++ if( p==0 ) continue; ++ if( pEList->a[i].zName ){ ++ char *zName = pEList->a[i].zName; ++ sqliteVdbeOp3(v, OP_ColumnName, i, p2, zName, 0); ++ continue; ++ } ++ if( p->op==TK_COLUMN && pTabList ){ ++ Table *pTab; ++ char *zCol; ++ int iCol = p->iColumn; ++ for(j=0; jnSrc && pTabList->a[j].iCursor!=p->iTable; j++){} ++ 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 && p->span.z && p->span.z[0] ){ ++ int addr = sqliteVdbeOp3(v,OP_ColumnName, i, p2, p->span.z, p->span.n); ++ sqliteVdbeCompressSpace(v, addr); ++ }else if( fullNames || (!shortNames && pTabList->nSrc>1) ){ ++ char *zName = 0; ++ char *zTab; ++ ++ zTab = pTabList->a[j].zAlias; ++ if( fullNames || zTab==0 ) zTab = pTab->zName; ++ sqliteSetString(&zName, zTab, ".", zCol, 0); ++ sqliteVdbeOp3(v, OP_ColumnName, i, p2, zName, P3_DYNAMIC); ++ }else{ ++ sqliteVdbeOp3(v, OP_ColumnName, i, p2, zCol, 0); ++ } ++ }else if( p->span.z && p->span.z[0] ){ ++ int addr = sqliteVdbeOp3(v,OP_ColumnName, i, p2, p->span.z, p->span.n); ++ sqliteVdbeCompressSpace(v, addr); ++ }else{ ++ char zName[30]; ++ assert( p->op!=TK_COLUMN || pTabList==0 ); ++ sprintf(zName, "column%d", i+1); ++ sqliteVdbeOp3(v, OP_ColumnName, i, p2, zName, 0); ++ } ++ } ++} ++ ++/* ++** 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; ++} ++ ++/* ++** Forward declaration ++*/ ++static int fillInColumnList(Parse*, Select*); ++ ++/* ++** Given a SELECT statement, generate a Table structure that describes ++** the result set of that SELECT. ++*/ ++Table *sqliteResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){ ++ Table *pTab; ++ int i, j; ++ ExprList *pEList; ++ Column *aCol; ++ ++ if( fillInColumnList(pParse, pSelect) ){ ++ return 0; ++ } ++ pTab = sqliteMalloc( sizeof(Table) ); ++ if( pTab==0 ){ ++ return 0; ++ } ++ pTab->zName = zTabName ? sqliteStrDup(zTabName) : 0; ++ pEList = pSelect->pEList; ++ pTab->nCol = pEList->nExpr; ++ assert( pTab->nCol>0 ); ++ pTab->aCol = aCol = sqliteMalloc( sizeof(pTab->aCol[0])*pTab->nCol ); ++ for(i=0; inCol; i++){ ++ Expr *p, *pR; ++ if( pEList->a[i].zName ){ ++ aCol[i].zName = sqliteStrDup(pEList->a[i].zName); ++ }else if( (p=pEList->a[i].pExpr)->op==TK_DOT ++ && (pR=p->pRight)!=0 && pR->token.z && pR->token.z[0] ){ ++ int cnt; ++ sqliteSetNString(&aCol[i].zName, pR->token.z, pR->token.n, 0); ++ for(j=cnt=0; jtoken.z, pR->token.n, zBuf, n,0); ++ j = -1; ++ } ++ } ++ }else if( p->span.z && p->span.z[0] ){ ++ sqliteSetNString(&pTab->aCol[i].zName, p->span.z, p->span.n, 0); ++ }else{ ++ char zBuf[30]; ++ sprintf(zBuf, "column%d", i+1); ++ aCol[i].zName = sqliteStrDup(zBuf); ++ } ++ sqliteDequote(aCol[i].zName); ++ } ++ pTab->iPKey = -1; ++ return pTab; ++} ++ ++/* ++** For the given SELECT statement, do three things. ++** ++** (1) Fill in the pTabList->a[].pTab fields in the SrcList that ++** defines the set of tables that should be scanned. For views, ++** 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 presistent representation ++** of the view. ++** ++** (2) Add terms to the WHERE clause to accomodate the NATURAL keyword ++** on joins and the ON and USING clause of joins. ++** ++** (3) 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. ++** ++** Return 0 on success. If there are problems, leave an error message ++** in pParse and return non-zero. ++*/ ++static int fillInColumnList(Parse *pParse, Select *p){ ++ int i, j, k, rc; ++ SrcList *pTabList; ++ ExprList *pEList; ++ Table *pTab; ++ ++ if( p==0 || p->pSrc==0 ) return 1; ++ pTabList = p->pSrc; ++ pEList = p->pEList; ++ ++ /* Look up every table in the table list. ++ */ ++ for(i=0; inSrc; i++){ ++ if( pTabList->a[i].pTab ){ ++ /* This routine has run before! No need to continue */ ++ return 0; ++ } ++ if( pTabList->a[i].zName==0 ){ ++ /* A sub-query in the FROM clause of a SELECT */ ++ assert( pTabList->a[i].pSelect!=0 ); ++ if( pTabList->a[i].zAlias==0 ){ ++ char zFakeName[60]; ++ sprintf(zFakeName, "sqlite_subquery_%p_", ++ (void*)pTabList->a[i].pSelect); ++ sqliteSetString(&pTabList->a[i].zAlias, zFakeName, 0); ++ } ++ pTabList->a[i].pTab = pTab = ++ sqliteResultSetOfSelect(pParse, pTabList->a[i].zAlias, ++ pTabList->a[i].pSelect); ++ if( pTab==0 ){ ++ return 1; ++ } ++ /* The isTransient flag indicates that the Table structure has been ++ ** dynamically allocated and may be freed at any time. In other words, ++ ** pTab is not pointing to a persistent table structure that defines ++ ** part of the schema. */ ++ pTab->isTransient = 1; ++ }else{ ++ /* An ordinary table or view name in the FROM clause */ ++ pTabList->a[i].pTab = pTab = ++ sqliteLocateTable(pParse,pTabList->a[i].zName,pTabList->a[i].zDatabase); ++ if( pTab==0 ){ ++ return 1; ++ } ++ if( pTab->pSelect ){ ++ /* We reach here if the named table is a really a view */ ++ if( sqliteViewGetColumnNames(pParse, pTab) ){ ++ return 1; ++ } ++ /* If pTabList->a[i].pSelect!=0 it means we are dealing with a ++ ** view within a view. The SELECT structure has already been ++ ** copied by the outer view so we can skip the copy step here ++ ** in the inner view. ++ */ ++ if( pTabList->a[i].pSelect==0 ){ ++ pTabList->a[i].pSelect = sqliteSelectDup(pTab->pSelect); ++ } ++ } ++ } ++ } ++ ++ /* Process NATURAL keywords, and ON and USING clauses of joins. ++ */ ++ if( sqliteProcessJoin(pParse, p) ) return 1; ++ ++ /* 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++){ ++ Expr *pE = pEList->a[k].pExpr; ++ if( pE->op==TK_ALL ) break; ++ if( pE->op==TK_DOT && pE->pRight && pE->pRight->op==TK_ALL ++ && pE->pLeft && pE->pLeft->op==TK_ID ) break; ++ } ++ rc = 0; ++ 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; ++ for(k=0; knExpr; k++){ ++ Expr *pE = a[k].pExpr; ++ if( pE->op!=TK_ALL && ++ (pE->op!=TK_DOT || pE->pRight==0 || pE->pRight->op!=TK_ALL) ){ ++ /* This particular expression does not need to be expanded. ++ */ ++ pNew = sqliteExprListAppend(pNew, a[k].pExpr, 0); ++ pNew->a[pNew->nExpr-1].zName = a[k].zName; ++ a[k].pExpr = 0; ++ a[k].zName = 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; /* text of name of TABLE */ ++ if( pE->op==TK_DOT && pE->pLeft ){ ++ zTName = sqliteTableNameFromToken(&pE->pLeft->token); ++ }else{ ++ zTName = 0; ++ } ++ for(i=0; inSrc; i++){ ++ Table *pTab = pTabList->a[i].pTab; ++ char *zTabName = pTabList->a[i].zAlias; ++ if( zTabName==0 || zTabName[0]==0 ){ ++ zTabName = pTab->zName; ++ } ++ if( zTName && (zTabName==0 || zTabName[0]==0 || ++ sqliteStrICmp(zTName, zTabName)!=0) ){ ++ continue; ++ } ++ tableSeen = 1; ++ for(j=0; jnCol; j++){ ++ Expr *pExpr, *pLeft, *pRight; ++ char *zName = pTab->aCol[j].zName; ++ ++ if( i>0 && (pTabList->a[i-1].jointype & JT_NATURAL)!=0 && ++ columnIndex(pTabList->a[i-1].pTab, zName)>=0 ){ ++ /* In a NATURAL join, omit the join columns from the ++ ** table on the right */ ++ continue; ++ } ++ if( i>0 && sqliteIdListIndex(pTabList->a[i-1].pUsing, zName)>=0 ){ ++ /* In a join with a USING clause, omit columns in the ++ ** using clause from the table on the right. */ ++ continue; ++ } ++ pRight = sqliteExpr(TK_ID, 0, 0, 0); ++ if( pRight==0 ) break; ++ pRight->token.z = zName; ++ pRight->token.n = strlen(zName); ++ pRight->token.dyn = 0; ++ if( zTabName && pTabList->nSrc>1 ){ ++ pLeft = sqliteExpr(TK_ID, 0, 0, 0); ++ pExpr = sqliteExpr(TK_DOT, pLeft, pRight, 0); ++ if( pExpr==0 ) break; ++ pLeft->token.z = zTabName; ++ pLeft->token.n = strlen(zTabName); ++ pLeft->token.dyn = 0; ++ sqliteSetString((char**)&pExpr->span.z, zTabName, ".", zName, 0); ++ pExpr->span.n = strlen(pExpr->span.z); ++ pExpr->span.dyn = 1; ++ pExpr->token.z = 0; ++ pExpr->token.n = 0; ++ pExpr->token.dyn = 0; ++ }else{ ++ pExpr = pRight; ++ pExpr->span = pExpr->token; ++ } ++ pNew = sqliteExprListAppend(pNew, pExpr, 0); ++ } ++ } ++ if( !tableSeen ){ ++ if( zTName ){ ++ sqliteErrorMsg(pParse, "no such table: %s", zTName); ++ }else{ ++ sqliteErrorMsg(pParse, "no tables specified"); ++ } ++ rc = 1; ++ } ++ sqliteFree(zTName); ++ } ++ } ++ sqliteExprListDelete(pEList); ++ p->pEList = pNew; ++ } ++ return rc; ++} ++ ++/* ++** This routine recursively unlinks the Select.pSrc.a[].pTab pointers ++** in a select structure. It just sets the pointers to NULL. This ++** routine is recursive in the sense that if the Select.pSrc.a[].pSelect ++** pointer is not NULL, this routine is called recursively on that pointer. ++** ++** This routine is called on the Select structure that defines a ++** VIEW in order to undo any bindings to tables. This is necessary ++** because those tables might be DROPed by a subsequent SQL command. ++** If the bindings are not removed, then the Select.pSrc->a[].pTab field ++** will be left pointing to a deallocated Table structure after the ++** DROP and a coredump will occur the next time the VIEW is used. ++*/ ++void sqliteSelectUnbind(Select *p){ ++ int i; ++ SrcList *pSrc = p->pSrc; ++ Table *pTab; ++ if( p==0 ) return; ++ for(i=0; inSrc; i++){ ++ if( (pTab = pSrc->a[i].pTab)!=0 ){ ++ if( pTab->isTransient ){ ++ sqliteDeleteTable(0, pTab); ++ } ++ pSrc->a[i].pTab = 0; ++ if( pSrc->a[i].pSelect ){ ++ sqliteSelectUnbind(pSrc->a[i].pSelect); ++ } ++ } ++ } ++} ++ ++/* ++** This routine associates entries in an ORDER BY expression list with ++** columns in a result. For each ORDER BY expression, the opcode of ++** the top-level node is changed to TK_COLUMN and the iColumn value of ++** the top-level node is filled in with column number and the iTable ++** value of the top-level node is filled with iTable parameter. ++** ++** If there are prior SELECT clauses, they are processed first. A match ++** in an earlier SELECT takes precedence over a later SELECT. ++** ++** Any entry that does not match is flagged as an error. The number ++** of errors is returned. ++** ++** This routine does NOT correctly initialize the Expr.dataType field ++** of the ORDER BY expressions. The multiSelectSortOrder() routine ++** must be called to do that after the individual select statements ++** have all been analyzed. This routine is unable to compute Expr.dataType ++** because it must be called before the individual select statements ++** have been analyzed. ++*/ ++static int matchOrderbyToColumn( ++ Parse *pParse, /* A place to leave error messages */ ++ Select *pSelect, /* Match to result columns of this SELECT */ ++ ExprList *pOrderBy, /* The ORDER BY values to match against columns */ ++ int iTable, /* Insert this value in iTable */ ++ int mustComplete /* If TRUE all ORDER BYs must match */ ++){ ++ int nErr = 0; ++ int i, j; ++ ExprList *pEList; ++ ++ if( pSelect==0 || pOrderBy==0 ) return 1; ++ if( mustComplete ){ ++ for(i=0; inExpr; i++){ pOrderBy->a[i].done = 0; } ++ } ++ if( fillInColumnList(pParse, pSelect) ){ ++ return 1; ++ } ++ if( pSelect->pPrior ){ ++ if( matchOrderbyToColumn(pParse, pSelect->pPrior, pOrderBy, iTable, 0) ){ ++ return 1; ++ } ++ } ++ pEList = pSelect->pEList; ++ for(i=0; inExpr; i++){ ++ Expr *pE = pOrderBy->a[i].pExpr; ++ int iCol = -1; ++ if( pOrderBy->a[i].done ) continue; ++ if( sqliteExprIsInteger(pE, &iCol) ){ ++ if( iCol<=0 || iCol>pEList->nExpr ){ ++ sqliteErrorMsg(pParse, ++ "ORDER BY position %d should be between 1 and %d", ++ iCol, pEList->nExpr); ++ nErr++; ++ break; ++ } ++ if( !mustComplete ) continue; ++ iCol--; ++ } ++ for(j=0; iCol<0 && jnExpr; j++){ ++ if( pEList->a[j].zName && (pE->op==TK_ID || pE->op==TK_STRING) ){ ++ char *zName, *zLabel; ++ zName = pEList->a[j].zName; ++ assert( pE->token.z ); ++ zLabel = sqliteStrNDup(pE->token.z, pE->token.n); ++ sqliteDequote(zLabel); ++ if( sqliteStrICmp(zName, zLabel)==0 ){ ++ iCol = j; ++ } ++ sqliteFree(zLabel); ++ } ++ if( iCol<0 && sqliteExprCompare(pE, pEList->a[j].pExpr) ){ ++ iCol = j; ++ } ++ } ++ if( iCol>=0 ){ ++ pE->op = TK_COLUMN; ++ pE->iColumn = iCol; ++ pE->iTable = iTable; ++ pOrderBy->a[i].done = 1; ++ } ++ if( iCol<0 && mustComplete ){ ++ sqliteErrorMsg(pParse, ++ "ORDER BY term number %d does not match any result column", i+1); ++ nErr++; ++ break; ++ } ++ } ++ return nErr; ++} ++ ++/* ++** 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. ++*/ ++Vdbe *sqliteGetVdbe(Parse *pParse){ ++ Vdbe *v = pParse->pVdbe; ++ if( v==0 ){ ++ v = pParse->pVdbe = sqliteVdbeCreate(pParse->db); ++ } ++ return v; ++} ++ ++/* ++** This routine sets the Expr.dataType field on all elements of ++** the pOrderBy expression list. The pOrderBy list will have been ++** set up by matchOrderbyToColumn(). Hence each expression has ++** a TK_COLUMN as its root node. The Expr.iColumn refers to a ++** column in the result set. The datatype is set to SQLITE_SO_TEXT ++** if the corresponding column in p and every SELECT to the left of ++** p has a datatype of SQLITE_SO_TEXT. If the cooressponding column ++** in p or any of the left SELECTs is SQLITE_SO_NUM, then the datatype ++** of the order-by expression is set to SQLITE_SO_NUM. ++** ++** Examples: ++** ++** CREATE TABLE one(a INTEGER, b TEXT); ++** CREATE TABLE two(c VARCHAR(5), d FLOAT); ++** ++** SELECT b, b FROM one UNION SELECT d, c FROM two ORDER BY 1, 2; ++** ++** The primary sort key will use SQLITE_SO_NUM because the "d" in ++** the second SELECT is numeric. The 1st column of the first SELECT ++** is text but that does not matter because a numeric always overrides ++** a text. ++** ++** The secondary key will use the SQLITE_SO_TEXT sort order because ++** both the (second) "b" in the first SELECT and the "c" in the second ++** SELECT have a datatype of text. ++*/ ++static void multiSelectSortOrder(Select *p, ExprList *pOrderBy){ ++ int i; ++ ExprList *pEList; ++ if( pOrderBy==0 ) return; ++ if( p==0 ){ ++ for(i=0; inExpr; i++){ ++ pOrderBy->a[i].pExpr->dataType = SQLITE_SO_TEXT; ++ } ++ return; ++ } ++ multiSelectSortOrder(p->pPrior, pOrderBy); ++ pEList = p->pEList; ++ for(i=0; inExpr; i++){ ++ Expr *pE = pOrderBy->a[i].pExpr; ++ if( pE->dataType==SQLITE_SO_NUM ) continue; ++ assert( pE->iColumn>=0 ); ++ if( pEList->nExpr>pE->iColumn ){ ++ pE->dataType = sqliteExprType(pEList->a[pE->iColumn].pExpr); ++ } ++ } ++} ++ ++/* ++** Compute the iLimit and iOffset fields of the SELECT based on the ++** nLimit and nOffset fields. nLimit and nOffset hold the integers ++** that appear in the original SQL statement after the LIMIT and OFFSET ++** keywords. Or that hold -1 and 0 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 if iLimit and iOffset only if ++** a limit or offset is defined by nLimit and nOffset. iLimit and ++** iOffset should have been preset to appropriate default values ++** (usually but not always -1) prior to calling this routine. ++** Only if nLimit>=0 or nOffset>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){ ++ /* ++ ** If the comparison is p->nLimit>0 then "LIMIT 0" shows ++ ** all rows. It is the same as no limit. If the comparision is ++ ** p->nLimit>=0 then "LIMIT 0" show no rows at all. ++ ** "LIMIT -1" always shows all rows. There is some ++ ** contraversy about what the correct behavior should be. ++ ** The current implementation interprets "LIMIT 0" to mean ++ ** no rows. ++ */ ++ if( p->nLimit>=0 ){ ++ int iMem = pParse->nMem++; ++ Vdbe *v = sqliteGetVdbe(pParse); ++ if( v==0 ) return; ++ sqliteVdbeAddOp(v, OP_Integer, -p->nLimit, 0); ++ sqliteVdbeAddOp(v, OP_MemStore, iMem, 1); ++ p->iLimit = iMem; ++ } ++ if( p->nOffset>0 ){ ++ int iMem = pParse->nMem++; ++ Vdbe *v = sqliteGetVdbe(pParse); ++ if( v==0 ) return; ++ sqliteVdbeAddOp(v, OP_Integer, -p->nOffset, 0); ++ sqliteVdbeAddOp(v, OP_MemStore, iMem, 1); ++ p->iOffset = iMem; ++ } ++} ++ ++/* ++** This routine is called to process a query that is really the union ++** or intersection of two or more separate queries. ++** ++** "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, Select *p, int eDest, int iParm){ ++ int rc; /* Success code from a subroutine */ ++ Select *pPrior; /* Another SELECT immediately to our left */ ++ Vdbe *v; /* Generate code to this VDBE */ ++ ++ /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only ++ ** the last SELECT in the series may have an ORDER BY or LIMIT. ++ */ ++ if( p==0 || p->pPrior==0 ) return 1; ++ pPrior = p->pPrior; ++ if( pPrior->pOrderBy ){ ++ sqliteErrorMsg(pParse,"ORDER BY clause should come after %s not before", ++ selectOpName(p->op)); ++ return 1; ++ } ++ if( pPrior->nLimit>=0 || pPrior->nOffset>0 ){ ++ sqliteErrorMsg(pParse,"LIMIT clause should come after %s not before", ++ selectOpName(p->op)); ++ return 1; ++ } ++ ++ /* Make sure we have a valid query engine. If not, create a new one. ++ */ ++ v = sqliteGetVdbe(pParse); ++ if( v==0 ) return 1; ++ ++ /* Create the destination temporary table if necessary ++ */ ++ if( eDest==SRT_TempTable ){ ++ sqliteVdbeAddOp(v, OP_OpenTemp, iParm, 0); ++ eDest = SRT_Table; ++ } ++ ++ /* Generate code for the left and right SELECT statements. ++ */ ++ switch( p->op ){ ++ case TK_ALL: { ++ if( p->pOrderBy==0 ){ ++ pPrior->nLimit = p->nLimit; ++ pPrior->nOffset = p->nOffset; ++ rc = sqliteSelect(pParse, pPrior, eDest, iParm, 0, 0, 0); ++ if( rc ) return rc; ++ p->pPrior = 0; ++ p->iLimit = pPrior->iLimit; ++ p->iOffset = pPrior->iOffset; ++ p->nLimit = -1; ++ p->nOffset = 0; ++ rc = sqliteSelect(pParse, p, eDest, iParm, 0, 0, 0); ++ p->pPrior = pPrior; ++ if( rc ) return rc; ++ break; ++ } ++ /* For UNION ALL ... ORDER BY fall through to the next case */ ++ } ++ case TK_EXCEPT: ++ case TK_UNION: { ++ int unionTab; /* Cursor number of the temporary table holding result */ ++ int op; /* One of the SRT_ operations to apply to self */ ++ int priorOp; /* The SRT_ operation to apply to prior selects */ ++ int nLimit, nOffset; /* Saved values of p->nLimit and p->nOffset */ ++ ExprList *pOrderBy; /* The ORDER BY clause for the right SELECT */ ++ ++ priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union; ++ if( eDest==priorOp && p->pOrderBy==0 && p->nLimit<0 && p->nOffset==0 ){ ++ /* We can reuse a temporary table generated by a SELECT to our ++ ** right. ++ */ ++ unionTab = iParm; ++ }else{ ++ /* We will need to create our own temporary table to hold the ++ ** intermediate results. ++ */ ++ unionTab = pParse->nTab++; ++ if( p->pOrderBy ++ && matchOrderbyToColumn(pParse, p, p->pOrderBy, unionTab, 1) ){ ++ return 1; ++ } ++ if( p->op!=TK_ALL ){ ++ sqliteVdbeAddOp(v, OP_OpenTemp, unionTab, 1); ++ sqliteVdbeAddOp(v, OP_KeyAsData, unionTab, 1); ++ }else{ ++ sqliteVdbeAddOp(v, OP_OpenTemp, unionTab, 0); ++ } ++ } ++ ++ /* Code the SELECT statements to our left ++ */ ++ rc = sqliteSelect(pParse, pPrior, priorOp, unionTab, 0, 0, 0); ++ if( rc ) return rc; ++ ++ /* Code the current SELECT statement ++ */ ++ switch( p->op ){ ++ case TK_EXCEPT: op = SRT_Except; break; ++ case TK_UNION: op = SRT_Union; break; ++ case TK_ALL: op = SRT_Table; break; ++ } ++ p->pPrior = 0; ++ pOrderBy = p->pOrderBy; ++ p->pOrderBy = 0; ++ nLimit = p->nLimit; ++ p->nLimit = -1; ++ nOffset = p->nOffset; ++ p->nOffset = 0; ++ rc = sqliteSelect(pParse, p, op, unionTab, 0, 0, 0); ++ p->pPrior = pPrior; ++ p->pOrderBy = pOrderBy; ++ p->nLimit = nLimit; ++ p->nOffset = nOffset; ++ if( rc ) return rc; ++ ++ /* Convert the data in the temporary table into whatever form ++ ** it is that we currently need. ++ */ ++ if( eDest!=priorOp || unionTab!=iParm ){ ++ int iCont, iBreak, iStart; ++ assert( p->pEList ); ++ if( eDest==SRT_Callback ){ ++ generateColumnNames(pParse, 0, p->pEList); ++ generateColumnTypes(pParse, p->pSrc, p->pEList); ++ } ++ iBreak = sqliteVdbeMakeLabel(v); ++ iCont = sqliteVdbeMakeLabel(v); ++ sqliteVdbeAddOp(v, OP_Rewind, unionTab, iBreak); ++ computeLimitRegisters(pParse, p); ++ iStart = sqliteVdbeCurrentAddr(v); ++ multiSelectSortOrder(p, p->pOrderBy); ++ rc = selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr, ++ p->pOrderBy, -1, eDest, iParm, ++ iCont, iBreak); ++ if( rc ) return 1; ++ sqliteVdbeResolveLabel(v, iCont); ++ sqliteVdbeAddOp(v, OP_Next, unionTab, iStart); ++ sqliteVdbeResolveLabel(v, iBreak); ++ sqliteVdbeAddOp(v, OP_Close, unionTab, 0); ++ if( p->pOrderBy ){ ++ generateSortTail(p, v, p->pEList->nExpr, eDest, iParm); ++ } ++ } ++ break; ++ } ++ case TK_INTERSECT: { ++ int tab1, tab2; ++ int iCont, iBreak, iStart; ++ int nLimit, nOffset; ++ ++ /* 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++; ++ if( p->pOrderBy && matchOrderbyToColumn(pParse,p,p->pOrderBy,tab1,1) ){ ++ return 1; ++ } ++ sqliteVdbeAddOp(v, OP_OpenTemp, tab1, 1); ++ sqliteVdbeAddOp(v, OP_KeyAsData, tab1, 1); ++ ++ /* Code the SELECTs to our left into temporary table "tab1". ++ */ ++ rc = sqliteSelect(pParse, pPrior, SRT_Union, tab1, 0, 0, 0); ++ if( rc ) return rc; ++ ++ /* Code the current SELECT into temporary table "tab2" ++ */ ++ sqliteVdbeAddOp(v, OP_OpenTemp, tab2, 1); ++ sqliteVdbeAddOp(v, OP_KeyAsData, tab2, 1); ++ p->pPrior = 0; ++ nLimit = p->nLimit; ++ p->nLimit = -1; ++ nOffset = p->nOffset; ++ p->nOffset = 0; ++ rc = sqliteSelect(pParse, p, SRT_Union, tab2, 0, 0, 0); ++ p->pPrior = pPrior; ++ p->nLimit = nLimit; ++ p->nOffset = nOffset; ++ if( rc ) return rc; ++ ++ /* Generate code to take the intersection of the two temporary ++ ** tables. ++ */ ++ assert( p->pEList ); ++ if( eDest==SRT_Callback ){ ++ generateColumnNames(pParse, 0, p->pEList); ++ generateColumnTypes(pParse, p->pSrc, p->pEList); ++ } ++ iBreak = sqliteVdbeMakeLabel(v); ++ iCont = sqliteVdbeMakeLabel(v); ++ sqliteVdbeAddOp(v, OP_Rewind, tab1, iBreak); ++ computeLimitRegisters(pParse, p); ++ iStart = sqliteVdbeAddOp(v, OP_FullKey, tab1, 0); ++ sqliteVdbeAddOp(v, OP_NotFound, tab2, iCont); ++ multiSelectSortOrder(p, p->pOrderBy); ++ rc = selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr, ++ p->pOrderBy, -1, eDest, iParm, ++ iCont, iBreak); ++ if( rc ) return 1; ++ sqliteVdbeResolveLabel(v, iCont); ++ sqliteVdbeAddOp(v, OP_Next, tab1, iStart); ++ sqliteVdbeResolveLabel(v, iBreak); ++ sqliteVdbeAddOp(v, OP_Close, tab2, 0); ++ sqliteVdbeAddOp(v, OP_Close, tab1, 0); ++ if( p->pOrderBy ){ ++ generateSortTail(p, v, p->pEList->nExpr, eDest, iParm); ++ } ++ break; ++ } ++ } ++ assert( p->pEList && pPrior->pEList ); ++ if( p->pEList->nExpr!=pPrior->pEList->nExpr ){ ++ sqliteErrorMsg(pParse, "SELECTs to the left and right of %s" ++ " do not have the same number of result columns", selectOpName(p->op)); ++ return 1; ++ } ++ return 0; ++} ++ ++/* ++** 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 void substExprList(ExprList*,int,ExprList*); /* Forward Decl */ ++static void substExpr(Expr *pExpr, int iTable, ExprList *pEList){ ++ if( pExpr==0 ) return; ++ 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 && pExpr->pList==0 ); ++ pNew = pEList->a[pExpr->iColumn].pExpr; ++ assert( pNew!=0 ); ++ pExpr->op = pNew->op; ++ pExpr->dataType = pNew->dataType; ++ assert( pExpr->pLeft==0 ); ++ pExpr->pLeft = sqliteExprDup(pNew->pLeft); ++ assert( pExpr->pRight==0 ); ++ pExpr->pRight = sqliteExprDup(pNew->pRight); ++ assert( pExpr->pList==0 ); ++ pExpr->pList = sqliteExprListDup(pNew->pList); ++ pExpr->iTable = pNew->iTable; ++ pExpr->iColumn = pNew->iColumn; ++ pExpr->iAgg = pNew->iAgg; ++ sqliteTokenCopy(&pExpr->token, &pNew->token); ++ sqliteTokenCopy(&pExpr->span, &pNew->span); ++ } ++ }else{ ++ substExpr(pExpr->pLeft, iTable, pEList); ++ substExpr(pExpr->pRight, iTable, pEList); ++ substExprList(pExpr->pList, iTable, pEList); ++ } ++} ++static void ++substExprList(ExprList *pList, int iTable, ExprList *pEList){ ++ int i; ++ if( pList==0 ) return; ++ for(i=0; inExpr; i++){ ++ substExpr(pList->a[i].pExpr, iTable, pEList); ++ } ++} ++ ++/* ++** This routine attempts to flatten subqueries in order to speed ++** execution. It 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 simpification 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 the outer query is not a join. ++** ++** (3) The subquery is not the right operand of a left outer join, or ++** the subquery is not itself a join. (Ticket #306) ++** ++** (4) The subquery is not DISTINCT or the outer query is not a join. ++** ++** (5) The subquery is not DISTINCT or the outer query does not use ++** aggregates. ++** ++** (6) The subquery does not use aggregates or the outer query is not ++** DISTINCT. ++** ++** (7) The subquery has a FROM clause. ++** ++** (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. ++** ++** (10) 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. ++** ++** (12) The subquery is not the right term of a LEFT OUTER JOIN or the ++** subquery has no WHERE clause. (added by ticket #350) ++** ++** 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, /* The 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 */ ++){ ++ Select *pSub; /* The inner query or "subquery" */ ++ 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; ++ Expr *pWhere; ++ ++ /* Check to see if flattening is permitted. Return 0 if not. ++ */ ++ if( p==0 ) return 0; ++ pSrc = p->pSrc; ++ assert( pSrc && iFrom>=0 && iFromnSrc ); ++ pSub = pSrc->a[iFrom].pSelect; ++ assert( pSub!=0 ); ++ if( isAgg && subqueryIsAgg ) return 0; ++ if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; ++ pSubSrc = pSub->pSrc; ++ assert( pSubSrc ); ++ if( pSubSrc->nSrc==0 ) return 0; ++ if( (pSub->isDistinct || pSub->nLimit>=0) && (pSrc->nSrc>1 || isAgg) ){ ++ return 0; ++ } ++ if( (p->isDistinct || p->nLimit>=0) && subqueryIsAgg ) return 0; ++ if( p->pOrderBy && pSub->pOrderBy ) return 0; ++ ++ /* 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. ++ */ ++ if( pSubSrc->nSrc>1 && iFrom>0 && (pSrc->a[iFrom-1].jointype & JT_OUTER)!=0 ){ ++ return 0; ++ } ++ ++ /* 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. ++ */ ++ if( iFrom>0 && (pSrc->a[iFrom-1].jointype & JT_OUTER)!=0 ++ && pSub->pWhere!=0 ){ ++ return 0; ++ } ++ ++ /* If we reach this point, it means flattening is permitted for the ++ ** iFrom-th entry of the FROM clause in the outer query. ++ */ ++ ++ /* Move 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. ++ */ ++ iParent = pSrc->a[iFrom].iCursor; ++ { ++ int nSubSrc = pSubSrc->nSrc; ++ int jointype = pSrc->a[iFrom].jointype; ++ ++ if( pSrc->a[iFrom].pTab && pSrc->a[iFrom].pTab->isTransient ){ ++ sqliteDeleteTable(0, pSrc->a[iFrom].pTab); ++ } ++ sqliteFree(pSrc->a[iFrom].zDatabase); ++ sqliteFree(pSrc->a[iFrom].zName); ++ sqliteFree(pSrc->a[iFrom].zAlias); ++ if( nSubSrc>1 ){ ++ int extra = nSubSrc - 1; ++ for(i=1; ipSrc = pSrc; ++ for(i=pSrc->nSrc-1; i-extra>=iFrom; i--){ ++ pSrc->a[i] = pSrc->a[i-extra]; ++ } ++ } ++ for(i=0; ia[i+iFrom] = pSubSrc->a[i]; ++ memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i])); ++ } ++ pSrc->a[iFrom+nSubSrc-1].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". ++ */ ++ substExprList(p->pEList, iParent, pSub->pEList); ++ pList = p->pEList; ++ for(i=0; inExpr; i++){ ++ Expr *pExpr; ++ if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){ ++ pList->a[i].zName = sqliteStrNDup(pExpr->span.z, pExpr->span.n); ++ } ++ } ++ if( isAgg ){ ++ substExprList(p->pGroupBy, iParent, pSub->pEList); ++ substExpr(p->pHaving, iParent, pSub->pEList); ++ } ++ if( pSub->pOrderBy ){ ++ assert( p->pOrderBy==0 ); ++ p->pOrderBy = pSub->pOrderBy; ++ pSub->pOrderBy = 0; ++ }else if( p->pOrderBy ){ ++ substExprList(p->pOrderBy, iParent, pSub->pEList); ++ } ++ if( pSub->pWhere ){ ++ pWhere = sqliteExprDup(pSub->pWhere); ++ }else{ ++ pWhere = 0; ++ } ++ if( subqueryIsAgg ){ ++ assert( p->pHaving==0 ); ++ p->pHaving = p->pWhere; ++ p->pWhere = pWhere; ++ substExpr(p->pHaving, iParent, pSub->pEList); ++ if( pSub->pHaving ){ ++ Expr *pHaving = sqliteExprDup(pSub->pHaving); ++ if( p->pHaving ){ ++ p->pHaving = sqliteExpr(TK_AND, p->pHaving, pHaving, 0); ++ }else{ ++ p->pHaving = pHaving; ++ } ++ } ++ assert( p->pGroupBy==0 ); ++ p->pGroupBy = sqliteExprListDup(pSub->pGroupBy); ++ }else if( p->pWhere==0 ){ ++ p->pWhere = pWhere; ++ }else{ ++ substExpr(p->pWhere, iParent, pSub->pEList); ++ if( pWhere ){ ++ p->pWhere = sqliteExpr(TK_AND, p->pWhere, pWhere, 0); ++ } ++ } ++ ++ /* The flattened query is distinct if either the inner or the ++ ** outer query is distinct. ++ */ ++ p->isDistinct = p->isDistinct || pSub->isDistinct; ++ ++ /* Transfer the limit expression from the subquery to the outer ++ ** query. ++ */ ++ if( pSub->nLimit>=0 ){ ++ if( p->nLimit<0 ){ ++ p->nLimit = pSub->nLimit; ++ }else if( p->nLimit+p->nOffset > pSub->nLimit+pSub->nOffset ){ ++ p->nLimit = pSub->nLimit + pSub->nOffset - p->nOffset; ++ } ++ } ++ p->nOffset += pSub->nOffset; ++ ++ /* Finially, delete what is left of the subquery and return ++ ** success. ++ */ ++ sqliteSelectDelete(pSub); ++ return 1; ++} ++ ++/* ++** Analyze the SELECT statement passed in as an argument to see if it ++** is a simple min() or max() query. If it is and this query can be ++** satisfied using a single seek to the beginning or end of an index, ++** then generate the code for this SELECT and return 1. If this is not a ++** simple min() or max() query, then return 0; ++** ++** A simply min() or max() query looks like this: ++** ++** SELECT min(a) FROM table; ++** SELECT max(a) FROM table; ++** ++** The query may have only a single table in its FROM argument. There ++** can be no GROUP BY or HAVING or WHERE clauses. The result set must ++** be the min() or max() of a single column of the table. The column ++** in the min() or max() function must be indexed. ++** ++** The parameters to this routine are the same as for sqliteSelect(). ++** See the header comment on that routine for additional information. ++*/ ++static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ ++ Expr *pExpr; ++ int iCol; ++ Table *pTab; ++ Index *pIdx; ++ int base; ++ Vdbe *v; ++ int seekOp; ++ int cont; ++ ExprList *pEList, *pList, eList; ++ struct ExprList_item eListItem; ++ SrcList *pSrc; ++ ++ ++ /* Check to see if this query is a simple min() or max() query. Return ++ ** zero if it is not. ++ */ ++ if( p->pGroupBy || p->pHaving || p->pWhere ) return 0; ++ pSrc = p->pSrc; ++ if( pSrc->nSrc!=1 ) return 0; ++ pEList = p->pEList; ++ if( pEList->nExpr!=1 ) return 0; ++ pExpr = pEList->a[0].pExpr; ++ if( pExpr->op!=TK_AGG_FUNCTION ) return 0; ++ pList = pExpr->pList; ++ if( pList==0 || pList->nExpr!=1 ) return 0; ++ if( pExpr->token.n!=3 ) return 0; ++ if( sqliteStrNICmp(pExpr->token.z,"min",3)==0 ){ ++ seekOp = OP_Rewind; ++ }else if( sqliteStrNICmp(pExpr->token.z,"max",3)==0 ){ ++ seekOp = OP_Last; ++ }else{ ++ return 0; ++ } ++ pExpr = pList->a[0].pExpr; ++ if( pExpr->op!=TK_COLUMN ) return 0; ++ iCol = pExpr->iColumn; ++ pTab = pSrc->a[0].pTab; ++ ++ /* If we get to here, it means the query is of the correct form. ++ ** Check to make sure we have an index and make pIdx point to the ++ ** appropriate index. If the min() or max() is on an INTEGER PRIMARY ++ ** key column, no index is necessary so set pIdx to NULL. If no ++ ** usable index is found, return 0. ++ */ ++ if( iCol<0 ){ ++ pIdx = 0; ++ }else{ ++ for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ ++ assert( pIdx->nColumn>=1 ); ++ if( pIdx->aiColumn[0]==iCol ) break; ++ } ++ if( pIdx==0 ) return 0; ++ } ++ ++ /* Identify column types if we will be using the callback. This ++ ** step is skipped if the output is going to a table or a memory cell. ++ ** The column names have already been generated in the calling function. ++ */ ++ v = sqliteGetVdbe(pParse); ++ if( v==0 ) return 0; ++ if( eDest==SRT_Callback ){ ++ generateColumnTypes(pParse, p->pSrc, p->pEList); ++ } ++ ++ /* If the output is destined for a temporary table, open that table. ++ */ ++ if( eDest==SRT_TempTable ){ ++ sqliteVdbeAddOp(v, OP_OpenTemp, iParm, 0); ++ } ++ ++ /* Generating code to find the min or the max. Basically all we have ++ ** to do is find the first or the last entry in the chosen index. If ++ ** the min() or max() is on the INTEGER PRIMARY KEY, then find the first ++ ** or last entry in the main table. ++ */ ++ sqliteCodeVerifySchema(pParse, pTab->iDb); ++ base = pSrc->a[0].iCursor; ++ computeLimitRegisters(pParse, p); ++ if( pSrc->a[0].pSelect==0 ){ ++ sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); ++ sqliteVdbeOp3(v, OP_OpenRead, base, pTab->tnum, pTab->zName, 0); ++ } ++ cont = sqliteVdbeMakeLabel(v); ++ if( pIdx==0 ){ ++ sqliteVdbeAddOp(v, seekOp, base, 0); ++ }else{ ++ sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0); ++ sqliteVdbeOp3(v, OP_OpenRead, base+1, pIdx->tnum, pIdx->zName, P3_STATIC); ++ if( seekOp==OP_Rewind ){ ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ sqliteVdbeAddOp(v, OP_MakeKey, 1, 0); ++ sqliteVdbeAddOp(v, OP_IncrKey, 0, 0); ++ seekOp = OP_MoveTo; ++ } ++ sqliteVdbeAddOp(v, seekOp, base+1, 0); ++ sqliteVdbeAddOp(v, OP_IdxRecno, base+1, 0); ++ sqliteVdbeAddOp(v, OP_Close, base+1, 0); ++ sqliteVdbeAddOp(v, OP_MoveTo, base, 0); ++ } ++ eList.nExpr = 1; ++ memset(&eListItem, 0, sizeof(eListItem)); ++ eList.a = &eListItem; ++ eList.a[0].pExpr = pExpr; ++ selectInnerLoop(pParse, p, &eList, 0, 0, 0, -1, eDest, iParm, cont, cont); ++ sqliteVdbeResolveLabel(v, cont); ++ sqliteVdbeAddOp(v, OP_Close, base, 0); ++ ++ return 1; ++} ++ ++/* ++** Generate code for the given SELECT statement. ++** ++** The results are distributed in various ways depending on the ++** value of eDest and iParm. ++** ++** eDest Value Result ++** ------------ ------------------------------------------- ++** SRT_Callback Invoke the callback for each row of the result. ++** ++** SRT_Mem Store first result in memory cell iParm ++** ++** SRT_Set Store results as keys of a table with cursor iParm ++** ++** SRT_Union Store results as a key in a temporary table iParm ++** ++** SRT_Except Remove results from the temporary table iParm. ++** ++** SRT_Table Store results in temporary table iParm ++** ++** The table above is incomplete. Additional eDist value have be added ++** since this comment was written. See the selectInnerLoop() function for ++** a complete listing of the allowed values of eDest and their meanings. ++** ++** 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. ++** ++** The pParent, parentTab, and *pParentAgg fields are filled in if this ++** SELECT is a subquery. This routine may try to combine this SELECT ++** with its parent to form a single flat query. In so doing, it might ++** change the parent query from a non-aggregate to an aggregate query. ++** For that reason, the pParentAgg flag is passed as a pointer, so it ++** can be changed. ++** ++** Example 1: The meaning of the pParent parameter. ++** ++** SELECT * FROM t1 JOIN (SELECT x, count(*) FROM t2) JOIN t3; ++** \ \_______ subquery _______/ / ++** \ / ++** \____________________ outer query ___________________/ ++** ++** This routine is called for the outer query first. For that call, ++** pParent will be NULL. During the processing of the outer query, this ++** routine is called recursively to handle the subquery. For the recursive ++** call, pParent will point to the outer query. Because the subquery is ++** the second element in a three-way join, the parentTab parameter will ++** be 1 (the 2nd value of a 0-indexed array.) ++*/ ++int sqliteSelect( ++ Parse *pParse, /* The parser context */ ++ Select *p, /* The SELECT statement being coded. */ ++ int eDest, /* How to dispose of the results */ ++ int iParm, /* A parameter used by the eDest disposal method */ ++ Select *pParent, /* Another SELECT for which this is a sub-query */ ++ int parentTab, /* Index in pParent->pSrc of this query */ ++ int *pParentAgg /* True if pParent uses aggregate functions */ ++){ ++ int i; ++ WhereInfo *pWInfo; ++ Vdbe *v; ++ int isAgg = 0; /* True for select lists like "count(*)" */ ++ ExprList *pEList; /* List of columns to extract. */ ++ SrcList *pTabList; /* List of tables to select from */ ++ Expr *pWhere; /* The WHERE clause. May be NULL */ ++ ExprList *pOrderBy; /* The ORDER BY clause. May be NULL */ ++ ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */ ++ Expr *pHaving; /* The HAVING clause. May be NULL */ ++ int isDistinct; /* True if the DISTINCT keyword is present */ ++ int distinct; /* Table to use for the distinct set */ ++ int rc = 1; /* Value to return from this function */ ++ ++ if( sqlite_malloc_failed || pParse->nErr || p==0 ) return 1; ++ if( sqliteAuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; ++ ++ /* If there is are a sequence of queries, do the earlier ones first. ++ */ ++ if( p->pPrior ){ ++ return multiSelect(pParse, p, eDest, iParm); ++ } ++ ++ /* Make local copies of the parameters for this query. ++ */ ++ pTabList = p->pSrc; ++ pWhere = p->pWhere; ++ pOrderBy = p->pOrderBy; ++ pGroupBy = p->pGroupBy; ++ pHaving = p->pHaving; ++ isDistinct = p->isDistinct; ++ ++ /* Allocate VDBE cursors for each table in the FROM clause ++ */ ++ sqliteSrcListAssignCursors(pParse, pTabList); ++ ++ /* ++ ** Do not even attempt to generate any code if we have already seen ++ ** errors before this routine starts. ++ */ ++ if( pParse->nErr>0 ) goto select_end; ++ ++ /* Expand any "*" terms in the result set. (For example the "*" in ++ ** "SELECT * FROM t1") The fillInColumnlist() routine also does some ++ ** other housekeeping - see the header comment for details. ++ */ ++ if( fillInColumnList(pParse, p) ){ ++ goto select_end; ++ } ++ pWhere = p->pWhere; ++ pEList = p->pEList; ++ if( pEList==0 ) goto select_end; ++ ++ /* If writing to memory or generating a set ++ ** only a single column may be output. ++ */ ++ if( (eDest==SRT_Mem || eDest==SRT_Set) && pEList->nExpr>1 ){ ++ sqliteErrorMsg(pParse, "only a single result allowed for " ++ "a SELECT that is part of an expression"); ++ goto select_end; ++ } ++ ++ /* ORDER BY is ignored for some destinations. ++ */ ++ switch( eDest ){ ++ case SRT_Union: ++ case SRT_Except: ++ case SRT_Discard: ++ pOrderBy = 0; ++ break; ++ default: ++ break; ++ } ++ ++ /* At this point, we should have allocated all the cursors that we ++ ** need to handle subquerys and temporary tables. ++ ** ++ ** Resolve the column names and do a semantics check on all the expressions. ++ */ ++ for(i=0; inExpr; i++){ ++ if( sqliteExprResolveIds(pParse, pTabList, 0, pEList->a[i].pExpr) ){ ++ goto select_end; ++ } ++ if( sqliteExprCheck(pParse, pEList->a[i].pExpr, 1, &isAgg) ){ ++ goto select_end; ++ } ++ } ++ if( pWhere ){ ++ if( sqliteExprResolveIds(pParse, pTabList, pEList, pWhere) ){ ++ goto select_end; ++ } ++ if( sqliteExprCheck(pParse, pWhere, 0, 0) ){ ++ goto select_end; ++ } ++ } ++ if( pHaving ){ ++ if( pGroupBy==0 ){ ++ sqliteErrorMsg(pParse, "a GROUP BY clause is required before HAVING"); ++ goto select_end; ++ } ++ if( sqliteExprResolveIds(pParse, pTabList, pEList, pHaving) ){ ++ goto select_end; ++ } ++ if( sqliteExprCheck(pParse, pHaving, 1, &isAgg) ){ ++ goto select_end; ++ } ++ } ++ if( pOrderBy ){ ++ for(i=0; inExpr; i++){ ++ int iCol; ++ Expr *pE = pOrderBy->a[i].pExpr; ++ if( sqliteExprIsInteger(pE, &iCol) && iCol>0 && iCol<=pEList->nExpr ){ ++ sqliteExprDelete(pE); ++ pE = pOrderBy->a[i].pExpr = sqliteExprDup(pEList->a[iCol-1].pExpr); ++ } ++ if( sqliteExprResolveIds(pParse, pTabList, pEList, pE) ){ ++ goto select_end; ++ } ++ if( sqliteExprCheck(pParse, pE, isAgg, 0) ){ ++ goto select_end; ++ } ++ if( sqliteExprIsConstant(pE) ){ ++ if( sqliteExprIsInteger(pE, &iCol)==0 ){ ++ sqliteErrorMsg(pParse, ++ "ORDER BY terms must not be non-integer constants"); ++ goto select_end; ++ }else if( iCol<=0 || iCol>pEList->nExpr ){ ++ sqliteErrorMsg(pParse, ++ "ORDER BY column number %d out of range - should be " ++ "between 1 and %d", iCol, pEList->nExpr); ++ goto select_end; ++ } ++ } ++ } ++ } ++ if( pGroupBy ){ ++ for(i=0; inExpr; i++){ ++ int iCol; ++ Expr *pE = pGroupBy->a[i].pExpr; ++ if( sqliteExprIsInteger(pE, &iCol) && iCol>0 && iCol<=pEList->nExpr ){ ++ sqliteExprDelete(pE); ++ pE = pGroupBy->a[i].pExpr = sqliteExprDup(pEList->a[iCol-1].pExpr); ++ } ++ if( sqliteExprResolveIds(pParse, pTabList, pEList, pE) ){ ++ goto select_end; ++ } ++ if( sqliteExprCheck(pParse, pE, isAgg, 0) ){ ++ goto select_end; ++ } ++ if( sqliteExprIsConstant(pE) ){ ++ if( sqliteExprIsInteger(pE, &iCol)==0 ){ ++ sqliteErrorMsg(pParse, ++ "GROUP BY terms must not be non-integer constants"); ++ goto select_end; ++ }else if( iCol<=0 || iCol>pEList->nExpr ){ ++ sqliteErrorMsg(pParse, ++ "GROUP BY column number %d out of range - should be " ++ "between 1 and %d", iCol, pEList->nExpr); ++ goto select_end; ++ } ++ } ++ } ++ } ++ ++ /* Begin generating code. ++ */ ++ v = sqliteGetVdbe(pParse); ++ if( v==0 ) goto select_end; ++ ++ /* Identify column names if we will be using them in a callback. This ++ ** step is skipped if the output is going to some other destination. ++ */ ++ if( eDest==SRT_Callback ){ ++ generateColumnNames(pParse, pTabList, pEList); ++ } ++ ++ /* Generate code for all sub-queries in the FROM clause ++ */ ++ for(i=0; inSrc; i++){ ++ const char *zSavedAuthContext; ++ int needRestoreContext; ++ ++ if( pTabList->a[i].pSelect==0 ) continue; ++ if( pTabList->a[i].zName!=0 ){ ++ zSavedAuthContext = pParse->zAuthContext; ++ pParse->zAuthContext = pTabList->a[i].zName; ++ needRestoreContext = 1; ++ }else{ ++ needRestoreContext = 0; ++ } ++ sqliteSelect(pParse, pTabList->a[i].pSelect, SRT_TempTable, ++ pTabList->a[i].iCursor, p, i, &isAgg); ++ if( needRestoreContext ){ ++ pParse->zAuthContext = zSavedAuthContext; ++ } ++ pTabList = p->pSrc; ++ pWhere = p->pWhere; ++ if( eDest!=SRT_Union && eDest!=SRT_Except && eDest!=SRT_Discard ){ ++ pOrderBy = p->pOrderBy; ++ } ++ pGroupBy = p->pGroupBy; ++ pHaving = p->pHaving; ++ isDistinct = p->isDistinct; ++ } ++ ++ /* Check for the special case of a min() or max() function by itself ++ ** in the result set. ++ */ ++ if( simpleMinMaxQuery(pParse, p, eDest, iParm) ){ ++ rc = 0; ++ goto select_end; ++ } ++ ++ /* Check to see if this is a subquery that can be "flattened" into its parent. ++ ** If flattening is a possiblity, do so and return immediately. ++ */ ++ if( pParent && pParentAgg && ++ flattenSubquery(pParse, pParent, parentTab, *pParentAgg, isAgg) ){ ++ if( isAgg ) *pParentAgg = 1; ++ return rc; ++ } ++ ++ /* Set the limiter. ++ */ ++ computeLimitRegisters(pParse, p); ++ ++ /* Identify column types if we will be using a callback. This ++ ** step is skipped if the output is going to a destination other ++ ** than a callback. ++ ** ++ ** We have to do this separately from the creation of column names ++ ** above because if the pTabList contains views then they will not ++ ** have been resolved and we will not know the column types until ++ ** now. ++ */ ++ if( eDest==SRT_Callback ){ ++ generateColumnTypes(pParse, pTabList, pEList); ++ } ++ ++ /* If the output is destined for a temporary table, open that table. ++ */ ++ if( eDest==SRT_TempTable ){ ++ sqliteVdbeAddOp(v, OP_OpenTemp, iParm, 0); ++ } ++ ++ /* Do an analysis of aggregate expressions. ++ */ ++ sqliteAggregateInfoReset(pParse); ++ if( isAgg || pGroupBy ){ ++ assert( pParse->nAgg==0 ); ++ isAgg = 1; ++ for(i=0; inExpr; i++){ ++ if( sqliteExprAnalyzeAggregates(pParse, pEList->a[i].pExpr) ){ ++ goto select_end; ++ } ++ } ++ if( pGroupBy ){ ++ for(i=0; inExpr; i++){ ++ if( sqliteExprAnalyzeAggregates(pParse, pGroupBy->a[i].pExpr) ){ ++ goto select_end; ++ } ++ } ++ } ++ if( pHaving && sqliteExprAnalyzeAggregates(pParse, pHaving) ){ ++ goto select_end; ++ } ++ if( pOrderBy ){ ++ for(i=0; inExpr; i++){ ++ if( sqliteExprAnalyzeAggregates(pParse, pOrderBy->a[i].pExpr) ){ ++ goto select_end; ++ } ++ } ++ } ++ } ++ ++ /* Reset the aggregator ++ */ ++ if( isAgg ){ ++ sqliteVdbeAddOp(v, OP_AggReset, 0, pParse->nAgg); ++ for(i=0; inAgg; i++){ ++ FuncDef *pFunc; ++ if( (pFunc = pParse->aAgg[i].pFunc)!=0 && pFunc->xFinalize!=0 ){ ++ sqliteVdbeOp3(v, OP_AggInit, 0, i, (char*)pFunc, P3_POINTER); ++ } ++ } ++ if( pGroupBy==0 ){ ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ sqliteVdbeAddOp(v, OP_AggFocus, 0, 0); ++ } ++ } ++ ++ /* Initialize the memory cell to NULL ++ */ ++ if( eDest==SRT_Mem ){ ++ sqliteVdbeAddOp(v, OP_String, 0, 0); ++ sqliteVdbeAddOp(v, OP_MemStore, iParm, 1); ++ } ++ ++ /* Open a temporary table to use for the distinct set. ++ */ ++ if( isDistinct ){ ++ distinct = pParse->nTab++; ++ sqliteVdbeAddOp(v, OP_OpenTemp, distinct, 1); ++ }else{ ++ distinct = -1; ++ } ++ ++ /* Begin the database scan ++ */ ++ pWInfo = sqliteWhereBegin(pParse, pTabList, pWhere, 0, ++ pGroupBy ? 0 : &pOrderBy); ++ if( pWInfo==0 ) goto select_end; ++ ++ /* Use the standard inner loop if we are not dealing with ++ ** aggregates ++ */ ++ if( !isAgg ){ ++ if( selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, distinct, eDest, ++ iParm, pWInfo->iContinue, pWInfo->iBreak) ){ ++ goto select_end; ++ } ++ } ++ ++ /* If we are dealing with aggregates, then do the special aggregate ++ ** processing. ++ */ ++ else{ ++ AggExpr *pAgg; ++ if( pGroupBy ){ ++ int lbl1; ++ for(i=0; inExpr; i++){ ++ sqliteExprCode(pParse, pGroupBy->a[i].pExpr); ++ } ++ sqliteVdbeAddOp(v, OP_MakeKey, pGroupBy->nExpr, 0); ++ if( pParse->db->file_format>=4 ) sqliteAddKeyType(v, pGroupBy); ++ lbl1 = sqliteVdbeMakeLabel(v); ++ sqliteVdbeAddOp(v, OP_AggFocus, 0, lbl1); ++ for(i=0, pAgg=pParse->aAgg; inAgg; i++, pAgg++){ ++ if( pAgg->isAgg ) continue; ++ sqliteExprCode(pParse, pAgg->pExpr); ++ sqliteVdbeAddOp(v, OP_AggSet, 0, i); ++ } ++ sqliteVdbeResolveLabel(v, lbl1); ++ } ++ for(i=0, pAgg=pParse->aAgg; inAgg; i++, pAgg++){ ++ Expr *pE; ++ int nExpr; ++ FuncDef *pDef; ++ if( !pAgg->isAgg ) continue; ++ assert( pAgg->pFunc!=0 ); ++ assert( pAgg->pFunc->xStep!=0 ); ++ pDef = pAgg->pFunc; ++ pE = pAgg->pExpr; ++ assert( pE!=0 ); ++ assert( pE->op==TK_AGG_FUNCTION ); ++ nExpr = sqliteExprCodeExprList(pParse, pE->pList, pDef->includeTypes); ++ sqliteVdbeAddOp(v, OP_Integer, i, 0); ++ sqliteVdbeOp3(v, OP_AggFunc, 0, nExpr, (char*)pDef, P3_POINTER); ++ } ++ } ++ ++ /* End the database scan loop. ++ */ ++ sqliteWhereEnd(pWInfo); ++ ++ /* If we are processing aggregates, we need to set up a second loop ++ ** over all of the aggregate values and process them. ++ */ ++ if( isAgg ){ ++ int endagg = sqliteVdbeMakeLabel(v); ++ int startagg; ++ startagg = sqliteVdbeAddOp(v, OP_AggNext, 0, endagg); ++ pParse->useAgg = 1; ++ if( pHaving ){ ++ sqliteExprIfFalse(pParse, pHaving, startagg, 1); ++ } ++ if( selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, distinct, eDest, ++ iParm, startagg, endagg) ){ ++ goto select_end; ++ } ++ sqliteVdbeAddOp(v, OP_Goto, 0, startagg); ++ sqliteVdbeResolveLabel(v, endagg); ++ sqliteVdbeAddOp(v, OP_Noop, 0, 0); ++ pParse->useAgg = 0; ++ } ++ ++ /* If there is an ORDER BY clause, then we need to sort the results ++ ** and send them to the callback one by one. ++ */ ++ if( pOrderBy ){ ++ generateSortTail(p, v, pEList->nExpr, eDest, iParm); ++ } ++ ++ /* If this was a subquery, we have now converted the subquery into a ++ ** temporary table. So delete the subquery structure from the parent ++ ** to prevent this subquery from being evaluated again and to force the ++ ** the use of the temporary table. ++ */ ++ if( pParent ){ ++ assert( pParent->pSrc->nSrc>parentTab ); ++ assert( pParent->pSrc->a[parentTab].pSelect==p ); ++ sqliteSelectDelete(p); ++ pParent->pSrc->a[parentTab].pSelect = 0; ++ } ++ ++ /* The SELECT was successfully coded. Set the return code to 0 ++ ** to indicate no errors. ++ */ ++ rc = 0; ++ ++ /* Control jumps to here if an error is encountered above, or upon ++ ** successful coding of the SELECT. ++ */ ++select_end: ++ sqliteAggregateInfoReset(pParse); ++ return rc; ++} +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/sqlite_config.w32.h +@@ -0,0 +1,8 @@ ++#include "config.w32.h" ++#if ZTS ++# define THREADSAFE 1 ++#endif ++#if !ZEND_DEBUG && !defined(NDEBUG) ++# define NDEBUG ++#endif ++#define SQLITE_PTR_SZ 4 +\ No newline at end of file +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/sqlite.h.in +@@ -0,0 +1,886 @@ ++/* ++** 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. ++** ++** @(#) $Id$ ++*/ ++#ifndef _SQLITE_H_ ++#define _SQLITE_H_ ++#include /* Needed for the definition of va_list */ ++ ++/* ++** Make sure we can call this stuff from C++. ++*/ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* ++** The version of the SQLite library. ++*/ ++#ifdef SQLITE_VERSION ++# undef SQLITE_VERSION ++#else ++# define SQLITE_VERSION "--VERS--" ++#endif ++ ++/* ++** The version string is also compiled into the library so that a program ++** can check to make sure that the lib*.a file and the *.h file are from ++** the same version. ++*/ ++extern const char sqlite_version[]; ++ ++/* ++** The SQLITE_UTF8 macro is defined if the library expects to see ++** UTF-8 encoded data. The SQLITE_ISO8859 macro is defined if the ++** iso8859 encoded should be used. ++*/ ++#define SQLITE_--ENCODING-- 1 ++ ++/* ++** The following constant holds one of two strings, "UTF-8" or "iso8859", ++** depending on which character encoding the SQLite library expects to ++** see. The character encoding makes a difference for the LIKE and GLOB ++** operators and for the LENGTH() and SUBSTR() functions. ++*/ ++extern const char sqlite_encoding[]; ++ ++/* ++** Each open sqlite database is represented by an instance of the ++** following opaque structure. ++*/ ++typedef struct sqlite sqlite; ++ ++/* ++** A function to open a new sqlite database. ++** ++** If the database does not exist and mode indicates write ++** permission, then a new database is created. If the database ++** does not exist and mode does not indicate write permission, ++** then the open fails, an error message generated (if errmsg!=0) ++** and the function returns 0. ++** ++** If mode does not indicates user write permission, then the ++** database is opened read-only. ++** ++** The Truth: As currently implemented, all databases are opened ++** for writing all the time. Maybe someday we will provide the ++** ability to open a database readonly. The mode parameters is ++** provided in anticipation of that enhancement. ++*/ ++sqlite *sqlite_open(const char *filename, int mode, char **errmsg); ++ ++/* ++** A function to close the database. ++** ++** Call this function with a pointer to a structure that was previously ++** returned from sqlite_open() and the corresponding database will by closed. ++*/ ++void sqlite_close(sqlite *); ++ ++/* ++** The type for a callback function. ++*/ ++typedef int (*sqlite_callback)(void*,int,char**, char**); ++ ++/* ++** A function to executes one or more statements of SQL. ++** ++** If one or more of the SQL statements are queries, then ++** the callback function specified by the 3rd parameter is ++** invoked once for each row of the query result. This callback ++** should normally return 0. If the callback returns a non-zero ++** value then the query is aborted, all subsequent SQL statements ++** are skipped and the sqlite_exec() function returns the SQLITE_ABORT. ++** ++** The 4th parameter is an arbitrary pointer that is passed ++** to the callback function as its first parameter. ++** ++** The 2nd parameter to the callback function is the number of ++** columns in the query result. The 3rd parameter to the callback ++** is an array of strings holding the values for each column. ++** The 4th parameter to the callback is an array of strings holding ++** the names of each column. ++** ++** The callback function may be NULL, even for queries. A NULL ++** callback is not an error. It just means that no callback ++** will be invoked. ++** ++** If an error occurs while parsing or evaluating the SQL (but ++** not while executing the callback) then an appropriate error ++** message is written into memory obtained from malloc() and ++** *errmsg is made to point to that message. The calling function ++** is responsible for freeing the memory that holds the error ++** message. Use sqlite_freemem() for this. If errmsg==NULL, ++** then no error message is ever written. ++** ++** The return value is is SQLITE_OK if there are no errors and ++** some other return code if there is an error. The particular ++** return value depends on the type of error. ++** ++** If the query could not be executed because a database file is ++** locked or busy, then this function returns SQLITE_BUSY. (This ++** behavior can be modified somewhat using the sqlite_busy_handler() ++** and sqlite_busy_timeout() functions below.) ++*/ ++int sqlite_exec( ++ sqlite*, /* An open database */ ++ const char *sql, /* SQL to be executed */ ++ sqlite_callback, /* Callback function */ ++ void *, /* 1st argument to callback function */ ++ char **errmsg /* Error msg written here */ ++); ++ ++/* ++** Return values for sqlite_exec() and sqlite_step() ++*/ ++#define SQLITE_OK 0 /* Successful result */ ++#define SQLITE_ERROR 1 /* SQL error or missing database */ ++#define SQLITE_INTERNAL 2 /* An 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 sqlite_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 /* (Internal Only) Table or record not found */ ++#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 /* (Internal Only) Database table is empty */ ++#define SQLITE_SCHEMA 17 /* The database schema changed */ ++#define SQLITE_TOOBIG 18 /* Too much data for one row of a table */ ++#define SQLITE_CONSTRAINT 19 /* Abort due to contraint 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 sqlite_bind out of range */ ++#define SQLITE_NOTADB 26 /* File opened that is not a database file */ ++#define SQLITE_ROW 100 /* sqlite_step() has another row ready */ ++#define SQLITE_DONE 101 /* sqlite_step() has finished executing */ ++ ++/* ++** Each entry in an SQLite table has a unique integer key. (The key is ++** the value of the INTEGER PRIMARY KEY column if there is such a column, ++** otherwise the key is generated at random. The unique key is always ++** available as the ROWID, OID, or _ROWID_ column.) The following routine ++** returns the integer key of the most recent insert in the database. ++** ++** This function is similar to the mysql_insert_id() function from MySQL. ++*/ ++int sqlite_last_insert_rowid(sqlite*); ++ ++/* ++** This function returns the number of database rows that were changed ++** (or inserted or deleted) by the most recent called sqlite_exec(). ++** ++** All changes are counted, even if they were later undone by a ++** ROLLBACK or ABORT. Except, changes associated with creating and ++** dropping tables are not counted. ++** ++** If a callback invokes sqlite_exec() recursively, then the changes ++** in the inner, recursive call are counted together with the changes ++** in the outer call. ++** ++** SQLite implements the command "DELETE FROM table" without a WHERE clause ++** by dropping and recreating the table. (This is much faster than going ++** through and deleting individual elements form the table.) Because of ++** this optimization, the change count for "DELETE FROM table" will be ++** zero regardless of the number of elements that were originally in the ++** table. To get an accurate count of the number of rows deleted, use ++** "DELETE FROM table WHERE 1" instead. ++*/ ++int sqlite_changes(sqlite*); ++ ++/* ++** This function returns the number of database rows that were changed ++** by the last INSERT, UPDATE, or DELETE statment executed by sqlite_exec(), ++** or by the last VM to run to completion. The change count is not updated ++** by SQL statements other than INSERT, UPDATE or DELETE. ++** ++** Changes are counted, even if they are later undone by a ROLLBACK or ++** ABORT. Changes associated with trigger programs that execute as a ++** result of the INSERT, UPDATE, or DELETE statement are not counted. ++** ++** If a callback invokes sqlite_exec() recursively, then the changes ++** in the inner, recursive call are counted together with the changes ++** in the outer call. ++** ++** SQLite implements the command "DELETE FROM table" without a WHERE clause ++** by dropping and recreating the table. (This is much faster than going ++** through and deleting individual elements form the table.) Because of ++** this optimization, the change count for "DELETE FROM table" will be ++** zero regardless of the number of elements that were originally in the ++** table. To get an accurate count of the number of rows deleted, use ++** "DELETE FROM table WHERE 1" instead. ++** ++******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** ++*/ ++int sqlite_last_statement_changes(sqlite*); ++ ++/* If the parameter to this routine is one of the return value constants ++** defined above, then this routine returns a constant text string which ++** descripts (in English) the meaning of the return value. ++*/ ++const char *sqlite_error_string(int); ++#define sqliteErrStr sqlite_error_string /* Legacy. Do not use in new code. */ ++ ++/* 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. ++*/ ++void sqlite_interrupt(sqlite*); ++ ++ ++/* This function returns true if the given input string comprises ++** one or more complete SQL statements. ++** ++** The algorithm is simple. If the last token other than spaces ++** and comments is a semicolon, then return true. otherwise return ++** false. ++*/ ++int sqlite_complete(const char *sql); ++ ++/* ++** This routine identifies a callback function that is invoked ++** whenever an attempt is made to open a database table that is ++** currently locked by another process or thread. If the busy callback ++** is NULL, then sqlite_exec() returns SQLITE_BUSY immediately if ++** it finds a locked table. If the busy callback is not NULL, then ++** sqlite_exec() invokes the callback with three arguments. The ++** second argument is the name of the locked table and the third ++** argument is the number of times the table has been busy. If the ++** busy callback returns 0, then sqlite_exec() immediately returns ++** SQLITE_BUSY. If the callback returns non-zero, then sqlite_exec() ++** tries to open the table again and the cycle repeats. ++** ++** The default busy callback is NULL. ++** ++** Sqlite is re-entrant, so the busy handler may start a new query. ++** (It is not clear why anyone would every want to do this, but it ++** is allowed, in theory.) But the busy handler may not close the ++** database. Closing the database from a busy handler will delete ++** data structures out from under the executing query and will ++** probably result in a coredump. ++*/ ++void sqlite_busy_handler(sqlite*, int(*)(void*,const char*,int), void*); ++ ++/* ++** This routine sets a busy handler that sleeps for a while when a ++** table is locked. The handler will sleep multiple times until ++** at least "ms" milleseconds of sleeping have been done. After ++** "ms" milleseconds of sleeping, the handler returns 0 which ++** causes sqlite_exec() to return SQLITE_BUSY. ++** ++** Calling this routine with an argument less than or equal to zero ++** turns off all busy handlers. ++*/ ++void sqlite_busy_timeout(sqlite*, int ms); ++ ++/* ++** This next routine is really just a wrapper around sqlite_exec(). ++** Instead of invoking a user-supplied callback for each row of the ++** result, this routine remembers each row of the result in memory ++** obtained from malloc(), then returns all of the result after the ++** query has finished. ++** ++** As an example, suppose the query result where this table: ++** ++** Name | Age ++** ----------------------- ++** Alice | 43 ++** Bob | 28 ++** Cindy | 21 ++** ++** If the 3rd argument were &azResult then after the function returns ++** azResult will contain the following data: ++** ++** azResult[0] = "Name"; ++** azResult[1] = "Age"; ++** azResult[2] = "Alice"; ++** azResult[3] = "43"; ++** azResult[4] = "Bob"; ++** azResult[5] = "28"; ++** azResult[6] = "Cindy"; ++** azResult[7] = "21"; ++** ++** Notice that there is an extra row of data containing the column ++** headers. But the *nrow return value is still 3. *ncolumn is ++** set to 2. In general, the number of values inserted into azResult ++** will be ((*nrow) + 1)*(*ncolumn). ++** ++** After the calling function has finished using the result, it should ++** pass the result data pointer to sqlite_free_table() in order to ++** release the memory that was malloc-ed. Because of the way the ++** malloc() happens, the calling function must not try to call ++** malloc() directly. Only sqlite_free_table() is able to release ++** the memory properly and safely. ++** ++** The return value of this routine is the same as from sqlite_exec(). ++*/ ++int sqlite_get_table( ++ sqlite*, /* An open database */ ++ const char *sql, /* SQL to be executed */ ++ char ***resultp, /* Result written to a char *[] that this points to */ ++ int *nrow, /* Number of result rows written here */ ++ int *ncolumn, /* Number of result columns written here */ ++ char **errmsg /* Error msg written here */ ++); ++ ++/* ++** Call this routine to free the memory that sqlite_get_table() allocated. ++*/ ++void sqlite_free_table(char **result); ++ ++/* ++** The following routines are wrappers around sqlite_exec() and ++** sqlite_get_table(). The only difference between the routines that ++** follow and the originals is that the second argument to the ++** routines that follow is really a printf()-style format ++** string describing the SQL to be executed. Arguments to the format ++** string appear at the end of the argument list. ++** ++** All of the usual printf formatting options apply. In addition, there ++** is a "%q" option. %q works like %s in that it substitutes a null-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, so some string variable contains text as follows: ++** ++** char *zText = "It's a happy day!"; ++** ++** We can use this text in an SQL statement as follows: ++** ++** sqlite_exec_printf(db, "INSERT INTO table VALUES('%q')", ++** callback1, 0, 0, zText); ++** ++** 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. ++*/ ++int sqlite_exec_printf( ++ sqlite*, /* An open database */ ++ const char *sqlFormat, /* printf-style format string for the SQL */ ++ sqlite_callback, /* Callback function */ ++ void *, /* 1st argument to callback function */ ++ char **errmsg, /* Error msg written here */ ++ ... /* Arguments to the format string. */ ++); ++int sqlite_exec_vprintf( ++ sqlite*, /* An open database */ ++ const char *sqlFormat, /* printf-style format string for the SQL */ ++ sqlite_callback, /* Callback function */ ++ void *, /* 1st argument to callback function */ ++ char **errmsg, /* Error msg written here */ ++ va_list ap /* Arguments to the format string. */ ++); ++int sqlite_get_table_printf( ++ sqlite*, /* An open database */ ++ const char *sqlFormat, /* printf-style format string for the SQL */ ++ char ***resultp, /* Result written to a char *[] that this points to */ ++ int *nrow, /* Number of result rows written here */ ++ int *ncolumn, /* Number of result columns written here */ ++ char **errmsg, /* Error msg written here */ ++ ... /* Arguments to the format string */ ++); ++int sqlite_get_table_vprintf( ++ sqlite*, /* An open database */ ++ const char *sqlFormat, /* printf-style format string for the SQL */ ++ char ***resultp, /* Result written to a char *[] that this points to */ ++ int *nrow, /* Number of result rows written here */ ++ int *ncolumn, /* Number of result columns written here */ ++ char **errmsg, /* Error msg written here */ ++ va_list ap /* Arguments to the format string */ ++); ++char *sqlite_mprintf(const char*,...); ++char *sqlite_vmprintf(const char*, va_list); ++ ++/* ++** Windows systems should call this routine to free memory that ++** is returned in the in the errmsg parameter of sqlite_open() when ++** SQLite is a DLL. For some reason, it does not work to call free() ++** directly. ++*/ ++void sqlite_freemem(void *p); ++ ++/* ++** Windows systems need functions to call to return the sqlite_version ++** and sqlite_encoding strings. ++*/ ++const char *sqlite_libversion(void); ++const char *sqlite_libencoding(void); ++ ++/* ++** A pointer to the following structure is used to communicate with ++** the implementations of user-defined functions. ++*/ ++typedef struct sqlite_func sqlite_func; ++ ++/* ++** Use the following routines to create new user-defined functions. See ++** the documentation for details. ++*/ ++int sqlite_create_function( ++ sqlite*, /* Database where the new function is registered */ ++ const char *zName, /* Name of the new function */ ++ int nArg, /* Number of arguments. -1 means any number */ ++ void (*xFunc)(sqlite_func*,int,const char**), /* C code to implement */ ++ void *pUserData /* Available via the sqlite_user_data() call */ ++); ++int sqlite_create_aggregate( ++ sqlite*, /* Database where the new function is registered */ ++ const char *zName, /* Name of the function */ ++ int nArg, /* Number of arguments */ ++ void (*xStep)(sqlite_func*,int,const char**), /* Called for each row */ ++ void (*xFinalize)(sqlite_func*), /* Called once to get final result */ ++ void *pUserData /* Available via the sqlite_user_data() call */ ++); ++ ++/* ++** Use the following routine to define the datatype returned by a ++** user-defined function. The second argument can be one of the ++** constants SQLITE_NUMERIC, SQLITE_TEXT, or SQLITE_ARGS or it ++** can be an integer greater than or equal to zero. When the datatype ++** parameter is non-negative, the type of the result will be the ++** same as the datatype-th argument. If datatype==SQLITE_NUMERIC ++** then the result is always numeric. If datatype==SQLITE_TEXT then ++** the result is always text. If datatype==SQLITE_ARGS then the result ++** is numeric if any argument is numeric and is text otherwise. ++*/ ++int sqlite_function_type( ++ sqlite *db, /* The database there the function is registered */ ++ const char *zName, /* Name of the function */ ++ int datatype /* The datatype for this function */ ++); ++#define SQLITE_NUMERIC (-1) ++/* #define SQLITE_TEXT (-2) // See below */ ++#define SQLITE_ARGS (-3) ++ ++/* ++** SQLite version 3 defines SQLITE_TEXT differently. To allow both ++** version 2 and version 3 to be included, undefine them both if a ++** conflict is seen. Define SQLITE2_TEXT to be the version 2 value. ++*/ ++#ifdef SQLITE_TEXT ++# undef SQLITE_TEXT ++#else ++# define SQLITE_TEXT (-2) ++#endif ++#define SQLITE2_TEXT (-2) ++ ++ ++ ++/* ++** The user function implementations call one of the following four routines ++** in order to return their results. The first parameter to each of these ++** routines is a copy of the first argument to xFunc() or xFinialize(). ++** The second parameter to these routines is the result to be returned. ++** A NULL can be passed as the second parameter to sqlite_set_result_string() ++** in order to return a NULL result. ++** ++** The 3rd argument to _string and _error is the number of characters to ++** take from the string. If this argument is negative, then all characters ++** up to and including the first '\000' are used. ++** ++** The sqlite_set_result_string() function allocates a buffer to hold the ++** result and returns a pointer to this buffer. The calling routine ++** (that is, the implmentation of a user function) can alter the content ++** of this buffer if desired. ++*/ ++char *sqlite_set_result_string(sqlite_func*,const char*,int); ++void sqlite_set_result_int(sqlite_func*,int); ++void sqlite_set_result_double(sqlite_func*,double); ++void sqlite_set_result_error(sqlite_func*,const char*,int); ++ ++/* ++** The pUserData parameter to the sqlite_create_function() and ++** sqlite_create_aggregate() routines used to register user functions ++** is available to the implementation of the function using this ++** call. ++*/ ++void *sqlite_user_data(sqlite_func*); ++ ++/* ++** Aggregate functions use the following routine to allocate ++** a structure for storing their state. The first time this routine ++** is called for a particular aggregate, a new structure of size nBytes ++** is allocated, zeroed, and returned. On subsequent calls (for the ++** same aggregate instance) the same buffer is returned. The implementation ++** of the aggregate can use the returned buffer to accumulate data. ++** ++** The buffer allocated is freed automatically be SQLite. ++*/ ++void *sqlite_aggregate_context(sqlite_func*, int nBytes); ++ ++/* ++** The next routine returns the number of calls to xStep for a particular ++** aggregate function instance. The current call to xStep counts so this ++** routine always returns at least 1. ++*/ ++int sqlite_aggregate_count(sqlite_func*); ++ ++/* ++** This routine registers a callback with the SQLite library. The ++** callback is invoked (at compile-time, not at run-time) for each ++** attempt to access a column of a table in the database. The callback ++** returns SQLITE_OK if access is allowed, SQLITE_DENY if the entire ++** SQL statement should be aborted with an error and SQLITE_IGNORE ++** if the column should be treated as a NULL value. ++*/ ++int sqlite_set_authorizer( ++ sqlite*, ++ int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), ++ void *pUserData ++); ++ ++/* ++** The second parameter to the access authorization function above will ++** be one of the values below. These values signify what kind of operation ++** is to be authorized. The 3rd and 4th parameters to the authorization ++** function will be parameters or NULL depending on which of the following ++** codes is used as the second parameter. The 5th parameter is the name ++** of the database ("main", "temp", etc.) if applicable. The 6th parameter ++** 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 ++** input SQL code. ++** ++** Arg-3 Arg-4 ++*/ ++#define SQLITE_COPY 0 /* Table Name File Name */ ++#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 /* NULL NULL */ ++#define SQLITE_UPDATE 23 /* Table Name Column Name */ ++#define SQLITE_ATTACH 24 /* Filename NULL */ ++#define SQLITE_DETACH 25 /* Database Name NULL */ ++ ++ ++/* ++** The return value of the authorization function should be one of the ++** following constants: ++*/ ++/* #define SQLITE_OK 0 // Allow access (This is actually defined above) */ ++#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 */ ++ ++/* ++** Register a function that is called at every invocation of sqlite_exec() ++** or sqlite_compile(). This function can be used (for example) to generate ++** a log file of all SQL executed against a database. ++*/ ++void *sqlite_trace(sqlite*, void(*xTrace)(void*,const char*), void*); ++ ++/*** The Callback-Free API ++** ++** The following routines implement a new way to access SQLite that does not ++** involve the use of callbacks. ++** ++** An sqlite_vm is an opaque object that represents a single SQL statement ++** that is ready to be executed. ++*/ ++typedef struct sqlite_vm sqlite_vm; ++ ++/* ++** To execute an SQLite query without the use of callbacks, you first have ++** to compile the SQL using this routine. The 1st parameter "db" is a pointer ++** to an sqlite object obtained from sqlite_open(). The 2nd parameter ++** "zSql" is the text of the SQL to be compiled. The remaining parameters ++** are all outputs. ++** ++** *pzTail is made to point to the first character past the end of the first ++** SQL statement in zSql. This routine only compiles the first statement ++** in zSql, so *pzTail is left pointing to what remains uncompiled. ++** ++** *ppVm is left pointing to a "virtual machine" that can be used to execute ++** the compiled statement. Or if there is an error, *ppVm may be set to NULL. ++** If the input text contained no SQL (if the input is and empty string or ++** a comment) then *ppVm is set to NULL. ++** ++** If any errors are detected during compilation, an error message is written ++** into space obtained from malloc() and *pzErrMsg is made to point to that ++** error message. The calling routine is responsible for freeing the text ++** of this message when it has finished with it. Use sqlite_freemem() to ++** free the message. pzErrMsg may be NULL in which case no error message ++** will be generated. ++** ++** On success, SQLITE_OK is returned. Otherwise and error code is returned. ++*/ ++int sqlite_compile( ++ sqlite *db, /* The open database */ ++ const char *zSql, /* SQL statement to be compiled */ ++ const char **pzTail, /* OUT: uncompiled tail of zSql */ ++ sqlite_vm **ppVm, /* OUT: the virtual machine to execute zSql */ ++ char **pzErrmsg /* OUT: Error message. */ ++); ++ ++/* ++** After an SQL statement has been compiled, it is handed to this routine ++** to be executed. This routine executes the statement as far as it can ++** go then returns. The return value will be one of SQLITE_DONE, ++** SQLITE_ERROR, SQLITE_BUSY, SQLITE_ROW, or SQLITE_MISUSE. ++** ++** SQLITE_DONE means that the execute of the SQL statement is complete ++** an no errors have occurred. sqlite_step() should not be called again ++** for the same virtual machine. *pN is set to the number of columns in ++** the result set and *pazColName is set to an array of strings that ++** describe the column names and datatypes. The name of the i-th column ++** is (*pazColName)[i] and the datatype of the i-th column is ++** (*pazColName)[i+*pN]. *pazValue is set to NULL. ++** ++** SQLITE_ERROR means that the virtual machine encountered a run-time ++** error. sqlite_step() should not be called again for the same ++** virtual machine. *pN is set to 0 and *pazColName and *pazValue are set ++** to NULL. Use sqlite_finalize() to obtain the specific error code ++** and the error message text for the error. ++** ++** SQLITE_BUSY means that an attempt to open the database failed because ++** another thread or process is holding a lock. The calling routine ++** can try again to open the database by calling sqlite_step() again. ++** The return code will only be SQLITE_BUSY if no busy handler is registered ++** using the sqlite_busy_handler() or sqlite_busy_timeout() routines. If ++** a busy handler callback has been registered but returns 0, then this ++** routine will return SQLITE_ERROR and sqltie_finalize() will return ++** SQLITE_BUSY when it is called. ++** ++** SQLITE_ROW means that a single row of the result is now available. ++** The data is contained in *pazValue. The value of the i-th column is ++** (*azValue)[i]. *pN and *pazColName are set as described in SQLITE_DONE. ++** Invoke sqlite_step() again to advance to the next row. ++** ++** SQLITE_MISUSE is returned if sqlite_step() is called incorrectly. ++** For example, if you call sqlite_step() after the virtual machine ++** has halted (after a prior call to sqlite_step() has returned SQLITE_DONE) ++** or if you call sqlite_step() with an incorrectly initialized virtual ++** machine or a virtual machine that has been deleted or that is associated ++** with an sqlite structure that has been closed. ++*/ ++int sqlite_step( ++ sqlite_vm *pVm, /* The virtual machine to execute */ ++ int *pN, /* OUT: Number of columns in result */ ++ const char ***pazValue, /* OUT: Column data */ ++ const char ***pazColName /* OUT: Column names and datatypes */ ++); ++ ++/* ++** This routine is called to delete a virtual machine after it has finished ++** executing. The return value is the result code. SQLITE_OK is returned ++** if the statement executed successfully and some other value is returned if ++** there was any kind of error. If an error occurred and pzErrMsg is not ++** NULL, then an error message is written into memory obtained from malloc() ++** and *pzErrMsg is made to point to that error message. The calling routine ++** should use sqlite_freemem() to delete this message when it has finished ++** with it. ++** ++** This routine can be called at any point during the execution of the ++** virtual machine. If the virtual machine has not completed execution ++** when this routine is called, that is like encountering an error or ++** an interrupt. (See sqlite_interrupt().) Incomplete updates may be ++** rolled back and transactions cancelled, depending on the circumstances, ++** and the result code returned will be SQLITE_ABORT. ++*/ ++int sqlite_finalize(sqlite_vm*, char **pzErrMsg); ++ ++/* ++** This routine deletes the virtual machine, writes any error message to ++** *pzErrMsg and returns an SQLite return code in the same way as the ++** sqlite_finalize() function. ++** ++** Additionally, if ppVm is not NULL, *ppVm is left pointing to a new virtual ++** machine loaded with the compiled version of the original query ready for ++** execution. ++** ++** If sqlite_reset() returns SQLITE_SCHEMA, then *ppVm is set to NULL. ++** ++******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** ++*/ ++int sqlite_reset(sqlite_vm*, char **pzErrMsg); ++ ++/* ++** If the SQL that was handed to sqlite_compile contains variables that ++** are represeted in the SQL text by a question mark ('?'). This routine ++** is used to assign values to those variables. ++** ++** The first parameter is a virtual machine obtained from sqlite_compile(). ++** The 2nd "idx" parameter determines which variable in the SQL statement ++** to bind the value to. The left most '?' is 1. The 3rd parameter is ++** the value to assign to that variable. The 4th parameter is the number ++** of bytes in the value, including the terminating \000 for strings. ++** Finally, the 5th "copy" parameter is TRUE if SQLite should make its ++** own private copy of this value, or false if the space that the 3rd ++** parameter points to will be unchanging and can be used directly by ++** SQLite. ++** ++** Unbound variables are treated as having a value of NULL. To explicitly ++** set a variable to NULL, call this routine with the 3rd parameter as a ++** NULL pointer. ++** ++** If the 4th "len" parameter is -1, then strlen() is used to find the ++** length. ++** ++** This routine can only be called immediately after sqlite_compile() ++** or sqlite_reset() and before any calls to sqlite_step(). ++** ++******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** ++*/ ++int sqlite_bind(sqlite_vm*, int idx, const char *value, int len, int copy); ++ ++/* ++** This routine configures a callback function - the progress callback - that ++** is invoked periodically during long running calls to sqlite_exec(), ++** sqlite_step() and sqlite_get_table(). An example use for this API is to keep ++** a GUI updated during a large query. ++** ++** The progress callback is invoked once for every N virtual machine opcodes, ++** where N is the second argument to this function. The progress callback ++** itself is identified by the third argument to this function. The fourth ++** argument to this function is a void pointer passed to the progress callback ++** function each time it is invoked. ++** ++** If a call to sqlite_exec(), sqlite_step() or sqlite_get_table() results ++** in less than N opcodes being executed, then the progress callback is not ++** invoked. ++** ++** Calling this routine overwrites any previously installed progress callback. ++** To remove the progress callback altogether, pass NULL as the third ++** argument to this function. ++** ++** If the progress callback returns a result other than 0, then the current ++** query is immediately terminated and any database changes rolled back. If the ++** query was part of a larger transaction, then the transaction is not rolled ++** back and remains active. The sqlite_exec() call returns SQLITE_ABORT. ++** ++******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** ++*/ ++void sqlite_progress_handler(sqlite*, int, int(*)(void*), void*); ++ ++/* ++** Register a callback function to be invoked whenever a new transaction ++** is committed. The pArg argument is passed through to the callback. ++** callback. If the callback function returns non-zero, then the commit ++** is converted into a rollback. ++** ++** If another function was previously registered, its pArg value is returned. ++** Otherwise NULL is returned. ++** ++** Registering a NULL function disables the callback. ++** ++******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** ++*/ ++void *sqlite_commit_hook(sqlite*, int(*)(void*), void*); ++ ++/* ++** Open an encrypted SQLite database. If pKey==0 or nKey==0, this routine ++** is the same as sqlite_open(). ++** ++** The code to implement this API is not available in the public release ++** of SQLite. ++*/ ++sqlite *sqlite_open_encrypted( ++ const char *zFilename, /* Name of the encrypted database */ ++ const void *pKey, /* Pointer to the key */ ++ int nKey, /* Number of bytes in the key */ ++ int *pErrcode, /* Write error code here */ ++ char **pzErrmsg /* Write error message here */ ++); ++ ++/* ++** 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. ++*/ ++int sqlite_rekey( ++ sqlite *db, /* Database to be rekeyed */ ++ const void *pKey, int nKey /* The new key */ ++); ++ ++/* ++** Encode a binary buffer "in" of size n bytes so that it contains ++** no instances of characters '\'' or '\000'. The output is ++** null-terminated and can be used as a string value in an INSERT ++** or UPDATE statement. Use sqlite_decode_binary() to convert the ++** string back into its original binary. ++** ++** The result is written into a preallocated output buffer "out". ++** "out" must be able to hold at least 2 +(257*n)/254 bytes. ++** In other words, the output will be expanded by as much as 3 ++** bytes for every 254 bytes of input plus 2 bytes of fixed overhead. ++** (This is approximately 2 + 1.0118*n or about a 1.2% size increase.) ++** ++** The return value is the number of characters in the encoded ++** string, excluding the "\000" terminator. ++** ++** If out==NULL then no output is generated but the routine still returns ++** the number of characters that would have been generated if out had ++** not been NULL. ++*/ ++int sqlite_encode_binary(const unsigned char *in, int n, unsigned char *out); ++ ++/* ++** Decode the string "in" into binary data and write it into "out". ++** This routine reverses the encoding created by sqlite_encode_binary(). ++** The output will always be a few bytes less than the input. The number ++** of bytes of output is returned. If the input is not a well-formed ++** encoding, -1 is returned. ++** ++** The "in" and "out" parameters may point to the same buffer in order ++** to decode a string in place. ++*/ ++int sqlite_decode_binary(const unsigned char *in, unsigned char *out); ++ ++#ifdef __cplusplus ++} /* End of the 'extern "C"' block */ ++#endif ++ ++#endif /* _SQLITE_H_ */ +--- /dev/null ++++ b/ext/sqlite/libsqlite/src/sqliteInt.h +@@ -0,0 +1,1270 @@ ++/* ++** 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. ++** ++************************************************************************* ++** Internal interface definitions for SQLite. ++** ++** @(#) $Id$ ++*/ ++#include "config.h" ++#include "sqlite.h" ++#include "hash.h" ++#include "parse.h" ++#include "btree.h" ++#include ++#include ++#include ++#include ++ ++/* ++** The maximum number of in-memory pages to use for the main database ++** table and for temporary tables. ++*/ ++#define MAX_PAGES 2000 ++#define TEMP_PAGES 500 ++ ++/* ++** If the following macro is set to 1, then NULL values are considered ++** distinct for the SELECT DISTINCT statement and for UNION or EXCEPT ++** compound queries. No other SQL database engine (among those tested) ++** works this way except for OCELOT. But the SQL92 spec implies that ++** this is how things should work. ++** ++** If the following macro is set to 0, then NULLs are indistinct for ++** SELECT DISTINCT and for UNION. ++*/ ++#define NULL_ALWAYS_DISTINCT 0 ++ ++/* ++** If the following macro is set to 1, then NULL values are considered ++** distinct when determining whether or not two entries are the same ++** in a UNIQUE index. This is the way PostgreSQL, Oracle, DB2, MySQL, ++** OCELOT, and Firebird all work. The SQL92 spec explicitly says this ++** is the way things are suppose to work. ++** ++** If the following macro is set to 0, the NULLs are indistinct for ++** a UNIQUE index. In this mode, you can only have a single NULL entry ++** for a column declared UNIQUE. This is the way Informix and SQL Server ++** work. ++*/ ++#define NULL_DISTINCT_FOR_UNIQUE 1 ++ ++/* ++** The maximum number of attached databases. This must be at least 2 ++** in order to support the main database file (0) and the file used to ++** hold temporary tables (1). And it must be less than 256 because ++** an unsigned character is used to stored the database index. ++*/ ++#define MAX_ATTACHED 10 ++ ++/* ++** The next macro is used to determine where TEMP tables and indices ++** are stored. Possible values: ++** ++** 0 Always use a temporary files ++** 1 Use a file unless overridden by "PRAGMA temp_store" ++** 2 Use memory unless overridden by "PRAGMA temp_store" ++** 3 Always use memory ++*/ ++#ifndef TEMP_STORE ++# define TEMP_STORE 1 ++#endif ++ ++/* ++** When building SQLite for embedded systems where memory is scarce, ++** you can define one or more of the following macros to omit extra ++** features of the library and thus keep the size of the library to ++** a minimum. ++*/ ++/* #define SQLITE_OMIT_AUTHORIZATION 1 */ ++/* #define SQLITE_OMIT_INMEMORYDB 1 */ ++/* #define SQLITE_OMIT_VACUUM 1 */ ++/* #define SQLITE_OMIT_DATETIME_FUNCS 1 */ ++/* #define SQLITE_OMIT_PROGRESS_CALLBACK 1 */ ++ ++/* ++** 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 ++# define UINT32_TYPE unsigned int ++#endif ++#ifndef UINT16_TYPE ++# define UINT16_TYPE unsigned short int ++#endif ++#ifndef INT16_TYPE ++# define INT16_TYPE short int ++#endif ++#ifndef UINT8_TYPE ++# define UINT8_TYPE unsigned char ++#endif ++#ifndef INT8_TYPE ++# define INT8_TYPE signed char ++#endif ++#ifndef INTPTR_TYPE ++# if SQLITE_PTR_SZ==4 ++# define INTPTR_TYPE int ++# else ++# define INTPTR_TYPE long long ++# endif ++#endif ++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 UINT8_TYPE i8; /* 1-byte signed integer */ ++typedef INTPTR_TYPE ptr; /* Big enough to hold a pointer */ ++typedef unsigned INTPTR_TYPE uptr; /* Big enough to hold a pointer */ ++ ++/* ++** Defer sourcing vdbe.h until after the "u8" typedef is defined. ++*/ ++#include "vdbe.h" ++ ++/* ++** Most C compilers these days recognize "long double", don't they? ++** Just in case we encounter one that does not, we will create a macro ++** for long double so that it can be easily changed to just "double". ++*/ ++#ifndef LONGDOUBLE_TYPE ++# define LONGDOUBLE_TYPE long double ++#endif ++ ++/* ++** This macro casts a pointer to an integer. Useful for doing ++** pointer arithmetic. ++*/ ++#define Addr(X) ((uptr)X) ++ ++/* ++** The maximum number of bytes of data that can be put into a single ++** row of a single table. The upper bound on this limit is 16777215 ++** bytes (or 16MB-1). We have arbitrarily set the limit to just 1MB ++** here because the overflow page chain is inefficient for really big ++** records and we want to discourage people from thinking that ++** multi-megabyte records are OK. If your needs are different, you can ++** change this define and recompile to increase or decrease the record ++** size. ++** ++** The 16777198 is computed as follows: 238 bytes of payload on the ++** original pages plus 16448 overflow pages each holding 1020 bytes of ++** data. ++*/ ++#define MAX_BYTES_PER_ROW 1048576 ++/* #define MAX_BYTES_PER_ROW 16777198 */ ++ ++/* ++** If memory allocation problems are found, recompile with ++** ++** -DMEMORY_DEBUG=1 ++** ++** to enable some sanity checking on malloc() and free(). To ++** check for memory leaks, recompile with ++** ++** -DMEMORY_DEBUG=2 ++** ++** and a line of text will be written to standard error for ++** each malloc() and free(). This output can be analyzed ++** by an AWK script to determine if there are any leaks. ++*/ ++#ifdef MEMORY_DEBUG ++# define sqliteMalloc(X) sqliteMalloc_(X,1,__FILE__,__LINE__) ++# define sqliteMallocRaw(X) sqliteMalloc_(X,0,__FILE__,__LINE__) ++# define sqliteFree(X) sqliteFree_(X,__FILE__,__LINE__) ++# define sqliteRealloc(X,Y) sqliteRealloc_(X,Y,__FILE__,__LINE__) ++# define sqliteStrDup(X) sqliteStrDup_(X,__FILE__,__LINE__) ++# define sqliteStrNDup(X,Y) sqliteStrNDup_(X,Y,__FILE__,__LINE__) ++ void sqliteStrRealloc(char**); ++#else ++# define sqliteRealloc_(X,Y) sqliteRealloc(X,Y) ++# define sqliteStrRealloc(X) ++#endif ++ ++/* ++** This variable gets set if malloc() ever fails. After it gets set, ++** the SQLite library shuts down permanently. ++*/ ++extern int sqlite_malloc_failed; ++ ++/* ++** The following global variables are used for testing and debugging ++** only. They only work if MEMORY_DEBUG is defined. ++*/ ++#ifdef MEMORY_DEBUG ++extern int sqlite_nMalloc; /* Number of sqliteMalloc() calls */ ++extern int sqlite_nFree; /* Number of sqliteFree() calls */ ++extern int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */ ++#endif ++ ++/* ++** 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 name of the schema table. ++*/ ++#define SCHEMA_TABLE(x) (x?TEMP_MASTER_NAME:MASTER_NAME) ++ ++/* ++** A convenience macro that returns the number of elements in ++** an array. ++*/ ++#define ArraySize(X) (sizeof(X)/sizeof(X[0])) ++ ++/* ++** Forward references to structures ++*/ ++typedef struct Column Column; ++typedef struct Table Table; ++typedef struct Index Index; ++typedef struct Instruction Instruction; ++typedef struct Expr Expr; ++typedef struct ExprList ExprList; ++typedef struct Parse Parse; ++typedef struct Token Token; ++typedef struct IdList IdList; ++typedef struct SrcList SrcList; ++typedef struct WhereInfo WhereInfo; ++typedef struct WhereLevel WhereLevel; ++typedef struct Select Select; ++typedef struct AggExpr AggExpr; ++typedef struct FuncDef FuncDef; ++typedef struct Trigger Trigger; ++typedef struct TriggerStep TriggerStep; ++typedef struct TriggerStack TriggerStack; ++typedef struct FKey FKey; ++typedef struct Db Db; ++typedef struct AuthContext AuthContext; ++ ++/* ++** 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 */ ++ int schema_cookie; /* Database schema version number for this file */ ++ Hash tblHash; /* All tables indexed by name */ ++ Hash idxHash; /* All (named) indices indexed by name */ ++ Hash trigHash; /* All triggers indexed by name */ ++ Hash aFKey; /* Foreign keys indexed by to-table */ ++ u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */ ++ u16 flags; /* Flags associated with this database */ ++ void *pAux; /* Auxiliary data. Usually NULL */ ++ void (*xFreeAux)(void*); /* Routine to free pAux */ ++}; ++ ++/* ++** These macros can be used to test, set, or clear bits in the ++** Db.flags field. ++*/ ++#define DbHasProperty(D,I,P) (((D)->aDb[I].flags&(P))==(P)) ++#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].flags&(P))!=0) ++#define DbSetProperty(D,I,P) (D)->aDb[I].flags|=(P) ++#define DbClearProperty(D,I,P) (D)->aDb[I].flags&=~(P) ++ ++/* ++** Allowed values for the DB.flags field. ++** ++** The DB_Locked flag is set when the first OP_Transaction or OP_Checkpoint ++** opcode is emitted for a database. This prevents multiple occurances ++** of those opcodes for the same database in the same program. Similarly, ++** the DB_Cookie flag is set when the OP_VerifyCookie opcode is emitted, ++** and prevents duplicate OP_VerifyCookies from taking up space and slowing ++** down execution. ++** ++** 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_Locked 0x0001 /* OP_Transaction opcode has been emitted */ ++#define DB_Cookie 0x0002 /* OP_VerifyCookie opcode has been emiited */ ++#define DB_SchemaLoaded 0x0004 /* The schema has been loaded */ ++#define DB_UnresetViews 0x0008 /* Some views have defined column names */ ++ ++ ++/* ++** Each database is an instance of the following structure. ++** ++** The sqlite.file_format is initialized by the database file ++** and helps determines how the data in the database file is ++** represented. This field allows newer versions of the library ++** to read and write older databases. The various file formats ++** are as follows: ++** ++** file_format==1 Version 2.1.0. ++** file_format==2 Version 2.2.0. Add support for INTEGER PRIMARY KEY. ++** file_format==3 Version 2.6.0. Fix empty-string index bug. ++** file_format==4 Version 2.7.0. Add support for separate numeric and ++** text datatypes. ++** ++** The sqlite.temp_store determines where temporary database files ++** are stored. If 1, then a file is created to hold those tables. If ++** 2, then they are held in memory. 0 means use the default value in ++** the TEMP_STORE macro. ++** ++** The sqlite.lastRowid records the last insert rowid generated by an ++** insert statement. Inserts on views do not affect its value. Each ++** trigger has its own context, so that lastRowid can be updated inside ++** triggers as usual. The previous value will be restored once the trigger ++** exits. Upon entering a before or instead of trigger, lastRowid is no ++** longer (since after version 2.8.12) reset to -1. ++** ++** The sqlite.nChange does not count changes within triggers and keeps no ++** context. It is reset at start of sqlite_exec. ++** The sqlite.lsChange represents the number of changes made by the last ++** insert, update, or delete statement. It remains constant throughout the ++** length of a statement and is then updated by OP_SetCounts. It keeps a ++** context stack just like lastRowid so that the count of changes ++** within a trigger is not seen outside the trigger. Changes to views do not ++** affect the value of lsChange. ++** The sqlite.csChange keeps track of the number of current changes (since ++** the last statement) and is used to update sqlite_lsChange. ++*/ ++struct sqlite { ++ int nDb; /* Number of backends currently in use */ ++ Db *aDb; /* All backends */ ++ Db aDbStatic[2]; /* Static space for the 2 default backends */ ++ int flags; /* Miscellanous flags. See below */ ++ u8 file_format; /* What file format version is this database? */ ++ u8 safety_level; /* How aggressive at synching data to disk */ ++ u8 want_to_close; /* Close after all VDBEs are deallocated */ ++ u8 temp_store; /* 1=file, 2=memory, 0=compile-time default */ ++ u8 onError; /* Default conflict algorithm */ ++ int next_cookie; /* Next value of aDb[0].schema_cookie */ ++ int cache_size; /* Number of pages to use in the cache */ ++ int nTable; /* Number of tables in the database */ ++ void *pBusyArg; /* 1st Argument to the busy callback */ ++ int (*xBusyCallback)(void *,const char*,int); /* The busy callback */ ++ void *pCommitArg; /* Argument to xCommitCallback() */ ++ int (*xCommitCallback)(void*);/* Invoked at every commit. */ ++ Hash aFunc; /* All functions that can be in SQL exprs */ ++ int lastRowid; /* ROWID of most recent insert (see above) */ ++ int priorNewRowid; /* Last randomly generated ROWID */ ++ int magic; /* Magic number for detect library misuse */ ++ int nChange; /* Number of rows changed (see above) */ ++ int lsChange; /* Last statement change count (see above) */ ++ int csChange; /* Current statement change count (see above) */ ++ struct sqliteInitInfo { /* Information used during initialization */ ++ int iDb; /* When back is being initialized */ ++ int newTnum; /* Rootpage of table being initialized */ ++ u8 busy; /* TRUE if currently initializing */ ++ } init; ++ struct Vdbe *pVdbe; /* List of active virtual machines */ ++ void (*xTrace)(void*,const char*); /* Trace function */ ++ void *pTraceArg; /* Argument to the trace function */ ++#ifndef SQLITE_OMIT_AUTHORIZATION ++ int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); ++ /* 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 */ ++ int nProgressOps; /* Number of opcodes for progress callback */ ++#endif ++}; ++ ++/* ++** Possible values for the sqlite.flags and or Db.flags fields. ++** ++** On sqlite.flags, the SQLITE_InTrans value means that we have ++** executed a BEGIN. On Db.flags, SQLITE_InTrans means a statement ++** transaction is active on that particular database file. ++*/ ++#define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */ ++#define SQLITE_Initialized 0x00000002 /* True after initialization */ ++#define SQLITE_Interrupt 0x00000004 /* Cancel current operation */ ++#define SQLITE_InTrans 0x00000008 /* True if in a transaction */ ++#define SQLITE_InternChanges 0x00000010 /* Uncommitted Hash table changes */ ++#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_ReportTypes 0x00000200 /* Include information on datatypes */ ++ /* in 4th argument of callback */ ++ ++/* ++** 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_BUSY 0xf03b7906 /* Database currently in use */ ++#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ ++ ++/* ++** 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 { ++ void (*xFunc)(sqlite_func*,int,const char**); /* Regular function */ ++ void (*xStep)(sqlite_func*,int,const char**); /* Aggregate function step */ ++ void (*xFinalize)(sqlite_func*); /* Aggregate function finializer */ ++ signed char nArg; /* Number of arguments. -1 means unlimited */ ++ signed char dataType; /* Arg that determines datatype. -1=NUMERIC, */ ++ /* -2=TEXT. -3=SQLITE_ARGS */ ++ u8 includeTypes; /* Add datatypes to args of xFunc and xStep */ ++ void *pUserData; /* User data parameter */ ++ FuncDef *pNext; /* Next function with same name */ ++}; ++ ++/* ++** information about each column of an SQL table is held in an instance ++** of this structure. ++*/ ++struct Column { ++ char *zName; /* Name of this column */ ++ char *zDflt; /* Default value of this column */ ++ char *zType; /* Data type for this column */ ++ u8 notNull; /* True if there is a NOT NULL constraint */ ++ u8 isPrimKey; /* True if this column is part of the PRIMARY KEY */ ++ u8 sortOrder; /* Some combination of SQLITE_SO_... values */ ++ u8 dottedName; /* True if zName contains a "." character */ ++}; ++ ++/* ++** The allowed sort orders. ++** ++** The TEXT and NUM values use bits that do not overlap with DESC and ASC. ++** That way the two can be combined into a single number. ++*/ ++#define SQLITE_SO_UNK 0 /* Use the default collating type. (SCT_NUM) */ ++#define SQLITE_SO_TEXT 2 /* Sort using memcmp() */ ++#define SQLITE_SO_NUM 4 /* Sort using sqliteCompare() */ ++#define SQLITE_SO_TYPEMASK 6 /* Mask to extract the collating sequence */ ++#define SQLITE_SO_ASC 0 /* Sort in ascending order */ ++#define SQLITE_SO_DESC 1 /* Sort in descending order */ ++#define SQLITE_SO_DIRMASK 1 /* Mask to extract the sort direction */ ++ ++/* ++** Each SQL table is represented in memory by an instance of the ++** following structure. ++** ++** Table.zName is the name of the table. The case of the original ++** CREATE TABLE statement is stored, but case is not significant for ++** comparisons. ++** ++** Table.nCol is the number of columns in this table. Table.aCol is a ++** pointer to an array of Column structures, one for each column. ++** ++** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of ++** the column that is that key. Otherwise Table.iPKey is negative. Note ++** that the datatype of the PRIMARY KEY must be INTEGER for this field to ++** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of ++** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid ++** is generated for each row of the table. Table.hasPrimKey is true if ++** the table has any PRIMARY KEY, INTEGER or otherwise. ++** ++** Table.tnum is the page number for the root BTree page of the table in the ++** database file. If Table.iDb is the index of the database table backend ++** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that ++** holds temporary tables and indices. If Table.isTransient ++** is true, then the table is stored in a file that is automatically deleted ++** when the VDBE cursor to the table is closed. In this case Table.tnum ++** refers VDBE cursor number that holds the table open, not to the root ++** page number. Transient tables are used to hold the results of a ++** sub-query that appears instead of a real table name in the FROM clause ++** of a SELECT statement. ++*/ ++struct Table { ++ char *zName; /* Name of the table */ ++ int nCol; /* Number of columns in this table */ ++ Column *aCol; /* Information about each column */ ++ int iPKey; /* If not less then 0, use aCol[iPKey] as the primary key */ ++ Index *pIndex; /* List of SQL indexes on this table. */ ++ int tnum; /* Root BTree node for this table (see note above) */ ++ Select *pSelect; /* NULL for tables. Points to definition if a view. */ ++ u8 readOnly; /* True if this table should not be written by the user */ ++ u8 iDb; /* Index into sqlite.aDb[] of the backend for this table */ ++ u8 isTransient; /* True if automatically deleted when VDBE finishes */ ++ u8 hasPrimKey; /* True if there exists a primary key */ ++ u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ ++ Trigger *pTrigger; /* List of SQL triggers on this table */ ++ FKey *pFKey; /* Linked list of all foreign keys in this table */ ++}; ++ ++/* ++** 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". ++** ++** 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 existance of the to-table is not checked ++** until an attempt is made to insert data into the from-table. ++** ++** The sqlite.aFKey hash table stores pointers to this structure ++** given the name of a to-table. For each to-table, all foreign keys ++** associated with that table are on a linked list using the FKey.pNextTo ++** field. ++*/ ++struct FKey { ++ Table *pFrom; /* The table that constains the REFERENCES clause */ ++ FKey *pNextFrom; /* Next foreign key in pFrom */ ++ char *zTo; /* Name of table that the key points to */ ++ FKey *pNextTo; /* Next foreign key that points to zTo */ ++ int nCol; /* Number of columns in this key */ ++ 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 0 use PRIMARY KEY */ ++ } *aCol; /* One entry for each of nCol column s */ ++ u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ ++ u8 updateConf; /* How to resolve conflicts that occur on UPDATE */ ++ u8 deleteConf; /* How to resolve conflicts that occur on DELETE */ ++ u8 insertConf; /* How to resolve conflicts that occur on INSERT */ ++}; ++ ++/* ++** SQLite supports many different ways to resolve a contraint ++** 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 99 /* Do whatever the default action is */ ++ ++/* ++** 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. ++*/ ++struct Index { ++ char *zName; /* Name of this index */ ++ int nColumn; /* Number of columns in the table used by this index */ ++ int *aiColumn; /* Which columns are used by this index. 1st is 0 */ ++ Table *pTable; /* The SQL table being indexed */ ++ int tnum; /* Page containing root of this index in database file */ ++ u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ ++ u8 autoIndex; /* True if is automatically created (ex: by UNIQUE) */ ++ u8 iDb; /* Index in sqlite.aDb[] of where this index is stored */ ++ Index *pNext; /* The next index associated with the same table */ ++}; ++ ++/* ++** 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 assuptions about Token.dyn ++** and Token.n when Token.z==0. ++*/ ++struct Token { ++ const char *z; /* Text of the token. Not NULL-terminated! */ ++ unsigned dyn : 1; /* True for malloced memory, false for static */ ++ unsigned n : 31; /* Number of characters in this token */ ++}; ++ ++/* ++** 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. ++** ++** Expr.pRight and Expr.pLeft are subexpressions. Expr.pList is a list ++** of argument if the expression is a function. ++** ++** Expr.token is the operator token for this node. For some expressions ++** that have subexpressions, Expr.token can be the complete text that gave ++** rise to the Expr. In the latter case, the token is marked as being ++** a compound token. ++** ++** 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 a function, the Expr.iTable is an integer code ++** representing which function. 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. ++** ++** The Expr.pSelect field points to a SELECT statement. The SELECT might ++** be the right operand of an IN operator. Or, if a scalar SELECT appears ++** in an expression the opcode is TK_SELECT and Expr.pSelect is the only ++** operand. ++*/ ++struct Expr { ++ u8 op; /* Operation performed by this node */ ++ u8 dataType; /* Either SQLITE_SO_TEXT or SQLITE_SO_NUM */ ++ u8 iDb; /* Database referenced by this expression */ ++ u8 flags; /* Various flags. See below */ ++ Expr *pLeft, *pRight; /* Left and right subnodes */ ++ ExprList *pList; /* A list of expressions used as function arguments ++ ** or in " IN (useAgg==TRUE, pull ++ ** result from the iAgg-th element of the aggregator */ ++ Select *pSelect; /* When the expression is a sub-select. Also the ++ ** right side of " IN (