From e883f21fe86726c2527323b54144af6e9feba60f Mon Sep 17 00:00:00 2001 From: guy Date: Thu, 13 Apr 2006 12:44:29 +0000 Subject: [PATCH] Patch level : 2.2 Files correlati : sqlite Ricompilazione Demo : [ ] Commento : Passaggio da Sqlite 2 a Sqlite 3.3.5 git-svn-id: svn://10.65.10.50/trunk@13902 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- sqlite/alter.c | 562 ++++ sqlite/analyze.c | 403 +++ sqlite/attach.c | 460 ++- sqlite/auth.c | 67 +- sqlite/btree.c | 7295 ++++++++++++++++++++++++++++++------------ sqlite/btree.h | 236 +- sqlite/btree_rb.c | 1488 --------- sqlite/build.c | 3066 ++++++++++++------ sqlite/callback.c | 367 +++ sqlite/complete.c | 263 ++ sqlite/config.h | 1 - sqlite/copy.c | 110 - sqlite/date.c | 257 +- sqlite/delete.c | 332 +- sqlite/expr.c | 2664 +++++++++------ sqlite/func.c | 1152 +++++-- sqlite/hash.c | 184 +- sqlite/hash.h | 14 +- sqlite/insert.c | 692 ++-- sqlite/keywordhash.h | 98 + sqlite/legacy.c | 135 + sqlite/main.c | 1844 ++++++----- sqlite/opcodes.c | 283 +- sqlite/opcodes.h | 295 +- sqlite/os.c | 1850 +---------- sqlite/os.h | 521 ++- sqlite/os_common.h | 188 ++ sqlite/os_unix.c | 1995 ++++++++++++ sqlite/os_win.c | 1516 +++++++++ sqlite/pager.c | 3585 +++++++++++++++------ sqlite/pager.h | 143 +- sqlite/parse.c | 4981 ++++++++++++---------------- sqlite/parse.h | 261 +- sqlite/pragma.c | 1253 +++++--- sqlite/prepare.c | 583 ++++ sqlite/printf.c | 489 +-- sqlite/random.c | 15 +- sqlite/select.c | 2984 +++++++++++------ sqlite/shell.c | 722 ++++- sqlite/sqlite.h | 849 ----- sqlite/sqlite3.def | 101 + sqlite/sqlite3.h | 1482 +++++++++ sqlite/sqliteInt.h | 1463 ++++++--- sqlite/table.c | 69 +- sqlite/tclsqlite.c | 2120 ++++++++---- sqlite/tokenize.c | 638 ++-- sqlite/trigger.c | 657 ++-- sqlite/update.c | 316 +- sqlite/utf.c | 596 ++++ sqlite/util.c | 1935 ++++++----- sqlite/vacuum.c | 501 +-- sqlite/vdbe.c | 5388 +++++++++++++++---------------- sqlite/vdbe.h | 86 +- sqlite/vdbeInt.h | 343 +- sqlite/vdbeapi.c | 815 +++++ sqlite/vdbeaux.c | 2164 +++++++++---- sqlite/vdbefifo.c | 114 + sqlite/vdbemem.c | 907 ++++++ sqlite/where.c | 2656 ++++++++++----- 59 files changed, 42398 insertions(+), 24156 deletions(-) create mode 100755 sqlite/alter.c create mode 100755 sqlite/analyze.c delete mode 100755 sqlite/btree_rb.c create mode 100755 sqlite/callback.c create mode 100755 sqlite/complete.c delete mode 100755 sqlite/config.h delete mode 100755 sqlite/copy.c create mode 100755 sqlite/keywordhash.h create mode 100755 sqlite/legacy.c create mode 100755 sqlite/os_common.h create mode 100755 sqlite/os_unix.c create mode 100755 sqlite/os_win.c create mode 100755 sqlite/prepare.c delete mode 100755 sqlite/sqlite.h create mode 100755 sqlite/sqlite3.def create mode 100755 sqlite/sqlite3.h create mode 100755 sqlite/utf.c create mode 100755 sqlite/vdbeapi.c create mode 100755 sqlite/vdbefifo.c create mode 100755 sqlite/vdbemem.c diff --git a/sqlite/alter.c b/sqlite/alter.c new file mode 100755 index 000000000..ccc49c8d5 --- /dev/null +++ b/sqlite/alter.c @@ -0,0 +1,562 @@ +/* +** 2005 February 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that used to generate VDBE code +** that implements the ALTER TABLE command. +** +** $Id: alter.c,v 1.1 2006-04-13 12:44:29 guy Exp $ +*/ +#include "sqliteInt.h" +#include + +/* +** The code in this file only exists if we are not omitting the +** ALTER TABLE logic from the build. +*/ +#ifndef SQLITE_OMIT_ALTERTABLE + + +/* +** This function is used by SQL generated to implement the +** ALTER TABLE command. The first argument is the text of a CREATE TABLE or +** CREATE INDEX command. The second is a table name. The table name in +** the CREATE TABLE or CREATE INDEX statement is replaced with the second +** argument and the result returned. Examples: +** +** sqlite_rename_table('CREATE TABLE abc(a, b, c)', 'def') +** -> 'CREATE TABLE def(a, b, c)' +** +** sqlite_rename_table('CREATE INDEX i ON abc(a)', 'def') +** -> 'CREATE INDEX i ON def(a, b, c)' +*/ +static void renameTableFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + unsigned char const *zSql = sqlite3_value_text(argv[0]); + unsigned char const *zTableName = sqlite3_value_text(argv[1]); + + int token; + Token tname; + unsigned char const *zCsr = zSql; + int len = 0; + char *zRet; + + /* The principle used to locate the table name in the CREATE TABLE + ** statement is that the table name is the first token that is immediatedly + ** followed by a left parenthesis - TK_LP. + */ + if( zSql ){ + do { + /* Store the token that zCsr points to in tname. */ + tname.z = zCsr; + tname.n = len; + + /* Advance zCsr to the next token. Store that token type in 'token', + ** and it's length in 'len' (to be used next iteration of this loop). + */ + do { + zCsr += len; + len = sqlite3GetToken(zCsr, &token); + } while( token==TK_SPACE ); + assert( len>0 ); + } while( token!=TK_LP ); + + zRet = sqlite3MPrintf("%.*s%Q%s", tname.z - zSql, zSql, + zTableName, tname.z+tname.n); + sqlite3_result_text(context, zRet, -1, sqlite3FreeX); + } +} + +#ifndef SQLITE_OMIT_TRIGGER +/* This function is used by SQL generated to implement the ALTER TABLE +** ALTER TABLE command. The first argument is the text of a CREATE TRIGGER +** statement. The second is a table name. The table name in the CREATE +** TRIGGER statement is replaced with the second argument and the result +** returned. This is analagous to renameTableFunc() above, except for CREATE +** TRIGGER, not CREATE INDEX and CREATE TABLE. +*/ +static void renameTriggerFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + unsigned char const *zSql = sqlite3_value_text(argv[0]); + unsigned char const *zTableName = sqlite3_value_text(argv[1]); + + int token; + Token tname; + int dist = 3; + unsigned char const *zCsr = zSql; + int len = 0; + char *zRet; + + /* The principle used to locate the table name in the CREATE TRIGGER + ** statement is that the table name is the first token that is immediatedly + ** preceded by either TK_ON or TK_DOT and immediatedly followed by one + ** of TK_WHEN, TK_BEGIN or TK_FOR. + */ + if( zSql ){ + do { + /* Store the token that zCsr points to in tname. */ + tname.z = zCsr; + tname.n = len; + + /* Advance zCsr to the next token. Store that token type in 'token', + ** and it's length in 'len' (to be used next iteration of this loop). + */ + do { + zCsr += len; + len = sqlite3GetToken(zCsr, &token); + }while( token==TK_SPACE ); + assert( len>0 ); + + /* Variable 'dist' stores the number of tokens read since the most + ** recent TK_DOT or TK_ON. This means that when a WHEN, FOR or BEGIN + ** token is read and 'dist' equals 2, the condition stated above + ** to be met. + ** + ** Note that ON cannot be a database, table or column name, so + ** there is no need to worry about syntax like + ** "CREATE TRIGGER ... ON ON.ON BEGIN ..." etc. + */ + dist++; + if( token==TK_DOT || token==TK_ON ){ + dist = 0; + } + } while( dist!=2 || (token!=TK_WHEN && token!=TK_FOR && token!=TK_BEGIN) ); + + /* Variable tname now contains the token that is the old table-name + ** in the CREATE TRIGGER statement. + */ + zRet = sqlite3MPrintf("%.*s%Q%s", tname.z - zSql, zSql, + zTableName, tname.z+tname.n); + sqlite3_result_text(context, zRet, -1, sqlite3FreeX); + } +} +#endif /* !SQLITE_OMIT_TRIGGER */ + +/* +** Register built-in functions used to help implement ALTER TABLE +*/ +void sqlite3AlterFunctions(sqlite3 *db){ + static const struct { + char *zName; + signed char nArg; + void (*xFunc)(sqlite3_context*,int,sqlite3_value **); + } aFuncs[] = { + { "sqlite_rename_table", 2, renameTableFunc}, +#ifndef SQLITE_OMIT_TRIGGER + { "sqlite_rename_trigger", 2, renameTriggerFunc}, +#endif + }; + int i; + + for(i=0; idb->aDb[1].pSchema; /* Temp db schema */ + + /* If the table is not located in the temp-db (in which case NULL is + ** returned, loop through the tables list of triggers. For each trigger + ** that is not part of the temp-db schema, add a clause to the WHERE + ** expression being built up in zWhere. + */ + if( pTab->pSchema!=pTempSchema ){ + for( pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext ){ + if( pTrig->pSchema==pTempSchema ){ + if( !zWhere ){ + zWhere = sqlite3MPrintf("name=%Q", pTrig->name); + }else{ + tmp = zWhere; + zWhere = sqlite3MPrintf("%s OR name=%Q", zWhere, pTrig->name); + sqliteFree(tmp); + } + } + } + } + return zWhere; +} + +/* +** Generate code to drop and reload the internal representation of table +** pTab from the database, including triggers and temporary triggers. +** Argument zName is the name of the table in the database schema at +** the time the generated code is executed. This can be different from +** pTab->zName if this function is being called to code part of an +** "ALTER TABLE RENAME TO" statement. +*/ +static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){ + Vdbe *v; + char *zWhere; + int iDb; /* Index of database containing pTab */ +#ifndef SQLITE_OMIT_TRIGGER + Trigger *pTrig; +#endif + + v = sqlite3GetVdbe(pParse); + if( !v ) return; + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + assert( iDb>=0 ); + +#ifndef SQLITE_OMIT_TRIGGER + /* Drop any table triggers from the internal schema. */ + for(pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext){ + int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema); + assert( iTrigDb==iDb || iTrigDb==1 ); + sqlite3VdbeOp3(v, OP_DropTrigger, iTrigDb, 0, pTrig->name, 0); + } +#endif + + /* Drop the table and index from the internal schema */ + sqlite3VdbeOp3(v, OP_DropTable, iDb, 0, pTab->zName, 0); + + /* Reload the table, index and permanent trigger schemas. */ + zWhere = sqlite3MPrintf("tbl_name=%Q", zName); + if( !zWhere ) return; + sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, zWhere, P3_DYNAMIC); + +#ifndef SQLITE_OMIT_TRIGGER + /* Now, if the table is not stored in the temp database, reload any temp + ** triggers. Don't use IN(...) in case SQLITE_OMIT_SUBQUERY is defined. + */ + if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){ + sqlite3VdbeOp3(v, OP_ParseSchema, 1, 0, zWhere, P3_DYNAMIC); + } +#endif +} + +/* +** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy" +** command. +*/ +void sqlite3AlterRenameTable( + Parse *pParse, /* Parser context. */ + SrcList *pSrc, /* The table to rename. */ + Token *pName /* The new table name. */ +){ + int iDb; /* Database that contains the table */ + char *zDb; /* Name of database iDb */ + Table *pTab; /* Table being renamed */ + char *zName = 0; /* NULL-terminated version of pName */ + sqlite3 *db = pParse->db; /* Database connection */ + Vdbe *v; +#ifndef SQLITE_OMIT_TRIGGER + char *zWhere = 0; /* Where clause to locate temp triggers */ +#endif + + if( sqlite3MallocFailed() ) goto exit_rename_table; + assert( pSrc->nSrc==1 ); + + pTab = sqlite3LocateTable(pParse, pSrc->a[0].zName, pSrc->a[0].zDatabase); + if( !pTab ) goto exit_rename_table; + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + zDb = db->aDb[iDb].zName; + + /* Get a NULL terminated version of the new table name. */ + zName = sqlite3NameFromToken(pName); + if( !zName ) goto exit_rename_table; + + /* Check that a table or index named 'zName' does not already exist + ** in database iDb. If so, this is an error. + */ + if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){ + sqlite3ErrorMsg(pParse, + "there is already another table or index with this name: %s", zName); + goto exit_rename_table; + } + + /* Make sure it is not a system table being altered, or a reserved name + ** that the table is being renamed to. + */ + if( strlen(pTab->zName)>6 && 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) ){ + sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName); + goto exit_rename_table; + } + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ + goto exit_rename_table; + } + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + goto exit_rename_table; + } +#endif + + /* Begin a transaction and code the VerifyCookie for database iDb. + ** Then modify the schema cookie (since the ALTER TABLE modifies the + ** schema). + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + goto exit_rename_table; + } + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3ChangeCookie(db, v, iDb); + + /* Modify the sqlite_master table to use the new table name. */ + sqlite3NestedParse(pParse, + "UPDATE %Q.%s SET " +#ifdef SQLITE_OMIT_TRIGGER + "sql = sqlite_rename_table(sql, %Q), " +#else + "sql = CASE " + "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)" + "ELSE sqlite_rename_table(sql, %Q) END, " +#endif + "tbl_name = %Q, " + "name = CASE " + "WHEN type='table' THEN %Q " + "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN " + "'sqlite_autoindex_' || %Q || substr(name, %d+18,10) " + "ELSE name END " + "WHERE tbl_name=%Q AND " + "(type='table' OR type='index' OR type='trigger');", + zDb, SCHEMA_TABLE(iDb), zName, zName, zName, +#ifndef SQLITE_OMIT_TRIGGER + zName, +#endif + zName, strlen(pTab->zName), pTab->zName + ); + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* If the sqlite_sequence table exists in this database, then update + ** it with the new table name. + */ + if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){ + sqlite3NestedParse(pParse, + "UPDATE %Q.sqlite_sequence set name = %Q WHERE name = %Q", + zDb, zName, pTab->zName); + } +#endif + +#ifndef SQLITE_OMIT_TRIGGER + /* If there are TEMP triggers on this table, modify the sqlite_temp_master + ** table. Don't do this if the table being ALTERed is itself located in + ** the temp database. + */ + if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){ + sqlite3NestedParse(pParse, + "UPDATE sqlite_temp_master SET " + "sql = sqlite_rename_trigger(sql, %Q), " + "tbl_name = %Q " + "WHERE %s;", zName, zName, zWhere); + sqliteFree(zWhere); + } +#endif + + /* Drop and reload the internal table schema. */ + reloadTableSchema(pParse, pTab, zName); + +exit_rename_table: + sqlite3SrcListDelete(pSrc); + sqliteFree(zName); +} + + +/* +** This function is called after an "ALTER TABLE ... ADD" statement +** has been parsed. Argument pColDef contains the text of the new +** column definition. +** +** The Table structure pParse->pNewTable was extended to include +** the new column during parsing. +*/ +void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){ + Table *pNew; /* Copy of pParse->pNewTable */ + Table *pTab; /* Table being altered */ + int iDb; /* Database number */ + const char *zDb; /* Database name */ + const char *zTab; /* Table name */ + char *zCol; /* Null-terminated column definition */ + Column *pCol; /* The new column */ + Expr *pDflt; /* Default value for the new column */ + + if( pParse->nErr ) return; + pNew = pParse->pNewTable; + assert( pNew ); + + iDb = sqlite3SchemaToIndex(pParse->db, pNew->pSchema); + zDb = pParse->db->aDb[iDb].zName; + zTab = pNew->zName; + pCol = &pNew->aCol[pNew->nCol-1]; + pDflt = pCol->pDflt; + pTab = sqlite3FindTable(pParse->db, zTab, zDb); + assert( pTab ); + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + return; + } +#endif + + /* If the default value for the new column was specified with a + ** literal NULL, then set pDflt to 0. This simplifies checking + ** for an SQL NULL default below. + */ + if( pDflt && pDflt->op==TK_NULL ){ + pDflt = 0; + } + + /* Check that the new column is not specified as PRIMARY KEY or UNIQUE. + ** If there is a NOT NULL constraint, then the default value for the + ** column must not be NULL. + */ + if( pCol->isPrimKey ){ + sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column"); + return; + } + if( pNew->pIndex ){ + sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column"); + return; + } + if( pCol->notNull && !pDflt ){ + sqlite3ErrorMsg(pParse, + "Cannot add a NOT NULL column with default value NULL"); + return; + } + + /* Ensure the default expression is something that sqlite3ValueFromExpr() + ** can handle (i.e. not CURRENT_TIME etc.) + */ + if( pDflt ){ + sqlite3_value *pVal; + if( sqlite3ValueFromExpr(pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal) ){ + /* malloc() has failed */ + return; + } + if( !pVal ){ + sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default"); + return; + } + sqlite3ValueFree(pVal); + } + + /* Modify the CREATE TABLE statement. */ + zCol = sqliteStrNDup((char*)pColDef->z, pColDef->n); + if( zCol ){ + char *zEnd = &zCol[pColDef->n-1]; + while( (zEnd>zCol && *zEnd==';') || isspace(*(unsigned char *)zEnd) ){ + *zEnd-- = '\0'; + } + sqlite3NestedParse(pParse, + "UPDATE %Q.%s SET " + "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d,length(sql)) " + "WHERE type = 'table' AND name = %Q", + zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1, + zTab + ); + sqliteFree(zCol); + } + + /* If the default value of the new column is NULL, then set the file + ** format to 2. If the default value of the new column is not NULL, + ** the file format becomes 3. + */ + sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2); + + /* Reload the schema of the modified table. */ + reloadTableSchema(pParse, pTab, pTab->zName); +} + +/* +** This function is called by the parser after the table-name in +** an "ALTER TABLE ADD" statement is parsed. Argument +** pSrc is the full-name of the table being altered. +** +** This routine makes a (partial) copy of the Table structure +** for the table being altered and sets Parse.pNewTable to point +** to it. Routines called by the parser as the column definition +** is parsed (i.e. sqlite3AddColumn()) add the new Column data to +** the copy. The copy of the Table structure is deleted by tokenize.c +** after parsing is finished. +** +** Routine sqlite3AlterFinishAddColumn() will be called to complete +** coding the "ALTER TABLE ... ADD" statement. +*/ +void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){ + Table *pNew; + Table *pTab; + Vdbe *v; + int iDb; + int i; + int nAlloc; + + /* Look up the table being altered. */ + assert( pParse->pNewTable==0 ); + if( sqlite3MallocFailed() ) goto exit_begin_add_column; + pTab = sqlite3LocateTable(pParse, pSrc->a[0].zName, pSrc->a[0].zDatabase); + if( !pTab ) goto exit_begin_add_column; + + /* Make sure this is not an attempt to ALTER a view. */ + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "Cannot add a column to a view"); + goto exit_begin_add_column; + } + + assert( pTab->addColOffset>0 ); + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + + /* Put a copy of the Table struct in Parse.pNewTable for the + ** sqlite3AddColumn() function and friends to modify. + */ + pNew = (Table *)sqliteMalloc(sizeof(Table)); + if( !pNew ) goto exit_begin_add_column; + pParse->pNewTable = pNew; + pNew->nRef = 1; + pNew->nCol = pTab->nCol; + assert( pNew->nCol>0 ); + nAlloc = (((pNew->nCol-1)/8)*8)+8; + assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 ); + pNew->aCol = (Column *)sqliteMalloc(sizeof(Column)*nAlloc); + pNew->zName = sqliteStrDup(pTab->zName); + if( !pNew->aCol || !pNew->zName ){ + goto exit_begin_add_column; + } + memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol); + for(i=0; inCol; i++){ + Column *pCol = &pNew->aCol[i]; + pCol->zName = sqliteStrDup(pCol->zName); + pCol->zColl = 0; + pCol->zType = 0; + pCol->pDflt = 0; + } + pNew->pSchema = pParse->db->aDb[iDb].pSchema; + pNew->addColOffset = pTab->addColOffset; + pNew->nRef = 1; + + /* Begin a transaction and increment the schema cookie. */ + sqlite3BeginWriteOperation(pParse, 0, iDb); + v = sqlite3GetVdbe(pParse); + if( !v ) goto exit_begin_add_column; + sqlite3ChangeCookie(pParse->db, v, iDb); + +exit_begin_add_column: + sqlite3SrcListDelete(pSrc); + return; +} +#endif /* SQLITE_ALTER_TABLE */ diff --git a/sqlite/analyze.c b/sqlite/analyze.c new file mode 100755 index 000000000..557cd3c86 --- /dev/null +++ b/sqlite/analyze.c @@ -0,0 +1,403 @@ +/* +** 2005 July 8 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code associated with the ANALYZE command. +** +** @(#) $Id: analyze.c,v 1.1 2006-04-13 12:44:29 guy Exp $ +*/ +#ifndef SQLITE_OMIT_ANALYZE +#include "sqliteInt.h" + +/* +** This routine generates code that opens the sqlite_stat1 table on cursor +** iStatCur. +** +** If the sqlite_stat1 tables does not previously exist, it is created. +** If it does previously exist, all entires associated with table zWhere +** are removed. If zWhere==0 then all entries are removed. +*/ +static void openStatTable( + Parse *pParse, /* Parsing context */ + int iDb, /* The database we are looking in */ + int iStatCur, /* Open the sqlite_stat1 table on this cursor */ + const char *zWhere /* Delete entries associated with this table */ +){ + sqlite3 *db = pParse->db; + Db *pDb; + int iRootPage; + Table *pStat; + Vdbe *v = sqlite3GetVdbe(pParse); + + pDb = &db->aDb[iDb]; + if( (pStat = sqlite3FindTable(db, "sqlite_stat1", pDb->zName))==0 ){ + /* The sqlite_stat1 tables does not exist. Create it. + ** Note that a side-effect of the CREATE TABLE statement is to leave + ** the rootpage of the new table on the top of the stack. This is + ** important because the OpenWrite opcode below will be needing it. */ + sqlite3NestedParse(pParse, + "CREATE TABLE %Q.sqlite_stat1(tbl,idx,stat)", + pDb->zName + ); + iRootPage = 0; /* Cause rootpage to be taken from top of stack */ + }else if( zWhere ){ + /* The sqlite_stat1 table exists. Delete all entries associated with + ** the table zWhere. */ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.sqlite_stat1 WHERE tbl=%Q", + pDb->zName, zWhere + ); + iRootPage = pStat->tnum; + }else{ + /* The sqlite_stat1 table already exists. Delete all rows. */ + iRootPage = pStat->tnum; + sqlite3VdbeAddOp(v, OP_Clear, pStat->tnum, iDb); + } + + /* Open the sqlite_stat1 table for writing. Unless it was created + ** by this vdbe program, lock it for writing at the shared-cache level. + ** If this vdbe did create the sqlite_stat1 table, then it must have + ** already obtained a schema-lock, making the write-lock redundant. + */ + if( iRootPage>0 ){ + sqlite3TableLock(pParse, iDb, iRootPage, 1, "sqlite_stat1"); + } + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + sqlite3VdbeAddOp(v, OP_OpenWrite, iStatCur, iRootPage); + sqlite3VdbeAddOp(v, OP_SetNumColumns, iStatCur, 3); +} + +/* +** Generate code to do an analysis of all indices associated with +** a single table. +*/ +static void analyzeOneTable( + Parse *pParse, /* Parser context */ + Table *pTab, /* Table whose indices are to be analyzed */ + int iStatCur, /* Cursor that writes to the sqlite_stat1 table */ + int iMem /* Available memory locations begin here */ +){ + Index *pIdx; /* An index to being analyzed */ + int iIdxCur; /* Cursor number for index being analyzed */ + int nCol; /* Number of columns in the index */ + Vdbe *v; /* The virtual machine being built up */ + int i; /* Loop counter */ + int topOfLoop; /* The top of the loop */ + int endOfLoop; /* The end of the loop */ + int addr; /* The address of an instruction */ + int iDb; /* Index of database containing pTab */ + + v = sqlite3GetVdbe(pParse); + if( pTab==0 || pTab->pIndex==0 ){ + /* Do no analysis for tables that have no indices */ + return; + } + + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + assert( iDb>=0 ); +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0, + pParse->db->aDb[iDb].zName ) ){ + return; + } +#endif + + /* Establish a read-lock on the table at the shared-cache level. */ + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + + iIdxCur = pParse->nTab; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx); + + /* Open a cursor to the index to be analyzed + */ + assert( iDb==sqlite3SchemaToIndex(pParse->db, pIdx->pSchema) ); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + VdbeComment((v, "# %s", pIdx->zName)); + sqlite3VdbeOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, + (char *)pKey, P3_KEYINFO_HANDOFF); + nCol = pIdx->nColumn; + if( iMem+nCol*2>=pParse->nMem ){ + pParse->nMem = iMem+nCol*2+1; + } + sqlite3VdbeAddOp(v, OP_SetNumColumns, iIdxCur, nCol+1); + + /* Memory cells are used as follows: + ** + ** mem[iMem]: The total number of rows in the table. + ** mem[iMem+1]: Number of distinct values in column 1 + ** ... + ** mem[iMem+nCol]: Number of distinct values in column N + ** mem[iMem+nCol+1] Last observed value of column 1 + ** ... + ** mem[iMem+nCol+nCol]: Last observed value of column N + ** + ** Cells iMem through iMem+nCol are initialized to 0. The others + ** are initialized to NULL. + */ + for(i=0; i<=nCol; i++){ + sqlite3VdbeAddOp(v, OP_MemInt, 0, iMem+i); + } + for(i=0; i0 then it is always the case the D>0 so division by zero + ** is never possible. + */ + sqlite3VdbeAddOp(v, OP_MemLoad, iMem, 0); + addr = sqlite3VdbeAddOp(v, OP_IfNot, 0, 0); + sqlite3VdbeAddOp(v, OP_NewRowid, iStatCur, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->zName, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pIdx->zName, 0); + sqlite3VdbeAddOp(v, OP_MemLoad, iMem, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, " ", 0); + for(i=0; idb; + Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */ + HashElem *k; + int iStatCur; + int iMem; + + sqlite3BeginWriteOperation(pParse, 0, iDb); + iStatCur = pParse->nTab++; + openStatTable(pParse, iDb, iStatCur, 0); + iMem = pParse->nMem; + for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){ + Table *pTab = (Table*)sqliteHashData(k); + analyzeOneTable(pParse, pTab, iStatCur, iMem); + } + loadAnalysis(pParse, iDb); +} + +/* +** Generate code that will do an analysis of a single table in +** a database. +*/ +static void analyzeTable(Parse *pParse, Table *pTab){ + int iDb; + int iStatCur; + + assert( pTab!=0 ); + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3BeginWriteOperation(pParse, 0, iDb); + iStatCur = pParse->nTab++; + openStatTable(pParse, iDb, iStatCur, pTab->zName); + analyzeOneTable(pParse, pTab, iStatCur, pParse->nMem); + loadAnalysis(pParse, iDb); +} + +/* +** Generate code for the ANALYZE command. The parser calls this routine +** when it recognizes an ANALYZE command. +** +** ANALYZE -- 1 +** ANALYZE -- 2 +** ANALYZE ?.? -- 3 +** +** Form 1 causes all indices in all attached databases to be analyzed. +** Form 2 analyzes all indices the single database named. +** Form 3 analyzes all indices associated with the named table. +*/ +void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){ + sqlite3 *db = pParse->db; + int iDb; + int i; + char *z, *zDb; + Table *pTab; + Token *pTableName; + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return; + } + + if( pName1==0 ){ + /* Form 1: Analyze everything */ + for(i=0; inDb; i++){ + if( i==1 ) continue; /* Do not analyze the TEMP database */ + analyzeDatabase(pParse, i); + } + }else if( pName2==0 || pName2->n==0 ){ + /* Form 2: Analyze the database or table named */ + iDb = sqlite3FindDb(db, pName1); + if( iDb>=0 ){ + analyzeDatabase(pParse, iDb); + }else{ + z = sqlite3NameFromToken(pName1); + pTab = sqlite3LocateTable(pParse, z, 0); + sqliteFree(z); + if( pTab ){ + analyzeTable(pParse, pTab); + } + } + }else{ + /* Form 3: Analyze the fully qualified table name */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName); + if( iDb>=0 ){ + zDb = db->aDb[iDb].zName; + z = sqlite3NameFromToken(pTableName); + pTab = sqlite3LocateTable(pParse, z, zDb); + sqliteFree(z); + if( pTab ){ + analyzeTable(pParse, pTab); + } + } + } +} + +/* +** Used to pass information from the analyzer reader through to the +** callback routine. +*/ +typedef struct analysisInfo analysisInfo; +struct analysisInfo { + sqlite3 *db; + const char *zDatabase; +}; + +/* +** This callback is invoked once for each index when reading the +** sqlite_stat1 table. +** +** argv[0] = name of the index +** argv[1] = results of analysis - on integer for each column +*/ +static int analysisLoader(void *pData, int argc, char **argv, char **azNotUsed){ + analysisInfo *pInfo = (analysisInfo*)pData; + Index *pIndex; + int i, c; + unsigned int v; + const char *z; + + assert( argc==2 ); + if( argv==0 || argv[0]==0 || argv[1]==0 ){ + return 0; + } + pIndex = sqlite3FindIndex(pInfo->db, argv[0], pInfo->zDatabase); + if( pIndex==0 ){ + return 0; + } + z = argv[1]; + for(i=0; *z && i<=pIndex->nColumn; i++){ + v = 0; + while( (c=z[0])>='0' && c<='9' ){ + v = v*10 + c - '0'; + z++; + } + pIndex->aiRowEst[i] = v; + if( *z==' ' ) z++; + } + return 0; +} + +/* +** Load the content of the sqlite_stat1 table into the index hash tables. +*/ +void sqlite3AnalysisLoad(sqlite3 *db, int iDb){ + analysisInfo sInfo; + HashElem *i; + char *zSql; + + /* Clear any prior statistics */ + for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){ + Index *pIdx = sqliteHashData(i); + sqlite3DefaultRowEst(pIdx); + } + + /* Check to make sure the sqlite_stat1 table existss */ + sInfo.db = db; + sInfo.zDatabase = db->aDb[iDb].zName; + if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){ + return; + } + + + /* Load new statistics out of the sqlite_stat1 table */ + zSql = sqlite3MPrintf("SELECT idx, stat FROM %Q.sqlite_stat1", + sInfo.zDatabase); + sqlite3SafetyOff(db); + sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0); + sqlite3SafetyOn(db); + sqliteFree(zSql); +} + + +#endif /* SQLITE_OMIT_ANALYZE */ diff --git a/sqlite/attach.c b/sqlite/attach.c index c79b67753..107451022 100755 --- a/sqlite/attach.c +++ b/sqlite/attach.c @@ -11,165 +11,347 @@ ************************************************************************* ** This file contains code used to implement the ATTACH and DETACH commands. ** -** $Id: attach.c,v 1.1.1.1 2004-03-11 22:22:22 alex Exp $ +** $Id: attach.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #include "sqliteInt.h" /* -** This routine is called by the parser to process an ATTACH statement: +** Resolve an expression that was part of an ATTACH or DETACH statement. This +** is slightly different from resolving a normal SQL expression, because simple +** identifiers are treated as strings, not possible column names or aliases. ** -** ATTACH DATABASE filename AS dbname +** i.e. if the parser sees: ** -** The pFilename and pDbname arguments are the tokens that define the -** filename and dbname in the ATTACH statement. +** ATTACH DATABASE abc AS def +** +** it treats the two expressions as literal strings 'abc' and 'def' instead of +** looking for columns of the same name. +** +** This only applies to the root node of pExpr, so the statement: +** +** ATTACH DATABASE abc||def AS 'db2' +** +** will fail because neither abc or def can be resolved. */ -void sqliteAttach(Parse *pParse, Token *pFilename, Token *pDbname, Token *pKey){ +static int resolveAttachExpr(NameContext *pName, Expr *pExpr) +{ + int rc = SQLITE_OK; + if( pExpr ){ + if( pExpr->op!=TK_ID ){ + rc = sqlite3ExprResolveNames(pName, pExpr); + }else{ + pExpr->op = TK_STRING; + } + } + return rc; +} + +/* +** An SQL user-function registered to do the work of an ATTACH statement. The +** three arguments to the function come directly from an attach statement: +** +** ATTACH DATABASE x AS y KEY z +** +** SELECT sqlite_attach(x, y, z) +** +** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the +** third argument. +*/ +static void attachFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + int rc = 0; + sqlite3 *db = sqlite3_user_data(context); + const char *zName; + const char *zFile; Db *aNew; - int rc, i; - char *zFile, *zName; - sqlite *db; - Vdbe *v; + char zErr[128]; + char *zErrDyn = 0; - v = sqliteGetVdbe(pParse); - sqliteVdbeAddOp(v, OP_Halt, 0, 0); - if( pParse->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; - } + zFile = (const char *)sqlite3_value_text(argv[0]); + zName = (const char *)sqlite3_value_text(argv[1]); + + /* Check for the following errors: + ** + ** * Too many attached databases, + ** * Transaction currently open + ** * Specified database name already being used. + */ if( db->nDb>=MAX_ATTACHED+2 ){ - sqliteErrorMsg(pParse, "too many attached databases - max %d", - MAX_ATTACHED); - pParse->rc = SQLITE_ERROR; - return; + sqlite3_snprintf( + 127, zErr, "too many attached databases - max %d", MAX_ATTACHED + ); + goto attach_error; } - - 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; + if( !db->autoCommit ){ + strcpy(zErr, "cannot ATTACH database within transaction"); + goto attach_error; } -#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; + char *z = db->aDb[i].zName; + if( z && sqlite3StrICmp(z, zName)==0 ){ + sqlite3_snprintf(127, zErr, "database %s is already in use", zName); + goto attach_error; } } + /* Allocate the new entry in the db->aDb[] array and initialise the schema + ** hash tables. + */ if( db->aDb==db->aDbStatic ){ aNew = sqliteMalloc( sizeof(db->aDb[0])*3 ); - if( aNew==0 ) return; + 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; + 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); + + /* Open the database file. If the btree is successfully opened, use + ** it to obtain the database schema. At this point the schema may + ** or may not be initialised. + */ + rc = sqlite3BtreeFactory(db, zFile, 0, MAX_PAGES, &aNew->pBt); + if( rc==SQLITE_OK ){ + aNew->pSchema = sqlite3SchemaGet(aNew->pBt); + if( !aNew->pSchema ){ + rc = SQLITE_NOMEM; + }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){ + strcpy(zErr, + "attached databases must use the same text encoding as main database"); + goto attach_error; + } } + aNew->zName = sqliteStrDup(zName); + aNew->safety_level = 3; + #if SQLITE_HAS_CODEC { - extern int sqliteCodecAttach(sqlite*, int, void*, int); - char *zKey = 0; + extern int sqlite3CodecAttach(sqlite3*, int, void*, int); + extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*); 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; + char *zKey; + int t = sqlite3_value_type(argv[2]); + switch( t ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: + zErrDyn = sqliteStrDup("Invalid key value"); + rc = SQLITE_ERROR; + break; + + case SQLITE_TEXT: + case SQLITE_BLOB: + nKey = sqlite3_value_bytes(argv[2]); + zKey = (char *)sqlite3_value_blob(argv[2]); + sqlite3CodecAttach(db, db->nDb-1, zKey, nKey); + break; + + case SQLITE_NULL: + /* No key specified. Use the key from the main database */ + sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey); + sqlite3CodecAttach(db, db->nDb-1, zKey, nKey); + break; } - sqliteCodecAttach(db, db->nDb-1, zKey, nKey); } #endif - sqliteFree(zFile); - db->flags &= ~SQLITE_Initialized; - if( pParse->nErr ) return; + + /* If the file was opened successfully, read the schema for the new database. + ** If this fails, or if opening the file failed, then close the file and + ** remove the entry from the db->aDb[] array. i.e. put everything back the way + ** we found it. + */ if( rc==SQLITE_OK ){ - rc = sqliteInit(pParse->db, &pParse->zErrMsg); + sqlite3SafetyOn(db); + rc = sqlite3Init(db, &zErrDyn); + sqlite3SafetyOff(db); } 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; + int iDb = db->nDb - 1; + assert( iDb>=2 ); + if( db->aDb[iDb].pBt ){ + sqlite3BtreeClose(db->aDb[iDb].pBt); + db->aDb[iDb].pBt = 0; + db->aDb[iDb].pSchema = 0; } - sqliteResetInternalSchema(db, 0); - pParse->nErr++; - pParse->rc = SQLITE_ERROR; + sqlite3ResetInternalSchema(db, 0); + db->nDb = iDb; + if( rc==SQLITE_NOMEM ){ + sqlite3MallocFailed(); + sqlite3_snprintf(127, zErr, "out of memory"); + }else{ + sqlite3_snprintf(127, zErr, "unable to open database: %s", zFile); + } + goto attach_error; + } + + return; + +attach_error: + /* Return an error if we get here */ + if( zErrDyn ){ + sqlite3_result_error(context, zErrDyn, -1); + sqliteFree(zErrDyn); + }else{ + zErr[sizeof(zErr)-1] = 0; + sqlite3_result_error(context, zErr, -1); } } /* -** This routine is called by the parser to process a DETACH statement: +** An SQL user-function registered to do the work of an DETACH statement. The +** three arguments to the function come directly from a detach statement: ** -** DETACH DATABASE dbname +** DETACH DATABASE x ** -** The pDbname argument is the name of the database in the DETACH statement. +** SELECT sqlite_detach(x) */ -void sqliteDetach(Parse *pParse, Token *pDbname){ +static void detachFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zName = (const char *)sqlite3_value_text(argv[0]); + sqlite3 *db = sqlite3_user_data(context); int i; - sqlite *db; - Vdbe *v; + Db *pDb = 0; + char zErr[128]; - v = sqliteGetVdbe(pParse); - sqliteVdbeAddOp(v, OP_Halt, 0, 0); - if( pParse->explain ) return; - db = pParse->db; + assert(zName); for(i=0; inDb; i++){ - if( db->aDb[i].pBt==0 || db->aDb[i].zName==0 ) continue; - if( strlen(db->aDb[i].zName)!=pDbname->n ) continue; - if( sqliteStrNICmp(db->aDb[i].zName, pDbname->z, pDbname->n)==0 ) break; + pDb = &db->aDb[i]; + if( pDb->pBt==0 ) continue; + if( sqlite3StrICmp(pDb->zName, zName)==0 ) break; } + if( i>=db->nDb ){ - sqliteErrorMsg(pParse, "no such database: %T", pDbname); - return; + sqlite3_snprintf(sizeof(zErr), zErr, "no such database: %s", zName); + goto detach_error; } if( i<2 ){ - sqliteErrorMsg(pParse, "cannot detach database %T", pDbname); - return; + sqlite3_snprintf(sizeof(zErr), zErr, "cannot detach database %s", zName); + goto detach_error; } + if( !db->autoCommit ){ + strcpy(zErr, "cannot DETACH database within transaction"); + goto detach_error; + } + + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + pDb->pSchema = 0; + sqlite3ResetInternalSchema(db, 0); + return; + +detach_error: + sqlite3_result_error(context, zErr, -1); +} + +/* +** This procedure generates VDBE code for a single invocation of either the +** sqlite_detach() or sqlite_attach() SQL user functions. +*/ +static void codeAttach( + Parse *pParse, /* The parser context */ + int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */ + const char *zFunc, /* Either "sqlite_attach" or "sqlite_detach */ + int nFunc, /* Number of args to pass to zFunc */ + Expr *pAuthArg, /* Expression to pass to authorization callback */ + Expr *pFilename, /* Name of database file */ + Expr *pDbname, /* Name of the database to use internally */ + Expr *pKey /* Database key for encryption extension */ +){ + int rc; + NameContext sName; + Vdbe *v; + FuncDef *pFunc; + sqlite3* db = pParse->db; + #ifndef SQLITE_OMIT_AUTHORIZATION - if( sqliteAuthCheck(pParse,SQLITE_DETACH,db->aDb[i].zName,0,0)!=SQLITE_OK ){ - return; + assert( sqlite3MallocFailed() || pAuthArg ); + if( pAuthArg ){ + char *zAuthArg = sqlite3NameFromToken(&pAuthArg->span); + if( !zAuthArg ){ + goto attach_end; + } + rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0); + sqliteFree(zAuthArg); + if(rc!=SQLITE_OK ){ + goto attach_end; + } } #endif /* SQLITE_OMIT_AUTHORIZATION */ - sqliteBtreeClose(db->aDb[i].pBt); - db->aDb[i].pBt = 0; - sqliteFree(db->aDb[i].zName); - sqliteResetInternalSchema(db, i); - db->nDb--; - if( inDb ){ - db->aDb[i] = db->aDb[db->nDb]; - memset(&db->aDb[db->nDb], 0, sizeof(db->aDb[0])); - sqliteResetInternalSchema(db, i); + + memset(&sName, 0, sizeof(NameContext)); + sName.pParse = pParse; + + if( + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) || + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) || + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey)) + ){ + pParse->nErr++; + goto attach_end; } + + v = sqlite3GetVdbe(pParse); + sqlite3ExprCode(pParse, pFilename); + sqlite3ExprCode(pParse, pDbname); + sqlite3ExprCode(pParse, pKey); + + assert( v || sqlite3MallocFailed() ); + if( v ){ + sqlite3VdbeAddOp(v, OP_Function, 0, nFunc); + pFunc = sqlite3FindFunction(db, zFunc, strlen(zFunc), nFunc, SQLITE_UTF8,0); + sqlite3VdbeChangeP3(v, -1, (char *)pFunc, P3_FUNCDEF); + + /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this + ** statement only). For DETACH, set it to false (expire all existing + ** statements). + */ + sqlite3VdbeAddOp(v, OP_Expire, (type==SQLITE_ATTACH), 0); + } + +attach_end: + sqlite3ExprDelete(pFilename); + sqlite3ExprDelete(pDbname); + sqlite3ExprDelete(pKey); +} + +/* +** Called by the parser to compile a DETACH statement. +** +** DETACH pDbname +*/ +void sqlite3Detach(Parse *pParse, Expr *pDbname){ + codeAttach(pParse, SQLITE_DETACH, "sqlite_detach", 1, pDbname, 0, 0, pDbname); +} + +/* +** Called by the parser to compile an ATTACH statement. +** +** ATTACH p AS pDbname KEY pKey +*/ +void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){ + codeAttach(pParse, SQLITE_ATTACH, "sqlite_attach", 3, p, p, pDbname, pKey); +} + +/* +** Register the functions sqlite_attach and sqlite_detach. +*/ +void sqlite3AttachFunctions(sqlite3 *db){ + static const int enc = SQLITE_UTF8; + sqlite3CreateFunc(db, "sqlite_attach", 3, enc, db, attachFunc, 0, 0); + sqlite3CreateFunc(db, "sqlite_detach", 1, enc, db, detachFunc, 0, 0); } /* @@ -179,14 +361,14 @@ void sqliteDetach(Parse *pParse, Token *pDbname){ ** 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( +int sqlite3FixInit( 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 */ + int iDb, /* This is the database that must be used */ const char *zType, /* "view", "trigger", or "index" */ const Token *pName /* Name of the view, trigger, or index */ ){ - sqlite *db; + sqlite3 *db; if( iDb<0 || iDb==1 ) return 0; db = pParse->db; @@ -202,7 +384,7 @@ int sqliteFixInit( ** 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(). +** must have been initialized by a prior call to sqlite3FixInit(). ** ** These routines are used to make sure that an index, trigger, or ** view in one database does not refer to objects in a different database. @@ -212,97 +394,105 @@ int sqliteFixInit( ** pParse->zErrMsg and these routines return non-zero. If everything ** checks out, these routines return 0. */ -int sqliteFixSrcList( +int sqlite3FixSrcList( DbFixer *pFix, /* Context of the fixation */ SrcList *pList /* The Source list to check and modify */ ){ int i; const char *zDb; + struct SrcList_item *pItem; if( 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); + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pItem->zDatabase==0 ){ + pItem->zDatabase = sqliteStrDup(zDb); + }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){ + sqlite3ErrorMsg(pFix->pParse, + "%s %T cannot reference objects in database %s", + pFix->zType, pFix->pName, pItem->zDatabase); return 1; } - if( sqliteFixSelect(pFix, pList->a[i].pSelect) ) return 1; - if( sqliteFixExpr(pFix, pList->a[i].pOn) ) return 1; +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) + if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1; + if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1; +#endif } return 0; } -int sqliteFixSelect( +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) +int sqlite3FixSelect( DbFixer *pFix, /* Context of the fixation */ Select *pSelect /* The SELECT statement to be fixed to one database */ ){ while( pSelect ){ - if( sqliteFixExprList(pFix, pSelect->pEList) ){ + if( sqlite3FixExprList(pFix, pSelect->pEList) ){ return 1; } - if( sqliteFixSrcList(pFix, pSelect->pSrc) ){ + if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){ return 1; } - if( sqliteFixExpr(pFix, pSelect->pWhere) ){ + if( sqlite3FixExpr(pFix, pSelect->pWhere) ){ return 1; } - if( sqliteFixExpr(pFix, pSelect->pHaving) ){ + if( sqlite3FixExpr(pFix, pSelect->pHaving) ){ return 1; } pSelect = pSelect->pPrior; } return 0; } -int sqliteFixExpr( +int sqlite3FixExpr( DbFixer *pFix, /* Context of the fixation */ Expr *pExpr /* The expression to be fixed to one database */ ){ while( pExpr ){ - if( sqliteFixSelect(pFix, pExpr->pSelect) ){ + if( sqlite3FixSelect(pFix, pExpr->pSelect) ){ return 1; } - if( sqliteFixExprList(pFix, pExpr->pList) ){ + if( sqlite3FixExprList(pFix, pExpr->pList) ){ return 1; } - if( sqliteFixExpr(pFix, pExpr->pRight) ){ + if( sqlite3FixExpr(pFix, pExpr->pRight) ){ return 1; } pExpr = pExpr->pLeft; } return 0; } -int sqliteFixExprList( +int sqlite3FixExprList( DbFixer *pFix, /* Context of the fixation */ ExprList *pList /* The expression to be fixed to one database */ ){ int i; + struct ExprList_item *pItem; if( pList==0 ) return 0; - for(i=0; inExpr; i++){ - if( sqliteFixExpr(pFix, pList->a[i].pExpr) ){ + for(i=0, pItem=pList->a; inExpr; i++, pItem++){ + if( sqlite3FixExpr(pFix, pItem->pExpr) ){ return 1; } } return 0; } -int sqliteFixTriggerStep( +#endif + +#ifndef SQLITE_OMIT_TRIGGER +int sqlite3FixTriggerStep( DbFixer *pFix, /* Context of the fixation */ TriggerStep *pStep /* The trigger step be fixed to one database */ ){ while( pStep ){ - if( sqliteFixSelect(pFix, pStep->pSelect) ){ + if( sqlite3FixSelect(pFix, pStep->pSelect) ){ return 1; } - if( sqliteFixExpr(pFix, pStep->pWhere) ){ + if( sqlite3FixExpr(pFix, pStep->pWhere) ){ return 1; } - if( sqliteFixExprList(pFix, pStep->pExprList) ){ + if( sqlite3FixExprList(pFix, pStep->pExprList) ){ return 1; } pStep = pStep->pNext; } return 0; } +#endif diff --git a/sqlite/auth.c b/sqlite/auth.c index 006bc555f..a51ff439a 100755 --- a/sqlite/auth.c +++ b/sqlite/auth.c @@ -9,12 +9,12 @@ ** May you share freely, never taking more than you give. ** ************************************************************************* -** This file contains code used to implement the sqlite_set_authorizer() +** This file contains code used to implement the sqlite3_set_authorizer() ** API. This facility is an optional feature of the library. Embedded ** systems that do not need this facility may omit it by recompiling ** the library with -DSQLITE_OMIT_AUTHORIZATION=1 ** -** $Id: auth.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** $Id: auth.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #include "sqliteInt.h" @@ -33,7 +33,6 @@ ** 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 @@ -62,7 +61,7 @@ ** 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 +** means that the SQL statement will never-run - the sqlite3_exec() call ** will return with an error. SQLITE_IGNORE means that the SQL statement ** should run but attempts to read the specified column will return NULL ** and attempts to write the column will be ignored. @@ -70,13 +69,14 @@ ** 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 sqlite3_set_authorizer( + sqlite3 *db, int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), void *pArg ){ db->xAuth = xAuth; db->pAuthArg = pArg; + sqlite3ExpirePreparedStatements(db); return SQLITE_OK; } @@ -85,10 +85,10 @@ int sqlite_set_authorizer( ** user-supplied authorization function returned an illegal value. */ static void sqliteAuthBadReturnCode(Parse *pParse, int rc){ - sqliteErrorMsg(pParse, "illegal return value (%d) from the " + sqlite3ErrorMsg(pParse, "illegal return value (%d) from the " "authorization function - should be SQLITE_OK, SQLITE_IGNORE, " "or SQLITE_DENY", rc); - pParse->rc = SQLITE_MISUSE; + pParse->rc = SQLITE_ERROR; } /* @@ -100,34 +100,42 @@ static void sqliteAuthBadReturnCode(Parse *pParse, int rc){ ** instruction into a TK_NULL. If the auth function returns SQLITE_DENY, ** then generate an error. */ -void sqliteAuthRead( +void sqlite3AuthRead( 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; + sqlite3 *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 */ + int iDb; /* The index of the database the expression refers to */ if( db->xAuth==0 ) return; + if( pExpr->op==TK_AS ) return; assert( pExpr->op==TK_COLUMN ); - for(iSrc=0; iSrcnSrc; iSrc++){ + iDb = sqlite3SchemaToIndex(pParse->db, pExpr->pSchema); + if( iDb<0 ){ + /* An attempt to read a column out of a subquery or other + ** temporary table. */ + return; + } + for(iSrc=0; pTabList && iSrcnSrc; iSrc++){ if( pExpr->iTable==pTabList->a[iSrc].iCursor ) break; } - if( iSrc>=0 && iSrcnSrc ){ + if( iSrc>=0 && pTabList && iSrcnSrc ){ pTab = pTabList->a[iSrc].pTab; - }else{ + }else if( (pStack = pParse->trigStack)!=0 ){ /* This must be an attempt to read the NEW or OLD pseudo-tables ** of a trigger. */ - TriggerStack *pStack; /* The stack of current triggers */ - pStack = pParse->trigStack; - assert( pStack!=0 ); assert( pExpr->iTable==pStack->newIdx || pExpr->iTable==pStack->oldIdx ); pTab = pStack->pTab; + }else{ + return; } if( pTab==0 ) return; if( pExpr->iColumn>=0 ){ @@ -139,18 +147,18 @@ void sqliteAuthRead( }else{ zCol = "ROWID"; } - assert( pExpr->iDbnDb ); - zDBase = db->aDb[pExpr->iDb].zName; + assert( iDb>=0 && iDbnDb ); + zDBase = db->aDb[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", + if( db->nDb>2 || iDb!=0 ){ + sqlite3ErrorMsg(pParse, "access to %s.%s.%s is prohibited", zDBase, pTab->zName, zCol); }else{ - sqliteErrorMsg(pParse, "access to %s.%s is prohibited", pTab->zName,zCol); + sqlite3ErrorMsg(pParse, "access to %s.%s is prohibited",pTab->zName,zCol); } pParse->rc = SQLITE_AUTH; }else if( rc!=SQLITE_OK ){ @@ -164,22 +172,27 @@ void sqliteAuthRead( ** is returned, then the error count and error message in pParse are ** modified appropriately. */ -int sqliteAuthCheck( +int sqlite3AuthCheck( Parse *pParse, int code, const char *zArg1, const char *zArg2, const char *zArg3 ){ - sqlite *db = pParse->db; + sqlite3 *db = pParse->db; int rc; + /* Don't do any authorization checks if the database is initialising. */ + if( db->init.busy ){ + return SQLITE_OK; + } + if( 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"); + sqlite3ErrorMsg(pParse, "not authorized"); pParse->rc = SQLITE_AUTH; }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){ rc = SQLITE_DENY; @@ -193,7 +206,7 @@ int sqliteAuthCheck( ** zArg3 argument to authorization callbacks will be zContext until ** popped. Or if pParse==0, this routine is a no-op. */ -void sqliteAuthContextPush( +void sqlite3AuthContextPush( Parse *pParse, AuthContext *pContext, const char *zContext @@ -207,9 +220,9 @@ void sqliteAuthContextPush( /* ** Pop an authorization context that was previously pushed -** by sqliteAuthContextPush +** by sqlite3AuthContextPush */ -void sqliteAuthContextPop(AuthContext *pContext){ +void sqlite3AuthContextPop(AuthContext *pContext){ if( pContext->pParse ){ pContext->pParse->zAuthContext = pContext->zAuthContext; pContext->pParse = 0; diff --git a/sqlite/btree.c b/sqlite/btree.c index 248cec5f9..64a14e54f 100755 --- a/sqlite/btree.c +++ b/sqlite/btree.c @@ -1,5 +1,5 @@ /* -** 2001 September 15 +** 2004 April 6 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: @@ -9,7 +9,7 @@ ** May you share freely, never taking more than you give. ** ************************************************************************* -** $Id: btree.c,v 1.1.1.1 2004-03-11 22:22:24 alex Exp $ +** $Id: btree.c,v 1.2 2006-04-13 12:44:29 guy Exp $ ** ** This file implements a external (disk-based) database using BTrees. ** For a detailed discussion of BTrees, refer to @@ -36,282 +36,232 @@ ** ** 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. +** key and data for any entry are combined to form the "payload". A +** fixed amount of payload can be carried directly on the database +** page. If the payload is larger than the preset amount then surplus +** bytes are stored on overflow pages. The payload for an entry +** and the preceding pointer are combined to form a "Cell". Each +** page has a small header which contains the Ptr(N+1) pointer and other +** information such as the size of key and data. ** -** 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. +** FORMAT DETAILS +** +** The file is divided into pages. The first page is called page 1, +** the second is page 2, and so forth. A page number of zero indicates +** "no such page". The page size can be anything between 512 and 65536. +** Each page can be either a btree page, a freelist page or an overflow +** page. +** +** The first page is always a btree page. The first 100 bytes of the first +** page contain a special header (the "file header") that describes the file. +** The format of the file header is as follows: +** +** OFFSET SIZE DESCRIPTION +** 0 16 Header string: "SQLite format 3\000" +** 16 2 Page size in bytes. +** 18 1 File format write version +** 19 1 File format read version +** 20 1 Bytes of unused space at the end of each page +** 21 1 Max embedded payload fraction +** 22 1 Min embedded payload fraction +** 23 1 Min leaf payload fraction +** 24 4 File change counter +** 28 4 Reserved for future use +** 32 4 First freelist page +** 36 4 Number of freelist pages in the file +** 40 60 15 4-byte meta values passed to higher layers +** +** All of the integer values are big-endian (most significant byte first). +** +** The file change counter is incremented when the database is changed more +** than once within the same second. This counter, together with the +** modification time of the file, allows other processes to know +** when the file has changed and thus when they need to flush their +** cache. +** +** The max embedded payload fraction is the amount of the total usable +** space in a page that can be consumed by a single cell for standard +** B-tree (non-LEAFDATA) tables. A value of 255 means 100%. The default +** is to limit the maximum cell size so that at least 4 cells will fit +** on one page. Thus the default max embedded payload fraction is 64. +** +** If the payload for a cell is larger than the max payload, then extra +** payload is spilled to overflow pages. Once an overflow page is allocated, +** as many bytes as possible are moved into the overflow pages without letting +** the cell size drop below the min embedded payload fraction. +** +** The min leaf payload fraction is like the min embedded payload fraction +** except that it applies to leaf nodes in a LEAFDATA tree. The maximum +** payload fraction for a LEAFDATA tree is always 100% (or 255) and it +** not specified in the header. +** +** Each btree pages is divided into three sections: The header, the +** cell pointer array, and the cell area area. Page 1 also has a 100-byte +** file header that occurs before the page header. +** +** |----------------| +** | file header | 100 bytes. Page 1 only. +** |----------------| +** | page header | 8 bytes for leaves. 12 bytes for interior nodes +** |----------------| +** | cell pointer | | 2 bytes per cell. Sorted order. +** | array | | Grows downward +** | | v +** |----------------| +** | unallocated | +** | space | +** |----------------| ^ Grows upwards +** | cell content | | Arbitrary order interspersed with freeblocks. +** | area | | and free space fragments. +** |----------------| +** +** The page headers looks like this: +** +** OFFSET SIZE DESCRIPTION +** 0 1 Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf +** 1 2 byte offset to the first freeblock +** 3 2 number of cells on this page +** 5 2 first byte of the cell content area +** 7 1 number of fragmented free bytes +** 8 4 Right child (the Ptr(N+1) value). Omitted on leaves. +** +** The flags define the format of this btree page. The leaf flag means that +** this page has no children. The zerodata flag means that this page carries +** only keys and no data. The intkey flag means that the key is a integer +** which is stored in the key size entry of the cell header rather than in +** the payload area. +** +** The cell pointer array begins on the first byte after the page header. +** The cell pointer array contains zero or more 2-byte numbers which are +** offsets from the beginning of the page to the cell content in the cell +** content area. The cell pointers occur in sorted order. The system strives +** to keep free space after the last cell pointer so that new cells can +** be easily added without having to defragment the page. +** +** Cell content is stored at the very end of the page and grows toward the +** beginning of the page. +** +** Unused space within the cell content area is collected into a linked list of +** freeblocks. Each freeblock is at least 4 bytes in size. The byte offset +** to the first freeblock is given in the header. Freeblocks occur in +** increasing order. Because a freeblock must be at least 4 bytes in size, +** any group of 3 or fewer unused bytes in the cell content area cannot +** exist on the freeblock chain. A group of 3 or fewer free bytes is called +** a fragment. The total number of bytes in all fragments is recorded. +** in the page header at offset 7. +** +** SIZE DESCRIPTION +** 2 Byte offset of the next freeblock +** 2 Bytes in this freeblock +** +** Cells are of variable length. Cells are stored in the cell content area at +** the end of the page. Pointers to the cells are in the cell pointer array +** that immediately follows the page header. Cells is not necessarily +** contiguous or in order, but cell pointers are contiguous and in order. +** +** Cell content makes use of variable length integers. A variable +** length integer is 1 to 9 bytes where the lower 7 bits of each +** byte are used. The integer consists of all bytes that have bit 8 set and +** the first byte with bit 8 clear. The most significant byte of the integer +** appears first. A variable-length integer may not be more than 9 bytes long. +** As a special case, all 8 bytes of the 9th byte are used as data. This +** allows a 64-bit integer to be encoded in 9 bytes. +** +** 0x00 becomes 0x00000000 +** 0x7f becomes 0x0000007f +** 0x81 0x00 becomes 0x00000080 +** 0x82 0x00 becomes 0x00000100 +** 0x80 0x7f becomes 0x0000007f +** 0x8a 0x91 0xd1 0xac 0x78 becomes 0x12345678 +** 0x81 0x81 0x81 0x81 0x01 becomes 0x10204081 +** +** Variable length integers are used for rowids and to hold the number of +** bytes of key and data in a btree cell. +** +** The content of a cell looks like this: +** +** SIZE DESCRIPTION +** 4 Page number of the left child. Omitted if leaf flag is set. +** var Number of bytes of data. Omitted if the zerodata flag is set. +** var Number of bytes of key. Or the key itself if intkey flag is set. +** * Payload +** 4 First page of the overflow chain. Omitted if no overflow +** +** Overflow pages form a linked list. Each page except the last is completely +** filled with data (pagesize - 4 bytes). The last page can have as little +** as 1 byte of data. +** +** SIZE DESCRIPTION +** 4 Page number of next overflow page +** * Data +** +** Freelist pages come in two subtypes: trunk pages and leaf pages. The +** file header points to first in a linked list of trunk page. Each trunk +** page points to multiple leaf pages. The content of a leaf page is +** unspecified. A trunk page looks like this: +** +** SIZE DESCRIPTION +** 4 Page number of next trunk page +** 4 Number of leaf pointers on this page +** * zero or more pages numbers of leaves */ #include "sqliteInt.h" #include "pager.h" #include "btree.h" +#include "os.h" #include +/* Round up a number to the next larger multiple of 8. This is used +** to force 8-byte alignment on 64-bit architectures. +*/ +#define ROUND8(x) ((x+7)&~7) + + +/* The following value is the maximum cell size assuming a maximum page +** size give above. +*/ +#define MX_CELL_SIZE(pBt) (pBt->pageSize-8) + +/* The maximum number of cells on a single page of the database. This +** assumes a minimum cell size of 3 bytes. Such small cells will be +** exceedingly rare, but they are possible. +*/ +#define MX_CELL(pBt) ((pBt->pageSize-8)/3) + /* 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) +typedef struct BtLock BtLock; /* ** 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. +** You can change this value at compile-time by specifying a +** -DSQLITE_FILE_HEADER="..." on the compiler command-line. The +** header must be exactly 16 bytes including the zero-terminator so +** the string itself should be 15 characters long. If you change +** the header, then your custom library will not be able to read +** databases generated by the standard tools and the standard tools +** will not be able to read databases created by your custom library. */ -#define MAGIC 0xdae37528 +#ifndef SQLITE_FILE_HEADER /* 123456789 123456 */ +# define SQLITE_FILE_HEADER "SQLite format 3" +#endif +static const char zMagicHeader[] = SQLITE_FILE_HEADER; /* -** 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". +** Page type flags. An ORed combination of these flags appear as the +** first byte of every BTree 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 */ -}; +#define PTF_INTKEY 0x01 +#define PTF_ZERODATA 0x02 +#define PTF_LEAFDATA 0x04 +#define PTF_LEAF 0x08 /* -** 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. +** As each page of the file is loaded into memory, an instance of the following +** structure is appended and initialized to zero. This structure stores +** information about the page that is decoded from the raw file page. ** ** The pParent field points back to the parent page. This allows us to ** walk up the BTree from any leaf to the root. Care must be taken to @@ -319,18 +269,30 @@ struct FreelistInfo { ** 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 */ + u8 isInit; /* True if previously initialized. MUST BE FIRST! */ + u8 idxShift; /* True if Cell indices have changed */ + u8 nOverflow; /* Number of overflow cell bodies in aCell[] */ + u8 intKey; /* True if intkey flag is set */ + u8 leaf; /* True if leaf flag is set */ + u8 zeroData; /* True if table stores keys only */ + u8 leafData; /* True if tables stores data on leaves only */ + u8 hasData; /* True if this page stores data */ + u8 hdrOffset; /* 100 for page 1. 0 otherwise */ + u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */ + u16 maxLocal; /* Copy of Btree.maxLocal or Btree.maxLeaf */ + u16 minLocal; /* Copy of Btree.minLocal or Btree.minLeaf */ + u16 cellOffset; /* Index in aData of first cell pointer */ + u16 idxParent; /* Index in parent of this node */ + u16 nFree; /* Number of free bytes on the page */ + u16 nCell; /* Number of cells on this page, local and ovfl */ + struct _OvflCell { /* Cells that will not fit on aData[] */ + u8 *pCell; /* Pointers to the body of the overflow cell */ + u16 idx; /* Insert this cell before idx-th non-overflow cell */ + } aOvfl[5]; + BtShared *pBt; /* Pointer back to BTree structure */ + u8 *aData; /* Pointer back to the start of the page */ + Pgno pgno; /* Page number for this page */ + MemPage *pParent; /* The parent of this page. NULL for root */ }; /* @@ -338,127 +300,907 @@ struct MemPage { ** 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)) +#define EXTRA_SIZE sizeof(MemPage) + +/* Btree handle */ +struct Btree { + sqlite3 *pSqlite; + BtShared *pBt; + u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */ +}; + +/* +** Btree.inTrans may take one of the following values. +** +** If the shared-data extension is enabled, there may be multiple users +** of the Btree structure. At most one of these may open a write transaction, +** but any number may have active read transactions. Variable Btree.pDb +** points to the handle that owns any current write-transaction. +*/ +#define TRANS_NONE 0 +#define TRANS_READ 1 +#define TRANS_WRITE 2 /* ** Everything we need to know about an open database */ -struct Btree { - BtOps *pOps; /* Function table */ +struct BtShared { 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 */ + MemPage *pPage1; /* First page of the database */ + u8 inStmt; /* True if we are in a statement subtransaction */ u8 readOnly; /* True if the underlying file is readonly */ - u8 needSwab; /* Need to byte-swapping */ + u8 maxEmbedFrac; /* Maximum payload as % of total page size */ + u8 minEmbedFrac; /* Minimum payload as % of total page size */ + u8 minLeafFrac; /* Minimum leaf payload as % of total page size */ + u8 pageSizeFixed; /* True if the page size can no longer be changed */ +#ifndef SQLITE_OMIT_AUTOVACUUM + u8 autoVacuum; /* True if database supports auto-vacuum */ +#endif + u16 pageSize; /* Total number of bytes on a page */ + u16 usableSize; /* Number of usable bytes on each page */ + int maxLocal; /* Maximum local payload in non-LEAFDATA tables */ + int minLocal; /* Minimum local payload in non-LEAFDATA tables */ + int maxLeaf; /* Maximum local payload in a LEAFDATA table */ + int minLeaf; /* Minimum local payload in a LEAFDATA table */ + BusyHandler *pBusyHandler; /* Callback for when there is lock contention */ + u8 inTransaction; /* Transaction state */ + int nRef; /* Number of references to this structure */ + int nTransaction; /* Number of open transactions (read + write) */ + void *pSchema; /* Pointer to space allocated by sqlite3BtreeSchema() */ + void (*xFreeSchema)(void*); /* Destructor for BtShared.pSchema */ +#ifndef SQLITE_OMIT_SHARED_CACHE + BtLock *pLock; /* List of locks held on this shared-btree struct */ + BtShared *pNext; /* Next in ThreadData.pBtree linked list */ +#endif +}; + +/* +** An instance of the following structure is used to hold information +** about a cell. The parseCellPtr() function fills in this structure +** based on information extract from the raw disk page. +*/ +typedef struct CellInfo CellInfo; +struct CellInfo { + u8 *pCell; /* Pointer to the start of cell content */ + i64 nKey; /* The key for INTKEY tables, or number of bytes in key */ + u32 nData; /* Number of bytes of data */ + u16 nHeader; /* Size of the cell content header in bytes */ + u16 nLocal; /* Amount of payload held locally */ + u16 iOverflow; /* Offset to overflow page number. Zero if no overflow */ + u16 nSize; /* Size of the cell content on the main b-tree page */ }; -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. +** MemPage.aCell[] of the entry. */ struct BtCursor { - BtCursorOps *pOps; /* Function table */ - Btree *pBt; /* The Btree to which this cursor belongs */ + Btree *pBtree; /* 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 */ + int (*xCompare)(void*,int,const void*,int,const void*); /* Key comp func */ + void *pArg; /* First arg to xCompare() */ Pgno pgnoRoot; /* The root page of this tree */ MemPage *pPage; /* Page that contains the entry */ - int idx; /* Index of the entry in pPage->apCell[] */ + int idx; /* Index of the entry in pPage->aCell[] */ + CellInfo info; /* A parse of the cell we are pointing at */ u8 wrFlag; /* True if writable */ - u8 eSkip; /* Determines if next step operation is a no-op */ - u8 iMatch; /* compare result from last sqliteBtreeMoveto() */ + u8 eState; /* One of the CURSOR_XXX constants (see below) */ +#ifndef SQLITE_OMIT_SHARED_CACHE + void *pKey; /* Saved key that was cursor's last known position */ + i64 nKey; /* Size of pKey, or last integer key */ + int skip; /* (skip<0) -> Prev() is a no-op. (skip>0) -> Next() is */ +#endif }; /* -** Legal values for BtCursor.eSkip. +** Potential values for BtCursor.eState. The first two values (VALID and +** INVALID) may occur in any build. The third (REQUIRESEEK) may only occur +** if sqlite was compiled without the OMIT_SHARED_CACHE symbol defined. +** +** CURSOR_VALID: +** Cursor points to a valid entry. getPayload() etc. may be called. +** +** CURSOR_INVALID: +** Cursor does not point to a valid entry. This can happen (for example) +** because the table is empty or because BtreeCursorFirst() has not been +** called. +** +** CURSOR_REQUIRESEEK: +** The table that this cursor was opened on still exists, but has been +** modified since the cursor was last used. The cursor position is saved +** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in +** this state, restoreOrClearCursorPosition() can be called to attempt to +** seek the cursor to the saved position. */ -#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); +#define CURSOR_INVALID 0 +#define CURSOR_VALID 1 +#define CURSOR_REQUIRESEEK 2 /* -** Routines for byte swapping. +** The TRACE macro will print high-level status information about the +** btree operation when the global variable sqlite3_btree_trace is +** enabled. */ -u16 swab16(u16 x){ - return ((x & 0xff)<<8) | ((x>>8)&0xff); +#if SQLITE_TEST +# define TRACE(X) if( sqlite3_btree_trace )\ + { sqlite3DebugPrintf X; fflush(stdout); } +#else +# define TRACE(X) +#endif +int sqlite3_btree_trace=0; /* True to enable tracing */ + +/* +** Forward declaration +*/ +static int checkReadLocks(BtShared*,Pgno,BtCursor*); + +/* +** Read or write a two- and four-byte big-endian integer values. +*/ +static u32 get2byte(unsigned char *p){ + return (p[0]<<8) | p[1]; } -u32 swab32(u32 x){ - return ((x & 0xff)<<24) | ((x & 0xff00)<<8) | - ((x>>8) & 0xff00) | ((x>>24)&0xff); +static u32 get4byte(unsigned char *p){ + return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3]; +} +static void put2byte(unsigned char *p, u32 v){ + p[0] = v>>8; + p[1] = v; +} +static void put4byte(unsigned char *p, u32 v){ + p[0] = v>>24; + p[1] = v>>16; + p[2] = v>>8; + p[3] = v; } /* -** 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. +** Routines to read and write variable-length integers. These used to +** be defined locally, but now we use the varint routines in the util.c +** file. */ -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); +#define getVarint sqlite3GetVarint +/* #define getVarint32 sqlite3GetVarint32 */ +#define getVarint32(A,B) ((*B=*(A))<=0x7f?1:sqlite3GetVarint32(A,B)) +#define putVarint sqlite3PutVarint + +/* The database page the PENDING_BYTE occupies. This page is never used. +** TODO: This macro is very similary to PAGER_MJ_PGNO() in pager.c. They +** should possibly be consolidated (presumably in pager.h). +** +** If disk I/O is omitted (meaning that the database is stored purely +** in memory) then there is no pending byte. +*/ +#ifdef SQLITE_OMIT_DISKIO +# define PENDING_BYTE_PAGE(pBt) 0x7fffffff +#else +# define PENDING_BYTE_PAGE(pBt) ((PENDING_BYTE/(pBt)->pageSize)+1) +#endif + +/* +** A linked list of the following structures is stored at BtShared.pLock. +** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor +** is opened on the table with root page BtShared.iTable. Locks are removed +** from this list when a transaction is committed or rolled back, or when +** a btree handle is closed. +*/ +struct BtLock { + Btree *pBtree; /* Btree handle holding this lock */ + Pgno iTable; /* Root page of table */ + u8 eLock; /* READ_LOCK or WRITE_LOCK */ + BtLock *pNext; /* Next in BtShared.pLock list */ +}; + +/* Candidate values for BtLock.eLock */ +#define READ_LOCK 1 +#define WRITE_LOCK 2 + +#ifdef SQLITE_OMIT_SHARED_CACHE + /* + ** The functions queryTableLock(), lockTable() and unlockAllTables() + ** manipulate entries in the BtShared.pLock linked list used to store + ** shared-cache table level locks. If the library is compiled with the + ** shared-cache feature disabled, then there is only ever one user + ** of each BtShared structure and so this locking is not necessary. + ** So define the lock related functions as no-ops. + */ + #define queryTableLock(a,b,c) SQLITE_OK + #define lockTable(a,b,c) SQLITE_OK + #define unlockAllTables(a) + #define restoreOrClearCursorPosition(a,b) SQLITE_OK + #define saveAllCursors(a,b,c) SQLITE_OK + +#else + +static void releasePage(MemPage *pPage); + +/* +** Save the current cursor position in the variables BtCursor.nKey +** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK. +*/ +static int saveCursorPosition(BtCursor *pCur){ + int rc; + + assert( CURSOR_VALID==pCur->eState ); + assert( 0==pCur->pKey ); + + rc = sqlite3BtreeKeySize(pCur, &pCur->nKey); + + /* If this is an intKey table, then the above call to BtreeKeySize() + ** stores the integer key in pCur->nKey. In this case this value is + ** all that is required. Otherwise, if pCur is not open on an intKey + ** table, then malloc space for and store the pCur->nKey bytes of key + ** data. + */ + if( rc==SQLITE_OK && 0==pCur->pPage->intKey){ + void *pKey = sqliteMalloc(pCur->nKey); + if( pKey ){ + rc = sqlite3BtreeKey(pCur, 0, pCur->nKey, pKey); + if( rc==SQLITE_OK ){ + pCur->pKey = pKey; + }else{ + sqliteFree(pKey); + } + }else{ + rc = SQLITE_NOMEM; + } } - n += sizeof(CellHdr); - return n; + assert( !pCur->pPage->intKey || !pCur->pKey ); + + if( rc==SQLITE_OK ){ + releasePage(pCur->pPage); + pCur->pPage = 0; + pCur->eState = CURSOR_REQUIRESEEK; + } + + return rc; } +/* +** Save the positions of all cursors except pExcept open on the table +** with root-page iRoot. Usually, this is called just before cursor +** pExcept is used to modify the table (BtreeDelete() or BtreeInsert()). +*/ +static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){ + BtCursor *p; + if( sqlite3ThreadDataReadOnly()->useSharedData ){ + for(p=pBt->pCursor; p; p=p->pNext){ + if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) && + p->eState==CURSOR_VALID ){ + int rc = saveCursorPosition(p); + if( SQLITE_OK!=rc ){ + return rc; + } + } + } + } + return SQLITE_OK; +} + +/* +** Restore the cursor to the position it was in (or as close to as possible) +** when saveCursorPosition() was called. Note that this call deletes the +** saved position info stored by saveCursorPosition(), so there can be +** at most one effective restoreOrClearCursorPosition() call after each +** saveCursorPosition(). +** +** If the second argument argument - doSeek - is false, then instead of +** returning the cursor to it's saved position, any saved position is deleted +** and the cursor state set to CURSOR_INVALID. +*/ +static int restoreOrClearCursorPositionX(BtCursor *pCur, int doSeek){ + int rc = SQLITE_OK; + assert( sqlite3ThreadDataReadOnly()->useSharedData ); + assert( pCur->eState==CURSOR_REQUIRESEEK ); + pCur->eState = CURSOR_INVALID; + if( doSeek ){ + rc = sqlite3BtreeMoveto(pCur, pCur->pKey, pCur->nKey, &pCur->skip); + } + if( rc==SQLITE_OK ){ + sqliteFree(pCur->pKey); + pCur->pKey = 0; + assert( CURSOR_VALID==pCur->eState || CURSOR_INVALID==pCur->eState ); + } + return rc; +} + +#define restoreOrClearCursorPosition(p,x) \ + (p->eState==CURSOR_REQUIRESEEK?restoreOrClearCursorPositionX(p,x):SQLITE_OK) + +/* +** Query to see if btree handle p may obtain a lock of type eLock +** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return +** SQLITE_OK if the lock may be obtained (by calling lockTable()), or +** SQLITE_LOCKED if not. +*/ +static int queryTableLock(Btree *p, Pgno iTab, u8 eLock){ + BtShared *pBt = p->pBt; + BtLock *pIter; + + /* This is a no-op if the shared-cache is not enabled */ + if( 0==sqlite3ThreadDataReadOnly()->useSharedData ){ + return SQLITE_OK; + } + + /* This (along with lockTable()) is where the ReadUncommitted flag is + ** dealt with. If the caller is querying for a read-lock and the flag is + ** set, it is unconditionally granted - even if there are write-locks + ** on the table. If a write-lock is requested, the ReadUncommitted flag + ** is not considered. + ** + ** In function lockTable(), if a read-lock is demanded and the + ** ReadUncommitted flag is set, no entry is added to the locks list + ** (BtShared.pLock). + ** + ** To summarize: If the ReadUncommitted flag is set, then read cursors do + ** not create or respect table locks. The locking procedure for a + ** write-cursor does not change. + */ + if( + !p->pSqlite || + 0==(p->pSqlite->flags&SQLITE_ReadUncommitted) || + eLock==WRITE_LOCK || + iTab==MASTER_ROOT + ){ + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + if( pIter->pBtree!=p && pIter->iTable==iTab && + (pIter->eLock!=eLock || eLock!=READ_LOCK) ){ + return SQLITE_LOCKED; + } + } + } + return SQLITE_OK; +} + +/* +** Add a lock on the table with root-page iTable to the shared-btree used +** by Btree handle p. Parameter eLock must be either READ_LOCK or +** WRITE_LOCK. +** +** SQLITE_OK is returned if the lock is added successfully. SQLITE_BUSY and +** SQLITE_NOMEM may also be returned. +*/ +static int lockTable(Btree *p, Pgno iTable, u8 eLock){ + BtShared *pBt = p->pBt; + BtLock *pLock = 0; + BtLock *pIter; + + /* This is a no-op if the shared-cache is not enabled */ + if( 0==sqlite3ThreadDataReadOnly()->useSharedData ){ + return SQLITE_OK; + } + + assert( SQLITE_OK==queryTableLock(p, iTable, eLock) ); + + /* If the read-uncommitted flag is set and a read-lock is requested, + ** return early without adding an entry to the BtShared.pLock list. See + ** comment in function queryTableLock() for more info on handling + ** the ReadUncommitted flag. + */ + if( + (p->pSqlite) && + (p->pSqlite->flags&SQLITE_ReadUncommitted) && + (eLock==READ_LOCK) && + iTable!=MASTER_ROOT + ){ + return SQLITE_OK; + } + + /* First search the list for an existing lock on this table. */ + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + if( pIter->iTable==iTable && pIter->pBtree==p ){ + pLock = pIter; + break; + } + } + + /* If the above search did not find a BtLock struct associating Btree p + ** with table iTable, allocate one and link it into the list. + */ + if( !pLock ){ + pLock = (BtLock *)sqliteMalloc(sizeof(BtLock)); + if( !pLock ){ + return SQLITE_NOMEM; + } + pLock->iTable = iTable; + pLock->pBtree = p; + pLock->pNext = pBt->pLock; + pBt->pLock = pLock; + } + + /* Set the BtLock.eLock variable to the maximum of the current lock + ** and the requested lock. This means if a write-lock was already held + ** and a read-lock requested, we don't incorrectly downgrade the lock. + */ + assert( WRITE_LOCK>READ_LOCK ); + if( eLock>pLock->eLock ){ + pLock->eLock = eLock; + } + + return SQLITE_OK; +} + +/* +** Release all the table locks (locks obtained via calls to the lockTable() +** procedure) held by Btree handle p. +*/ +static void unlockAllTables(Btree *p){ + BtLock **ppIter = &p->pBt->pLock; + + /* If the shared-cache extension is not enabled, there should be no + ** locks in the BtShared.pLock list, making this procedure a no-op. Assert + ** that this is the case. + */ + assert( sqlite3ThreadDataReadOnly()->useSharedData || 0==*ppIter ); + + while( *ppIter ){ + BtLock *pLock = *ppIter; + if( pLock->pBtree==p ){ + *ppIter = pLock->pNext; + sqliteFree(pLock); + }else{ + ppIter = &pLock->pNext; + } + } +} +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** These macros define the location of the pointer-map entry for a +** database page. The first argument to each is the number of usable +** bytes on each page of the database (often 1024). The second is the +** page number to look up in the pointer map. +** +** PTRMAP_PAGENO returns the database page number of the pointer-map +** page that stores the required pointer. PTRMAP_PTROFFSET returns +** the offset of the requested map entry. +** +** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page, +** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be +** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements +** this test. +*/ +#define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno) +#define PTRMAP_PTROFFSET(pBt, pgno) (5*(pgno-ptrmapPageno(pBt, pgno)-1)) +#define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno)) + +static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){ + int nPagesPerMapPage = (pBt->usableSize/5)+1; + int iPtrMap = (pgno-2)/nPagesPerMapPage; + int ret = (iPtrMap*nPagesPerMapPage) + 2; + if( ret==PENDING_BYTE_PAGE(pBt) ){ + ret++; + } + return ret; +} + +/* +** The pointer map is a lookup table that identifies the parent page for +** each child page in the database file. The parent page is the page that +** contains a pointer to the child. Every page in the database contains +** 0 or 1 parent pages. (In this context 'database page' refers +** to any page that is not part of the pointer map itself.) Each pointer map +** entry consists of a single byte 'type' and a 4 byte parent page number. +** The PTRMAP_XXX identifiers below are the valid types. +** +** The purpose of the pointer map is to facility moving pages from one +** position in the file to another as part of autovacuum. When a page +** is moved, the pointer in its parent must be updated to point to the +** new location. The pointer map is used to locate the parent page quickly. +** +** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not +** used in this case. +** +** PTRMAP_FREEPAGE: The database page is an unused (free) page. The page-number +** is not used in this case. +** +** PTRMAP_OVERFLOW1: The database page is the first page in a list of +** overflow pages. The page number identifies the page that +** contains the cell with a pointer to this overflow page. +** +** PTRMAP_OVERFLOW2: The database page is the second or later page in a list of +** overflow pages. The page-number identifies the previous +** page in the overflow page list. +** +** PTRMAP_BTREE: The database page is a non-root btree page. The page number +** identifies the parent page in the btree. +*/ +#define PTRMAP_ROOTPAGE 1 +#define PTRMAP_FREEPAGE 2 +#define PTRMAP_OVERFLOW1 3 +#define PTRMAP_OVERFLOW2 4 +#define PTRMAP_BTREE 5 + +/* +** Write an entry into the pointer map. +** +** This routine updates the pointer map entry for page number 'key' +** so that it maps to type 'eType' and parent page number 'pgno'. +** An error code is returned if something goes wrong, otherwise SQLITE_OK. +*/ +static int ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent){ + u8 *pPtrmap; /* The pointer map page */ + Pgno iPtrmap; /* The pointer map page number */ + int offset; /* Offset in pointer map page */ + int rc; + + /* The master-journal page number must never be used as a pointer map page */ + assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) ); + + assert( pBt->autoVacuum ); + if( key==0 ){ + return SQLITE_CORRUPT_BKPT; + } + iPtrmap = PTRMAP_PAGENO(pBt, key); + rc = sqlite3pager_get(pBt->pPager, iPtrmap, (void **)&pPtrmap); + if( rc!=SQLITE_OK ){ + return rc; + } + offset = PTRMAP_PTROFFSET(pBt, key); + + if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){ + TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent)); + rc = sqlite3pager_write(pPtrmap); + if( rc==SQLITE_OK ){ + pPtrmap[offset] = eType; + put4byte(&pPtrmap[offset+1], parent); + } + } + + sqlite3pager_unref(pPtrmap); + return rc; +} + +/* +** Read an entry from the pointer map. +** +** This routine retrieves the pointer map entry for page 'key', writing +** the type and parent page number to *pEType and *pPgno respectively. +** An error code is returned if something goes wrong, otherwise SQLITE_OK. +*/ +static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){ + int iPtrmap; /* Pointer map page index */ + u8 *pPtrmap; /* Pointer map page data */ + int offset; /* Offset of entry in pointer map */ + int rc; + + iPtrmap = PTRMAP_PAGENO(pBt, key); + rc = sqlite3pager_get(pBt->pPager, iPtrmap, (void **)&pPtrmap); + if( rc!=0 ){ + return rc; + } + + offset = PTRMAP_PTROFFSET(pBt, key); + assert( pEType!=0 ); + *pEType = pPtrmap[offset]; + if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]); + + sqlite3pager_unref(pPtrmap); + if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_BKPT; + return SQLITE_OK; +} + +#endif /* SQLITE_OMIT_AUTOVACUUM */ + +/* +** Given a btree page and a cell index (0 means the first cell on +** the page, 1 means the second cell, and so forth) return a pointer +** to the cell content. +** +** This routine works only for pages that do not contain overflow cells. +*/ +static u8 *findCell(MemPage *pPage, int iCell){ + u8 *data = pPage->aData; + assert( iCell>=0 ); + assert( iCellhdrOffset+3]) ); + return data + get2byte(&data[pPage->cellOffset+2*iCell]); +} + +/* +** This a more complex version of findCell() that works for +** pages that do contain overflow cells. See insert +*/ +static u8 *findOverflowCell(MemPage *pPage, int iCell){ + int i; + for(i=pPage->nOverflow-1; i>=0; i--){ + int k; + struct _OvflCell *pOvfl; + pOvfl = &pPage->aOvfl[i]; + k = pOvfl->idx; + if( k<=iCell ){ + if( k==iCell ){ + return pOvfl->pCell; + } + iCell--; + } + } + return findCell(pPage, iCell); +} + +/* +** Parse a cell content block and fill in the CellInfo structure. There +** are two versions of this function. parseCell() takes a cell index +** as the second argument and parseCellPtr() takes a pointer to the +** body of the cell as its second argument. +*/ +static void parseCellPtr( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + int n; /* Number bytes in cell content header */ + u32 nPayload; /* Number of bytes of cell payload */ + + pInfo->pCell = pCell; + assert( pPage->leaf==0 || pPage->leaf==1 ); + n = pPage->childPtrSize; + assert( n==4-4*pPage->leaf ); + if( pPage->hasData ){ + n += getVarint32(&pCell[n], &nPayload); + }else{ + nPayload = 0; + } + pInfo->nData = nPayload; + if( pPage->intKey ){ + n += getVarint(&pCell[n], (u64 *)&pInfo->nKey); + }else{ + u32 x; + n += getVarint32(&pCell[n], &x); + pInfo->nKey = x; + nPayload += x; + } + pInfo->nHeader = n; + if( nPayload<=pPage->maxLocal ){ + /* This is the (easy) common case where the entire payload fits + ** on the local page. No overflow is required. + */ + int nSize; /* Total size of cell content in bytes */ + pInfo->nLocal = nPayload; + pInfo->iOverflow = 0; + nSize = nPayload + n; + if( nSize<4 ){ + nSize = 4; /* Minimum cell size is 4 */ + } + pInfo->nSize = nSize; + }else{ + /* If the payload will not fit completely on the local page, we have + ** to decide how much to store locally and how much to spill onto + ** overflow pages. The strategy is to minimize the amount of unused + ** space on overflow pages while keeping the amount of local storage + ** in between minLocal and maxLocal. + ** + ** Warning: changing the way overflow payload is distributed in any + ** way will result in an incompatible file format. + */ + int minLocal; /* Minimum amount of payload held locally */ + int maxLocal; /* Maximum amount of payload held locally */ + int surplus; /* Overflow payload available for local storage */ + + minLocal = pPage->minLocal; + maxLocal = pPage->maxLocal; + surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4); + if( surplus <= maxLocal ){ + pInfo->nLocal = surplus; + }else{ + pInfo->nLocal = minLocal; + } + pInfo->iOverflow = pInfo->nLocal + n; + pInfo->nSize = pInfo->iOverflow + 4; + } +} +static void parseCell( + MemPage *pPage, /* Page containing the cell */ + int iCell, /* The cell index. First cell is 0 */ + CellInfo *pInfo /* Fill in this structure */ +){ + parseCellPtr(pPage, findCell(pPage, iCell), pInfo); +} + +/* +** Compute the total number of bytes that a Cell needs in the cell +** data area of the btree-page. The return number includes the cell +** data header and the local payload, but not any overflow page or +** the space used by the cell pointer. +*/ +#ifndef NDEBUG +static int cellSize(MemPage *pPage, int iCell){ + CellInfo info; + parseCell(pPage, iCell, &info); + return info.nSize; +} +#endif +static int cellSizePtr(MemPage *pPage, u8 *pCell){ + CellInfo info; + parseCellPtr(pPage, pCell, &info); + return info.nSize; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** If the cell pCell, part of page pPage contains a pointer +** to an overflow page, insert an entry into the pointer-map +** for the overflow page. +*/ +static int ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell){ + if( pCell ){ + CellInfo info; + parseCellPtr(pPage, pCell, &info); + if( (info.nData+(pPage->intKey?0:info.nKey))>info.nLocal ){ + Pgno ovfl = get4byte(&pCell[info.iOverflow]); + return ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno); + } + } + return SQLITE_OK; +} +/* +** If the cell with index iCell on page pPage contains a pointer +** to an overflow page, insert an entry into the pointer-map +** for the overflow page. +*/ +static int ptrmapPutOvfl(MemPage *pPage, int iCell){ + u8 *pCell; + pCell = findOverflowCell(pPage, iCell); + return ptrmapPutOvflPtr(pPage, pCell); +} +#endif + + +/* +** Do sanity checking on a page. Throw an exception if anything is +** not right. +** +** This routine is used for internal error checking only. It is omitted +** from most builds. +*/ +#if defined(BTREE_DEBUG) && !defined(NDEBUG) && 0 +static void _pageIntegrity(MemPage *pPage){ + int usableSize; + u8 *data; + int i, j, idx, c, pc, hdr, nFree; + int cellOffset; + int nCell, cellLimit; + u8 *used; + + used = sqliteMallocRaw( pPage->pBt->pageSize ); + if( used==0 ) return; + usableSize = pPage->pBt->usableSize; + assert( pPage->aData==&((unsigned char*)pPage)[-pPage->pBt->pageSize] ); + hdr = pPage->hdrOffset; + assert( hdr==(pPage->pgno==1 ? 100 : 0) ); + assert( pPage->pgno==sqlite3pager_pagenumber(pPage->aData) ); + c = pPage->aData[hdr]; + if( pPage->isInit ){ + assert( pPage->leaf == ((c & PTF_LEAF)!=0) ); + assert( pPage->zeroData == ((c & PTF_ZERODATA)!=0) ); + assert( pPage->leafData == ((c & PTF_LEAFDATA)!=0) ); + assert( pPage->intKey == ((c & (PTF_INTKEY|PTF_LEAFDATA))!=0) ); + assert( pPage->hasData == + !(pPage->zeroData || (!pPage->leaf && pPage->leafData)) ); + assert( pPage->cellOffset==pPage->hdrOffset+12-4*pPage->leaf ); + assert( pPage->nCell = get2byte(&pPage->aData[hdr+3]) ); + } + data = pPage->aData; + memset(used, 0, usableSize); + for(i=0; ileaf*4; i++) used[i] = 1; + nFree = 0; + pc = get2byte(&data[hdr+1]); + while( pc ){ + int size; + assert( pc>0 && pcisInit==0 + || pPage->nFree==nFree+data[hdr+7]+cellLimit-(cellOffset+2*nCell) ); + cellOffset = pPage->cellOffset; + for(i=0; i0 && pcinTrans!=TRANS_NONE || p->pBt->nTransactionpBt->nRef ); \ + assert( p->pBt->nTransaction<=p->pBt->nRef ); \ + assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \ + assert( p->pBt->inTransaction>=p->inTrans ); + /* ** 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. +** end of the page and all free space is collected into one +** big FreeBlk that occurs in between the header and cell +** pointer array and the cell content area. */ -static void defragmentPage(Btree *pBt, MemPage *pPage){ - int pc, i, n; - FreeBlk *pFBlk; - char newPage[SQLITE_USABLE_SIZE]; +static int defragmentPage(MemPage *pPage){ + int i; /* Loop counter */ + int pc; /* Address of a i-th cell */ + int addr; /* Offset of first byte after cell pointer array */ + int hdr; /* Offset to the page header */ + int size; /* Size of a cell */ + int usableSize; /* Number of usable bytes on a page */ + int cellOffset; /* Offset to the cell pointer array */ + int brk; /* Offset to the cell content area */ + int nCell; /* Number of cells on the page */ + unsigned char *data; /* The page data */ + unsigned char *temp; /* Temp area for cell content */ - 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( sqlite3pager_iswriteable(pPage->aData) ); + assert( pPage->pBt!=0 ); + assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE ); + assert( pPage->nOverflow==0 ); + temp = sqliteMalloc( pPage->pBt->pageSize ); + if( temp==0 ) return SQLITE_NOMEM; + data = pPage->aData; + hdr = pPage->hdrOffset; + cellOffset = pPage->cellOffset; + nCell = pPage->nCell; + assert( nCell==get2byte(&data[hdr+3]) ); + usableSize = pPage->pBt->usableSize; + brk = get2byte(&data[hdr+5]); + memcpy(&temp[brk], &data[brk], usableSize - brk); + brk = usableSize; + for(i=0; ipBt->usableSize ); + size = cellSizePtr(pPage, &temp[pc]); + brk -= size; + memcpy(&data[brk], &temp[pc], size); + put2byte(pAddr, brk); } - 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)); + assert( brk>=cellOffset+2*nCell ); + put2byte(&data[hdr+5], brk); + data[hdr+1] = 0; + data[hdr+2] = 0; + data[hdr+7] = 0; + addr = cellOffset+2*nCell; + memset(&data[addr], 0, brk-addr); + sqliteFree(temp); + return SQLITE_OK; } /* -** Allocate nByte bytes of space on a page. nByte must be a -** multiple of 4. +** Allocate nByte bytes of space on a page. ** -** Return the index into pPage->u.aDisk[] of the first byte of +** Return the index into pPage->aData[] 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. ** @@ -467,109 +1209,159 @@ static void defragmentPage(Btree *pBt, MemPage *pPage){ ** 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); - } +static int allocateSpace(MemPage *pPage, int nByte){ + int addr, pc, hdr; + int size; + int nFrag; + int top; + int nCell; + int cellOffset; + unsigned char *data; + + data = pPage->aData; + assert( sqlite3pager_iswriteable(data) ); + assert( pPage->pBt ); + if( nByte<4 ) nByte = 4; + if( pPage->nFreenOverflow>0 ) return 0; pPage->nFree -= nByte; - return start; + hdr = pPage->hdrOffset; + + nFrag = data[hdr+7]; + if( nFrag<60 ){ + /* Search the freelist looking for a slot big enough to satisfy the + ** space request. */ + addr = hdr+1; + while( (pc = get2byte(&data[addr]))>0 ){ + size = get2byte(&data[pc+2]); + if( size>=nByte ){ + if( sizecellOffset; + if( nFrag>=60 || cellOffset + 2*nCell > top - nByte ){ + if( defragmentPage(pPage) ) return 0; + top = get2byte(&data[hdr+5]); + } + top -= nByte; + assert( cellOffset + 2*nCell <= top ); + put2byte(&data[hdr+5], top); + return top; } /* -** 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. +** Return a section of the pPage->aData to the freelist. +** The first byte of the new free block is pPage->aDisk[start] +** and the size of the block is "size" bytes. ** ** 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; +static void freeSpace(MemPage *pPage, int start, int size){ + int addr, pbegin, hdr; + unsigned char *data = pPage->aData; - 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); + assert( pPage->pBt!=0 ); + assert( sqlite3pager_iswriteable(data) ); + assert( start>=pPage->hdrOffset+6+(pPage->leaf?0:4) ); + assert( (start + size)<=pPage->pBt->usableSize ); + if( size<4 ) size = 4; + +#ifdef SQLITE_SECURE_DELETE + /* Overwrite deleted information with zeros when the SECURE_DELETE + ** option is enabled at compile-time */ + memset(&data[start], 0, size); +#endif + + /* Add the space back into the linked list of freeblocks */ + hdr = pPage->hdrOffset; + addr = hdr + 1; + while( (pbegin = get2byte(&data[addr]))0 ){ + assert( pbegin<=pPage->pBt->usableSize-4 ); + assert( pbegin>addr ); + addr = pbegin; } - 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); + assert( pbegin<=pPage->pBt->usableSize-4 ); + assert( pbegin>addr || pbegin==0 ); + put2byte(&data[addr], start); + put2byte(&data[start], pbegin); + put2byte(&data[start+2], size); pPage->nFree += size; + + /* Coalesce adjacent free blocks */ + addr = pPage->hdrOffset + 1; + while( (pbegin = get2byte(&data[addr]))>0 ){ + int pnext, psize; + assert( pbegin>addr ); + assert( pbegin<=pPage->pBt->usableSize-4 ); + pnext = get2byte(&data[pbegin]); + psize = get2byte(&data[pbegin+2]); + if( pbegin + psize + 3 >= pnext && pnext>0 ){ + int frag = pnext - (pbegin+psize); + assert( frag<=data[pPage->hdrOffset+7] ); + data[pPage->hdrOffset+7] -= frag; + put2byte(&data[pbegin], get2byte(&data[pnext])); + put2byte(&data[pbegin+2], pnext+get2byte(&data[pnext+2])-pbegin); + }else{ + addr = pbegin; + } + } + + /* If the cell content area begins with a freeblock, remove it. */ + if( data[hdr+1]==data[hdr+5] && data[hdr+2]==data[hdr+6] ){ + int top; + pbegin = get2byte(&data[hdr+1]); + memcpy(&data[hdr+1], &data[pbegin], 2); + top = get2byte(&data[hdr+5]); + put2byte(&data[hdr+5], top + get2byte(&data[pbegin+2])); + } +} + +/* +** Decode the flags byte (the first byte of the header) for a page +** and initialize fields of the MemPage structure accordingly. +*/ +static void decodeFlags(MemPage *pPage, int flagByte){ + BtShared *pBt; /* A copy of pPage->pBt */ + + assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) ); + pPage->intKey = (flagByte & (PTF_INTKEY|PTF_LEAFDATA))!=0; + pPage->zeroData = (flagByte & PTF_ZERODATA)!=0; + pPage->leaf = (flagByte & PTF_LEAF)!=0; + pPage->childPtrSize = 4*(pPage->leaf==0); + pBt = pPage->pBt; + if( flagByte & PTF_LEAFDATA ){ + pPage->leafData = 1; + pPage->maxLocal = pBt->maxLeaf; + pPage->minLocal = pBt->minLeaf; + }else{ + pPage->leafData = 0; + pPage->maxLocal = pBt->maxLocal; + pPage->minLocal = pBt->minLocal; + } + pPage->hasData = !(pPage->zeroData || (!pPage->leaf && pPage->leafData)); } /* ** 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. +** is the parent of the page being initialized. The root of a +** BTree 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 @@ -577,79 +1369,162 @@ static void freeSpace(Btree *pBt, MemPage *pPage, int start, int size){ ** 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 */ +static int initPage( + MemPage *pPage, /* The page to be initialized */ + MemPage *pParent /* The parent. Might be NULL */ +){ + int pc; /* Address of a freeblock within pPage->aData[] */ + int hdr; /* Offset to beginning of page header */ + u8 *data; /* Equal to pPage->aData */ + BtShared *pBt; /* The main btree structure */ + int usableSize; /* Amount of usable space on each page */ + int cellOffset; /* Offset from start of page to first cell pointer */ + int nFree; /* Number of unused bytes on the page */ + int top; /* First byte of the cell content area */ - if( pPage->pParent ){ - assert( pPage->pParent==pParent ); - return SQLITE_OK; - } - if( pParent ){ - pPage->pParent = pParent; - sqlitepager_ref(pParent); + pBt = pPage->pBt; + assert( pBt!=0 ); + assert( pParent==0 || pParent->pBt==pBt ); + assert( pPage->pgno==sqlite3pager_pagenumber(pPage->aData) ); + assert( pPage->aData == &((unsigned char*)pPage)[-pBt->pageSize] ); + if( pPage->pParent!=pParent && (pPage->pParent!=0 || pPage->isInit) ){ + /* The parent page should never change unless the file is corrupt */ + return SQLITE_CORRUPT_BKPT; } 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); + if( pPage->pParent==0 && pParent!=0 ){ + pPage->pParent = pParent; + sqlite3pager_ref(pParent->aData); } - 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; + hdr = pPage->hdrOffset; + data = pPage->aData; + decodeFlags(pPage, data[hdr]); + pPage->nOverflow = 0; + pPage->idxShift = 0; + usableSize = pBt->usableSize; + pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf; + top = get2byte(&data[hdr+5]); + pPage->nCell = get2byte(&data[hdr+3]); + if( pPage->nCell>MX_CELL(pBt) ){ + /* To many cells for a single page. The page must be corrupt */ + return SQLITE_CORRUPT_BKPT; } - 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->nCell==0 && pParent!=0 && pParent->pgno!=1 ){ + /* All pages must have at least one cell, except for root pages */ + return SQLITE_CORRUPT_BKPT; } - if( pPage->nFree!=freeSpace ) goto page_format_error; - return SQLITE_OK; -page_format_error: - return SQLITE_CORRUPT; + /* Compute the total free space on the page */ + pc = get2byte(&data[hdr+1]); + nFree = data[hdr+7] + top - (cellOffset + 2*pPage->nCell); + while( pc>0 ){ + int next, size; + if( pc>usableSize-4 ){ + /* Free block is off the page */ + return SQLITE_CORRUPT_BKPT; + } + next = get2byte(&data[pc]); + size = get2byte(&data[pc+2]); + if( next>0 && next<=pc+size+3 ){ + /* Free blocks must be in accending order */ + return SQLITE_CORRUPT_BKPT; + } + nFree += size; + pc = next; + } + pPage->nFree = nFree; + if( nFree>=usableSize ){ + /* Free space cannot exceed total page size */ + return SQLITE_CORRUPT_BKPT; + } + + pPage->isInit = 1; + pageIntegrity(pPage); + return SQLITE_OK; } /* ** 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); +static void zeroPage(MemPage *pPage, int flags){ + unsigned char *data = pPage->aData; + BtShared *pBt = pPage->pBt; + int hdr = pPage->hdrOffset; + int first; + + assert( sqlite3pager_pagenumber(data)==pPage->pgno ); + assert( &data[pBt->pageSize] == (unsigned char*)pPage ); + assert( sqlite3pager_iswriteable(data) ); + memset(&data[hdr], 0, pBt->usableSize - hdr); + data[hdr] = flags; + first = hdr + 8 + 4*((flags&PTF_LEAF)==0); + memset(&data[hdr+1], 0, 4); + data[hdr+7] = 0; + put2byte(&data[hdr+5], pBt->usableSize); + pPage->nFree = pBt->usableSize - first; + decodeFlags(pPage, flags); + pPage->hdrOffset = hdr; + pPage->cellOffset = first; + pPage->nOverflow = 0; + pPage->idxShift = 0; pPage->nCell = 0; - pPage->isOverfull = 0; + pPage->isInit = 1; + pageIntegrity(pPage); +} + +/* +** Get a page from the pager. Initialize the MemPage.pBt and +** MemPage.aData elements if needed. +*/ +static int getPage(BtShared *pBt, Pgno pgno, MemPage **ppPage){ + int rc; + unsigned char *aData; + MemPage *pPage; + rc = sqlite3pager_get(pBt->pPager, pgno, (void**)&aData); + if( rc ) return rc; + pPage = (MemPage*)&aData[pBt->pageSize]; + pPage->aData = aData; + pPage->pBt = pBt; + pPage->pgno = pgno; + pPage->hdrOffset = pPage->pgno==1 ? 100 : 0; + *ppPage = pPage; + return SQLITE_OK; +} + +/* +** Get a page from the pager and initialize it. This routine +** is just a convenience wrapper around separate calls to +** getPage() and initPage(). +*/ +static int getAndInitPage( + BtShared *pBt, /* The database file */ + Pgno pgno, /* Number of the page to get */ + MemPage **ppPage, /* Write the page pointer here */ + MemPage *pParent /* Parent of the page */ +){ + int rc; + if( pgno==0 ){ + return SQLITE_CORRUPT_BKPT; + } + rc = getPage(pBt, pgno, ppPage); + if( rc==SQLITE_OK && (*ppPage)->isInit==0 ){ + rc = initPage(*ppPage, pParent); + } + return rc; +} + +/* +** Release a MemPage. This should be called once for each prior +** call to getPage. +*/ +static void releasePage(MemPage *pPage){ + if( pPage ){ + assert( pPage->aData ); + assert( pPage->pBt ); + assert( &pPage->aData[pPage->pBt->pageSize]==(unsigned char*)pPage ); + sqlite3pager_unref(pPage->aData); + } } /* @@ -657,86 +1532,261 @@ static void zeroPage(Btree *pBt, MemPage *pPage){ ** reaches zero. We need to unref the pParent pointer when that ** happens. */ -static void pageDestructor(void *pData){ - MemPage *pPage = (MemPage*)pData; +static void pageDestructor(void *pData, int pageSize){ + MemPage *pPage; + assert( (pageSize & 7)==0 ); + pPage = (MemPage*)&((char*)pData)[pageSize]; if( pPage->pParent ){ MemPage *pParent = pPage->pParent; pPage->pParent = 0; - sqlitepager_unref(pParent); + releasePage(pParent); + } + pPage->isInit = 0; +} + +/* +** During a rollback, when the pager reloads information into the cache +** so that the cache is restored to its original state at the start of +** the transaction, for each page restored this routine is called. +** +** This routine needs to reset the extra data section at the end of the +** page to agree with the restored data. +*/ +static void pageReinit(void *pData, int pageSize){ + MemPage *pPage; + assert( (pageSize & 7)==0 ); + pPage = (MemPage*)&((char*)pData)[pageSize]; + if( pPage->isInit ){ + pPage->isInit = 0; + initPage(pPage, pPage->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. -** +** Open a database file. +** ** 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. +** database file will be deleted when sqlite3BtreeClose() 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 */ +int sqlite3BtreeOpen( + const char *zFilename, /* Name of the file containing the BTree database */ + sqlite3 *pSqlite, /* Associated database handle */ + Btree **ppBtree, /* Pointer to new Btree object written here */ + int flags /* Options */ ){ - Btree *pBt; + BtShared *pBt; /* Shared part of btree structure */ + Btree *p; /* Handle to return */ int rc; + int nReserve; + unsigned char zDbHeader[100]; +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + const ThreadData *pTsdro; +#endif + + /* Set the variable isMemdb to true for an in-memory database, or + ** false for a file-based database. This symbol is only required if + ** either of the shared-data or autovacuum features are compiled + ** into the library. + */ +#if !defined(SQLITE_OMIT_SHARED_CACHE) || !defined(SQLITE_OMIT_AUTOVACUUM) + #ifdef SQLITE_OMIT_MEMORYDB + const int isMemdb = !zFilename; + #else + const int isMemdb = !zFilename || (strcmp(zFilename, ":memory:")?0:1); + #endif +#endif + + p = sqliteMalloc(sizeof(Btree)); + if( !p ){ + return SQLITE_NOMEM; + } + p->inTrans = TRANS_NONE; + p->pSqlite = pSqlite; + + /* Try to find an existing Btree structure opened on zFilename. */ +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + pTsdro = sqlite3ThreadDataReadOnly(); + if( pTsdro->useSharedData && zFilename && !isMemdb ){ + char *zFullPathname = sqlite3OsFullPathname(zFilename); + if( !zFullPathname ){ + sqliteFree(p); + return SQLITE_NOMEM; + } + for(pBt=pTsdro->pBtree; pBt; pBt=pBt->pNext){ + assert( pBt->nRef>0 ); + if( 0==strcmp(zFullPathname, sqlite3pager_filename(pBt->pPager)) ){ + p->pBt = pBt; + *ppBtree = p; + pBt->nRef++; + sqliteFree(zFullPathname); + return SQLITE_OK; + } + } + sqliteFree(zFullPathname); + } +#endif /* ** The following asserts make sure that structures used by the btree are ** the right size. This is to guard against size changes that result ** when compiling on a different architecture. */ + assert( sizeof(i64)==8 || sizeof(i64)==4 ); + assert( sizeof(u64)==8 || sizeof(u64)==4 ); 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; + sqliteFree(p); return SQLITE_NOMEM; } - if( nCache<10 ) nCache = 10; - rc = sqlitepager_open(&pBt->pPager, zFilename, nCache, EXTRA_SIZE, - !omitJournal); + rc = sqlite3pager_open(&pBt->pPager, zFilename, EXTRA_SIZE, flags); if( rc!=SQLITE_OK ){ - if( pBt->pPager ) sqlitepager_close(pBt->pPager); + if( pBt->pPager ) sqlite3pager_close(pBt->pPager); sqliteFree(pBt); + sqliteFree(p); *ppBtree = 0; return rc; } - sqlitepager_set_destructor(pBt->pPager, pageDestructor); + p->pBt = pBt; + + sqlite3pager_set_destructor(pBt->pPager, pageDestructor); + sqlite3pager_set_reiniter(pBt->pPager, pageReinit); pBt->pCursor = 0; - pBt->page1 = 0; - pBt->readOnly = sqlitepager_isreadonly(pBt->pPager); - pBt->pOps = &sqliteBtreeOps; - *ppBtree = pBt; + pBt->pPage1 = 0; + pBt->readOnly = sqlite3pager_isreadonly(pBt->pPager); + sqlite3pager_read_fileheader(pBt->pPager, sizeof(zDbHeader), zDbHeader); + pBt->pageSize = get2byte(&zDbHeader[16]); + if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE + || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){ + pBt->pageSize = SQLITE_DEFAULT_PAGE_SIZE; + pBt->maxEmbedFrac = 64; /* 25% */ + pBt->minEmbedFrac = 32; /* 12.5% */ + pBt->minLeafFrac = 32; /* 12.5% */ +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the magic name ":memory:" will create an in-memory database, then + ** do not set the auto-vacuum flag, even if SQLITE_DEFAULT_AUTOVACUUM + ** is true. On the other hand, if SQLITE_OMIT_MEMORYDB has been defined, + ** then ":memory:" is just a regular file-name. Respect the auto-vacuum + ** default in this case. + */ + if( zFilename && !isMemdb ){ + pBt->autoVacuum = SQLITE_DEFAULT_AUTOVACUUM; + } +#endif + nReserve = 0; + }else{ + nReserve = zDbHeader[20]; + pBt->maxEmbedFrac = zDbHeader[21]; + pBt->minEmbedFrac = zDbHeader[22]; + pBt->minLeafFrac = zDbHeader[23]; + pBt->pageSizeFixed = 1; +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0); +#endif + } + pBt->usableSize = pBt->pageSize - nReserve; + assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */ + sqlite3pager_set_pagesize(pBt->pPager, pBt->pageSize); + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* Add the new btree to the linked list starting at ThreadData.pBtree. + ** There is no chance that a malloc() may fail inside of the + ** sqlite3ThreadData() call, as the ThreadData structure must have already + ** been allocated for pTsdro->useSharedData to be non-zero. + */ + if( pTsdro->useSharedData && zFilename && !isMemdb ){ + pBt->pNext = pTsdro->pBtree; + sqlite3ThreadData()->pBtree = pBt; + } +#endif + pBt->nRef = 1; + *ppBtree = p; return SQLITE_OK; } /* ** Close an open database and invalidate all cursors. */ -static int fileBtreeClose(Btree *pBt){ - while( pBt->pCursor ){ - fileBtreeCloseCursor(pBt->pCursor); +int sqlite3BtreeClose(Btree *p){ + BtShared *pBt = p->pBt; + BtCursor *pCur; + +#ifndef SQLITE_OMIT_SHARED_CACHE + ThreadData *pTsd; +#endif + + /* Close all cursors opened via this handle. */ + pCur = pBt->pCursor; + while( pCur ){ + BtCursor *pTmp = pCur; + pCur = pCur->pNext; + if( pTmp->pBtree==p ){ + sqlite3BtreeCloseCursor(pTmp); + } } - sqlitepager_close(pBt->pPager); + + /* Rollback any active transaction and free the handle structure. + ** The call to sqlite3BtreeRollback() drops any table-locks held by + ** this handle. + */ + sqlite3BtreeRollback(p); + sqliteFree(p); + +#ifndef SQLITE_OMIT_SHARED_CACHE + /* If there are still other outstanding references to the shared-btree + ** structure, return now. The remainder of this procedure cleans + ** up the shared-btree. + */ + assert( pBt->nRef>0 ); + pBt->nRef--; + if( pBt->nRef ){ + return SQLITE_OK; + } + + /* Remove the shared-btree from the thread wide list. Call + ** ThreadDataReadOnly() and then cast away the const property of the + ** pointer to avoid allocating thread data if it is not really required. + */ + pTsd = (ThreadData *)sqlite3ThreadDataReadOnly(); + if( pTsd->pBtree==pBt ){ + assert( pTsd==sqlite3ThreadData() ); + pTsd->pBtree = pBt->pNext; + }else{ + BtShared *pPrev; + for(pPrev=pTsd->pBtree; pPrev && pPrev->pNext!=pBt; pPrev=pPrev->pNext){} + if( pPrev ){ + assert( pTsd==sqlite3ThreadData() ); + pPrev->pNext = pBt->pNext; + } + } +#endif + + /* Close the pager and free the shared-btree structure */ + assert( !pBt->pCursor ); + sqlite3pager_close(pBt->pPager); + if( pBt->xFreeSchema && pBt->pSchema ){ + pBt->xFreeSchema(pBt->pSchema); + } + sqliteFree(pBt->pSchema); sqliteFree(pBt); return SQLITE_OK; } +/* +** Change the busy handler callback function. +*/ +int sqlite3BtreeSetBusyHandler(Btree *p, BusyHandler *pHandler){ + BtShared *pBt = p->pBt; + pBt->pBusyHandler = pHandler; + sqlite3pager_set_busyhandler(pBt->pPager, pHandler); + return SQLITE_OK; +} + /* ** Change the limit on the number of pages allowed in the cache. ** @@ -752,8 +1802,9 @@ static int fileBtreeClose(Btree *pBt){ ** 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); +int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){ + BtShared *pBt = p->pBt; + sqlite3pager_set_cachesize(pBt->pPager, mxPage); return SQLITE_OK; } @@ -765,13 +1816,103 @@ static int fileBtreeSetCacheSize(Btree *pBt, int mxPage){ ** 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); +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +int sqlite3BtreeSetSafetyLevel(Btree *p, int level, int fullSync){ + BtShared *pBt = p->pBt; + sqlite3pager_set_safety_level(pBt->pPager, level, fullSync); + return SQLITE_OK; +} +#endif + +/* +** Return TRUE if the given btree is set to safety level 1. In other +** words, return TRUE if no sync() occurs on the disk files. +*/ +int sqlite3BtreeSyncDisabled(Btree *p){ + BtShared *pBt = p->pBt; + assert( pBt && pBt->pPager ); + return sqlite3pager_nosync(pBt->pPager); +} + +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) +/* +** Change the default pages size and the number of reserved bytes per page. +** +** The page size must be a power of 2 between 512 and 65536. If the page +** size supplied does not meet this constraint then the page size is not +** changed. +** +** Page sizes are constrained to be a power of two so that the region +** of the database file used for locking (beginning at PENDING_BYTE, +** the first byte past the 1GB boundary, 0x40000000) needs to occur +** at the beginning of a page. +** +** If parameter nReserve is less than zero, then the number of reserved +** bytes per page is left unchanged. +*/ +int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve){ + BtShared *pBt = p->pBt; + if( pBt->pageSizeFixed ){ + return SQLITE_READONLY; + } + if( nReserve<0 ){ + nReserve = pBt->pageSize - pBt->usableSize; + } + if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE && + ((pageSize-1)&pageSize)==0 ){ + assert( (pageSize & 7)==0 ); + assert( !pBt->pPage1 && !pBt->pCursor ); + pBt->pageSize = sqlite3pager_set_pagesize(pBt->pPager, pageSize); + } + pBt->usableSize = pBt->pageSize - nReserve; return SQLITE_OK; } /* -** Get a reference to page1 of the database file. This will +** Return the currently defined page size +*/ +int sqlite3BtreeGetPageSize(Btree *p){ + return p->pBt->pageSize; +} +int sqlite3BtreeGetReserve(Btree *p){ + return p->pBt->pageSize - p->pBt->usableSize; +} +#endif /* !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) */ + +/* +** Change the 'auto-vacuum' property of the database. If the 'autoVacuum' +** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it +** is disabled. The default value for the auto-vacuum property is +** determined by the SQLITE_DEFAULT_AUTOVACUUM macro. +*/ +int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){ + BtShared *pBt = p->pBt;; +#ifdef SQLITE_OMIT_AUTOVACUUM + return SQLITE_READONLY; +#else + if( pBt->pageSizeFixed ){ + return SQLITE_READONLY; + } + pBt->autoVacuum = (autoVacuum?1:0); + return SQLITE_OK; +#endif +} + +/* +** Return the value of the 'auto-vacuum' property. If auto-vacuum is +** enabled 1 is returned. Otherwise 0. +*/ +int sqlite3BtreeGetAutoVacuum(Btree *p){ +#ifdef SQLITE_OMIT_AUTOVACUUM + return 0; +#else + return p->pBt->autoVacuum; +#endif +} + + +/* +** Get a reference to pPage1 of the database file. This will ** also acquire a readlock on that file. ** ** SQLITE_OK is returned on success. If the file is not a @@ -780,32 +1921,95 @@ static int fileBtreeSetSafetyLevel(Btree *pBt, int level){ ** 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); +static int lockBtree(BtShared *pBt){ + int rc, pageSize; + MemPage *pPage1; + if( pBt->pPage1 ) return SQLITE_OK; + rc = getPage(pBt, 1, &pPage1); 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; + rc = SQLITE_NOTADB; + if( sqlite3pager_pagecount(pBt->pPager)>0 ){ + u8 *page1 = pPage1->aData; + if( memcmp(page1, zMagicHeader, 16)!=0 ){ goto page1_init_failed; } - pBt->needSwab = pP1->iMagic!=MAGIC; + if( page1[18]>1 || page1[19]>1 ){ + goto page1_init_failed; + } + pageSize = get2byte(&page1[16]); + if( ((pageSize-1)&pageSize)!=0 ){ + goto page1_init_failed; + } + assert( (pageSize & 7)==0 ); + pBt->pageSize = pageSize; + pBt->usableSize = pageSize - page1[20]; + if( pBt->usableSize<500 ){ + goto page1_init_failed; + } + pBt->maxEmbedFrac = page1[21]; + pBt->minEmbedFrac = page1[22]; + pBt->minLeafFrac = page1[23]; +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0); +#endif } - return rc; + + /* maxLocal is the maximum amount of payload to store locally for + ** a cell. Make sure it is small enough so that at least minFanout + ** cells can will fit on one page. We assume a 10-byte page header. + ** Besides the payload, the cell must store: + ** 2-byte pointer to the cell + ** 4-byte child pointer + ** 9-byte nKey value + ** 4-byte nData value + ** 4-byte overflow page pointer + ** So a cell consists of a 2-byte poiner, a header which is as much as + ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow + ** page pointer. + */ + pBt->maxLocal = (pBt->usableSize-12)*pBt->maxEmbedFrac/255 - 23; + pBt->minLocal = (pBt->usableSize-12)*pBt->minEmbedFrac/255 - 23; + pBt->maxLeaf = pBt->usableSize - 35; + pBt->minLeaf = (pBt->usableSize-12)*pBt->minLeafFrac/255 - 23; + if( pBt->minLocal>pBt->maxLocal || pBt->maxLocal<0 ){ + goto page1_init_failed; + } + assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) ); + pBt->pPage1 = pPage1; + return SQLITE_OK; page1_init_failed: - sqlitepager_unref(pBt->page1); - pBt->page1 = 0; + releasePage(pPage1); + pBt->pPage1 = 0; return rc; } +/* +** This routine works like lockBtree() except that it also invokes the +** busy callback if there is lock contention. +*/ +static int lockBtreeWithRetry(Btree *pRef){ + int rc = SQLITE_OK; + if( pRef->inTrans==TRANS_NONE ){ + u8 inTransaction = pRef->pBt->inTransaction; + btreeIntegrity(pRef); + rc = sqlite3BtreeBeginTrans(pRef, 0); + pRef->pBt->inTransaction = inTransaction; + pRef->inTrans = TRANS_NONE; + if( rc==SQLITE_OK ){ + pRef->pBt->nTransaction--; + } + btreeIntegrity(pRef); + } + 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 @@ -816,100 +2020,553 @@ page1_init_failed: ** ** 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; +static void unlockBtreeIfUnused(BtShared *pBt){ + if( pBt->inTransaction==TRANS_NONE && pBt->pCursor==0 && pBt->pPage1!=0 ){ + if( pBt->pPage1->aData==0 ){ + MemPage *pPage = pBt->pPage1; + pPage->aData = &((u8*)pPage)[-pBt->pageSize]; + pPage->pBt = pBt; + pPage->pgno = 1; + } + releasePage(pBt->pPage1); + pBt->pPage1 = 0; + pBt->inStmt = 0; } } /* -** Create a new database by initializing the first two pages of the +** Create a new database by initializing the first page of the ** file. */ -static int newDatabase(Btree *pBt){ - MemPage *pRoot; - PageOne *pP1; +static int newDatabase(BtShared *pBt){ + MemPage *pP1; + unsigned char *data; int rc; - if( sqlitepager_pagecount(pBt->pPager)>1 ) return SQLITE_OK; - pP1 = pBt->page1; - rc = sqlitepager_write(pBt->page1); + if( sqlite3pager_pagecount(pBt->pPager)>0 ) return SQLITE_OK; + pP1 = pBt->pPage1; + assert( pP1!=0 ); + data = pP1->aData; + rc = sqlite3pager_write(data); 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; + memcpy(data, zMagicHeader, sizeof(zMagicHeader)); + assert( sizeof(zMagicHeader)==16 ); + put2byte(&data[16], pBt->pageSize); + data[18] = 1; + data[19] = 1; + data[20] = pBt->pageSize - pBt->usableSize; + data[21] = pBt->maxEmbedFrac; + data[22] = pBt->minEmbedFrac; + data[23] = pBt->minLeafFrac; + memset(&data[24], 0, 100-24); + zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA ); + pBt->pageSizeFixed = 1; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + put4byte(&data[36 + 4*4], 1); } - 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); +#endif return SQLITE_OK; } /* -** Attempt to start a new transaction. +** Attempt to start a new transaction. A write-transaction +** is started if the second argument is nonzero, otherwise a read- +** transaction. If the second argument is 2 or more and exclusive +** transaction is started, meaning that no other process is allowed +** to access the database. A preexisting transaction may not be +** upgraded to exclusive by calling this routine a second time - the +** exclusivity flag only works for a new transaction. ** -** A transaction must be started before attempting any changes -** to the database. None of the following routines will work -** unless a transaction is started first: +** A write-transaction must be started before attempting any +** changes to the database. None of the following routines +** will work unless a transaction is started first: ** -** sqliteBtreeCreateTable() -** sqliteBtreeCreateIndex() -** sqliteBtreeClearTable() -** sqliteBtreeDropTable() -** sqliteBtreeInsert() -** sqliteBtreeDelete() -** sqliteBtreeUpdateMeta() +** sqlite3BtreeCreateTable() +** sqlite3BtreeCreateIndex() +** sqlite3BtreeClearTable() +** sqlite3BtreeDropTable() +** sqlite3BtreeInsert() +** sqlite3BtreeDelete() +** sqlite3BtreeUpdateMeta() +** +** If an initial attempt to acquire the lock fails because of lock contention +** and the database was previously unlocked, then invoke the busy handler +** if there is one. But if there was previously a read-lock, do not +** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is +** returned when there is already a read-lock in order to avoid a deadlock. +** +** Suppose there are two processes A and B. A has a read lock and B has +** a reserved lock. B tries to promote to exclusive but is blocked because +** of A's read lock. A tries to promote to reserved but is blocked by B. +** One or the other of the two processes must give way or there can be +** no progress. By returning SQLITE_BUSY and not invoking the busy callback +** when A already has a read lock, we encourage A to give up and let B +** proceed. */ -static int fileBtreeBeginTrans(Btree *pBt){ +int sqlite3BtreeBeginTrans(Btree *p, int wrflag){ + BtShared *pBt = p->pBt; + int rc = SQLITE_OK; + + btreeIntegrity(p); + + /* If the btree is already in a write-transaction, or it + ** is already in a read-transaction and a read-transaction + ** is requested, this is a no-op. + */ + if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){ + return SQLITE_OK; + } + + /* Write transactions are not possible on a read-only database */ + if( pBt->readOnly && wrflag ){ + return SQLITE_READONLY; + } + + /* If another database handle has already opened a write transaction + ** on this shared-btree structure and a second write transaction is + ** requested, return SQLITE_BUSY. + */ + if( pBt->inTransaction==TRANS_WRITE && wrflag ){ + return SQLITE_BUSY; + } + + do { + if( pBt->pPage1==0 ){ + rc = lockBtree(pBt); + } + + if( rc==SQLITE_OK && wrflag ){ + rc = sqlite3pager_begin(pBt->pPage1->aData, wrflag>1); + if( rc==SQLITE_OK ){ + rc = newDatabase(pBt); + } + } + + if( rc==SQLITE_OK ){ + if( wrflag ) pBt->inStmt = 0; + }else{ + unlockBtreeIfUnused(pBt); + } + }while( rc==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE && + sqlite3InvokeBusyHandler(pBt->pBusyHandler) ); + + if( rc==SQLITE_OK ){ + if( p->inTrans==TRANS_NONE ){ + pBt->nTransaction++; + } + p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ); + if( p->inTrans>pBt->inTransaction ){ + pBt->inTransaction = p->inTrans; + } + } + + btreeIntegrity(p); + return rc; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM + +/* +** Set the pointer-map entries for all children of page pPage. Also, if +** pPage contains cells that point to overflow pages, set the pointer +** map entries for the overflow pages as well. +*/ +static int setChildPtrmaps(MemPage *pPage){ + int i; /* Counter variable */ + int nCell; /* Number of cells in page pPage */ + int rc = SQLITE_OK; /* Return code */ + BtShared *pBt = pPage->pBt; + int isInitOrig = pPage->isInit; + Pgno pgno = pPage->pgno; + + initPage(pPage, 0); + nCell = pPage->nCell; + + for(i=0; ileaf ){ + Pgno childPgno = get4byte(pCell); + rc = ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno); + if( rc!=SQLITE_OK ) goto set_child_ptrmaps_out; + } + } + + if( !pPage->leaf ){ + Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + rc = ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno); + } + +set_child_ptrmaps_out: + pPage->isInit = isInitOrig; + return rc; +} + +/* +** Somewhere on pPage, which is guarenteed to be a btree page, not an overflow +** page, is a pointer to page iFrom. Modify this pointer so that it points to +** iTo. Parameter eType describes the type of pointer to be modified, as +** follows: +** +** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child +** page of pPage. +** +** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow +** page pointed to by one of the cells on pPage. +** +** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next +** overflow page in the list. +*/ +static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){ + if( eType==PTRMAP_OVERFLOW2 ){ + /* The pointer is always the first 4 bytes of the page in this case. */ + if( get4byte(pPage->aData)!=iFrom ){ + return SQLITE_CORRUPT_BKPT; + } + put4byte(pPage->aData, iTo); + }else{ + int isInitOrig = pPage->isInit; + int i; + int nCell; + + initPage(pPage, 0); + nCell = pPage->nCell; + + for(i=0; iaData[pPage->hdrOffset+8])!=iFrom ){ + return SQLITE_CORRUPT_BKPT; + } + put4byte(&pPage->aData[pPage->hdrOffset+8], iTo); + } + + pPage->isInit = isInitOrig; + } + return SQLITE_OK; +} + + +/* +** Move the open database page pDbPage to location iFreePage in the +** database. The pDbPage reference remains valid. +*/ +static int relocatePage( + BtShared *pBt, /* Btree */ + MemPage *pDbPage, /* Open page to move */ + u8 eType, /* Pointer map 'type' entry for pDbPage */ + Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */ + Pgno iFreePage /* The location to move pDbPage to */ +){ + MemPage *pPtrPage; /* The page that contains a pointer to pDbPage */ + Pgno iDbPage = pDbPage->pgno; + Pager *pPager = pBt->pPager; int rc; - if( pBt->inTrans ) return SQLITE_ERROR; - if( pBt->readOnly ) return SQLITE_READONLY; - if( pBt->page1==0 ){ - rc = lockBtree(pBt); + + assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 || + eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ); + + /* Move page iDbPage from it's current location to page number iFreePage */ + TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n", + iDbPage, iFreePage, iPtrPage, eType)); + rc = sqlite3pager_movepage(pPager, pDbPage->aData, iFreePage); + if( rc!=SQLITE_OK ){ + return rc; + } + pDbPage->pgno = iFreePage; + + /* If pDbPage was a btree-page, then it may have child pages and/or cells + ** that point to overflow pages. The pointer map entries for all these + ** pages need to be changed. + ** + ** If pDbPage is an overflow page, then the first 4 bytes may store a + ** pointer to a subsequent overflow page. If this is the case, then + ** the pointer map needs to be updated for the subsequent overflow page. + */ + if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){ + rc = setChildPtrmaps(pDbPage); if( rc!=SQLITE_OK ){ return rc; } - } - 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); + Pgno nextOvfl = get4byte(pDbPage->aData); + if( nextOvfl!=0 ){ + rc = ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage); + if( rc!=SQLITE_OK ){ + return rc; + } + } + } + + /* Fix the database pointer on page iPtrPage that pointed at iDbPage so + ** that it points at iFreePage. Also fix the pointer map entry for + ** iPtrPage. + */ + if( eType!=PTRMAP_ROOTPAGE ){ + rc = getPage(pBt, iPtrPage, &pPtrPage); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3pager_write(pPtrPage->aData); + if( rc!=SQLITE_OK ){ + releasePage(pPtrPage); + return rc; + } + rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType); + releasePage(pPtrPage); + if( rc==SQLITE_OK ){ + rc = ptrmapPut(pBt, iFreePage, eType, iPtrPage); + } } return rc; } +/* Forward declaration required by autoVacuumCommit(). */ +static int allocatePage(BtShared *, MemPage **, Pgno *, Pgno, u8); + +/* +** This routine is called prior to sqlite3pager_commit when a transaction +** is commited for an auto-vacuum database. +*/ +static int autoVacuumCommit(BtShared *pBt, Pgno *nTrunc){ + Pager *pPager = pBt->pPager; + Pgno nFreeList; /* Number of pages remaining on the free-list. */ + int nPtrMap; /* Number of pointer-map pages deallocated */ + Pgno origSize; /* Pages in the database file */ + Pgno finSize; /* Pages in the database file after truncation */ + int rc; /* Return code */ + u8 eType; + int pgsz = pBt->pageSize; /* Page size for this database */ + Pgno iDbPage; /* The database page to move */ + MemPage *pDbMemPage = 0; /* "" */ + Pgno iPtrPage; /* The page that contains a pointer to iDbPage */ + Pgno iFreePage; /* The free-list page to move iDbPage to */ + MemPage *pFreeMemPage = 0; /* "" */ + +#ifndef NDEBUG + int nRef = *sqlite3pager_stats(pPager); +#endif + + assert( pBt->autoVacuum ); + if( PTRMAP_ISPAGE(pBt, sqlite3pager_pagecount(pPager)) ){ + return SQLITE_CORRUPT_BKPT; + } + + /* Figure out how many free-pages are in the database. If there are no + ** free pages, then auto-vacuum is a no-op. + */ + nFreeList = get4byte(&pBt->pPage1->aData[36]); + if( nFreeList==0 ){ + *nTrunc = 0; + return SQLITE_OK; + } + + /* This block figures out how many pages there are in the database + ** now (variable origSize), and how many there will be after the + ** truncation (variable finSize). + ** + ** The final size is the original size, less the number of free pages + ** in the database, less any pointer-map pages that will no longer + ** be required, less 1 if the pending-byte page was part of the database + ** but is not after the truncation. + **/ + origSize = sqlite3pager_pagecount(pPager); + if( origSize==PENDING_BYTE_PAGE(pBt) ){ + origSize--; + } + nPtrMap = (nFreeList-origSize+PTRMAP_PAGENO(pBt, origSize)+pgsz/5)/(pgsz/5); + finSize = origSize - nFreeList - nPtrMap; + if( origSize>PENDING_BYTE_PAGE(pBt) && finSize<=PENDING_BYTE_PAGE(pBt) ){ + finSize--; + } + while( PTRMAP_ISPAGE(pBt, finSize) || finSize==PENDING_BYTE_PAGE(pBt) ){ + finSize--; + } + TRACE(("AUTOVACUUM: Begin (db size %d->%d)\n", origSize, finSize)); + + /* Variable 'finSize' will be the size of the file in pages after + ** the auto-vacuum has completed (the current file size minus the number + ** of pages on the free list). Loop through the pages that lie beyond + ** this mark, and if they are not already on the free list, move them + ** to a free page earlier in the file (somewhere before finSize). + */ + for( iDbPage=finSize+1; iDbPage<=origSize; iDbPage++ ){ + /* If iDbPage is a pointer map page, or the pending-byte page, skip it. */ + if( PTRMAP_ISPAGE(pBt, iDbPage) || iDbPage==PENDING_BYTE_PAGE(pBt) ){ + continue; + } + + rc = ptrmapGet(pBt, iDbPage, &eType, &iPtrPage); + if( rc!=SQLITE_OK ) goto autovacuum_out; + if( eType==PTRMAP_ROOTPAGE ){ + rc = SQLITE_CORRUPT_BKPT; + goto autovacuum_out; + } + + /* If iDbPage is free, do not swap it. */ + if( eType==PTRMAP_FREEPAGE ){ + continue; + } + rc = getPage(pBt, iDbPage, &pDbMemPage); + if( rc!=SQLITE_OK ) goto autovacuum_out; + + /* Find the next page in the free-list that is not already at the end + ** of the file. A page can be pulled off the free list using the + ** allocatePage() routine. + */ + do{ + if( pFreeMemPage ){ + releasePage(pFreeMemPage); + pFreeMemPage = 0; + } + rc = allocatePage(pBt, &pFreeMemPage, &iFreePage, 0, 0); + if( rc!=SQLITE_OK ){ + releasePage(pDbMemPage); + goto autovacuum_out; + } + assert( iFreePage<=origSize ); + }while( iFreePage>finSize ); + releasePage(pFreeMemPage); + pFreeMemPage = 0; + + /* Relocate the page into the body of the file. Note that although the + ** page has moved within the database file, the pDbMemPage pointer + ** remains valid. This means that this function can run without + ** invalidating cursors open on the btree. This is important in + ** shared-cache mode. + */ + rc = relocatePage(pBt, pDbMemPage, eType, iPtrPage, iFreePage); + releasePage(pDbMemPage); + if( rc!=SQLITE_OK ) goto autovacuum_out; + } + + /* The entire free-list has been swapped to the end of the file. So + ** truncate the database file to finSize pages and consider the + ** free-list empty. + */ + rc = sqlite3pager_write(pBt->pPage1->aData); + if( rc!=SQLITE_OK ) goto autovacuum_out; + put4byte(&pBt->pPage1->aData[32], 0); + put4byte(&pBt->pPage1->aData[36], 0); + *nTrunc = finSize; + assert( finSize!=PENDING_BYTE_PAGE(pBt) ); + +autovacuum_out: + assert( nRef==*sqlite3pager_stats(pPager) ); + if( rc!=SQLITE_OK ){ + sqlite3pager_rollback(pPager); + } + return rc; +} +#endif + /* ** 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; +int sqlite3BtreeCommit(Btree *p){ + BtShared *pBt = p->pBt; + + btreeIntegrity(p); + + /* If the handle has a write-transaction open, commit the shared-btrees + ** transaction and set the shared state to TRANS_READ. + */ + if( p->inTrans==TRANS_WRITE ){ + int rc; + assert( pBt->inTransaction==TRANS_WRITE ); + assert( pBt->nTransaction>0 ); + rc = sqlite3pager_commit(pBt->pPager); + if( rc!=SQLITE_OK ){ + return rc; + } + pBt->inTransaction = TRANS_READ; + pBt->inStmt = 0; + } + unlockAllTables(p); + + /* If the handle has any kind of transaction open, decrement the transaction + ** count of the shared btree. If the transaction count reaches 0, set + ** the shared state to TRANS_NONE. The unlockBtreeIfUnused() call below + ** will unlock the pager. + */ + if( p->inTrans!=TRANS_NONE ){ + pBt->nTransaction--; + if( 0==pBt->nTransaction ){ + pBt->inTransaction = TRANS_NONE; + } + } + + /* Set the handles current transaction state to TRANS_NONE and unlock + ** the pager if this call closed the only read or write transaction. + */ + p->inTrans = TRANS_NONE; unlockBtreeIfUnused(pBt); - return rc; + + btreeIntegrity(p); + return SQLITE_OK; } +#ifndef NDEBUG +/* +** Return the number of write-cursors open on this handle. This is for use +** in assert() expressions, so it is only compiled if NDEBUG is not +** defined. +*/ +static int countWriteCursors(BtShared *pBt){ + BtCursor *pCur; + int r = 0; + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + if( pCur->wrFlag ) r++; + } + return r; +} +#endif + +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) +/* +** Print debugging information about all cursors to standard output. +*/ +void sqlite3BtreeCursorList(Btree *p){ + BtCursor *pCur; + BtShared *pBt = p->pBt; + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + MemPage *pPage = pCur->pPage; + char *zMode = pCur->wrFlag ? "rw" : "ro"; + sqlite3DebugPrintf("CURSOR %p rooted at %4d(%s) currently at %d.%d%s\n", + pCur, pCur->pgnoRoot, zMode, + pPage ? pPage->pgno : 0, pCur->idx, + (pCur->eState==CURSOR_VALID) ? "" : " eof" + ); + } +} +#endif + /* ** Rollback the transaction in progress. All cursors will be ** invalided by this operation. Any attempt to use a cursor @@ -919,82 +2576,149 @@ static int fileBtreeCommit(Btree *pBt){ ** 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 sqlite3BtreeRollback(Btree *p){ 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; + BtShared *pBt = p->pBt; + MemPage *pPage1; + + rc = saveAllCursors(pBt, 0, 0); +#ifndef SQLITE_OMIT_SHARED_CACHE + if( rc!=SQLITE_OK ){ + /* This is a horrible situation. An IO or malloc() error occured whilst + ** trying to save cursor positions. If this is an automatic rollback (as + ** the result of a constraint, malloc() failure or IO error) then + ** the cache may be internally inconsistent (not contain valid trees) so + ** we cannot simply return the error to the caller. Instead, abort + ** all queries that may be using any of the cursors that failed to save. + */ + while( pBt->pCursor ){ + sqlite3 *db = pBt->pCursor->pBtree->pSqlite; + if( db ){ + sqlite3AbortOtherActiveVdbes(db, 0); + } } } +#endif + btreeIntegrity(p); + unlockAllTables(p); + + if( p->inTrans==TRANS_WRITE ){ + int rc2; + + assert( TRANS_WRITE==pBt->inTransaction ); + rc2 = sqlite3pager_rollback(pBt->pPager); + if( rc2!=SQLITE_OK ){ + rc = rc2; + } + + /* The rollback may have destroyed the pPage1->aData value. So + ** call getPage() on page 1 again to make sure pPage1->aData is + ** set correctly. */ + if( getPage(pBt, 1, &pPage1)==SQLITE_OK ){ + releasePage(pPage1); + } + assert( countWriteCursors(pBt)==0 ); + pBt->inTransaction = TRANS_READ; + } + + if( p->inTrans!=TRANS_NONE ){ + assert( pBt->nTransaction>0 ); + pBt->nTransaction--; + if( 0==pBt->nTransaction ){ + pBt->inTransaction = TRANS_NONE; + } + } + + p->inTrans = TRANS_NONE; + pBt->inStmt = 0; unlockBtreeIfUnused(pBt); + + btreeIntegrity(p); 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 +** Start a statement subtransaction. The subtransaction can +** can be rolled back independently of the main transaction. +** You must start a transaction before starting a subtransaction. +** The subtransaction is ended automatically if the main transaction ** commits or rolls back. ** -** 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. +** Only one subtransaction may be active at a time. It is an error to try +** to start a new subtransaction if another subtransaction is already active. +** +** Statement subtransactions are used around individual SQL statements +** that are contained within a BEGIN...COMMIT block. If a constraint +** error occurs within the statement, the effect of that one statement +** can be rolled back without having to rollback the entire transaction. */ -static int fileBtreeBeginCkpt(Btree *pBt){ +int sqlite3BtreeBeginStmt(Btree *p){ int rc; - if( !pBt->inTrans || pBt->inCkpt ){ + BtShared *pBt = p->pBt; + if( (p->inTrans!=TRANS_WRITE) || pBt->inStmt ){ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; } - rc = pBt->readOnly ? SQLITE_OK : sqlitepager_ckpt_begin(pBt->pPager); - pBt->inCkpt = 1; + assert( pBt->inTransaction==TRANS_WRITE ); + rc = pBt->readOnly ? SQLITE_OK : sqlite3pager_stmt_begin(pBt->pPager); + pBt->inStmt = 1; return rc; } /* -** Commit a checkpoint to transaction currently in progress. If no -** checkpoint is active, this is a no-op. +** Commit the statment subtransaction currently in progress. If no +** subtransaction is active, this is a no-op. */ -static int fileBtreeCommitCkpt(Btree *pBt){ +int sqlite3BtreeCommitStmt(Btree *p){ int rc; - if( pBt->inCkpt && !pBt->readOnly ){ - rc = sqlitepager_ckpt_commit(pBt->pPager); + BtShared *pBt = p->pBt; + if( pBt->inStmt && !pBt->readOnly ){ + rc = sqlite3pager_stmt_commit(pBt->pPager); }else{ rc = SQLITE_OK; } - pBt->inCkpt = 0; + pBt->inStmt = 0; return rc; } /* -** Rollback the checkpoint to the current transaction. If there -** is no active checkpoint or transaction, this routine is a no-op. +** Rollback the active statement subtransaction. If no subtransaction +** is active this routine is a no-op. ** -** All cursors will be invalided by this operation. Any attempt +** All cursors will be invalidated 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; - } +int sqlite3BtreeRollbackStmt(Btree *p){ + int rc = SQLITE_OK; + BtShared *pBt = p->pBt; + sqlite3MallocDisallow(); + if( pBt->inStmt && !pBt->readOnly ){ + rc = sqlite3pager_stmt_rollback(pBt->pPager); + assert( countWriteCursors(pBt)==0 ); + pBt->inStmt = 0; } - pBt->inCkpt = 0; + sqlite3MallocAllow(); return rc; } +/* +** Default key comparison function to be used if no comparison function +** is specified on the sqlite3BtreeCursor() call. +*/ +static int dfltCompare( + void *NotUsed, /* User data is not used */ + int n1, const void *p1, /* First key to compare */ + int n2, const void *p2 /* Second key to compare */ +){ + int c; + c = memcmp(p1, p2, n1pBt; - if( pBt->page1==0 ){ - rc = lockBtree(pBt); + *ppCur = 0; + if( wrFlag ){ + if( pBt->readOnly ){ + return SQLITE_READONLY; + } + if( checkReadLocks(pBt, iTable, 0) ){ + return SQLITE_LOCKED; + } + } + + if( pBt->pPage1==0 ){ + rc = lockBtreeWithRetry(p); if( rc!=SQLITE_OK ){ - *ppCur = 0; return rc; } } @@ -1048,52 +2795,62 @@ static int fileBtreeCursor(Btree *pBt, int iTable, int wrFlag, BtCursor **ppCur) goto create_cursor_exception; } pCur->pgnoRoot = (Pgno)iTable; - rc = sqlitepager_get(pBt->pPager, pCur->pgnoRoot, (void**)&pCur->pPage); + if( iTable==1 && sqlite3pager_pagecount(pBt->pPager)==0 ){ + rc = SQLITE_EMPTY; + goto create_cursor_exception; + } + rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->pPage, 0); 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; + + /* Now that no other errors can occur, finish filling in the BtCursor + ** variables, link the cursor into the BtShared list and set *ppCur (the + ** output argument to this function). + */ + pCur->xCompare = xCmp ? xCmp : dfltCompare; + pCur->pArg = pArg; + pCur->pBtree = p; 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; + pCur->eState = CURSOR_INVALID; *ppCur = pCur; - return SQLITE_OK; + return SQLITE_OK; create_cursor_exception: - *ppCur = 0; if( pCur ){ - if( pCur->pPage ) sqlitepager_unref(pCur->pPage); + releasePage(pCur->pPage); sqliteFree(pCur); } unlockBtreeIfUnused(pBt); return rc; } +#if 0 /* Not Used */ +/* +** Change the value of the comparison function used by a cursor. +*/ +void sqlite3BtreeSetCompare( + BtCursor *pCur, /* The cursor to whose comparison function is changed */ + int(*xCmp)(void*,int,const void*,int,const void*), /* New comparison func */ + void *pArg /* First argument to xCmp() */ +){ + pCur->xCompare = xCmp ? xCmp : dfltCompare; + pCur->pArg = pArg; +} +#endif + /* ** 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; +int sqlite3BtreeCloseCursor(BtCursor *pCur){ + BtShared *pBt = pCur->pBtree->pBt; + restoreOrClearCursorPosition(pCur, 0); if( pCur->pPrev ){ pCur->pPrev->pNext = pCur->pNext; }else{ @@ -1102,14 +2859,7 @@ static int fileBtreeCloseCursor(BtCursor *pCur){ 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; - } + releasePage(pCur->pPage); unlockBtreeIfUnused(pBt); sqliteFree(pCur); return SQLITE_OK; @@ -1124,7 +2874,7 @@ static void getTempCursor(BtCursor *pCur, BtCursor *pTempCur){ pTempCur->pNext = 0; pTempCur->pPrev = 0; if( pTempCur->pPage ){ - sqlitepager_ref(pTempCur->pPage); + sqlite3pager_ref(pTempCur->pPage->aData); } } @@ -1134,119 +2884,50 @@ static void getTempCursor(BtCursor *pCur, BtCursor *pTempCur){ */ static void releaseTempCursor(BtCursor *pCur){ if( pCur->pPage ){ - sqlitepager_unref(pCur->pPage); + sqlite3pager_unref(pCur->pPage->aData); } } /* -** 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. +** Make sure the BtCursor.info field of the given cursor is valid. +** If it is not already valid, call parseCell() to fill it in. ** -** This routine does not make a distinction between key and data. -** It just reads bytes from the payload area. +** BtCursor.info is a cache of the information in the current cell. +** Using this cache reduces the number of calls to parseCell(). */ -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; +static void getCellInfo(BtCursor *pCur){ + if( pCur->info.nSize==0 ){ + parseCell(pCur->pPage, pCur->idx, &pCur->info); }else{ - offset -= MX_LOCAL_PAYLOAD; +#ifndef NDEBUG + CellInfo info; + memset(&info, 0, sizeof(info)); + parseCell(pCur->pPage, pCur->idx, &info); + assert( memcmp(&info, &pCur->info, sizeof(info))==0 ); +#endif } - 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; +} + +/* +** Set *pSize to the size of the buffer needed to hold the value of +** the key for the current entry. If the cursor is not pointing +** to a valid entry, *pSize is set to 0. +** +** For a table with the INTKEY flag set, this routine returns the key +** itself, not the number of bytes in the key. +*/ +int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){ + int rc = restoreOrClearCursorPosition(pCur, 1); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID ); + if( pCur->eState==CURSOR_INVALID ){ + *pSize = 0; }else{ - offset -= OVERFLOW_SIZE; + getCellInfo(pCur); + *pSize = pCur->info.nKey; } - 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; + return rc; } /* @@ -1256,158 +2937,280 @@ static int fileBtreeKey(BtCursor *pCur, int offset, int amt, char *zBuf){ ** 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); +int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){ + int rc = restoreOrClearCursorPosition(pCur, 1); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID ); + if( pCur->eState==CURSOR_INVALID ){ + /* Not pointing at a valid entry - set *pSize to 0. */ + *pSize = 0; + }else{ + getCellInfo(pCur); + *pSize = pCur->info.nData; + } } - return SQLITE_OK; + return rc; } /* -** 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. +** 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. Data might appear +** on the main page or be scattered out on multiple overflow pages. */ -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 */ +static int getPayload( + BtCursor *pCur, /* Cursor pointing to entry to read from */ + int offset, /* Begin reading this far into payload */ + int amt, /* Read this many bytes */ + unsigned char *pBuf, /* Write the bytes into this buffer */ + int skipKey /* offset begins at data if this is true */ ){ + unsigned char *aPayload; Pgno nextPage; - int n, c, rc, nLocal; - Cell *pCell; - Btree *pBt = pCur->pBt; - const char *zKey = (const char*)pKey; + int rc; + MemPage *pPage; + BtShared *pBt; + int ovflSize; + u32 nKey; - 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; + assert( pCur!=0 && pCur->pPage!=0 ); + assert( pCur->eState==CURSOR_VALID ); + pBt = pCur->pBtree->pBt; + pPage = pCur->pPage; + pageIntegrity(pPage); + assert( pCur->idx>=0 && pCur->idxnCell ); + getCellInfo(pCur); + aPayload = pCur->info.pCell + pCur->info.nHeader; + if( pPage->intKey ){ + nKey = 0; + }else{ + nKey = pCur->info.nKey; } - c = memcmp(pCell->aPayload, zKey, n); - if( c!=0 ){ - *pResult = c; - return SQLITE_OK; + assert( offset>=0 ); + if( skipKey ){ + offset += nKey; } - zKey += n; - nKey -= n; - nLocal -= n; - nextPage = SWAB32(pBt, pCell->ovfl); - while( nKey>0 && nLocal>0 ){ - OverflowPage *pOvfl; - if( nextPage==0 ){ - return SQLITE_CORRUPT; + if( offset+amt > nKey+pCur->info.nData ){ + return SQLITE_ERROR; + } + if( offsetinfo.nLocal ){ + int a = amt; + if( a+offset>pCur->info.nLocal ){ + a = pCur->info.nLocal - offset; } - 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; + memcpy(pBuf, &aPayload[offset], a); + if( a==amt ){ return SQLITE_OK; } - nKey -= n; - nLocal -= n; - zKey += n; + offset = 0; + pBuf += a; + amt -= a; + }else{ + offset -= pCur->info.nLocal; } - if( c==0 ){ - c = nLocal - nKey; + ovflSize = pBt->usableSize - 4; + if( amt>0 ){ + nextPage = get4byte(&aPayload[pCur->info.nLocal]); + while( amt>0 && nextPage ){ + rc = sqlite3pager_get(pBt->pPager, nextPage, (void**)&aPayload); + if( rc!=0 ){ + return rc; + } + nextPage = get4byte(aPayload); + if( offset ovflSize ){ + a = ovflSize - offset; + } + memcpy(pBuf, &aPayload[offset+4], a); + offset = 0; + amt -= a; + pBuf += a; + }else{ + offset -= ovflSize; + } + sqlite3pager_unref(aPayload); + } + } + + if( amt>0 ){ + return SQLITE_CORRUPT_BKPT; } - *pResult = c; return SQLITE_OK; } +/* +** Read part of the key associated with cursor pCur. Exactly +** "amt" bytes will be transfered into pBuf[]. The transfer +** begins at "offset". +** +** Return SQLITE_OK on success or an error code if anything goes +** wrong. An error is returned if "offset+amt" is larger than +** the available payload. +*/ +int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ + int rc = restoreOrClearCursorPosition(pCur, 1); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->pPage!=0 ); + if( pCur->pPage->intKey ){ + return SQLITE_CORRUPT_BKPT; + } + assert( pCur->pPage->intKey==0 ); + assert( pCur->idx>=0 && pCur->idxpPage->nCell ); + rc = getPayload(pCur, offset, amt, (unsigned char*)pBuf, 0); + } + return rc; +} + +/* +** Read part of the data associated with cursor pCur. Exactly +** "amt" bytes will be transfered into pBuf[]. The transfer +** begins at "offset". +** +** Return SQLITE_OK on success or an error code if anything goes +** wrong. An error is returned if "offset+amt" is larger than +** the available payload. +*/ +int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ + int rc = restoreOrClearCursorPosition(pCur, 1); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->pPage!=0 ); + assert( pCur->idx>=0 && pCur->idxpPage->nCell ); + rc = getPayload(pCur, offset, amt, pBuf, 1); + } + return rc; +} + +/* +** Return a pointer to payload information from the entry that the +** pCur cursor is pointing to. The pointer is to the beginning of +** the key if skipKey==0 and it points to the beginning of data if +** skipKey==1. The number of bytes of available key/data is written +** into *pAmt. If *pAmt==0, then the value returned will not be +** a valid pointer. +** +** This routine is an optimization. It is common for the entire key +** and data to fit on the local page and for there to be no overflow +** pages. When that is so, this routine can be used to access the +** key and data without making a copy. If the key and/or data spills +** onto overflow pages, then getPayload() must be used to reassembly +** the key/data and copy it into a preallocated buffer. +** +** The pointer returned by this routine looks directly into the cached +** page of the database. The data might change or move the next time +** any btree routine is called. +*/ +static const unsigned char *fetchPayload( + BtCursor *pCur, /* Cursor pointing to entry to read from */ + int *pAmt, /* Write the number of available bytes here */ + int skipKey /* read beginning at data if this is true */ +){ + unsigned char *aPayload; + MemPage *pPage; + u32 nKey; + int nLocal; + + assert( pCur!=0 && pCur->pPage!=0 ); + assert( pCur->eState==CURSOR_VALID ); + pPage = pCur->pPage; + pageIntegrity(pPage); + assert( pCur->idx>=0 && pCur->idxnCell ); + getCellInfo(pCur); + aPayload = pCur->info.pCell; + aPayload += pCur->info.nHeader; + if( pPage->intKey ){ + nKey = 0; + }else{ + nKey = pCur->info.nKey; + } + if( skipKey ){ + aPayload += nKey; + nLocal = pCur->info.nLocal - nKey; + }else{ + nLocal = pCur->info.nLocal; + if( nLocal>nKey ){ + nLocal = nKey; + } + } + *pAmt = nLocal; + return aPayload; +} + + +/* +** For the entry that cursor pCur is point to, return as +** many bytes of the key or data as are available on the local +** b-tree page. Write the number of available bytes into *pAmt. +** +** The pointer returned is ephemeral. The key/data may move +** or be destroyed on the next call to any Btree routine. +** +** These routines is used to get quick access to key and data +** in the common case where no overflow pages are used. +*/ +const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){ + if( pCur->eState==CURSOR_VALID ){ + return (const void*)fetchPayload(pCur, pAmt, 0); + } + return 0; +} +const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){ + if( pCur->eState==CURSOR_VALID ){ + return (const void*)fetchPayload(pCur, pAmt, 1); + } + return 0; +} + + /* ** 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. +** page number of the child page to move to. */ -static int moveToChild(BtCursor *pCur, int newPgno){ +static int moveToChild(BtCursor *pCur, u32 newPgno){ int rc; MemPage *pNewPage; - Btree *pBt = pCur->pBt; + MemPage *pOldPage; + BtShared *pBt = pCur->pBtree->pBt; - newPgno = SWAB32(pBt, newPgno); - rc = sqlitepager_get(pBt->pPager, newPgno, (void**)&pNewPage); + assert( pCur->eState==CURSOR_VALID ); + rc = getAndInitPage(pBt, newPgno, &pNewPage, pCur->pPage); 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) ); + pageIntegrity(pNewPage); pNewPage->idxParent = pCur->idx; - pCur->pPage->idxShift = 0; - sqlitepager_unref(pCur->pPage); + pOldPage = pCur->pPage; + pOldPage->idxShift = 0; + releasePage(pOldPage); pCur->pPage = pNewPage; pCur->idx = 0; + pCur->info.nSize = 0; if( pNewPage->nCell<1 ){ - return SQLITE_CORRUPT; + return SQLITE_CORRUPT_BKPT; } return SQLITE_OK; } +/* +** Return true if the page is the virtual root of its table. +** +** The virtual root page is the root page for most tables. But +** for the table rooted on page 1, sometime the real root page +** is empty except for the right-pointer. In such cases the +** virtual root page is the page that the right-pointer of page +** 1 is pointing to. +*/ +static int isRootPage(MemPage *pPage){ + MemPage *pParent = pPage->pParent; + if( pParent==0 ) return 1; + if( pParent->pgno>1 ) return 0; + if( get2byte(&pParent->aData[pParent->hdrOffset+3])==0 ) return 1; + return 0; +} + /* ** Move the cursor up to the parent page. ** @@ -1417,77 +3220,80 @@ static int moveToChild(BtCursor *pCur, int newPgno){ ** the largest cell index. */ static void moveToParent(BtCursor *pCur){ - Pgno oldPgno; MemPage *pParent; MemPage *pPage; int idxParent; + + assert( pCur->eState==CURSOR_VALID ); pPage = pCur->pPage; assert( pPage!=0 ); + assert( !isRootPage(pPage) ); + pageIntegrity(pPage); pParent = pPage->pParent; assert( pParent!=0 ); + pageIntegrity(pParent); idxParent = pPage->idxParent; - sqlitepager_ref(pParent); - sqlitepager_unref(pPage); + sqlite3pager_ref(pParent->aData); + releasePage(pPage); pCur->pPage = pParent; + pCur->info.nSize = 0; 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; - } - } - } + pCur->idx = idxParent; } /* ** Move the cursor to the root page */ static int moveToRoot(BtCursor *pCur){ - MemPage *pNew; - int rc; - Btree *pBt = pCur->pBt; + MemPage *pRoot; + int rc = SQLITE_OK; + BtShared *pBt = pCur->pBtree->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; + restoreOrClearCursorPosition(pCur, 0); + pRoot = pCur->pPage; + if( pRoot && pRoot->pgno==pCur->pgnoRoot ){ + assert( pRoot->isInit ); + }else{ + if( + SQLITE_OK!=(rc = getAndInitPage(pBt, pCur->pgnoRoot, &pRoot, 0)) + ){ + pCur->eState = CURSOR_INVALID; + return rc; + } + releasePage(pCur->pPage); + pageIntegrity(pRoot); + pCur->pPage = pRoot; + } pCur->idx = 0; - return SQLITE_OK; + pCur->info.nSize = 0; + if( pRoot->nCell==0 && !pRoot->leaf ){ + Pgno subpage; + assert( pRoot->pgno==1 ); + subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]); + assert( subpage>0 ); + pCur->eState = CURSOR_VALID; + rc = moveToChild(pCur, subpage); + } + pCur->eState = ((pCur->pPage->nCell>0)?CURSOR_VALID:CURSOR_INVALID); + return rc; } /* ** Move the cursor down to the left-most leaf entry beneath the ** entry to which it is currently pointing. +** +** The left-most leaf is the one with the smallest key - the first +** in ascending order. */ static int moveToLeftmost(BtCursor *pCur){ Pgno pgno; int rc; + MemPage *pPage; - while( (pgno = pCur->pPage->apCell[pCur->idx]->h.leftChild)!=0 ){ + assert( pCur->eState==CURSOR_VALID ); + while( !(pPage = pCur->pPage)->leaf ){ + assert( pCur->idx>=0 && pCur->idxnCell ); + pgno = get4byte(findCell(pPage, pCur->idx)); rc = moveToChild(pCur, pgno); if( rc ) return rc; } @@ -1500,17 +3306,24 @@ static int moveToLeftmost(BtCursor *pCur){ ** between moveToLeftmost() and moveToRightmost(). moveToLeftmost() ** finds the left-most entry beneath the *entry* whereas moveToRightmost() ** finds the right-most entry beneath the *page*. +** +** The right-most entry is the one with the largest key - the last +** key in ascending order. */ static int moveToRightmost(BtCursor *pCur){ Pgno pgno; int rc; + MemPage *pPage; - while( (pgno = pCur->pPage->u.hdr.rightChild)!=0 ){ - pCur->idx = pCur->pPage->nCell; + assert( pCur->eState==CURSOR_VALID ); + while( !(pPage = pCur->pPage)->leaf ){ + pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + pCur->idx = pPage->nCell; rc = moveToChild(pCur, pgno); if( rc ) return rc; } - pCur->idx = pCur->pPage->nCell - 1; + pCur->idx = pPage->nCell - 1; + pCur->info.nSize = 0; return SQLITE_OK; } @@ -1518,18 +3331,18 @@ static int moveToRightmost(BtCursor *pCur){ ** 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 sqlite3BtreeFirst(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 ){ + if( pCur->eState==CURSOR_INVALID ){ + assert( pCur->pPage->nCell==0 ); *pRes = 1; return SQLITE_OK; } + assert( pCur->pPage->nCell>0 ); *pRes = 0; rc = moveToLeftmost(pCur); - pCur->eSkip = SKIP_NONE; return rc; } @@ -1537,33 +3350,36 @@ static int fileBtreeFirst(BtCursor *pCur, int *pRes){ ** 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 sqlite3BtreeLast(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 ){ + if( CURSOR_INVALID==pCur->eState ){ + assert( pCur->pPage->nCell==0 ); *pRes = 1; return SQLITE_OK; } + assert( pCur->eState==CURSOR_VALID ); *pRes = 0; rc = moveToRightmost(pCur); - pCur->eSkip = SKIP_NONE; return rc; } -/* Move the cursor so that it points to an entry near pKey. +/* Move the cursor so that it points to an entry near pKey/nKey. ** Return a success code. ** +** For INTKEY tables, only the nKey parameter is used. pKey is +** ignored. For other tables, nKey is the number of bytes of data +** in pKey. The comparison function specified when the cursor was +** created is used to compare keys. +** ** 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 +** cursor is 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 @@ -1576,28 +3392,78 @@ static int fileBtreeLast(BtCursor *pCur, int *pRes){ ** *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 sqlite3BtreeMoveto(BtCursor *pCur, const void *pKey, i64 nKey, int *pRes){ int rc; - if( pCur->pPage==0 ) return SQLITE_ABORT; - pCur->eSkip = SKIP_NONE; + int tryRightmost; rc = moveToRoot(pCur); if( rc ) return rc; - for(;;){ + assert( pCur->pPage ); + assert( pCur->pPage->isInit ); + tryRightmost = pCur->pPage->intKey; + if( pCur->eState==CURSOR_INVALID ){ + *pRes = -1; + assert( pCur->pPage->nCell==0 ); + return SQLITE_OK; + } + 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; + if( !pPage->intKey && pKey==0 ){ + return SQLITE_CORRUPT_BKPT; + } + pageIntegrity(pPage); while( lwr<=upr ){ + void *pCellKey; + i64 nCellKey; pCur->idx = (lwr+upr)/2; - rc = fileBtreeKeyCompare(pCur, pKey, nKey, 0, &c); - if( rc ) return rc; + pCur->info.nSize = 0; + if( pPage->intKey ){ + u8 *pCell; + if( tryRightmost ){ + pCur->idx = upr; + } + pCell = findCell(pPage, pCur->idx) + pPage->childPtrSize; + if( pPage->hasData ){ + u32 dummy; + pCell += getVarint32(pCell, &dummy); + } + getVarint(pCell, (u64 *)&nCellKey); + if( nCellKeynKey ){ + c = +1; + tryRightmost = 0; + }else{ + c = 0; + } + }else{ + int available; + pCellKey = (void *)fetchPayload(pCur, &available, 0); + nCellKey = pCur->info.nKey; + if( available>=nCellKey ){ + c = pCur->xCompare(pCur->pArg, nCellKey, pCellKey, nKey, pKey); + }else{ + pCellKey = sqliteMallocRaw( nCellKey ); + if( pCellKey==0 ) return SQLITE_NOMEM; + rc = sqlite3BtreeKey(pCur, 0, nCellKey, (void *)pCellKey); + c = pCur->xCompare(pCur->pArg, nCellKey, pCellKey, nKey, pKey); + sqliteFree(pCellKey); + if( rc ) return rc; + } + } if( c==0 ){ - pCur->iMatch = c; - if( pRes ) *pRes = 0; - return SQLITE_OK; + if( pPage->leafData && !pPage->leaf ){ + lwr = pCur->idx; + upr = lwr - 1; + break; + }else{ + if( pRes ) *pRes = 0; + return SQLITE_OK; + } } if( c<0 ){ lwr = pCur->idx+1; @@ -1607,72 +3473,104 @@ int fileBtreeMoveto(BtCursor *pCur, const void *pKey, int nKey, int *pRes){ } assert( lwr==upr+1 ); assert( pPage->isInit ); - if( lwr>=pPage->nCell ){ - chldPg = pPage->u.hdr.rightChild; + if( pPage->leaf ){ + chldPg = 0; + }else if( lwr>=pPage->nCell ){ + chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]); }else{ - chldPg = pPage->apCell[lwr]->h.leftChild; + chldPg = get4byte(findCell(pPage, lwr)); } if( chldPg==0 ){ - pCur->iMatch = c; + assert( pCur->idx>=0 && pCur->idxpPage->nCell ); if( pRes ) *pRes = c; return SQLITE_OK; } pCur->idx = lwr; + pCur->info.nSize = 0; rc = moveToChild(pCur, chldPg); - if( rc ) return rc; + if( rc ){ + return rc; + } } /* NOT REACHED */ } +/* +** Return TRUE if the cursor is not pointing at an entry of the table. +** +** TRUE will be returned after a call to sqlite3BtreeNext() moves +** past the last entry in the table or sqlite3BtreePrev() moves past +** the first entry. TRUE is also returned if the table is empty. +*/ +int sqlite3BtreeEof(BtCursor *pCur){ + /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries + ** have been deleted? This API will need to change to return an error code + ** as well as the boolean result value. + */ + return (CURSOR_VALID!=pCur->eState); +} + /* ** Advance the cursor to the next entry in the database. If ** successful then set *pRes=0. If the cursor ** was already pointing to the last entry in the database before ** this routine was called, then set *pRes=1. */ -static int fileBtreeNext(BtCursor *pCur, int *pRes){ +int sqlite3BtreeNext(BtCursor *pCur, int *pRes){ int rc; - MemPage *pPage = pCur->pPage; - assert( pRes!=0 ); - if( pPage==0 ){ - *pRes = 1; - return SQLITE_ABORT; + MemPage *pPage; + +#ifndef SQLITE_OMIT_SHARED_CACHE + rc = restoreOrClearCursorPosition(pCur, 1); + if( rc!=SQLITE_OK ){ + return rc; } - 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; + if( pCur->skip>0 ){ + pCur->skip = 0; *pRes = 0; return SQLITE_OK; } - pCur->eSkip = SKIP_NONE; + pCur->skip = 0; +#endif + + assert( pRes!=0 ); + pPage = pCur->pPage; + if( CURSOR_INVALID==pCur->eState ){ + *pRes = 1; + return SQLITE_OK; + } + assert( pPage->isInit ); + assert( pCur->idxnCell ); + pCur->idx++; + pCur->info.nSize = 0; if( pCur->idx>=pPage->nCell ){ - if( pPage->u.hdr.rightChild ){ - rc = moveToChild(pCur, pPage->u.hdr.rightChild); + if( !pPage->leaf ){ + rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); if( rc ) return rc; rc = moveToLeftmost(pCur); *pRes = 0; return rc; } do{ - if( pPage->pParent==0 ){ + if( isRootPage(pPage) ){ *pRes = 1; + pCur->eState = CURSOR_INVALID; return SQLITE_OK; } moveToParent(pCur); pPage = pCur->pPage; }while( pCur->idx>=pPage->nCell ); *pRes = 0; - return SQLITE_OK; + if( pPage->leafData ){ + rc = sqlite3BtreeNext(pCur, pRes); + }else{ + rc = SQLITE_OK; + } + return rc; } *pRes = 0; - if( pPage->u.hdr.rightChild==0 ){ + if( pPage->leaf ){ return SQLITE_OK; } rc = moveToLeftmost(pCur); @@ -1685,43 +3583,54 @@ static int fileBtreeNext(BtCursor *pCur, int *pRes){ ** 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 sqlite3BtreePrevious(BtCursor *pCur, int *pRes){ int rc; Pgno pgno; MemPage *pPage; - pPage = pCur->pPage; - if( pPage==0 ){ - *pRes = 1; - return SQLITE_ABORT; + +#ifndef SQLITE_OMIT_SHARED_CACHE + rc = restoreOrClearCursorPosition(pCur, 1); + if( rc!=SQLITE_OK ){ + return rc; } - 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; + if( pCur->skip<0 ){ + pCur->skip = 0; *pRes = 0; return SQLITE_OK; } - pCur->eSkip = SKIP_NONE; + pCur->skip = 0; +#endif + + if( CURSOR_INVALID==pCur->eState ){ + *pRes = 1; + return SQLITE_OK; + } + + pPage = pCur->pPage; + assert( pPage->isInit ); assert( pCur->idx>=0 ); - if( (pgno = pPage->apCell[pCur->idx]->h.leftChild)!=0 ){ + if( !pPage->leaf ){ + pgno = get4byte( findCell(pPage, pCur->idx) ); rc = moveToChild(pCur, pgno); if( rc ) return rc; rc = moveToRightmost(pCur); }else{ while( pCur->idx==0 ){ - if( pPage->pParent==0 ){ - if( pRes ) *pRes = 1; + if( isRootPage(pPage) ){ + pCur->eState = CURSOR_INVALID; + *pRes = 1; return SQLITE_OK; } moveToParent(pCur); pPage = pCur->pPage; } pCur->idx--; - rc = SQLITE_OK; + pCur->info.nSize = 0; + if( pPage->leafData && !pPage->leaf ){ + rc = sqlite3BtreePrevious(pCur, pRes); + }else{ + rc = SQLITE_OK; + } } *pRes = 0; return rc; @@ -1730,243 +3639,456 @@ static int fileBtreePrevious(BtCursor *pCur, int *pRes){ /* ** Allocate a new page from the database file. ** -** The new page is marked as dirty. (In other words, sqlitepager_write() +** The new page is marked as dirty. (In other words, sqlite3pager_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. +** sqlite3pager_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. +** Do not invoke sqlite3pager_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. +** If the "exact" parameter is not 0, and the page-number nearby exists +** anywhere on the free-list, then it is guarenteed to be returned. This +** is only used by auto-vacuum databases when allocating a new table. */ -static int freePage(Btree *pBt, void *pPage, Pgno pgno){ - PageOne *pPage1 = pBt->page1; - OverflowPage *pOvfl = (OverflowPage*)pPage; +static int allocatePage( + BtShared *pBt, + MemPage **ppPage, + Pgno *pPgno, + Pgno nearby, + u8 exact +){ + MemPage *pPage1; int rc; - int needUnref = 0; - MemPage *pMemPage; + int n; /* Number of pages on the freelist */ + int k; /* Number of leaves on the trunk of the freelist */ - 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; + pPage1 = pBt->pPage1; + n = get4byte(&pPage1->aData[36]); + if( n>0 ){ + /* There are pages on the freelist. Reuse one of those pages. */ + MemPage *pTrunk = 0; + Pgno iTrunk; + MemPage *pPrevTrunk = 0; + u8 searchList = 0; /* If the free-list must be searched for 'nearby' */ + + /* If the 'exact' parameter was true and a query of the pointer-map + ** shows that the page 'nearby' is somewhere on the free-list, then + ** the entire-list will be searched for that page. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( exact ){ + u8 eType; + assert( nearby>0 ); + assert( pBt->autoVacuum ); + rc = ptrmapGet(pBt, nearby, &eType, 0); + if( rc ) return rc; + if( eType==PTRMAP_FREEPAGE ){ + searchList = 1; + } + *pPgno = nearby; + } +#endif + + /* Decrement the free-list count by 1. Set iTrunk to the index of the + ** first free-list trunk page. iPrevTrunk is initially 1. + */ + rc = sqlite3pager_write(pPage1->aData); + if( rc ) return rc; + put4byte(&pPage1->aData[36], n-1); + + /* The code within this loop is run only once if the 'searchList' variable + ** is not true. Otherwise, it runs once for each trunk-page on the + ** free-list until the page 'nearby' is located. + */ + do { + pPrevTrunk = pTrunk; + if( pPrevTrunk ){ + iTrunk = get4byte(&pPrevTrunk->aData[0]); + }else{ + iTrunk = get4byte(&pPage1->aData[32]); + } + rc = getPage(pBt, iTrunk, &pTrunk); + if( rc ){ + releasePage(pPrevTrunk); + return rc; + } + + /* TODO: This should move to after the loop? */ + rc = sqlite3pager_write(pTrunk->aData); + if( rc ){ + releasePage(pTrunk); + releasePage(pPrevTrunk); + return rc; + } + + k = get4byte(&pTrunk->aData[4]); + if( k==0 && !searchList ){ + /* The trunk has no leaves and the list is not being searched. + ** So extract the trunk page itself and use it as the newly + ** allocated page */ + assert( pPrevTrunk==0 ); + *pPgno = iTrunk; + memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); + *ppPage = pTrunk; + pTrunk = 0; + TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1)); + }else if( k>pBt->usableSize/4 - 8 ){ + /* Value of k is out of range. Database corruption */ + return SQLITE_CORRUPT_BKPT; +#ifndef SQLITE_OMIT_AUTOVACUUM + }else if( searchList && nearby==iTrunk ){ + /* The list is being searched and this trunk page is the page + ** to allocate, regardless of whether it has leaves. + */ + assert( *pPgno==iTrunk ); + *ppPage = pTrunk; + searchList = 0; + if( k==0 ){ + if( !pPrevTrunk ){ + memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); + }else{ + memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4); + } + }else{ + /* The trunk page is required by the caller but it contains + ** pointers to free-list leaves. The first leaf becomes a trunk + ** page in this case. + */ + MemPage *pNewTrunk; + Pgno iNewTrunk = get4byte(&pTrunk->aData[8]); + rc = getPage(pBt, iNewTrunk, &pNewTrunk); + if( rc!=SQLITE_OK ){ + releasePage(pTrunk); + releasePage(pPrevTrunk); + return rc; + } + rc = sqlite3pager_write(pNewTrunk->aData); + if( rc!=SQLITE_OK ){ + releasePage(pNewTrunk); + releasePage(pTrunk); + releasePage(pPrevTrunk); + return rc; + } + memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4); + put4byte(&pNewTrunk->aData[4], k-1); + memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4); + if( !pPrevTrunk ){ + put4byte(&pPage1->aData[32], iNewTrunk); + }else{ + put4byte(&pPrevTrunk->aData[0], iNewTrunk); + } + releasePage(pNewTrunk); + } + pTrunk = 0; + TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1)); +#endif + }else{ + /* Extract a leaf from the trunk */ + int closest; + Pgno iPage; + unsigned char *aData = pTrunk->aData; + if( nearby>0 ){ + int i, dist; + closest = 0; + dist = get4byte(&aData[8]) - nearby; + if( dist<0 ) dist = -dist; + for(i=1; isqlite3pager_pagecount(pBt->pPager) ){ + /* Free page off the end of the file */ + return SQLITE_CORRUPT_BKPT; + } + TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d" + ": %d more free pages\n", + *pPgno, closest+1, k, pTrunk->pgno, n-1)); + if( closestaData); + rc = sqlite3pager_write((*ppPage)->aData); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + } + } + searchList = 0; } } - sqlitepager_unref(pFreeIdx); + releasePage(pPrevTrunk); + }while( searchList ); + releasePage(pTrunk); + }else{ + /* There are no pages on the freelist, so create a new page at the + ** end of the file */ + *pPgno = sqlite3pager_pagecount(pBt->pPager) + 1; + +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, *pPgno) ){ + /* If *pPgno refers to a pointer-map page, allocate two new pages + ** at the end of the file instead of one. The first allocated page + ** becomes a new pointer-map page, the second is used by the caller. + */ + TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", *pPgno)); + assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); + (*pPgno)++; } - } - if( pOvfl==0 ){ - assert( pgno>0 ); - rc = sqlitepager_get(pBt->pPager, pgno, (void**)&pOvfl); +#endif + + assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); + rc = getPage(pBt, *pPgno, ppPage); if( rc ) return rc; - needUnref = 1; + rc = sqlite3pager_write((*ppPage)->aData); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + } + TRACE(("ALLOCATE: %d from end of file\n", *pPgno)); } - 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); + + assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); return rc; } /* -** Erase all the data out of a cell. This involves returning overflow -** pages back the freelist. +** Add a page of the database file to the freelist. +** +** sqlite3pager_unref() is NOT called for pPage. */ -static int clearCell(Btree *pBt, Cell *pCell){ - Pager *pPager = pBt->pPager; - OverflowPage *pOvfl; - Pgno ovfl, nextOvfl; +static int freePage(MemPage *pPage){ + BtShared *pBt = pPage->pBt; + MemPage *pPage1 = pBt->pPage1; + int rc, n, k; + + /* Prepare the page for freeing */ + assert( pPage->pgno>1 ); + pPage->isInit = 0; + releasePage(pPage->pParent); + pPage->pParent = 0; + + /* Increment the free page count on pPage1 */ + rc = sqlite3pager_write(pPage1->aData); + if( rc ) return rc; + n = get4byte(&pPage1->aData[36]); + put4byte(&pPage1->aData[36], n+1); + +#ifdef SQLITE_SECURE_DELETE + /* If the SQLITE_SECURE_DELETE compile-time option is enabled, then + ** always fully overwrite deleted information with zeros. + */ + rc = sqlite3pager_write(pPage->aData); + if( rc ) return rc; + memset(pPage->aData, 0, pPage->pBt->pageSize); +#endif + +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the database supports auto-vacuum, write an entry in the pointer-map + ** to indicate that the page is free. + */ + if( pBt->autoVacuum ){ + rc = ptrmapPut(pBt, pPage->pgno, PTRMAP_FREEPAGE, 0); + if( rc ) return rc; + } +#endif + + if( n==0 ){ + /* This is the first free page */ + rc = sqlite3pager_write(pPage->aData); + if( rc ) return rc; + memset(pPage->aData, 0, 8); + put4byte(&pPage1->aData[32], pPage->pgno); + TRACE(("FREE-PAGE: %d first\n", pPage->pgno)); + }else{ + /* Other free pages already exist. Retrive the first trunk page + ** of the freelist and find out how many leaves it has. */ + MemPage *pTrunk; + rc = getPage(pBt, get4byte(&pPage1->aData[32]), &pTrunk); + if( rc ) return rc; + k = get4byte(&pTrunk->aData[4]); + if( k>=pBt->usableSize/4 - 8 ){ + /* The trunk is full. Turn the page being freed into a new + ** trunk page with no leaves. */ + rc = sqlite3pager_write(pPage->aData); + if( rc ) return rc; + put4byte(pPage->aData, pTrunk->pgno); + put4byte(&pPage->aData[4], 0); + put4byte(&pPage1->aData[32], pPage->pgno); + TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", + pPage->pgno, pTrunk->pgno)); + }else{ + /* Add the newly freed page as a leaf on the current trunk */ + rc = sqlite3pager_write(pTrunk->aData); + if( rc ) return rc; + put4byte(&pTrunk->aData[4], k+1); + put4byte(&pTrunk->aData[8+k*4], pPage->pgno); +#ifndef SQLITE_SECURE_DELETE + sqlite3pager_dont_write(pBt->pPager, pPage->pgno); +#endif + TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno)); + } + releasePage(pTrunk); + } + return rc; +} + +/* +** Free any overflow pages associated with the given Cell. +*/ +static int clearCell(MemPage *pPage, unsigned char *pCell){ + BtShared *pBt = pPage->pBt; + CellInfo info; + Pgno ovflPgno; int rc; - if( NKEY(pBt, pCell->h) + NDATA(pBt, pCell->h) <= MX_LOCAL_PAYLOAD ){ - return SQLITE_OK; + parseCellPtr(pPage, pCell, &info); + if( info.iOverflow==0 ){ + return SQLITE_OK; /* No overflow pages. Return without doing anything */ } - ovfl = SWAB32(pBt, pCell->ovfl); - pCell->ovfl = 0; - while( ovfl ){ - rc = sqlitepager_get(pPager, ovfl, (void**)&pOvfl); + ovflPgno = get4byte(&pCell[info.iOverflow]); + while( ovflPgno!=0 ){ + MemPage *pOvfl; + if( ovflPgno>sqlite3pager_pagecount(pBt->pPager) ){ + return SQLITE_CORRUPT_BKPT; + } + rc = getPage(pBt, ovflPgno, &pOvfl); if( rc ) return rc; - nextOvfl = SWAB32(pBt, pOvfl->iNext); - rc = freePage(pBt, pOvfl, ovfl); + ovflPgno = get4byte(pOvfl->aData); + rc = freePage(pOvfl); + sqlite3pager_unref(pOvfl->aData); 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. +** Create the byte sequence used to represent a cell on page pPage +** and write that byte sequence into pCell[]. Overflow pages are +** allocated and filled in as necessary. The calling procedure +** is responsible for making sure sufficient space has been allocated +** for pCell[]. +** +** Note that pCell does not necessary need to point to the pPage->aData +** area. pCell might point to some temporary storage. The cell will +** be constructed in this temporary area then copied into pPage->aData +** later. */ static int fillInCell( - 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 */ + MemPage *pPage, /* The page that contains the cell */ + unsigned char *pCell, /* Complete text of the cell */ + const void *pKey, i64 nKey, /* The key */ + const void *pData,int nData, /* The data */ + int *pnSize /* Write cell size here */ ){ - OverflowPage *pOvfl, *pPrior; - Pgno *pNext; - int spaceLeft; - int n, rc; int nPayload; - const char *pPayload; - char *pSpace; - Pgno nearby = 0; + const u8 *pSrc; + int nSrc, n, rc; + int spaceLeft; + MemPage *pOvfl = 0; + MemPage *pToRelease = 0; + unsigned char *pPrior; + unsigned char *pPayload; + BtShared *pBt = pPage->pBt; + Pgno pgnoOvfl = 0; + int nHeader; + CellInfo info; - 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; + /* Fill in the header. */ + nHeader = 0; + if( !pPage->leaf ){ + nHeader += 4; + } + if( pPage->hasData ){ + nHeader += putVarint(&pCell[nHeader], nData); + }else{ + nData = 0; + } + nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey); + parseCellPtr(pPage, pCell, &info); + assert( info.nHeader==nHeader ); + assert( info.nKey==nKey ); + assert( info.nData==nData ); + + /* Fill in the payload */ + nPayload = nData; + if( pPage->intKey ){ + pSrc = pData; + nSrc = nData; + nData = 0; + }else{ + nPayload += nKey; + pSrc = pKey; + nSrc = nKey; + } + *pnSize = info.nSize; + spaceLeft = info.nLocal; + pPayload = &pCell[nHeader]; + pPrior = &pCell[info.iOverflow]; - 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; +#ifndef SQLITE_OMIT_AUTOVACUUM + Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */ +#endif + rc = allocatePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the database supports auto-vacuum, and the second or subsequent + ** overflow page is being allocated, add an entry to the pointer-map + ** for that page now. The entry for the first overflow page will be + ** added later, by the insertCell() routine. + */ + if( pBt->autoVacuum && pgnoPtrmap!=0 && rc==SQLITE_OK ){ + rc = ptrmapPut(pBt, pgnoOvfl, PTRMAP_OVERFLOW2, pgnoPtrmap); } - if( pPrior ) sqlitepager_unref(pPrior); +#endif if( rc ){ - clearCell(pBt, pCell); + releasePage(pToRelease); + /* clearCell(pPage, pCell); */ return rc; } - if( pBt->needSwab ) *pNext = swab32(*pNext); - pPrior = pOvfl; - spaceLeft = OVERFLOW_SIZE; - pSpace = pOvfl->aPayload; - pNext = &pOvfl->iNext; + put4byte(pPrior, pgnoOvfl); + releasePage(pToRelease); + pToRelease = pOvfl; + pPrior = pOvfl->aData; + put4byte(pPrior, 0); + pPayload = &pOvfl->aData[4]; + spaceLeft = pBt->usableSize - 4; } n = nPayload; if( n>spaceLeft ) n = spaceLeft; - memcpy(pSpace, pPayload, n); + if( n>nSrc ) n = nSrc; + assert( pSrc ); + memcpy(pPayload, pSrc, n); nPayload -= n; - if( nPayload==0 && pData ){ - pPayload = pData; - nPayload = nData; - pData = 0; - }else{ - pPayload += n; - } + pPayload += n; + pSrc += n; + nSrc -= n; spaceLeft -= n; - pSpace += n; - } - *pNext = 0; - if( pPrior ){ - sqlitepager_unref(pPrior); + if( nSrc==0 ){ + nSrc = nData; + pSrc = pData; + } } + releasePage(pToRelease); return SQLITE_OK; } @@ -1975,39 +4097,68 @@ static int fillInCell( ** 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){ +static int reparentPage(BtShared *pBt, Pgno pgno, MemPage *pNewParent, int idx){ MemPage *pThis; + unsigned char *aData; - 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); + assert( pNewParent!=0 ); + if( pgno==0 ) return SQLITE_OK; + assert( pBt->pPager!=0 ); + aData = sqlite3pager_lookup(pBt->pPager, pgno); + if( aData ){ + pThis = (MemPage*)&aData[pBt->pageSize]; + assert( pThis->aData==aData ); + if( pThis->isInit ){ + if( pThis->pParent!=pNewParent ){ + if( pThis->pParent ) sqlite3pager_unref(pThis->pParent->aData); + pThis->pParent = pNewParent; + sqlite3pager_ref(pNewParent->aData); + } + pThis->idxParent = idx; } - pThis->idxParent = idx; - sqlitepager_unref(pThis); + sqlite3pager_unref(aData); } + +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + return ptrmapPut(pBt, pgno, PTRMAP_BTREE, pNewParent->pgno); + } +#endif + return SQLITE_OK; } + + /* -** Reparent all children of the given page to be the given page. +** Change the pParent pointer of all children of pPage to point back +** to pPage. +** ** 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){ +static int reparentChildPages(MemPage *pPage){ int i; - Pager *pPager = pBt->pPager; + BtShared *pBt = pPage->pBt; + int rc = SQLITE_OK; + + if( pPage->leaf ) return SQLITE_OK; + for(i=0; inCell; i++){ - reparentPage(pPager, SWAB32(pBt, pPage->apCell[i]->h.leftChild), pPage, i); + u8 *pCell = findCell(pPage, i); + if( !pPage->leaf ){ + rc = reparentPage(pBt, get4byte(pCell), pPage, i); + if( rc!=SQLITE_OK ) return rc; + } } - reparentPage(pPager, SWAB32(pBt, pPage->u.hdr.rightChild), pPage, i); - pPage->idxShift = 0; + if( !pPage->leaf ){ + rc = reparentPage(pBt, get4byte(&pPage->aData[pPage->hdrOffset+8]), + pPage, i); + pPage->idxShift = 0; + } + return rc; } /* @@ -2017,22 +4168,28 @@ static void reparentChildPages(Btree *pBt, MemPage *pPage){ ** 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; +static void dropCell(MemPage *pPage, int idx, int sz){ + int i; /* Loop counter */ + int pc; /* Offset to cell content of cell being deleted */ + u8 *data; /* pPage->aData */ + u8 *ptr; /* Used to move bytes around within data[] */ + 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]; + assert( sz==cellSize(pPage, idx) ); + assert( sqlite3pager_iswriteable(pPage->aData) ); + data = pPage->aData; + ptr = &data[pPage->cellOffset + 2*idx]; + pc = get2byte(ptr); + assert( pc>10 && pc+sz<=pPage->pBt->usableSize ); + freeSpace(pPage, pc, sz); + for(i=idx+1; inCell; i++, ptr+=2){ + ptr[0] = ptr[2]; + ptr[1] = ptr[3]; } pPage->nCell--; + put2byte(&data[pPage->hdrOffset+3], pPage->nCell); + pPage->nFree += 2; pPage->idxShift = 1; } @@ -2041,79 +4198,137 @@ static void dropCell(Btree *pBt, MemPage *pPage, int idx, int sz){ ** 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. +** will not fit, then make a copy of the cell content into pTemp if +** pTemp is not null. Regardless of pTemp, allocate a new entry +** in pPage->aOvfl[] and make it point to the cell content (either +** in pTemp or the original pCell) and also record its index. +** Allocating a new entry in pPage->aCell[] implies that +** pPage->nOverflow is incremented. ** -** 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. +** If nSkip is non-zero, then do not copy the first nSkip bytes of the +** cell. The caller will overwrite them after this function returns. If +** nSkip is non-zero, then pCell may not point to an invalid memory location +** (but pCell+nSkip is always valid). */ -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; -} +static int insertCell( + MemPage *pPage, /* Page into which we are copying */ + int i, /* New cell becomes the i-th cell of the page */ + u8 *pCell, /* Content of the new cell */ + int sz, /* Bytes of content in pCell */ + u8 *pTemp, /* Temp storage space for pCell, if needed */ + u8 nSkip /* Do not write the first nSkip bytes of the cell */ +){ + int idx; /* Where to write new cell content in data[] */ + int j; /* Loop counter */ + int top; /* First byte of content for any cell in data[] */ + int end; /* First byte past the last cell pointer in data[] */ + int ins; /* Index in data[] where new cell pointer is inserted */ + int hdr; /* Offset into data[] of the page header */ + int cellOffset; /* Address of first cell pointer in data[] */ + u8 *data; /* The content of the whole page */ + u8 *ptr; /* Used for moving information around in data[] */ -/* -** 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]; + assert( i>=0 && i<=pPage->nCell+pPage->nOverflow ); + assert( sz==cellSizePtr(pPage, pCell) ); + assert( sqlite3pager_iswriteable(pPage->aData) ); + if( pPage->nOverflow || sz+2>pPage->nFree ){ + if( pTemp ){ + memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip); + pCell = pTemp; } + j = pPage->nOverflow++; + assert( jaOvfl)/sizeof(pPage->aOvfl[0]) ); + pPage->aOvfl[j].pCell = pCell; + pPage->aOvfl[j].idx = i; + pPage->nFree = 0; + }else{ + data = pPage->aData; + hdr = pPage->hdrOffset; + top = get2byte(&data[hdr+5]); + cellOffset = pPage->cellOffset; + end = cellOffset + 2*pPage->nCell + 2; + ins = cellOffset + 2*i; + if( end > top - sz ){ + int rc = defragmentPage(pPage); + if( rc!=SQLITE_OK ) return rc; + top = get2byte(&data[hdr+5]); + assert( end + sz <= top ); + } + idx = allocateSpace(pPage, sz); + assert( idx>0 ); + assert( end <= get2byte(&data[hdr+5]) ); + pPage->nCell++; + pPage->nFree -= 2; + memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip); + for(j=end-2, ptr=&data[j]; j>ins; j-=2, ptr-=2){ + ptr[0] = ptr[-2]; + ptr[1] = ptr[-1]; + } + put2byte(&data[ins], idx); + put2byte(&data[hdr+3], pPage->nCell); + pPage->idxShift = 1; + pageIntegrity(pPage); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pPage->pBt->autoVacuum ){ + /* The cell may contain a pointer to an overflow page. If so, write + ** the entry for the overflow page into the pointer map. + */ + CellInfo info; + parseCellPtr(pPage, pCell, &info); + if( (info.nData+(pPage->intKey?0:info.nKey))>info.nLocal ){ + Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]); + int rc = ptrmapPut(pPage->pBt, pgnoOvfl, PTRMAP_OVERFLOW1, pPage->pgno); + if( rc!=SQLITE_OK ) return rc; + } + } +#endif } + + return SQLITE_OK; +} + +/* +** Add a list of cells to a page. The page should be initially empty. +** The cells are guaranteed to fit on the page. +*/ +static void assemblePage( + MemPage *pPage, /* The page to be assemblied */ + int nCell, /* The number of cells to add to this page */ + u8 **apCell, /* Pointers to cell bodies */ + int *aSize /* Sizes of the cells */ +){ + int i; /* Loop counter */ + int totalSize; /* Total size of all cells */ + int hdr; /* Index of page header */ + int cellptr; /* Address of next cell pointer */ + int cellbody; /* Address of next cell body */ + u8 *data; /* Data for the page */ + + assert( pPage->nOverflow==0 ); + totalSize = 0; + for(i=0; inFree ); + assert( pPage->nCell==0 ); + cellptr = pPage->cellOffset; + data = pPage->aData; + hdr = pPage->hdrOffset; + put2byte(&data[hdr+3], nCell); + if( nCell ){ + cellbody = allocateSpace(pPage, totalSize); + assert( cellbody>0 ); + assert( pPage->nFree >= 2*nCell ); + pPage->nFree -= 2*nCell; + for(i=0; ipBt->usableSize ); + } + pPage->nCell = nCell; } /* @@ -2131,37 +4346,132 @@ static void copyPage(MemPage *pTo, MemPage *pFrom){ #define NN 1 /* Number of neighbors on either side of pPage */ #define NB (NN*2+1) /* Total pages involved in the balance */ +/* Forward reference */ +static int balance(MemPage*, int); + +#ifndef SQLITE_OMIT_QUICKBALANCE /* -** This routine redistributes Cells on pPage and up to two siblings +** This version of balance() handles the common special case where +** a new entry is being inserted on the extreme right-end of the +** tree, in other words, when the new entry will become the largest +** entry in the tree. +** +** Instead of trying balance the 3 right-most leaf pages, just add +** a new page to the right-hand side and put the one new entry in +** that page. This leaves the right side of the tree somewhat +** unbalanced. But odds are that we will be inserting new entries +** at the end soon afterwards so the nearly empty page will quickly +** fill up. On average. +** +** pPage is the leaf page which is the right-most page in the tree. +** pParent is its parent. pPage must have a single overflow entry +** which is also the right-most entry on the page. +*/ +static int balance_quick(MemPage *pPage, MemPage *pParent){ + int rc; + MemPage *pNew; + Pgno pgnoNew; + u8 *pCell; + int szCell; + CellInfo info; + BtShared *pBt = pPage->pBt; + int parentIdx = pParent->nCell; /* pParent new divider cell index */ + int parentSize; /* Size of new divider cell */ + u8 parentCell[64]; /* Space for the new divider cell */ + + /* Allocate a new page. Insert the overflow cell from pPage + ** into it. Then remove the overflow cell from pPage. + */ + rc = allocatePage(pBt, &pNew, &pgnoNew, 0, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + pCell = pPage->aOvfl[0].pCell; + szCell = cellSizePtr(pPage, pCell); + zeroPage(pNew, pPage->aData[0]); + assemblePage(pNew, 1, &pCell, &szCell); + pPage->nOverflow = 0; + + /* Set the parent of the newly allocated page to pParent. */ + pNew->pParent = pParent; + sqlite3pager_ref(pParent->aData); + + /* pPage is currently the right-child of pParent. Change this + ** so that the right-child is the new page allocated above and + ** pPage is the next-to-right child. + */ + assert( pPage->nCell>0 ); + parseCellPtr(pPage, findCell(pPage, pPage->nCell-1), &info); + rc = fillInCell(pParent, parentCell, 0, info.nKey, 0, 0, &parentSize); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( parentSize<64 ); + rc = insertCell(pParent, parentIdx, parentCell, parentSize, 0, 4); + if( rc!=SQLITE_OK ){ + return rc; + } + put4byte(findOverflowCell(pParent,parentIdx), pPage->pgno); + put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew); + +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If this is an auto-vacuum database, update the pointer map + ** with entries for the new page, and any pointer from the + ** cell on the page to an overflow page. + */ + if( pBt->autoVacuum ){ + rc = ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = ptrmapPutOvfl(pNew, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + } +#endif + + /* Release the reference to the new page and balance the parent page, + ** in case the divider cell inserted caused it to become overfull. + */ + releasePage(pNew); + return balance(pParent, 0); +} +#endif /* SQLITE_OMIT_QUICKBALANCE */ + +/* +** The ISAUTOVACUUM macro is used within balance_nonroot() to determine +** if the database supports auto-vacuum or not. Because it is used +** within an expression that is an argument to another macro +** (sqliteMallocRaw), it is not possible to use conditional compilation. +** So, this macro is defined instead. +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +#define ISAUTOVACUUM (pBt->autoVacuum) +#else +#define ISAUTOVACUUM 0 +#endif + +/* +** This routine redistributes Cells on pPage and up to NN*2 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 +** Usually NN siblings on either side of pPage is used in the balancing, +** though more siblings might come from one side if pPage is the first +** or last child of its parent. If pPage has fewer than 2*NN 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 number of siblings of pPage might be increased or decreased by one or +** two in an effort to keep pages nearly full but not over full. The root page +** is special and is allowed to be nearly empty. 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. +** overfull or completely empty. ** ** 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 +** might not actually be stored in pPage->aData[]. 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[]. +** make sure all Cells for pPage once again fit in pPage->aData[]. ** ** In the course of balancing the siblings of pPage, the parent of pPage ** might become overfull or underfull. If that happens, then this routine @@ -2171,135 +4481,94 @@ static void copyPage(MemPage *pTo, MemPage *pFrom){ ** in a corrupted state. So if this routine fails, the database should ** be rolled back. */ -static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){ +static int balance_nonroot(MemPage *pPage){ MemPage *pParent; /* The parent of pPage */ - int nCell; /* Number of cells in apCell[] */ + BtShared *pBt; /* The whole database */ + int nCell = 0; /* Number of cells in apCell[] */ + int nMaxCells = 0; /* Allocated size of apCell, szCell, aFrom. */ 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 idx; /* Index of pPage in pParent->aCell[] */ + int nxDiv; /* Next divider slot in pParent->aCell[] */ 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 leafCorrection; /* 4 if pPage is a leaf. 0 if not */ + int leafData; /* True if pPage is a leaf of a LEAFDATA tree */ + int usableSpace; /* Bytes in pPage beyond the header */ + int pageFlags; /* Value of pPage->aData[0] */ int subtotal; /* Subtotal of bytes in cells on one page */ - MemPage *extraUnref = 0; /* A page that needs to be unref-ed */ + int iSpace = 0; /* First unused byte of aSpace[] */ 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 */ + MemPage *apCopy[NB]; /* Private copies of apOld[] pages */ + MemPage *apNew[NB+2]; /* pPage and up to NB siblings after balancing */ + Pgno pgnoNew[NB+2]; /* Page numbers for each page in apNew[] */ + u8 *apDiv[NB]; /* Divider cells in pParent */ + int cntNew[NB+2]; /* Index in aCell[] of cell after i-th page */ + int szNew[NB+2]; /* Combined size of cells place on i-th page */ + u8 **apCell = 0; /* All cells begin balanced */ + int *szCell; /* Local size of all cells in apCell[] */ + u8 *aCopy[NB]; /* Space for holding data of apCopy[] */ + u8 *aSpace; /* Space to hold copies of dividers cells */ +#ifndef SQLITE_OMIT_AUTOVACUUM + u8 *aFrom = 0; +#endif /* - ** Return without doing any work if pPage is neither overfull nor - ** underfull. + ** Find the parent page. */ - assert( sqlitepager_iswriteable(pPage) ); - if( !pPage->isOverfull && pPage->nFreenCell>=2){ - relinkCellList(pBt, pPage); - return SQLITE_OK; + assert( pPage->isInit ); + assert( sqlite3pager_iswriteable(pPage->aData) ); + pBt = pPage->pBt; + pParent = pPage->pParent; + assert( pParent ); + if( SQLITE_OK!=(rc = sqlite3pager_write(pParent->aData)) ){ + return rc; } + TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno)); + +#ifndef SQLITE_OMIT_QUICKBALANCE + /* + ** A special case: If a new entry has just been inserted into a + ** table (that is, a btree with integer keys and all data at the leaves) + ** and the new entry is the right-most entry in the tree (it has the + ** largest key) then use the special balance_quick() routine for + ** balancing. balance_quick() is much faster and results in a tighter + ** packing of data in the common case. + */ + if( pPage->leaf && + pPage->intKey && + pPage->leafData && + pPage->nOverflow==1 && + pPage->aOvfl[0].idx==pPage->nCell && + pPage->pParent->pgno!=1 && + get4byte(&pParent->aData[pParent->hdrOffset+8])==pPage->pgno + ){ + /* + ** TODO: Check the siblings to the left of pPage. It may be that + ** they are not full and no new page is required. + */ + return balance_quick(pPage, pParent); + } +#endif /* - ** 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 + ** Find the cell in the parent page whose left child 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); + Pgno pgno; + pgno = pPage->pgno; + assert( pgno==sqlite3pager_pagenumber(pPage->aData) ); for(idx=0; idxnCell; idx++){ - if( pParent->apCell[idx]->h.leftChild==swabPgno ){ + if( get4byte(findCell(pParent, idx))==pgno ){ break; } } - assert( idxnCell || pParent->u.hdr.rightChild==swabPgno ); + assert( idxnCell + || get4byte(&pParent->aData[pParent->hdrOffset+8])==pgno ); }else{ idx = pPage->idxParent; } @@ -2309,10 +4578,10 @@ static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){ ** directly to balance_cleanup at any moment. */ nOld = nNew = 0; - sqlitepager_ref(pParent); + sqlite3pager_ref(pParent->aData); /* - ** Find sibling pages to pPage and the Cells in pParent that divide + ** 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 @@ -2328,47 +4597,57 @@ static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){ nDiv = 0; for(i=0, k=nxDiv; inCell ){ - idxDiv[i] = k; - apDiv[i] = pParent->apCell[k]; + apDiv[i] = findCell(pParent, k); nDiv++; - pgnoOld[i] = SWAB32(pBt, apDiv[i]->h.leftChild); + assert( !pParent->leaf ); + pgnoOld[i] = get4byte(apDiv[i]); }else if( k==pParent->nCell ){ - pgnoOld[i] = SWAB32(pBt, pParent->u.hdr.rightChild); + pgnoOld[i] = get4byte(&pParent->aData[pParent->hdrOffset+8]); }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); + rc = getAndInitPage(pBt, pgnoOld[i], &apOld[i], pParent); if( rc ) goto balance_cleanup; apOld[i]->idxParent = k; + apCopy[i] = 0; + assert( i==nOld ); nOld++; + nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow; } + /* Make nMaxCells a multiple of 2 in order to preserve 8-byte + ** alignment */ + nMaxCells = (nMaxCells + 1)&~1; + /* - ** 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. + ** Allocate space for memory structures */ - 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; + apCell = sqliteMallocRaw( + nMaxCells*sizeof(u8*) /* apCell */ + + nMaxCells*sizeof(int) /* szCell */ + + ROUND8(sizeof(MemPage))*NB /* aCopy */ + + pBt->pageSize*(5+NB) /* aSpace */ + + (ISAUTOVACUUM ? nMaxCells : 0) /* aFrom */ + ); + if( apCell==0 ){ + rc = SQLITE_NOMEM; + goto balance_cleanup; } - + szCell = (int*)&apCell[nMaxCells]; + aCopy[0] = (u8*)&szCell[nMaxCells]; + assert( ((aCopy[0] - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */ + for(i=1; ipageSize+ROUND8(sizeof(MemPage))]; + assert( ((aCopy[i] - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */ + } + aSpace = &aCopy[NB-1][pBt->pageSize+ROUND8(sizeof(MemPage))]; + assert( ((aSpace - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + aFrom = &aSpace[5*pBt->pageSize]; + } +#endif + /* ** Make copies of the content of pPage and its siblings into aOld[]. ** The rest of this function will use data from the copies rather @@ -2376,30 +4655,90 @@ static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){ ** process of being overwritten. */ for(i=0; ipageSize]; + p->aData = &((u8*)p)[-pBt->pageSize]; + memcpy(p->aData, apOld[i]->aData, pBt->pageSize + sizeof(MemPage)); + /* The memcpy() above changes the value of p->aData so we have to + ** set it again. */ + p->aData = &((u8*)p)[-pBt->pageSize]; } /* ** Load pointers to all cells on sibling pages and the divider cells ** into the local apCell[] array. Make copies of the divider cells - ** into aTemp[] and remove the the divider Cells from pParent. + ** into space obtained form aSpace[] and remove the the divider Cells + ** from pParent. + ** + ** If the siblings are on leaf pages, then the child pointers of the + ** divider cells are stripped from the cells before they are copied + ** into aSpace[]. In this way, all cells in apCell[] are without + ** child pointers. If siblings are not leaves, then all cell in + ** apCell[] include child pointers. Either way, all cells in apCell[] + ** are alike. + ** + ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf. + ** leafData: 1 if pPage holds key+data and pParent holds only keys. */ nCell = 0; + leafCorrection = pPage->leaf*4; + leafData = pPage->leafData && pPage->leaf; for(i=0; inCell; j++){ - apCell[nCell] = pOld->apCell[j]; - szCell[nCell] = cellSize(pBt, apCell[nCell]); + MemPage *pOld = apCopy[i]; + int limit = pOld->nCell+pOld->nOverflow; + for(j=0; jautoVacuum ){ + int a; + aFrom[nCell] = i; + for(a=0; anOverflow; a++){ + if( pOld->aOvfl[a].pCell==apCell[nCell] ){ + aFrom[nCell] = 0xFF; + break; + } + } + } +#endif nCell++; } if( ih.leftChild)==pgnoOld[i] ); - apCell[nCell]->h.leftChild = pOld->u.hdr.rightChild; - nCell++; + int sz = cellSizePtr(pParent, apDiv[i]); + if( leafData ){ + /* With the LEAFDATA flag, pParent cells hold only INTKEYs that + ** are duplicates of keys on the child pages. We need to remove + ** the divider cells from pParent, but the dividers cells are not + ** added to apCell[] because they are duplicates of child cells. + */ + dropCell(pParent, nxDiv, sz); + }else{ + u8 *pTemp; + assert( nCellpageSize*5 ); + memcpy(pTemp, apDiv[i], sz); + apCell[nCell] = pTemp+leafCorrection; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + aFrom[nCell] = 0xFF; + } +#endif + dropCell(pParent, nxDiv, sz); + szCell[nCell] -= leafCorrection; + assert( get4byte(pTemp)==pgnoOld[i] ); + if( !pOld->leaf ){ + assert( leafCorrection==0 ); + /* The right pointer of the child page pOld becomes the left + ** pointer of the divider cell */ + memcpy(apCell[nCell], &pOld->aData[pOld->hdrOffset+8], 4); + }else{ + assert( leafCorrection==4 ); + } + nCell++; + } } } @@ -2407,17 +4746,26 @@ static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){ ** 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. + ** in apCell[] of the cell that divides page i from page i+1. ** cntNew[k] should equal nCell. ** - ** This little patch of code is critical for keeping the tree - ** balanced. + ** Values computed by this block: + ** + ** k: The total number of sibling pages + ** szNew[i]: Spaced used on the i-th sibling page. + ** cntNew[i]: Index in apCell[] and szCell[] for the first cell to + ** the right of the i-th sibling page. + ** usableSpace: Number of bytes of space available on each sibling. + ** */ + usableSpace = pBt->usableSize - 12 + leafCorrection; for(subtotal=k=i=0; i USABLE_SPACE ){ + assert( i usableSpace ){ szNew[k] = subtotal - szCell[i]; cntNew[k] = i; + if( leafData ){ i--; } subtotal = 0; k++; } @@ -2425,40 +4773,73 @@ static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){ szNew[k] = subtotal; cntNew[k] = nCell; k++; + + /* + ** The packing computed by the previous block is biased toward the siblings + ** on the left side. The left siblings are always nearly full, while the + ** right-most sibling might be nearly empty. This block of code attempts + ** to adjust the packing of siblings to get a better balance. + ** + ** This adjustment is more than an optimization. The packing above might + ** be so out of balance as to be illegal. For example, the right-most + ** sibling might be completely empty. This adjustment is not optional. + */ for(i=k-1; i>0; i--){ - while( szNew[i]0 ); - szNew[i] += szCell[cntNew[i-1]]; - szNew[i-1] -= szCell[cntNew[i-1]-1]; + r = cntNew[i-1] - 1; + d = r + 1 - leafData; } + szNew[i] = szRight; + szNew[i-1] = szLeft; } - assert( cntNew[0]>0 ); + + /* Either we found one or more cells (cntnew[0])>0) or we are the + ** a virtual root page. A virtual root page is when the real root + ** page is page 1 and we are the only child of that page. + */ + assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) ); /* ** Allocate k new pages. Reuse old pages where possible. */ + assert( pPage->pgno>1 ); + pageFlags = pPage->aData[0]; for(i=0; iaData); if( rc ) goto balance_cleanup; + }else{ + assert( i>0 ); + rc = allocatePage(pBt, &pNew, &pgnoNew[i], pgnoNew[i-1], 0); + if( rc ) goto balance_cleanup; + apNew[i] = pNew; } nNew++; - zeroPage(pBt, apNew[i]); - apNew[i]->isInit = 1; + zeroPage(pNew, pageFlags); } /* Free any old pages that were not reused as new pages. */ while( i=2 ? pgnoOld[1] : 0, + nOld>=3 ? pgnoOld[2] : 0, + pgnoNew[0], szNew[0], + nNew>=2 ? pgnoNew[1] : 0, nNew>=2 ? szNew[1] : 0, + nNew>=3 ? pgnoNew[2] : 0, nNew>=3 ? szNew[2] : 0, + nNew>=4 ? pgnoNew[3] : 0, nNew>=4 ? szNew[3] : 0, + nNew>=5 ? pgnoNew[4] : 0, nNew>=5 ? szNew[4] : 0)); /* ** Evenly distribute the data in apCell[] across the new pages. @@ -2504,101 +4894,348 @@ static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){ */ 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( jpgno==pgnoNew[i] ); + assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]); + assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) ); + assert( pNew->nOverflow==0 ); + +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If this is an auto-vacuum database, update the pointer map entries + ** that point to the siblings that were rearranged. These can be: left + ** children of cells, the right-child of the page, or overflow pages + ** pointed to by cells. + */ + if( pBt->autoVacuum ){ + for(k=j; kpgno!=pNew->pgno ){ + rc = ptrmapPutOvfl(pNew, k-j); + if( rc!=SQLITE_OK ){ + goto balance_cleanup; + } + } + } } - assert( pNew->nCell>0 ); - assert( !pNew->isOverfull ); - relinkCellList(pBt, pNew); +#endif + + j = cntNew[i]; + + /* If the sibling page assembled above was not the right-most sibling, + ** insert a divider cell into the parent page. + */ 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]); + u8 *pCell; + u8 *pTemp; + int sz; + + assert( jleaf ){ + memcpy(&pNew->aData[8], pCell, 4); + pTemp = 0; + }else if( leafData ){ + /* If the tree is a leaf-data tree, and the siblings are leaves, + ** then there is no divider cell in apCell[]. Instead, the divider + ** cell consists of the integer key for the right-most cell of + ** the sibling-page assembled above only. + */ + CellInfo info; + j--; + parseCellPtr(pNew, apCell[j], &info); + pCell = &aSpace[iSpace]; + fillInCell(pParent, pCell, 0, info.nKey, 0, 0, &sz); + iSpace += sz; + assert( iSpace<=pBt->pageSize*5 ); + pTemp = 0; + }else{ + pCell -= 4; + pTemp = &aSpace[iSpace]; + iSpace += sz; + assert( iSpace<=pBt->pageSize*5 ); + } + rc = insertCell(pParent, nxDiv, pCell, sz, pTemp, 4); + if( rc!=SQLITE_OK ) goto balance_cleanup; + put4byte(findOverflowCell(pParent,nxDiv), pNew->pgno); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If this is an auto-vacuum database, and not a leaf-data tree, + ** then update the pointer map with an entry for the overflow page + ** that the cell just inserted points to (if any). + */ + if( pBt->autoVacuum && !leafData ){ + rc = ptrmapPutOvfl(pParent, nxDiv); + if( rc!=SQLITE_OK ){ + goto balance_cleanup; + } + } +#endif 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]); + assert( nOld>0 ); + assert( nNew>0 ); + if( (pageFlags & PTF_LEAF)==0 ){ + memcpy(&apNew[nNew-1]->aData[8], &apCopy[nOld-1]->aData[8], 4); } - 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); - } + if( nxDiv==pParent->nCell+pParent->nOverflow ){ + /* Right-most sibling is the right-most child of pParent */ + put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew[nNew-1]); + }else{ + /* Right-most sibling is the left child of the first entry in pParent + ** past the right-most divider entry */ + put4byte(findOverflowCell(pParent, nxDiv), pgnoNew[nNew-1]); } /* ** Reparent children of all cells. */ for(i=0; iisInit ); + /* assert( pPage->isInit ); // No! pPage might have been added to freelist */ + /* pageIntegrity(pPage); // No! pPage might have been added to freelist */ + rc = balance(pParent, 0); + /* ** Cleanup before returning. */ balance_cleanup: - if( extraUnref ){ - sqlitepager_unref(extraUnref); - } + sqliteFree(apCell); for(i=0; ipPage==0 ){ - pCur->pPage = pParent; - pCur->idx = 0; + releasePage(pParent); + TRACE(("BALANCE: finished with %d: old=%d new=%d cells=%d\n", + pPage->pgno, nOld, nNew, nCell)); + return rc; +} + +/* +** This routine is called for the root page of a btree when the root +** page contains no cells. This is an opportunity to make the tree +** shallower by one level. +*/ +static int balance_shallower(MemPage *pPage){ + MemPage *pChild; /* The only child page of pPage */ + Pgno pgnoChild; /* Page number for pChild */ + int rc = SQLITE_OK; /* Return code from subprocedures */ + BtShared *pBt; /* The main BTree structure */ + int mxCellPerPage; /* Maximum number of cells per page */ + u8 **apCell; /* All cells from pages being balanced */ + int *szCell; /* Local size of all cells */ + + assert( pPage->pParent==0 ); + assert( pPage->nCell==0 ); + pBt = pPage->pBt; + mxCellPerPage = MX_CELL(pBt); + apCell = sqliteMallocRaw( mxCellPerPage*(sizeof(u8*)+sizeof(int)) ); + if( apCell==0 ) return SQLITE_NOMEM; + szCell = (int*)&apCell[mxCellPerPage]; + if( pPage->leaf ){ + /* The table is completely empty */ + TRACE(("BALANCE: empty table %d\n", pPage->pgno)); }else{ - sqlitepager_unref(pParent); + /* The root page is empty but has one child. Transfer the + ** information from that one child into the root page if it + ** will fit. This reduces the depth of the tree by one. + ** + ** If the root page is page 1, it has less space available than + ** its child (due to the 100 byte header that occurs at the beginning + ** of the database fle), so it might not be able to hold all of the + ** information currently contained in the child. If this is the + ** case, then do not do the transfer. Leave page 1 empty except + ** for the right-pointer to the child page. The child page becomes + ** the virtual root of the tree. + */ + pgnoChild = get4byte(&pPage->aData[pPage->hdrOffset+8]); + assert( pgnoChild>0 ); + assert( pgnoChild<=sqlite3pager_pagecount(pPage->pBt->pPager) ); + rc = getPage(pPage->pBt, pgnoChild, &pChild); + if( rc ) goto end_shallow_balance; + if( pPage->pgno==1 ){ + rc = initPage(pChild, pPage); + if( rc ) goto end_shallow_balance; + assert( pChild->nOverflow==0 ); + if( pChild->nFree>=100 ){ + /* The child information will fit on the root page, so do the + ** copy */ + int i; + zeroPage(pPage, pChild->aData[0]); + for(i=0; inCell; i++){ + apCell[i] = findCell(pChild,i); + szCell[i] = cellSizePtr(pChild, apCell[i]); + } + assemblePage(pPage, pChild->nCell, apCell, szCell); + /* Copy the right-pointer of the child to the parent. */ + put4byte(&pPage->aData[pPage->hdrOffset+8], + get4byte(&pChild->aData[pChild->hdrOffset+8])); + freePage(pChild); + TRACE(("BALANCE: child %d transfer to page 1\n", pChild->pgno)); + }else{ + /* The child has more information that will fit on the root. + ** The tree is already balanced. Do nothing. */ + TRACE(("BALANCE: child %d will not fit on page 1\n", pChild->pgno)); + } + }else{ + memcpy(pPage->aData, pChild->aData, pPage->pBt->usableSize); + pPage->isInit = 0; + pPage->pParent = 0; + rc = initPage(pPage, 0); + assert( rc==SQLITE_OK ); + freePage(pChild); + TRACE(("BALANCE: transfer child %d into root %d\n", + pChild->pgno, pPage->pgno)); + } + rc = reparentChildPages(pPage); + assert( pPage->nOverflow==0 ); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + int i; + for(i=0; inCell; i++){ + rc = ptrmapPutOvfl(pPage, i); + if( rc!=SQLITE_OK ){ + goto end_shallow_balance; + } + } + } +#endif + if( rc!=SQLITE_OK ) goto end_shallow_balance; + releasePage(pChild); + } +end_shallow_balance: + sqliteFree(apCell); + return rc; +} + + +/* +** 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. Finally, call balance_internal() on the new child +** to cause it to split. +*/ +static int balance_deeper(MemPage *pPage){ + int rc; /* Return value from subprocedures */ + MemPage *pChild; /* Pointer to a new child page */ + Pgno pgnoChild; /* Page number of the new child page */ + BtShared *pBt; /* The BTree */ + int usableSize; /* Total usable size of a page */ + u8 *data; /* Content of the parent page */ + u8 *cdata; /* Content of the child page */ + int hdr; /* Offset to page header in parent */ + int brk; /* Offset to content of first cell in parent */ + + assert( pPage->pParent==0 ); + assert( pPage->nOverflow>0 ); + pBt = pPage->pBt; + rc = allocatePage(pBt, &pChild, &pgnoChild, pPage->pgno, 0); + if( rc ) return rc; + assert( sqlite3pager_iswriteable(pChild->aData) ); + usableSize = pBt->usableSize; + data = pPage->aData; + hdr = pPage->hdrOffset; + brk = get2byte(&data[hdr+5]); + cdata = pChild->aData; + memcpy(cdata, &data[hdr], pPage->cellOffset+2*pPage->nCell-hdr); + memcpy(&cdata[brk], &data[brk], usableSize-brk); + assert( pChild->isInit==0 ); + rc = initPage(pChild, pPage); + if( rc ) goto balancedeeper_out; + memcpy(pChild->aOvfl, pPage->aOvfl, pPage->nOverflow*sizeof(pPage->aOvfl[0])); + pChild->nOverflow = pPage->nOverflow; + if( pChild->nOverflow ){ + pChild->nFree = 0; + } + assert( pChild->nCell==pPage->nCell ); + zeroPage(pPage, pChild->aData[0] & ~PTF_LEAF); + put4byte(&pPage->aData[pPage->hdrOffset+8], pgnoChild); + TRACE(("BALANCE: copy root %d into %d\n", pPage->pgno, pChild->pgno)); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + int i; + rc = ptrmapPut(pBt, pChild->pgno, PTRMAP_BTREE, pPage->pgno); + if( rc ) goto balancedeeper_out; + for(i=0; inCell; i++){ + rc = ptrmapPutOvfl(pChild, i); + if( rc!=SQLITE_OK ){ + return rc; + } + } + } +#endif + rc = balance_nonroot(pChild); + +balancedeeper_out: + releasePage(pChild); + return rc; +} + +/* +** Decide if the page pPage needs to be balanced. If balancing is +** required, call the appropriate balancing routine. +*/ +static int balance(MemPage *pPage, int insert){ + int rc = SQLITE_OK; + if( pPage->pParent==0 ){ + if( pPage->nOverflow>0 ){ + rc = balance_deeper(pPage); + } + if( rc==SQLITE_OK && pPage->nCell==0 ){ + rc = balance_shallower(pPage); + } + }else{ + if( pPage->nOverflow>0 || + (!insert && pPage->nFree>pPage->pBt->usableSize*2/3) ){ + rc = balance_nonroot(pPage); + } } 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 +** This routine checks all cursors that point to table pgnoRoot. +** If any of those cursors other than pExclude were opened with ** wrFlag==0 then this routine returns SQLITE_LOCKED. If all -** cursors point to the same table were opened with wrFlag==1 +** cursors that point to pgnoRoot 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 +** all cursors other than pExclude 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){ +static int checkReadLocks(BtShared *pBt, Pgno pgnoRoot, BtCursor *pExclude){ BtCursor *p; - assert( pCur->wrFlag ); - for(p=pCur->pShared; p!=pCur; p=p->pShared){ - assert( p ); - assert( p->pgnoRoot==pCur->pgnoRoot ); + for(p=pBt->pCursor; p; p=p->pNext){ + u32 flags = (p->pBtree->pSqlite ? p->pBtree->pSqlite->flags : 0); + if( p->pgnoRoot!=pgnoRoot || p==pExclude ) continue; + if( p->wrFlag==0 && flags&SQLITE_ReadUncommitted ) continue; if( p->wrFlag==0 ) return SQLITE_LOCKED; - if( sqlitepager_pagenumber(p->pPage)!=p->pgnoRoot ){ + if( p->pPage->pgno!=p->pgnoRoot ){ moveToRoot(p); } } @@ -2608,25 +5245,26 @@ static int checkReadLocks(BtCursor *pCur){ /* ** 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. +** define what table the record should be inserted into. The cursor +** is left pointing at a random location. +** +** For an INTKEY table, only the nKey value of the key is used. pKey is +** ignored. For a ZERODATA table, the pData and nData are both ignored. */ -static int fileBtreeInsert( +int sqlite3BtreeInsert( BtCursor *pCur, /* Insert data into the table of this cursor */ - const void *pKey, int nKey, /* The key of the new record */ + const void *pKey, i64 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; + BtShared *pBt = pCur->pBtree->pBt; + unsigned char *oldCell; + unsigned char *newCell = 0; - if( pCur->pPage==0 ){ - return SQLITE_ABORT; /* A rollback destroyed this cursor */ - } - if( !pBt->inTrans || nKey+nData==0 ){ + if( pBt->inTransaction!=TRANS_WRITE ){ /* Must start a transaction before doing an insert */ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; } @@ -2634,63 +5272,78 @@ static int fileBtreeInsert( if( !pCur->wrFlag ){ return SQLITE_PERM; /* Cursor not open for writing */ } - if( checkReadLocks(pCur) ){ + if( checkReadLocks(pBt, pCur->pgnoRoot, 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 */ + + /* Save the positions of any other cursors open on this table */ + restoreOrClearCursorPosition(pCur, 0); + if( + SQLITE_OK!=(rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur)) || + SQLITE_OK!=(rc = sqlite3BtreeMoveto(pCur, pKey, nKey, &loc)) + ){ + return rc; } - insertCell(pBt, pPage, pCur->idx, &newCell, szNew); - rc = balance(pCur->pBt, pPage, pCur); - /* sqliteBtreePageDump(pCur->pBt, pCur->pgnoRoot, 1); */ + + pPage = pCur->pPage; + assert( pPage->intKey || nKey>=0 ); + assert( pPage->leaf || !pPage->leafData ); + TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n", + pCur->pgnoRoot, nKey, nData, pPage->pgno, + loc==0 ? "overwrite" : "new entry")); + assert( pPage->isInit ); + rc = sqlite3pager_write(pPage->aData); + if( rc ) return rc; + newCell = sqliteMallocRaw( MX_CELL_SIZE(pBt) ); + if( newCell==0 ) return SQLITE_NOMEM; + rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, &szNew); + if( rc ) goto end_insert; + assert( szNew==cellSizePtr(pPage, newCell) ); + assert( szNew<=MX_CELL_SIZE(pBt) ); + if( loc==0 && CURSOR_VALID==pCur->eState ){ + int szOld; + assert( pCur->idx>=0 && pCur->idxnCell ); + oldCell = findCell(pPage, pCur->idx); + if( !pPage->leaf ){ + memcpy(newCell, oldCell, 4); + } + szOld = cellSizePtr(pPage, oldCell); + rc = clearCell(pPage, oldCell); + if( rc ) goto end_insert; + dropCell(pPage, pCur->idx, szOld); + }else if( loc<0 && pPage->nCell>0 ){ + assert( pPage->leaf ); + pCur->idx++; + pCur->info.nSize = 0; + }else{ + assert( pPage->leaf ); + } + rc = insertCell(pPage, pCur->idx, newCell, szNew, 0, 0); + if( rc!=SQLITE_OK ) goto end_insert; + rc = balance(pPage, 1); + /* sqlite3BtreePageDump(pCur->pBt, pCur->pgnoRoot, 1); */ /* fflush(stdout); */ - pCur->eSkip = SKIP_INVALID; + if( rc==SQLITE_OK ){ + moveToRoot(pCur); + } +end_insert: + sqliteFree(newCell); 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. +** Delete the entry that the cursor is pointing to. The cursor +** is left pointing at a random location. */ -static int fileBtreeDelete(BtCursor *pCur){ +int sqlite3BtreeDelete(BtCursor *pCur){ MemPage *pPage = pCur->pPage; - Cell *pCell; + unsigned char *pCell; int rc; - Pgno pgnoChild; - Btree *pBt = pCur->pBt; + Pgno pgnoChild = 0; + BtShared *pBt = pCur->pBtree->pBt; assert( pPage->isInit ); - if( pCur->pPage==0 ){ - return SQLITE_ABORT; /* A rollback destroyed this cursor */ - } - if( !pBt->inTrans ){ + if( pBt->inTransaction!=TRANS_WRITE ){ /* Must start a transaction before doing a delete */ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; } @@ -2701,15 +5354,35 @@ static int fileBtreeDelete(BtCursor *pCur){ if( !pCur->wrFlag ){ return SQLITE_PERM; /* Did not open this cursor for writing */ } - if( checkReadLocks(pCur) ){ + if( checkReadLocks(pBt, pCur->pgnoRoot, pCur) ){ return SQLITE_LOCKED; /* The table pCur points to has a read lock */ } - rc = sqlitepager_write(pPage); + + /* Restore the current cursor position (a no-op if the cursor is not in + ** CURSOR_REQUIRESEEK state) and save the positions of any other cursors + ** open on the same table. Then call sqlite3pager_write() on the page + ** that the entry will be deleted from. + */ + if( + (rc = restoreOrClearCursorPosition(pCur, 1))!=0 || + (rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur))!=0 || + (rc = sqlite3pager_write(pPage->aData))!=0 + ){ + return rc; + } + + /* Locate the cell within it's page and leave pCell pointing to the + ** data. The clearCell() call frees any overflow pages associated with the + ** cell. The cell itself is still intact. + */ + pCell = findCell(pPage, pCur->idx); + if( !pPage->leaf ){ + pgnoChild = get4byte(pCell); + } + rc = clearCell(pPage, pCell); if( rc ) return rc; - pCell = pPage->apCell[pCur->idx]; - pgnoChild = SWAB32(pBt, pCell->h.leftChild); - clearCell(pBt, pCell); - if( pgnoChild ){ + + if( !pPage->leaf ){ /* ** 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. @@ -2718,42 +5391,56 @@ static int fileBtreeDelete(BtCursor *pCur){ ** to be a leaf so we can use it. */ BtCursor leafCur; - Cell *pNext; - int szNext; + unsigned char *pNext; + int szNext; /* The compiler warning is wrong: szNext is always + ** initialized before use. Adding an extra initialization + ** to silence the compiler slows down the code. */ int notUsed; + unsigned char *tempCell = 0; + assert( !pPage->leafData ); getTempCursor(pCur, &leafCur); - rc = fileBtreeNext(&leafCur, ¬Used); + rc = sqlite3BtreeNext(&leafCur, ¬Used); if( rc!=SQLITE_OK ){ - if( rc!=SQLITE_NOMEM ) rc = SQLITE_CORRUPT; - return rc; + if( rc!=SQLITE_NOMEM ){ + rc = SQLITE_CORRUPT_BKPT; + } } - 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); + if( rc==SQLITE_OK ){ + rc = sqlite3pager_write(leafCur.pPage->aData); + } + if( rc==SQLITE_OK ){ + TRACE(("DELETE: table=%d delete internal from %d replace from leaf %d\n", + pCur->pgnoRoot, pPage->pgno, leafCur.pPage->pgno)); + dropCell(pPage, pCur->idx, cellSizePtr(pPage, pCell)); + pNext = findCell(leafCur.pPage, leafCur.idx); + szNext = cellSizePtr(leafCur.pPage, pNext); + assert( MX_CELL_SIZE(pBt)>=szNext+4 ); + tempCell = sqliteMallocRaw( MX_CELL_SIZE(pBt) ); + if( tempCell==0 ){ + rc = SQLITE_NOMEM; + } + } + if( rc==SQLITE_OK ){ + rc = insertCell(pPage, pCur->idx, pNext-4, szNext+4, tempCell, 0); + } + if( rc==SQLITE_OK ){ + put4byte(findOverflowCell(pPage, pCur->idx), pgnoChild); + rc = balance(pPage, 0); + } + if( rc==SQLITE_OK ){ + dropCell(leafCur.pPage, leafCur.idx, szNext); + rc = balance(leafCur.pPage, 0); + } + sqliteFree(tempCell); 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); + TRACE(("DELETE: table=%d delete from leaf %d\n", + pCur->pgnoRoot, pPage->pgno)); + dropCell(pPage, pCur->idx, cellSizePtr(pPage, pCell)); + rc = balance(pPage, 0); + } + if( rc==SQLITE_OK ){ + moveToRoot(pCur); } return rc; } @@ -2762,28 +5449,126 @@ static int fileBtreeDelete(BtCursor *pCur){ ** 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. +** The type of type is determined by the flags parameter. Only the +** following values of flags are currently in use. Other values for +** flags might not work: +** +** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys +** BTREE_ZERODATA Used for SQL indices */ -static int fileBtreeCreateTable(Btree *pBt, int *piTable){ +int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){ + BtShared *pBt = p->pBt; MemPage *pRoot; Pgno pgnoRoot; int rc; - if( !pBt->inTrans ){ + if( pBt->inTransaction!=TRANS_WRITE ){ /* Must start a transaction first */ return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; } - if( pBt->readOnly ){ - return SQLITE_READONLY; + assert( !pBt->readOnly ); + + /* It is illegal to create a table if any cursors are open on the + ** database. This is because in auto-vacuum mode the backend may + ** need to move a database page to make room for the new root-page. + ** If an open cursor was using the page a problem would occur. + */ + if( pBt->pCursor ){ + return SQLITE_LOCKED; } - rc = allocatePage(pBt, &pRoot, &pgnoRoot, 0); + +#ifdef SQLITE_OMIT_AUTOVACUUM + rc = allocatePage(pBt, &pRoot, &pgnoRoot, 1, 0); if( rc ) return rc; - assert( sqlitepager_iswriteable(pRoot) ); - zeroPage(pBt, pRoot); - sqlitepager_unref(pRoot); +#else + if( pBt->autoVacuum ){ + Pgno pgnoMove; /* Move a page here to make room for the root-page */ + MemPage *pPageMove; /* The page to move to. */ + + /* Read the value of meta[3] from the database to determine where the + ** root page of the new table should go. meta[3] is the largest root-page + ** created so far, so the new root-page is (meta[3]+1). + */ + rc = sqlite3BtreeGetMeta(p, 4, &pgnoRoot); + if( rc!=SQLITE_OK ) return rc; + pgnoRoot++; + + /* The new root-page may not be allocated on a pointer-map page, or the + ** PENDING_BYTE page. + */ + if( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) || + pgnoRoot==PENDING_BYTE_PAGE(pBt) ){ + pgnoRoot++; + } + assert( pgnoRoot>=3 ); + + /* Allocate a page. The page that currently resides at pgnoRoot will + ** be moved to the allocated page (unless the allocated page happens + ** to reside at pgnoRoot). + */ + rc = allocatePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, 1); + if( rc!=SQLITE_OK ){ + return rc; + } + + if( pgnoMove!=pgnoRoot ){ + u8 eType; + Pgno iPtrPage; + + releasePage(pPageMove); + rc = getPage(pBt, pgnoRoot, &pRoot); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage); + if( rc!=SQLITE_OK || eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){ + releasePage(pRoot); + return rc; + } + assert( eType!=PTRMAP_ROOTPAGE ); + assert( eType!=PTRMAP_FREEPAGE ); + rc = sqlite3pager_write(pRoot->aData); + if( rc!=SQLITE_OK ){ + releasePage(pRoot); + return rc; + } + rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove); + releasePage(pRoot); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = getPage(pBt, pgnoRoot, &pRoot); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3pager_write(pRoot->aData); + if( rc!=SQLITE_OK ){ + releasePage(pRoot); + return rc; + } + }else{ + pRoot = pPageMove; + } + + /* Update the pointer-map and meta-data with the new root-page number. */ + rc = ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0); + if( rc ){ + releasePage(pRoot); + return rc; + } + rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot); + if( rc ){ + releasePage(pRoot); + return rc; + } + + }else{ + rc = allocatePage(pBt, &pRoot, &pgnoRoot, 1, 0); + if( rc ) return rc; + } +#endif + assert( sqlite3pager_iswriteable(pRoot->aData) ); + zeroPage(pRoot, flags | PTF_LEAF); + sqlite3pager_unref(pRoot->aData); *piTable = (int)pgnoRoot; return SQLITE_OK; } @@ -2792,312 +5577,399 @@ static int fileBtreeCreateTable(Btree *pBt, int *piTable){ ** 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; +static int clearDatabasePage( + BtShared *pBt, /* The BTree that contains the table */ + Pgno pgno, /* Page number to clear */ + MemPage *pParent, /* Parent page. NULL for the root */ + int freePageFlag /* Deallocate page if true */ +){ + MemPage *pPage = 0; int rc; - Cell *pCell; - int idx; + unsigned char *pCell; + int i; - 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( pgno>sqlite3pager_pagecount(pBt->pPager) ){ + return SQLITE_CORRUPT_BKPT; } - if( pPage->u.hdr.rightChild ){ - rc = clearDatabasePage(pBt, SWAB32(pBt, pPage->u.hdr.rightChild), 1); - if( rc ) return rc; + + rc = getAndInitPage(pBt, pgno, &pPage, pParent); + if( rc ) goto cleardatabasepage_out; + rc = sqlite3pager_write(pPage->aData); + if( rc ) goto cleardatabasepage_out; + for(i=0; inCell; i++){ + pCell = findCell(pPage, i); + if( !pPage->leaf ){ + rc = clearDatabasePage(pBt, get4byte(pCell), pPage->pParent, 1); + if( rc ) goto cleardatabasepage_out; + } + rc = clearCell(pPage, pCell); + if( rc ) goto cleardatabasepage_out; + } + if( !pPage->leaf ){ + rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), pPage->pParent, 1); + if( rc ) goto cleardatabasepage_out; } if( freePageFlag ){ - rc = freePage(pBt, pPage, pgno); + rc = freePage(pPage); }else{ - zeroPage(pBt, pPage); + zeroPage(pPage, pPage->aData[0] | PTF_LEAF); } - sqlitepager_unref(pPage); + +cleardatabasepage_out: + releasePage(pPage); return rc; } /* -** Delete all information from a single table in the database. +** Delete all information from a single table in the database. iTable is +** the page number of the root of the table. After this routine returns, +** the root page is empty, but still exists. +** +** This routine will fail with SQLITE_LOCKED if there are any open +** read cursors on the table. Open write cursors are moved to the +** root of the table. */ -static int fileBtreeClearTable(Btree *pBt, int iTable){ +int sqlite3BtreeClearTable(Btree *p, int iTable){ int rc; BtCursor *pCur; - if( !pBt->inTrans ){ + BtShared *pBt = p->pBt; + sqlite3 *db = p->pSqlite; + if( p->inTrans!=TRANS_WRITE ){ 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); + + /* If this connection is not in read-uncommitted mode and currently has + ** a read-cursor open on the table being cleared, return SQLITE_LOCKED. + */ + if( 0==db || 0==(db->flags&SQLITE_ReadUncommitted) ){ + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + if( pCur->pBtree==p && pCur->pgnoRoot==(Pgno)iTable ){ + if( 0==pCur->wrFlag ){ + return SQLITE_LOCKED; + } + moveToRoot(pCur); + } } } - rc = clearDatabasePage(pBt, (Pgno)iTable, 0); - if( rc ){ - fileBtreeRollback(pBt); + + /* Save the position of all cursors open on this table */ + if( SQLITE_OK!=(rc = saveAllCursors(pBt, iTable, 0)) ){ + return rc; } - return rc; + + return clearDatabasePage(pBt, (Pgno)iTable, 0, 0); } /* ** Erase all information in a table and add the root of the table to ** the freelist. Except, the root of the principle table (the one on -** page 2) is never added to the freelist. +** page 1) is never added to the freelist. +** +** This routine will fail with SQLITE_LOCKED if there are any open +** cursors on the table. +** +** If AUTOVACUUM is enabled and the page at iTable is not the last +** root page in the database file, then the last root page +** in the database file is moved into the slot formerly occupied by +** iTable and that last slot formerly occupied by the last root page +** is added to the freelist instead of iTable. In this say, all +** root pages are kept at the beginning of the database file, which +** is necessary for AUTOVACUUM to work right. *piMoved is set to the +** page number that used to be the last root page in the file before +** the move. If no page gets moved, *piMoved is set to 0. +** The last root page is recorded in meta[3] and the value of +** meta[3] is updated by this procedure. */ -static int fileBtreeDropTable(Btree *pBt, int iTable){ +int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){ int rc; - MemPage *pPage; - BtCursor *pCur; - if( !pBt->inTrans ){ + MemPage *pPage = 0; + BtShared *pBt = p->pBt; + + if( p->inTrans!=TRANS_WRITE ){ 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 */ + + /* It is illegal to drop a table if any cursors are open on the + ** database. This is because in auto-vacuum mode the backend may + ** need to move another root-page to fill a gap left by the deleted + ** root page. If an open cursor was using this page a problem would + ** occur. + */ + if( pBt->pCursor ){ + return SQLITE_LOCKED; + } + + rc = getPage(pBt, (Pgno)iTable, &pPage); + if( rc ) return rc; + rc = sqlite3BtreeClearTable(p, iTable); + if( rc ){ + releasePage(pPage); + return rc; + } + + *piMoved = 0; + + if( iTable>1 ){ +#ifdef SQLITE_OMIT_AUTOVACUUM + rc = freePage(pPage); + releasePage(pPage); +#else + if( pBt->autoVacuum ){ + Pgno maxRootPgno; + rc = sqlite3BtreeGetMeta(p, 4, &maxRootPgno); + if( rc!=SQLITE_OK ){ + releasePage(pPage); + return rc; + } + + if( iTable==maxRootPgno ){ + /* If the table being dropped is the table with the largest root-page + ** number in the database, put the root page on the free list. + */ + rc = freePage(pPage); + releasePage(pPage); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + /* The table being dropped does not have the largest root-page + ** number in the database. So move the page that does into the + ** gap left by the deleted root-page. + */ + MemPage *pMove; + releasePage(pPage); + rc = getPage(pBt, maxRootPgno, &pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable); + releasePage(pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = getPage(pBt, maxRootPgno, &pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = freePage(pMove); + releasePage(pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + *piMoved = maxRootPgno; + } + + /* Set the new 'max-root-page' value in the database header. This + ** is the old value less one, less one more if that happens to + ** be a root-page number, less one again if that is the + ** PENDING_BYTE_PAGE. + */ + maxRootPgno--; + if( maxRootPgno==PENDING_BYTE_PAGE(pBt) ){ + maxRootPgno--; + } + if( maxRootPgno==PTRMAP_PAGENO(pBt, maxRootPgno) ){ + maxRootPgno--; + } + assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) ); + + rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno); + }else{ + rc = freePage(pPage); + releasePage(pPage); } - } - 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); +#endif }else{ - zeroPage(pBt, pPage); + /* If sqlite3BtreeDropTable was called on page 1. */ + zeroPage(pPage, PTF_INTKEY|PTF_LEAF ); + releasePage(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; +/* +** Read the meta-information out of a database file. Meta[0] +** is the number of free pages currently in the database. Meta[1] +** through meta[15] are available for use by higher layers. Meta[0] +** is read-only, the others are read/write. +** +** The schema layer numbers meta values differently. At the schema +** layer (and the SetCookie and ReadCookie opcodes) the number of +** free pages is not visible. So Cookie[0] is the same as Meta[1]. +*/ +int sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){ + int rc; + unsigned char *pP1; + BtShared *pBt = p->pBt; + + /* Reading a meta-data value requires a read-lock on page 1 (and hence + ** the sqlite_master table. We grab this lock regardless of whether or + ** not the SQLITE_ReadUncommitted flag is set (the table rooted at page + ** 1 is treated as a special case by queryTableLock() and lockTable()). + */ + rc = queryTableLock(p, 1, READ_LOCK); + if( rc!=SQLITE_OK ){ + return rc; } - 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; -} + + assert( idx>=0 && idx<=15 ); + rc = sqlite3pager_get(pBt->pPager, 1, (void**)&pP1); + if( rc ) return rc; + *pMeta = get4byte(&pP1[36 + idx*4]); + sqlite3pager_unref(pP1); + + /* If autovacuumed is disabled in this build but we are trying to + ** access an autovacuumed database, then make the database readonly. + */ +#ifdef SQLITE_OMIT_AUTOVACUUM + if( idx==4 && *pMeta>0 ) pBt->readOnly = 1; #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); + /* Grab the read-lock on page 1. */ + rc = lockTable(p, 1, READ_LOCK); return rc; } -#endif /* -** Read the meta-information out of a database file. +** Write meta-information back into the database. Meta[0] is +** read-only and may not be written. */ -static int fileBtreeGetMeta(Btree *pBt, int *aMeta){ - PageOne *pP1; +int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){ + BtShared *pBt = p->pBt; + unsigned char *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 ){ + assert( idx>=1 && idx<=15 ); + if( p->inTrans!=TRANS_WRITE ){ 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]); - } + assert( pBt->pPage1!=0 ); + pP1 = pBt->pPage1->aData; + rc = sqlite3pager_write(pP1); + if( rc ) return rc; + put4byte(&pP1[36 + idx*4], iMeta); 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. -******************************************************************************/ +/* +** Return the flag byte at the beginning of the page that the cursor +** is currently pointing to. +*/ +int sqlite3BtreeFlags(BtCursor *pCur){ + /* TODO: What about CURSOR_REQUIRESEEK state? Probably need to call + ** restoreOrClearCursorPosition() here. + */ + MemPage *pPage = pCur->pPage; + return pPage ? pPage->aData[pPage->hdrOffset] : 0; +} +#ifdef SQLITE_DEBUG /* ** 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){ +static int btreePageDump(BtShared *pBt, int pgno, int recursive, MemPage *pParent){ int rc; MemPage *pPage; - int i, j; + int i, j, c; int nFree; u16 idx; + int hdr; + int nCell; + int isInit; + unsigned char *data; char range[20]; unsigned char payload[20]; - rc = sqlitepager_get(pBt->pPager, (Pgno)pgno, (void**)&pPage); + + rc = getPage(pBt, (Pgno)pgno, &pPage); + isInit = pPage->isInit; + if( pPage->isInit==0 ){ + initPage(pPage, pParent); + } 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); + hdr = pPage->hdrOffset; + data = pPage->aData; + c = data[hdr]; + pPage->intKey = (c & (PTF_INTKEY|PTF_LEAFDATA))!=0; + pPage->zeroData = (c & PTF_ZERODATA)!=0; + pPage->leafData = (c & PTF_LEAFDATA)!=0; + pPage->leaf = (c & PTF_LEAF)!=0; + pPage->hasData = !(pPage->zeroData || (!pPage->leaf && pPage->leafData)); + nCell = get2byte(&data[hdr+3]); + sqlite3DebugPrintf("PAGE %d: flags=0x%02x frag=%d parent=%d\n", pgno, + data[hdr], data[hdr+7], + (pPage->isInit && pPage->pParent) ? pPage->pParent->pgno : 0); + assert( hdr == (pgno==1 ? 100 : 0) ); + idx = hdr + 12 - pPage->leaf*4; + for(i=0; ileaf ){ + child = 0; + }else{ + child = get4byte(pCell); + } + sz = info.nData; + if( !pPage->intKey ) sz += info.nKey; if( sz>sizeof(payload)-1 ) sz = sizeof(payload)-1; - memcpy(payload, pCell->aPayload, sz); + memcpy(payload, &pCell[info.nHeader], 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 + sqlite3DebugPrintf( + "cell %2d: i=%-10s chld=%-4d nk=%-4lld nd=%-4d payload=%s\n", + i, range, child, info.nKey, info.nData, 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); + if( !pPage->leaf ){ + sqlite3DebugPrintf("right_child: %d\n", get4byte(&data[hdr+8])); } - 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); + idx = get2byte(&data[hdr+1]); + while( idx>0 && idxpBt->usableSize ){ + int sz = get2byte(&data[idx+2]); + sprintf(range,"%d..%d", idx, idx+sz-1); + nFree += sz; + sqlite3DebugPrintf("freeblock %2d: i=%-10s size=%-4d total=%d\n", + i, range, sz, nFree); + idx = get2byte(&data[idx]); i++; } if( idx!=0 ){ - printf("ERROR: next freeblock index out of range: %d\n", idx); + sqlite3DebugPrintf("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); + if( recursive && !pPage->leaf ){ + for(i=0; iu.hdr.rightChild), 1); + btreePageDump(pBt, get4byte(&data[hdr+8]), 1, pPage); } - sqlitepager_unref(pPage); + pPage->isInit = isInit; + sqlite3pager_unref(data); + fflush(stdout); return SQLITE_OK; } +int sqlite3BtreePageDump(Btree *p, int pgno, int recursive){ + return btreePageDump(p->pBt, pgno, recursive, 0); +} #endif -#ifdef SQLITE_TEST +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) /* ** Fill aResult[] with information about the entry and page that the ** cursor is pointing to. @@ -3105,37 +5977,64 @@ static int fileBtreePageDump(Btree *pBt, int pgno, int recursive){ ** 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[3] = Cell size (local payload + header) ** 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 +** aResult[6] = Total payload size (local + overflow) +** aResult[7] = Header size in bytes +** aResult[8] = Local payload size +** aResult[9] = Parent page number ** ** This routine is used for testing and debugging only. */ -static int fileBtreeCursorDump(BtCursor *pCur, int *aResult){ +int sqlite3BtreeCursorInfo(BtCursor *pCur, int *aResult, int upCnt){ int cnt, idx; MemPage *pPage = pCur->pPage; - Btree *pBt = pCur->pBt; - aResult[0] = sqlitepager_pagenumber(pPage); - aResult[1] = pCur->idx; + BtCursor tmpCur; + + int rc = restoreOrClearCursorPosition(pCur, 1); + if( rc!=SQLITE_OK ){ + return rc; + } + + pageIntegrity(pPage); + assert( pPage->isInit ); + getTempCursor(pCur, &tmpCur); + while( upCnt-- ){ + moveToParent(&tmpCur); + } + pPage = tmpCur.pPage; + pageIntegrity(pPage); + aResult[0] = sqlite3pager_pagenumber(pPage->aData); + assert( aResult[0]==pPage->pgno ); + aResult[1] = tmpCur.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); + if( tmpCur.idx>=0 && tmpCur.idxnCell ){ + getCellInfo(&tmpCur); + aResult[3] = tmpCur.info.nSize; + aResult[6] = tmpCur.info.nData; + aResult[7] = tmpCur.info.nHeader; + aResult[8] = tmpCur.info.nLocal; }else{ aResult[3] = 0; aResult[6] = 0; + aResult[7] = 0; + aResult[8] = 0; } aResult[4] = pPage->nFree; cnt = 0; - idx = SWAB16(pBt, pPage->u.hdr.firstFree); - while( idx>0 && idxaData[pPage->hdrOffset+1]); + while( idx>0 && idxpBt->usableSize ){ cnt++; - idx = SWAB16(pBt, ((FreeBlk*)&pPage->u.aDisk[idx])->iNext); + idx = get2byte(&pPage->aData[idx]); } aResult[5] = cnt; - aResult[7] = SWAB32(pBt, pPage->u.hdr.rightChild); + if( pPage->pParent==0 || isRootPage(pPage) ){ + aResult[9] = 0; + }else{ + aResult[9] = pPage->pParent->pgno; + } + releaseTempCursor(&tmpCur); return SQLITE_OK; } #endif @@ -3144,8 +6043,8 @@ static int fileBtreeCursorDump(BtCursor *pCur, int *aResult){ ** Return the pager associated with a BTree. This routine is used for ** testing and debugging only. */ -static Pager *fileBtreePager(Btree *pBt){ - return pBt->pPager; +Pager *sqlite3BtreePager(Btree *p){ + return p->pBt->pPager; } /* @@ -3154,27 +6053,42 @@ static Pager *fileBtreePager(Btree *pBt){ */ typedef struct IntegrityCk IntegrityCk; struct IntegrityCk { - Btree *pBt; /* The tree being checked out */ + BtShared *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. */ }; +#ifndef SQLITE_OMIT_INTEGRITY_CHECK /* ** Append a message to the error message string. */ -static void checkAppendMsg(IntegrityCk *pCheck, char *zMsg1, char *zMsg2){ +static void checkAppendMsg( + IntegrityCk *pCheck, + char *zMsg1, + const char *zFormat, + ... +){ + va_list ap; + char *zMsg2; + va_start(ap, zFormat); + zMsg2 = sqlite3VMPrintf(zFormat, ap); + va_end(ap); + if( zMsg1==0 ) zMsg1 = ""; if( pCheck->zErrMsg ){ char *zOld = pCheck->zErrMsg; pCheck->zErrMsg = 0; - sqliteSetString(&pCheck->zErrMsg, zOld, "\n", zMsg1, zMsg2, (char*)0); + sqlite3SetString(&pCheck->zErrMsg, zOld, "\n", zMsg1, zMsg2, (char*)0); sqliteFree(zOld); }else{ - sqliteSetString(&pCheck->zErrMsg, zMsg1, zMsg2, (char*)0); + sqlite3SetString(&pCheck->zErrMsg, zMsg1, zMsg2, (char*)0); } + sqliteFree(zMsg2); } +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ +#ifndef SQLITE_OMIT_INTEGRITY_CHECK /* ** 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. @@ -3186,20 +6100,47 @@ static void checkAppendMsg(IntegrityCk *pCheck, char *zMsg1, char *zMsg2){ 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); + checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage); return 1; } if( pCheck->anRef[iPage]==1 ){ - char zBuf[100]; - sprintf(zBuf, "2nd reference to page %d", iPage); - checkAppendMsg(pCheck, zContext, zBuf); + checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage); return 1; } return (pCheck->anRef[iPage]++)>1; } +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Check that the entry in the pointer-map for page iChild maps to +** page iParent, pointer type ptrType. If not, append an error message +** to pCheck. +*/ +static void checkPtrmap( + IntegrityCk *pCheck, /* Integrity check context */ + Pgno iChild, /* Child page number */ + u8 eType, /* Expected pointer map type */ + Pgno iParent, /* Expected pointer map parent page number */ + char *zContext /* Context description (used for error msg) */ +){ + int rc; + u8 ePtrmapType; + Pgno iPtrmapParent; + + rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent); + if( rc!=SQLITE_OK ){ + checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild); + return; + } + + if( ePtrmapType!=eType || iPtrmapParent!=iParent ){ + checkAppendMsg(pCheck, zContext, + "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)", + iChild, eType, iParent, ePtrmapType, iPtrmapParent); + } +} +#endif + /* ** Check the integrity of the freelist or of an overflow page list. ** Verify that the number of pages on the list is N. @@ -3212,50 +6153,64 @@ static void checkList( char *zContext /* Context for error messages */ ){ int i; - char zMsg[100]; + int expected = N; + int iFirst = iPage; while( N-- > 0 ){ - OverflowPage *pOvfl; + unsigned char *pOvfl; if( iPage<1 ){ - sprintf(zMsg, "%d pages missing from overflow list", N+1); - checkAppendMsg(pCheck, zContext, zMsg); + checkAppendMsg(pCheck, zContext, + "%d of %d pages missing from overflow list starting at %d", + N+1, expected, iFirst); 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); + if( sqlite3pager_get(pCheck->pPager, (Pgno)iPage, (void**)&pOvfl) ){ + checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage); break; } if( isFreeList ){ - FreelistInfo *pInfo = (FreelistInfo*)pOvfl->aPayload; - int n = SWAB32(pCheck->pBt, pInfo->nFree); - for(i=0; ipBt, pInfo->aFree[i]), zContext); + int n = get4byte(&pOvfl[4]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pCheck->pBt->autoVacuum ){ + checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext); + } +#endif + if( n>pCheck->pBt->usableSize/4-8 ){ + checkAppendMsg(pCheck, zContext, + "freelist leaf count too big on page %d", iPage); + N--; + }else{ + for(i=0; ipBt->autoVacuum ){ + checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext); + } +#endif + checkRef(pCheck, iFreePage, zContext); + } + N -= n; } - N -= n; } - iPage = SWAB32(pCheck->pBt, pOvfl->iNext); - sqlitepager_unref(pOvfl); +#ifndef SQLITE_OMIT_AUTOVACUUM + else{ + /* If this database supports auto-vacuum and iPage is not the last + ** page in this overflow list, check that the pointer-map entry for + ** the following page matches iPage. + */ + if( pCheck->pBt->autoVacuum && N>0 ){ + i = get4byte(pOvfl); + checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext); + } + } +#endif + iPage = get4byte(pOvfl); + sqlite3pager_unref(pOvfl); } } +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ -/* -** 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; -} - +#ifndef SQLITE_OMIT_INTEGRITY_CHECK /* ** Do various sanity checks on a single page of a tree. Return ** the tree depth. Root pages return 0. Parents of root pages @@ -3265,9 +6220,9 @@ static int keyCompare( ** ** 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. +** NO 2. Make sure cell keys are in order. +** NO 3. Make sure no key is less than or equal to zLowerBound. +** NO 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. @@ -3278,134 +6233,145 @@ 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 */ + char *zParentContext /* Parent context */ ){ MemPage *pPage; - int i, rc, depth, d2, pgno; - char *zKey1, *zKey2; - int nKey1, nKey2; - BtCursor cur; - Btree *pBt; - char zMsg[100]; + int i, rc, depth, d2, pgno, cnt; + int hdr, cellStart; + int nCell; + u8 *data; + BtShared *pBt; + int usableSize; char zContext[100]; - char hit[SQLITE_USABLE_SIZE]; + char *hit; + + sprintf(zContext, "Page %d: ", iPage); /* Check that the page exists */ - cur.pBt = pBt = pCheck->pBt; + pBt = pCheck->pBt; + usableSize = pBt->usableSize; 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); + if( (rc = getPage(pBt, (Pgno)iPage, &pPage))!=0 ){ + checkAppendMsg(pCheck, zContext, + "unable to get the page. error code=%d", rc); 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); + if( (rc = initPage(pPage, pParent))!=0 ){ + checkAppendMsg(pCheck, zContext, "initPage() returns error code %d", rc); + releasePage(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]; + u8 *pCell; int sz; + CellInfo info; /* 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"); + sprintf(zContext, "On tree page %d cell %d: ", iPage, i); + pCell = findCell(pPage,i); + parseCellPtr(pPage, pCell, &info); + sz = info.nData; + if( !pPage->intKey ) sz += info.nKey; + if( sz>info.nLocal ){ + int nPage = (sz - info.nLocal + usableSize - 5)/(usableSize - 4); + Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage, zContext); + } +#endif + checkList(pCheck, 0, pgnoOvfl, nPage, zContext); } /* 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"); + if( !pPage->leaf ){ + pgno = get4byte(pCell); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext); + } +#endif + d2 = checkTreePage(pCheck,pgno,pPage,zContext); + if( i>0 && d2!=depth ){ + checkAppendMsg(pCheck, zContext, "Child page depth differs"); + } + depth = d2; } - 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); + if( !pPage->leaf ){ + pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + sprintf(zContext, "On page %d at right child: ", iPage); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, 0); + } +#endif + checkTreePage(pCheck, pgno, pPage, zContext); + } /* 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; + data = pPage->aData; + hdr = pPage->hdrOffset; + hit = sqliteMalloc( usableSize ); + if( hit ){ + memset(hit, 1, get2byte(&data[hdr+5])); + nCell = get2byte(&data[hdr+3]); + cellStart = hdr + 12 - 4*pPage->leaf; + for(i=0; i=usableSize || pc<0 ){ + checkAppendMsg(pCheck, 0, + "Corruption detected in cell %d on page %d",i,iPage,0); + }else{ + for(j=pc+size-1; j>=pc; j--) hit[j]++; + } + } + for(cnt=0, i=get2byte(&data[hdr+1]); i>0 && i=usableSize || i<0 ){ + checkAppendMsg(pCheck, 0, + "Corruption detected in cell %d on page %d",i,iPage,0); + }else{ + for(j=i+size-1; j>=i; j--) hit[j]++; + } + i = get2byte(&data[i]); + } + for(i=cnt=0; i1 ){ + checkAppendMsg(pCheck, 0, + "Multiple uses for byte %d of page %d", i, iPage); + break; + } + } + if( cnt!=data[hdr+7] ){ + checkAppendMsg(pCheck, 0, + "Fragmented space is %d byte reported as %d on page %d", + cnt, data[hdr+7], iPage); } } + sqliteFree(hit); - /* 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; + releasePage(pPage); + return depth+1; } +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ +#ifndef SQLITE_OMIT_INTEGRITY_CHECK /* ** This routine does a complete check of the given BTree file. aRoot[] is ** an array of pages numbers were each page number is the root page of @@ -3416,59 +6382,83 @@ static int checkTreePage( ** 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){ +char *sqlite3BtreeIntegrityCheck(Btree *p, int *aRoot, int nRoot){ int i; int nRef; IntegrityCk sCheck; + BtShared *pBt = p->pBt; - nRef = *sqlitepager_stats(pBt->pPager); - if( lockBtree(pBt)!=SQLITE_OK ){ + nRef = *sqlite3pager_stats(pBt->pPager); + if( lockBtreeWithRetry(p)!=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); + sCheck.nPage = sqlite3pager_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; } + if( !sCheck.anRef ){ + unlockBtreeIfUnused(pBt); + return sqlite3MPrintf("Unable to malloc %d bytes", + (sCheck.nPage+1)*sizeof(sCheck.anRef[0])); + } + for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; } + i = PENDING_BYTE_PAGE(pBt); + if( i<=sCheck.nPage ){ + sCheck.anRef[i] = 1; + } sCheck.zErrMsg = 0; /* Check the integrity of the freelist */ - checkList(&sCheck, 1, SWAB32(pBt, pBt->page1->freeList), - SWAB32(pBt, pBt->page1->nFree), "Main freelist: "); + checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]), + get4byte(&pBt->pPage1->aData[36]), "Main freelist: "); /* Check all the tables. */ for(i=0; iautoVacuum && aRoot[i]>1 ){ + checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0, 0); + } +#endif + checkTreePage(&sCheck, aRoot[i], 0, "List of tree roots: "); } /* Make sure every page in the file is referenced */ for(i=1; i<=sCheck.nPage; i++){ +#ifdef SQLITE_OMIT_AUTOVACUUM if( sCheck.anRef[i]==0 ){ - char zBuf[100]; - sprintf(zBuf, "Page %d is never used", i); - checkAppendMsg(&sCheck, zBuf, 0); + checkAppendMsg(&sCheck, 0, "Page %d is never used", i); } +#else + /* If the database supports auto-vacuum, make sure no tables contain + ** references to pointer-map pages. + */ + if( sCheck.anRef[i]==0 && + (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){ + checkAppendMsg(&sCheck, 0, "Page %d is never used", i); + } + if( sCheck.anRef[i]!=0 && + (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){ + checkAppendMsg(&sCheck, 0, "Pointer map page %d is referenced", i); + } +#endif } /* Make sure this analysis did not leave any unref() pages */ unlockBtreeIfUnused(pBt); - if( nRef != *sqlitepager_stats(pBt->pPager) ){ - char zBuf[100]; - sprintf(zBuf, + if( nRef != *sqlite3pager_stats(pBt->pPager) ){ + checkAppendMsg(&sCheck, 0, "Outstanding page count goes from %d to %d during this analysis", - nRef, *sqlitepager_stats(pBt->pPager) + nRef, *sqlite3pager_stats(pBt->pPager) ); - checkAppendMsg(&sCheck, zBuf, 0); } /* Clean up and report errors. @@ -3476,15 +6466,35 @@ char *fileBtreeIntegrityCheck(Btree *pBt, int *aRoot, int nRoot){ sqliteFree(sCheck.anRef); return sCheck.zErrMsg; } +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ /* ** Return the full pathname of the underlying database file. */ -static const char *fileBtreeGetFilename(Btree *pBt){ - assert( pBt->pPager!=0 ); - return sqlitepager_filename(pBt->pPager); +const char *sqlite3BtreeGetFilename(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3pager_filename(p->pBt->pPager); } +/* +** Return the pathname of the directory that contains the database file. +*/ +const char *sqlite3BtreeGetDirname(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3pager_dirname(p->pBt->pPager); +} + +/* +** Return the pathname of the journal file for this database. The return +** value of this routine is the same regardless of whether the journal file +** has been created or not. +*/ +const char *sqlite3BtreeGetJournalname(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3pager_journalname(p->pBt->pPager); +} + +#ifndef SQLITE_OMIT_VACUUM /* ** Copy the complete content of pBtFrom into pBtTo. A transaction ** must be active for both files. @@ -3492,88 +6502,171 @@ static const char *fileBtreeGetFilename(Btree *pBt){ ** 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 sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){ int rc = SQLITE_OK; - Pgno i, nPage, nToPage; + Pgno i, nPage, nToPage, iSkip; - if( !pBtTo->inTrans || !pBtFrom->inTrans ) return SQLITE_ERROR; - if( pBtTo->needSwab!=pBtFrom->needSwab ) return SQLITE_ERROR; + BtShared *pBtTo = pTo->pBt; + BtShared *pBtFrom = pFrom->pBt; + + if( pTo->inTrans!=TRANS_WRITE || pFrom->inTrans!=TRANS_WRITE ){ + 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++){ + nToPage = sqlite3pager_pagecount(pBtTo->pPager); + nPage = sqlite3pager_pagecount(pBtFrom->pPager); + iSkip = PENDING_BYTE_PAGE(pBtTo); + for(i=1; rc==SQLITE_OK && i<=nPage; i++){ void *pPage; - rc = sqlitepager_get(pBtFrom->pPager, i, &pPage); + if( i==iSkip ) continue; + rc = sqlite3pager_get(pBtFrom->pPager, i, &pPage); if( rc ) break; - rc = sqlitepager_overwrite(pBtTo->pPager, i, pPage); + rc = sqlite3pager_overwrite(pBtTo->pPager, i, pPage); if( rc ) break; - sqlitepager_unref(pPage); + sqlite3pager_unref(pPage); } for(i=nPage+1; rc==SQLITE_OK && i<=nToPage; i++){ void *pPage; - rc = sqlitepager_get(pBtTo->pPager, i, &pPage); + if( i==iSkip ) continue; + rc = sqlite3pager_get(pBtTo->pPager, i, &pPage); if( rc ) break; - rc = sqlitepager_write(pPage); - sqlitepager_unref(pPage); - sqlitepager_dont_write(pBtTo->pPager, i); + rc = sqlite3pager_write(pPage); + sqlite3pager_unref(pPage); + sqlite3pager_dont_write(pBtTo->pPager, i); } if( !rc && nPagepPager, nPage); + rc = sqlite3pager_truncate(pBtTo->pPager, nPage); } if( rc ){ - fileBtreeRollback(pBtTo); + sqlite3BtreeRollback(pTo); } return rc; } +#endif /* SQLITE_OMIT_VACUUM */ /* -** 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. +** Return non-zero if a transaction is active. */ -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, +int sqlite3BtreeIsInTrans(Btree *p){ + return (p && (p->inTrans==TRANS_WRITE)); +} + +/* +** Return non-zero if a statement transaction is active. +*/ +int sqlite3BtreeIsInStmt(Btree *p){ + return (p->pBt && p->pBt->inStmt); +} + +/* +** This call is a no-op if no write-transaction is currently active on pBt. +** +** Otherwise, sync the database file for the btree pBt. zMaster points to +** the name of a master journal file that should be written into the +** individual journal file, or is NULL, indicating no master journal file +** (single database transaction). +** +** When this is called, the master journal should already have been +** created, populated with this journal pointer and synced to disk. +** +** Once this is routine has returned, the only thing required to commit +** the write-transaction for this database file is to delete the journal. +*/ +int sqlite3BtreeSync(Btree *p, const char *zMaster){ + int rc = SQLITE_OK; + if( p->inTrans==TRANS_WRITE ){ + BtShared *pBt = p->pBt; + Pgno nTrunc = 0; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + rc = autoVacuumCommit(pBt, &nTrunc); + if( rc!=SQLITE_OK ){ + return rc; + } + } #endif -}; -static BtCursorOps sqliteBtreeCursorOps = { - fileBtreeMoveto, - fileBtreeDelete, - fileBtreeInsert, - fileBtreeFirst, - fileBtreeLast, - fileBtreeNext, - fileBtreePrevious, - fileBtreeKeySize, - fileBtreeKey, - fileBtreeKeyCompare, - fileBtreeDataSize, - fileBtreeData, - fileBtreeCloseCursor, -#ifdef SQLITE_TEST - fileBtreeCursorDump, + rc = sqlite3pager_sync(pBt->pPager, zMaster, nTrunc); + } + return rc; +} + +/* +** This function returns a pointer to a blob of memory associated with +** a single shared-btree. The memory is used by client code for it's own +** purposes (for example, to store a high-level schema associated with +** the shared-btree). The btree layer manages reference counting issues. +** +** The first time this is called on a shared-btree, nBytes bytes of memory +** are allocated, zeroed, and returned to the caller. For each subsequent +** call the nBytes parameter is ignored and a pointer to the same blob +** of memory returned. +** +** Just before the shared-btree is closed, the function passed as the +** xFree argument when the memory allocation was made is invoked on the +** blob of allocated memory. This function should not call sqliteFree() +** on the memory, the btree layer does that. +*/ +void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){ + BtShared *pBt = p->pBt; + if( !pBt->pSchema ){ + pBt->pSchema = sqliteMalloc(nBytes); + pBt->xFreeSchema = xFree; + } + return pBt->pSchema; +} + +/* +** Return true if another user of the same shared btree as the argument +** handle holds an exclusive lock on the sqlite_master table. +*/ +int sqlite3BtreeSchemaLocked(Btree *p){ + return (queryTableLock(p, MASTER_ROOT, READ_LOCK)!=SQLITE_OK); +} + + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Obtain a lock on the table whose root page is iTab. The +** lock is a write lock if isWritelock is true or a read lock +** if it is false. +*/ +int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){ + int rc = SQLITE_OK; + u8 lockType = (isWriteLock?WRITE_LOCK:READ_LOCK); + rc = queryTableLock(p, iTab, lockType); + if( rc==SQLITE_OK ){ + rc = lockTable(p, iTab, lockType); + } + return rc; +} +#endif + +/* +** The following debugging interface has to be in this file (rather +** than in, for example, test1.c) so that it can get access to +** the definition of BtShared. +*/ +#if defined(SQLITE_DEBUG) && defined(TCLSH) +#include +int sqlite3_shared_cache_report( + void * clientData, + Tcl_Interp *interp, + int objc, + Tcl_Obj *CONST objv[] +){ +#ifndef SQLITE_OMIT_SHARED_CACHE + const ThreadData *pTd = sqlite3ThreadDataReadOnly(); + if( pTd->useSharedData ){ + BtShared *pBt; + Tcl_Obj *pRet = Tcl_NewObj(); + for(pBt=pTd->pBtree; pBt; pBt=pBt->pNext){ + const char *zFile = sqlite3pager_filename(pBt->pPager); + Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(zFile, -1)); + Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(pBt->nRef)); + } + Tcl_SetObjResult(interp, pRet); + } +#endif + return TCL_OK; +} #endif -}; diff --git a/sqlite/btree.h b/sqlite/btree.h index fa1a0d1d8..10e42cad2 100755 --- a/sqlite/btree.h +++ b/sqlite/btree.h @@ -13,144 +13,136 @@ ** subsystem. See comments in the source code for a detailed description ** of what each interface routine does. ** -** @(#) $Id: btree.h,v 1.1.1.1 2004-03-11 22:22:24 alex Exp $ +** @(#) $Id: btree.h,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #ifndef _BTREE_H_ #define _BTREE_H_ +/* TODO: This definition is just included so other modules compile. It +** needs to be revisited. +*/ +#define SQLITE_N_BTREE_META 10 + +/* +** If defined as non-zero, auto-vacuum is enabled by default. Otherwise +** it must be turned on for each database using "PRAGMA auto_vacuum = 1". +*/ +#ifndef SQLITE_DEFAULT_AUTOVACUUM + #define SQLITE_DEFAULT_AUTOVACUUM 0 +#endif + /* ** Forward declarations of structure */ typedef struct Btree Btree; typedef struct BtCursor BtCursor; -typedef struct BtOps BtOps; -typedef struct BtCursorOps BtCursorOps; +typedef struct BtShared BtShared; -/* -** 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. +int sqlite3BtreeOpen( + const char *zFilename, /* Name of database file to open */ + sqlite3 *db, /* Associated database connection */ + Btree **, /* Return open Btree* here */ + int flags /* Flags */ +); + +/* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the +** following values. ** -** 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. +** NOTE: These values must match the corresponding PAGER_ values in +** pager.h. */ -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*); +#define BTREE_OMIT_JOURNAL 1 /* Do not use journal. No argument */ +#define BTREE_NO_READLOCK 2 /* Omit readlocks on readonly files */ +#define BTREE_MEMORY 4 /* In-memory DB. No argument */ + +int sqlite3BtreeClose(Btree*); +int sqlite3BtreeSetBusyHandler(Btree*,BusyHandler*); +int sqlite3BtreeSetCacheSize(Btree*,int); +int sqlite3BtreeSetSafetyLevel(Btree*,int,int); +int sqlite3BtreeSyncDisabled(Btree*); +int sqlite3BtreeSetPageSize(Btree*,int,int); +int sqlite3BtreeGetPageSize(Btree*); +int sqlite3BtreeGetReserve(Btree*); +int sqlite3BtreeSetAutoVacuum(Btree *, int); +int sqlite3BtreeGetAutoVacuum(Btree *); +int sqlite3BtreeBeginTrans(Btree*,int); +int sqlite3BtreeCommit(Btree*); +int sqlite3BtreeRollback(Btree*); +int sqlite3BtreeBeginStmt(Btree*); +int sqlite3BtreeCommitStmt(Btree*); +int sqlite3BtreeRollbackStmt(Btree*); +int sqlite3BtreeCreateTable(Btree*, int*, int flags); +int sqlite3BtreeIsInTrans(Btree*); +int sqlite3BtreeIsInStmt(Btree*); +int sqlite3BtreeSync(Btree*, const char *zMaster); +void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); +int sqlite3BtreeSchemaLocked(Btree *); +int sqlite3BtreeLockTable(Btree *, int, u8); + +const char *sqlite3BtreeGetFilename(Btree *); +const char *sqlite3BtreeGetDirname(Btree *); +const char *sqlite3BtreeGetJournalname(Btree *); +int sqlite3BtreeCopyFile(Btree *, Btree *); + +/* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR +** of the following flags: +*/ +#define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */ +#define BTREE_ZERODATA 2 /* Table has keys only - no data */ +#define BTREE_LEAFDATA 4 /* Data stored in leaves only. Implies INTKEY */ + +int sqlite3BtreeDropTable(Btree*, int, int*); +int sqlite3BtreeClearTable(Btree*, int); +int sqlite3BtreeGetMeta(Btree*, int idx, u32 *pValue); +int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value); + +int sqlite3BtreeCursor( + Btree*, /* BTree containing table to open */ + int iTable, /* Index of root page */ + int wrFlag, /* 1 for writing. 0 for read-only */ + int(*)(void*,int,const void*,int,const void*), /* Key comparison function */ + void*, /* First argument to compare function */ + BtCursor **ppCursor /* Returned cursor */ +); + +void sqlite3BtreeSetCompare( + BtCursor *, + int(*)(void*,int,const void*,int,const void*), + void* +); + +int sqlite3BtreeCloseCursor(BtCursor*); +int sqlite3BtreeMoveto(BtCursor*, const void *pKey, i64 nKey, int *pRes); +int sqlite3BtreeDelete(BtCursor*); +int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey, + const void *pData, int nData); +int sqlite3BtreeFirst(BtCursor*, int *pRes); +int sqlite3BtreeLast(BtCursor*, int *pRes); +int sqlite3BtreeNext(BtCursor*, int *pRes); +int sqlite3BtreeEof(BtCursor*); +int sqlite3BtreeFlags(BtCursor*); +int sqlite3BtreePrevious(BtCursor*, int *pRes); +int sqlite3BtreeKeySize(BtCursor*, i64 *pSize); +int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*); +const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt); +const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt); +int sqlite3BtreeDataSize(BtCursor*, u32 *pSize); +int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*); + +char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot); +struct Pager *sqlite3BtreePager(Btree*); + + #ifdef SQLITE_TEST - int (*PageDump)(Btree*, int, int); +int sqlite3BtreeCursorInfo(BtCursor*, int*, int); +void sqlite3BtreeCursorList(Btree*); #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*); +#ifdef SQLITE_DEBUG +int sqlite3BtreePageDump(Btree*, int, int recursive); +#else +#define sqlite3BtreePageDump(X,Y,Z) SQLITE_OK #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_ */ diff --git a/sqlite/btree_rb.c b/sqlite/btree_rb.c deleted file mode 100755 index ecce6b572..000000000 --- a/sqlite/btree_rb.c +++ /dev/null @@ -1,1488 +0,0 @@ -/* -** 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: btree_rb.c,v 1.1.1.1 2004-03-11 22:22:22 alex Exp $ -** -** 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(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 */ diff --git a/sqlite/build.c b/sqlite/build.c index eb9759a5a..9c8a25fbc 100755 --- a/sqlite/build.c +++ b/sqlite/build.c @@ -21,62 +21,178 @@ ** BEGIN TRANSACTION ** COMMIT ** ROLLBACK -** PRAGMA ** -** $Id: build.c,v 1.1.1.1 2004-03-11 22:22:24 alex Exp $ +** $Id: build.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #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. +** be parsed. Initialize the pParse structure as needed. */ -void sqliteBeginParse(Parse *pParse, int explainFlag){ - sqlite *db = pParse->db; - int i; +void sqlite3BeginParse(Parse *pParse, int explainFlag){ 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; } +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** The TableLock structure is only used by the sqlite3TableLock() and +** codeTableLocks() functions. +*/ +struct TableLock { + int iDb; /* The database containing the table to be locked */ + int iTab; /* The root page of the table to be locked */ + u8 isWriteLock; /* True for write lock. False for a read lock */ + const char *zName; /* Name of the table */ +}; + +/* +** Record the fact that we want to lock a table at run-time. +** +** The table to be locked has root page iTab and is found in database iDb. +** A read or a write lock can be taken depending on isWritelock. +** +** This routine just records the fact that the lock is desired. The +** code to make the lock occur is generated by a later call to +** codeTableLocks() which occurs during sqlite3FinishCoding(). +*/ +void sqlite3TableLock( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database containing the table to lock */ + int iTab, /* Root page number of the table to be locked */ + u8 isWriteLock, /* True for a write lock */ + const char *zName /* Name of the table to be locked */ +){ + int i; + int nBytes; + TableLock *p; + + if( 0==sqlite3ThreadDataReadOnly()->useSharedData || iDb<0 ){ + return; + } + + for(i=0; inTableLock; i++){ + p = &pParse->aTableLock[i]; + if( p->iDb==iDb && p->iTab==iTab ){ + p->isWriteLock = (p->isWriteLock || isWriteLock); + return; + } + } + + nBytes = sizeof(TableLock) * (pParse->nTableLock+1); + sqliteReallocOrFree((void **)&pParse->aTableLock, nBytes); + if( pParse->aTableLock ){ + p = &pParse->aTableLock[pParse->nTableLock++]; + p->iDb = iDb; + p->iTab = iTab; + p->isWriteLock = isWriteLock; + p->zName = zName; + } +} + +/* +** Code an OP_TableLock instruction for each table locked by the +** statement (configured by calls to sqlite3TableLock()). +*/ +static void codeTableLocks(Parse *pParse){ + int i; + Vdbe *pVdbe; + assert( sqlite3ThreadDataReadOnly()->useSharedData || pParse->nTableLock==0 ); + + if( 0==(pVdbe = sqlite3GetVdbe(pParse)) ){ + return; + } + + for(i=0; inTableLock; i++){ + TableLock *p = &pParse->aTableLock[i]; + int p1 = p->iDb; + if( p->isWriteLock ){ + p1 = -1*(p1+1); + } + sqlite3VdbeOp3(pVdbe, OP_TableLock, p1, p->iTab, p->zName, P3_STATIC); + } +} +#else + #define codeTableLocks(x) +#endif + /* ** 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. +** parsed and a VDBE program to execute that statement has been +** prepared. This routine puts the finishing touches on the +** VDBE program and resets the pParse structure for the next +** parse. ** ** 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; +void sqlite3FinishCoding(Parse *pParse){ + sqlite3 *db; + Vdbe *v; - if( v==0 && (v = sqliteGetVdbe(pParse))!=0 ){ - sqliteVdbeAddOp(v, OP_Halt, 0, 0); + if( sqlite3MallocFailed() ) return; + if( pParse->nested ) return; + if( !pParse->pVdbe ){ + if( pParse->rc==SQLITE_OK && pParse->nErr ){ + pParse->rc = SQLITE_ERROR; + return; + } } - if( sqlite_malloc_failed ) return; - if( v && pParse->nErr==0 ){ + + /* Begin by generating some termination code at the end of the + ** vdbe program + */ + db = pParse->db; + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp(v, OP_Halt, 0, 0); + + /* The cookie mask contains one bit for each database file open. + ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are + ** set for each database that is used. Generate code to start a + ** transaction on each used database and to verify the schema cookie + ** on each used database. + */ + if( pParse->cookieGoto>0 ){ + u32 mask; + int iDb; + sqlite3VdbeJumpHere(v, pParse->cookieGoto-1); + for(iDb=0, mask=1; iDbnDb; mask<<=1, iDb++){ + if( (mask & pParse->cookieMask)==0 ) continue; + sqlite3VdbeAddOp(v, OP_Transaction, iDb, (mask & pParse->writeMask)!=0); + sqlite3VdbeAddOp(v, OP_VerifyCookie, iDb, pParse->cookieValue[iDb]); + } + + /* Once all the cookies have been verified and transactions opened, + ** obtain the required table-locks. This is a no-op unless the + ** shared-cache feature is enabled. + */ + codeTableLocks(pParse); + sqlite3VdbeAddOp(v, OP_Goto, 0, pParse->cookieGoto); + } + +#ifndef SQLITE_OMIT_TRACE + /* Add a No-op that contains the complete text of the compiled SQL + ** statement as its P3 argument. This does not change the functionality + ** of the program. + ** + ** This is used to implement sqlite3_trace(). + */ + sqlite3VdbeOp3(v, OP_Noop, 0, 0, pParse->zSql, pParse->zTail-pParse->zSql); +#endif /* SQLITE_OMIT_TRACE */ + } + + + /* Get the VDBE program ready for execution + */ + if( v && pParse->nErr==0 && !sqlite3MallocFailed() ){ 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; + sqlite3VdbeTrace(v, trace); + sqlite3VdbeMakeReady(v, pParse->nVar, pParse->nMem+3, + pParse->nTab+3, pParse->explain); + pParse->rc = SQLITE_DONE; pParse->colNamesSet = 0; }else if( pParse->rc==SQLITE_OK ){ pParse->rc = SQLITE_ERROR; @@ -84,60 +200,98 @@ void sqliteExec(Parse *pParse){ pParse->nTab = 0; pParse->nMem = 0; pParse->nSet = 0; - pParse->nAgg = 0; pParse->nVar = 0; + pParse->cookieMask = 0; + pParse->cookieGoto = 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. +** Run the parser and code generator recursively in order to generate +** code for the SQL statement given onto the end of the pParse context +** currently under construction. When the parser is run recursively +** this way, the final OP_Halt is not appended and other initialization +** and finalization steps are omitted because those are handling by the +** outermost parser. ** -** 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(). +** Not everything is nestable. This facility is designed to permit +** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER. Use +** care if you decide to try to use this routine for some other purposes. */ -Table *sqliteFindTable(sqlite *db, const char *zName, const char *zDatabase){ +void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){ + va_list ap; + char *zSql; +# define SAVE_SZ (sizeof(Parse) - offsetof(Parse,nVar)) + char saveBuf[SAVE_SZ]; + + if( pParse->nErr ) return; + assert( pParse->nested<10 ); /* Nesting should only be of limited depth */ + va_start(ap, zFormat); + zSql = sqlite3VMPrintf(zFormat, ap); + va_end(ap); + if( zSql==0 ){ + return; /* A malloc must have failed */ + } + pParse->nested++; + memcpy(saveBuf, &pParse->nVar, SAVE_SZ); + memset(&pParse->nVar, 0, SAVE_SZ); + sqlite3RunParser(pParse, zSql, 0); + sqliteFree(zSql); + memcpy(&pParse->nVar, saveBuf, SAVE_SZ); + pParse->nested--; +} + +/* +** Locate the in-memory structure that describes a particular database +** table given the name of that table and (optionally) the name of the +** database containing the table. Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the table and the +** first matching table is returned. (No checking for duplicate table +** names is done.) The search order is TEMP first, then MAIN, then any +** auxiliary databases added using the ATTACH command. +** +** See also sqlite3LocateTable(). +*/ +Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){ Table *p = 0; int i; - for(i=0; inDb; i++){ + assert( zName!=0 ); + for(i=OMIT_TEMPDB; 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( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue; + p = sqlite3HashFind(&db->aDb[j].pSchema->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. +** 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. +** The difference between this routine and sqlite3FindTable() is that this +** routine leaves an error message in pParse->zErrMsg where +** sqlite3FindTable() does not. */ -Table *sqliteLocateTable(Parse *pParse, const char *zName, const char *zDbase){ +Table *sqlite3LocateTable(Parse *pParse, const char *zName, const char *zDbase){ Table *p; - p = sqliteFindTable(pParse->db, zName, zDbase); + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return 0; + } + + p = sqlite3FindTable(pParse->db, zName, zDbase); if( p==0 ){ 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); + sqlite3ErrorMsg(pParse, "no such table: %s.%s", zDbase, zName); }else{ - sqliteErrorMsg(pParse, "no such table: %s", zName); + sqlite3ErrorMsg(pParse, "no such table: %s", zName); } + pParse->checkSchema = 1; } return p; } @@ -154,18 +308,30 @@ Table *sqliteLocateTable(Parse *pParse, const char *zName, const char *zDbase){ ** TEMP first, then MAIN, then any auxiliary databases added ** using the ATTACH command. */ -Index *sqliteFindIndex(sqlite *db, const char *zName, const char *zDb){ +Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){ Index *p = 0; int i; - for(i=0; inDb; i++){ + for(i=OMIT_TEMPDB; 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); + Schema *pSchema = db->aDb[j].pSchema; + if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue; + assert( pSchema || (j==1 && !db->aDb[1].pBt) ); + if( pSchema ){ + p = sqlite3HashFind(&pSchema->idxHash, zName, strlen(zName)+1); + } if( p ) break; } return p; } +/* +** Reclaim the memory used by an index +*/ +static void freeIndex(Index *p){ + sqliteFree(p->zColAff); + sqliteFree(p); +} + /* ** Remove the given index from the index hash table, and free ** its memory structures. @@ -174,81 +340,70 @@ Index *sqliteFindIndex(sqlite *db, const char *zName, const char *zDb){ ** 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){ +static void sqliteDeleteIndex(Index *p){ Index *pOld; + const char *zName = p->zName; - 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); + pOld = sqlite3HashInsert(&p->pSchema->idxHash, zName, strlen( zName)+1, 0); + assert( pOld==0 || pOld==p ); + freeIndex(p); } /* -** Unlink the given index from its table, then remove -** the index from the index hash table and free its memory -** structures. +** For the index called zIdxName which is found in the database iDb, +** unlike that index from its Table then remove the index from +** the index hash table and free all memory structures associated +** with the index. */ -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; +void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){ + Index *pIndex; + int len; + Hash *pHash = &db->aDb[iDb].pSchema->idxHash; + + len = strlen(zIdxName); + pIndex = sqlite3HashInsert(pHash, zIdxName, len+1, 0); + if( 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; + } } + freeIndex(pIndex); } - sqliteDeleteIndex(db, pIndex); + db->flags |= SQLITE_InternChanges; } /* ** 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. +** a single database. This routine is called to reclaim memory +** before the database closes. It is also called during a rollback +** if there were schema changes during the transaction or if a +** schema-cookie mismatch occurs. ** ** 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; +void sqlite3ResetInternalSchema(sqlite3 *db, int iDb){ 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); + if( pDb->pSchema ){ + sqlite3SchemaFree(pDb->pSchema); } - 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 + ** then remove them 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. @@ -286,20 +441,39 @@ void sqliteResetInternalSchema(sqlite *db, int iDb){ ** schema changes during the transaction, then we have to reset the ** internal hash tables and reload them from disk. */ -void sqliteRollbackInternalChanges(sqlite *db){ +void sqlite3RollbackInternalChanges(sqlite3 *db){ if( db->flags & SQLITE_InternChanges ){ - sqliteResetInternalSchema(db, 0); + sqlite3ResetInternalSchema(db, 0); } } /* ** This routine is called when a commit occurs. */ -void sqliteCommitInternalChanges(sqlite *db){ - db->aDb[0].schema_cookie = db->next_cookie; +void sqlite3CommitInternalChanges(sqlite3 *db){ db->flags &= ~SQLITE_InternChanges; } +/* +** Clear the column names from a table or view. +*/ +static void sqliteResetColumnNames(Table *pTable){ + int i; + Column *pCol; + assert( pTable!=0 ); + if( (pCol = pTable->aCol)!=0 ){ + for(i=0; inCol; i++, pCol++){ + sqliteFree(pCol->zName); + sqlite3ExprDelete(pCol->pDflt); + sqliteFree(pCol->zType); + sqliteFree(pCol->zColl); + } + sqliteFree(pTable->aCol); + } + pTable->aCol = 0; + pTable->nCol = 0; +} + /* ** Remove the memory data structures associated with the given ** Table. No changes are made to disk by this routine. @@ -315,42 +489,50 @@ void sqliteCommitInternalChanges(sqlite *db){ ** the table are deleted, but it is assumed they have already been ** unlinked. */ -void sqliteDeleteTable(sqlite *db, Table *pTable){ - int i; +void sqlite3DeleteTable(sqlite3 *db, Table *pTable){ Index *pIndex, *pNext; FKey *pFKey, *pNextFKey; + db = 0; + if( pTable==0 ) return; + /* Do not delete the table until the reference count reaches zero. */ + pTable->nRef--; + if( pTable->nRef>0 ){ + return; + } + assert( pTable->nRef==0 ); + /* 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); + assert( pIndex->pSchema==pTable->pSchema ); + sqliteDeleteIndex(pIndex); } +#ifndef SQLITE_OMIT_FOREIGN_KEY /* 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, + assert( sqlite3HashFind(&pTable->pSchema->aFKey, pFKey->zTo, strlen(pFKey->zTo)+1)!=pFKey ); sqliteFree(pFKey); } +#endif /* 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); - } + sqliteResetColumnNames(pTable); sqliteFree(pTable->zName); - sqliteFree(pTable->aCol); - sqliteSelectDelete(pTable->pSelect); + sqliteFree(pTable->zColAff); + sqlite3SelectDelete(pTable->pSelect); +#ifndef SQLITE_OMIT_CHECK + sqlite3ExprDelete(pTable->pCheck); +#endif sqliteFree(pTable); } @@ -358,57 +540,159 @@ void sqliteDeleteTable(sqlite *db, Table *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; +void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){ + Table *p; FKey *pF1, *pF2; - int i = p->iDb; + Db *pDb; + 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; + assert( iDb>=0 && iDbnDb ); + assert( zTabName && zTabName[0] ); + pDb = &db->aDb[iDb]; + p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, strlen(zTabName)+1,0); + if( p ){ +#ifndef SQLITE_OMIT_FOREIGN_KEY + for(pF1=p->pFKey; pF1; pF1=pF1->pNextFrom){ + int nTo = strlen(pF1->zTo) + 1; + pF2 = sqlite3HashFind(&pDb->pSchema->aFKey, pF1->zTo, nTo); + if( pF2==pF1 ){ + sqlite3HashInsert(&pDb->pSchema->aFKey, pF1->zTo, nTo, pF1->pNextTo); + }else{ + while( pF2 && pF2->pNextTo!=pF1 ){ pF2=pF2->pNextTo; } + if( pF2 ){ + pF2->pNextTo = pF1->pNextTo; + } } } +#endif + sqlite3DeleteTable(db, p); } - sqliteDeleteTable(db, p); + db->flags |= SQLITE_InternChanges; } /* -** Construct the name of a user table or index from a token. +** Given a token, return a string that consists of the text of that +** token with any quotations removed. Space to hold the returned string +** is obtained from sqliteMalloc() and must be freed by the calling +** function. ** -** Space to hold the name is obtained from sqliteMalloc() and must -** be freed by the calling function. +** Tokens are often just pointers into the original SQL text and so +** are not \000 terminated and are not persistent. The returned string +** is \000 terminated and is persistent. */ -char *sqliteTableNameFromToken(Token *pName){ - char *zName = sqliteStrNDup(pName->z, pName->n); - sqliteDequote(zName); +char *sqlite3NameFromToken(Token *pName){ + char *zName; + if( pName ){ + zName = sqliteStrNDup((char*)pName->z, pName->n); + sqlite3Dequote(zName); + }else{ + zName = 0; + } 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. +** Open the sqlite_master table stored in database number iDb for +** writing. The table is opened using cursor 0. */ -void sqliteOpenMasterTable(Vdbe *v, int isTemp){ - sqliteVdbeAddOp(v, OP_Integer, isTemp, 0); - sqliteVdbeAddOp(v, OP_OpenWrite, 0, 2); +void sqlite3OpenMasterTable(Parse *p, int iDb){ + Vdbe *v = sqlite3GetVdbe(p); + sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb)); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + sqlite3VdbeAddOp(v, OP_OpenWrite, 0, MASTER_ROOT); + sqlite3VdbeAddOp(v, OP_SetNumColumns, 0, 5); /* sqlite_master has 5 columns */ +} + +/* +** The token *pName contains the name of a database (either "main" or +** "temp" or the name of an attached db). This routine returns the +** index of the named database in db->aDb[], or -1 if the named db +** does not exist. +*/ +int sqlite3FindDb(sqlite3 *db, Token *pName){ + int i = -1; /* Database number */ + int n; /* Number of characters in the name */ + Db *pDb; /* A database whose name space is being searched */ + char *zName; /* Name we are searching for */ + + zName = sqlite3NameFromToken(pName); + if( zName ){ + n = strlen(zName); + for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){ + if( (!OMIT_TEMPDB || i!=1 ) && n==strlen(pDb->zName) && + 0==sqlite3StrICmp(pDb->zName, zName) ){ + break; + } + } + sqliteFree(zName); + } + return i; +} + +/* The table or view or trigger name is passed to this routine via tokens +** pName1 and pName2. If the table name was fully qualified, for example: +** +** CREATE TABLE xxx.yyy (...); +** +** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if +** the table name is not fully qualified, i.e.: +** +** CREATE TABLE yyy(...); +** +** Then pName1 is set to "yyy" and pName2 is "". +** +** This routine sets the *ppUnqual pointer to point at the token (pName1 or +** pName2) that stores the unqualified table name. The index of the +** database "xxx" is returned. +*/ +int sqlite3TwoPartName( + Parse *pParse, /* Parsing and code generating context */ + Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */ + Token *pName2, /* The "yyy" in the name "xxx.yyy" */ + Token **pUnqual /* Write the unqualified object name here */ +){ + int iDb; /* Database holding the object */ + sqlite3 *db = pParse->db; + + if( pName2 && pName2->n>0 ){ + assert( !db->init.busy ); + *pUnqual = pName2; + iDb = sqlite3FindDb(db, pName1); + if( iDb<0 ){ + sqlite3ErrorMsg(pParse, "unknown database %T", pName1); + pParse->nErr++; + return -1; + } + }else{ + assert( db->init.iDb==0 || db->init.busy ); + iDb = db->init.iDb; + *pUnqual = pName1; + } + return iDb; +} + +/* +** This routine is used to check if the UTF-8 string zName is a legal +** unqualified name for a new schema object (table, index, view or +** trigger). All names are legal except those that begin with the string +** "sqlite_" (in upper, lower or mixed case). This portion of the namespace +** is reserved for internal use. +*/ +int sqlite3CheckObjectName(Parse *pParse, const char *zName){ + if( !pParse->db->init.busy && pParse->nested==0 + && (pParse->db->flags & SQLITE_WriteSchema)==0 + && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){ + sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName); + return SQLITE_ERROR; + } + return SQLITE_OK; } /* ** 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 +** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp ** flag is true if the table should be stored in the auxiliary database ** file instead of in the main database file. This is normally the case ** when the "TEMP" or "TEMPORARY" keyword occurs in between @@ -417,113 +701,128 @@ void sqliteOpenMasterTable(Vdbe *v, int isTemp){ ** 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 +** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine ** is called to complete the construction of the new table record. */ -void sqliteStartTable( +void sqlite3StartTable( Parse *pParse, /* Parser context */ - Token *pStart, /* The "CREATE" token */ - Token *pName, /* Name of table or view to create */ + Token *pName1, /* First part of the name of the table or view */ + Token *pName2, /* Second part of the name of the table or view */ int isTemp, /* True if this is a TEMP table */ - int isView /* True if this is a VIEW */ + int isView, /* True if this is a VIEW */ + int noErr /* Do nothing if table already exists */ ){ Table *pTable; - Index *pIdx; - char *zName; - sqlite *db = pParse->db; + char *zName = 0; /* The name of the new table */ + sqlite3 *db = pParse->db; Vdbe *v; - int iDb; + int iDb; /* Database number to create the table in */ + Token *pName; /* Unqualified name of the table to create */ - pParse->sFirstToken = *pStart; - zName = sqliteTableNameFromToken(pName); + /* The table or view name to create is passed to this routine via tokens + ** pName1 and pName2. If the table name was fully qualified, for example: + ** + ** CREATE TABLE xxx.yyy (...); + ** + ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if + ** the table name is not fully qualified, i.e.: + ** + ** CREATE TABLE yyy(...); + ** + ** Then pName1 is set to "yyy" and pName2 is "". + ** + ** The call below sets the pName pointer to point at the token (pName1 or + ** pName2) that stores the unqualified table name. The variable iDb is + ** set to the index of the database that the table or view is to be + ** created in. + */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ) return; + if( !OMIT_TEMPDB && isTemp && iDb>1 ){ + /* If creating a temp table, the name may not be qualified */ + sqlite3ErrorMsg(pParse, "temporary table name must be unqualified"); + return; + } + if( !OMIT_TEMPDB && isTemp ) iDb = 1; + + pParse->sNameToken = *pName; + zName = sqlite3NameFromToken(pName); if( zName==0 ) return; + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ + goto begin_table_error; + } if( db->init.iDb==1 ) isTemp = 1; #ifndef SQLITE_OMIT_AUTHORIZATION assert( (isTemp & 1)==isTemp ); { int code; - char *zDb = isTemp ? "temp" : "main"; - if( sqliteAuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){ - sqliteFree(zName); - return; + char *zDb = db->aDb[iDb].zName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){ + goto begin_table_error; } if( isView ){ - if( isTemp ){ + if( !OMIT_TEMPDB && isTemp ){ code = SQLITE_CREATE_TEMP_VIEW; }else{ code = SQLITE_CREATE_VIEW; } }else{ - if( isTemp ){ + if( !OMIT_TEMPDB && isTemp ){ code = SQLITE_CREATE_TEMP_TABLE; }else{ code = SQLITE_CREATE_TABLE; } } - if( sqliteAuthCheck(pParse, code, zName, 0, zDb) ){ - sqliteFree(zName); - return; + if( sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){ + goto begin_table_error; } } #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"); - pParse->nErr++; - 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. + ** index or table name in the same database. Issue an error message if + ** it does. */ - 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( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto begin_table_error; } - 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 = sqlite3FindTable(db, zName, db->aDb[iDb].zName); + if( pTable ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "table %T already exists", pName); + } + goto begin_table_error; + } + if( sqlite3FindIndex(db, zName, 0)!=0 && (iDb==0 || !db->init.busy) ){ + sqlite3ErrorMsg(pParse, "there is already an index named %s", zName); + goto begin_table_error; } pTable = sqliteMalloc( sizeof(Table) ); if( pTable==0 ){ - sqliteFree(zName); - return; + pParse->rc = SQLITE_NOMEM; + pParse->nErr++; + goto begin_table_error; } 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); + pTable->pSchema = db->aDb[iDb].pSchema; + pTable->nRef = 1; + if( pParse->pNewTable ) sqlite3DeleteTable(db, pParse->pNewTable); pParse->pNewTable = pTable; + /* If this is the magic sqlite_sequence table used by autoincrement, + ** then record a pointer to this table in the main database structure + ** so that INSERT can find the table easily. + */ +#ifndef SQLITE_OMIT_AUTOINCREMENT + if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){ + pTable->pSchema->pSeqTab = pTable; + } +#endif + /* Begin generating the code that will insert the table record into ** the SQLITE_MASTER table. Note in particular that we must go ahead ** and allocate the record number for the table entry now. Before any @@ -532,40 +831,91 @@ void sqliteStartTable( ** 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); + if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){ + int lbl; + int fileFormat; + sqlite3BeginWriteOperation(pParse, 0, iDb); + + /* If the file format and encoding in the database have not been set, + ** set them now. + */ + sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 1); /* file_format */ + lbl = sqlite3VdbeMakeLabel(v); + sqlite3VdbeAddOp(v, OP_If, 0, lbl); + fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ? + 1 : SQLITE_DEFAULT_FILE_FORMAT; + sqlite3VdbeAddOp(v, OP_Integer, fileFormat, 0); + sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 1); + sqlite3VdbeAddOp(v, OP_Integer, ENC(db), 0); + sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 4); + sqlite3VdbeResolveLabel(v, lbl); + + /* This just creates a place-holder record in the sqlite_master table. + ** The record created does not contain anything yet. It will be replaced + ** by the real entry in code generated at sqlite3EndTable(). + ** + ** The rowid for the new entry is left on the top of the stack. + ** The rowid value is needed by the code that sqlite3EndTable will + ** generate. + */ +#ifndef SQLITE_OMIT_VIEW + if( isView ){ + sqlite3VdbeAddOp(v, OP_Integer, 0, 0); + }else +#endif + { + sqlite3VdbeAddOp(v, OP_CreateTable, iDb, 0); } - 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); + sqlite3OpenMasterTable(pParse, iDb); + sqlite3VdbeAddOp(v, OP_NewRowid, 0, 0); + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + sqlite3VdbeAddOp(v, OP_Insert, 0, 0); + sqlite3VdbeAddOp(v, OP_Close, 0, 0); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); } + + /* Normal (non-error) return. */ + return; + + /* If an error occurs, we jump here */ +begin_table_error: + sqliteFree(zName); + return; } +/* +** This macro is used to compare two strings in a case-insensitive manner. +** It is slightly faster than calling sqlite3StrICmp() directly, but +** produces larger code. +** +** WARNING: This macro is not compatible with the strcmp() family. It +** returns true if the two strings are equal, otherwise false. +*/ +#define STRICMP(x, y) (\ +sqlite3UpperToLower[*(unsigned char *)(x)]== \ +sqlite3UpperToLower[*(unsigned char *)(y)] \ +&& sqlite3StrICmp((x)+1,(y)+1)==0 ) + /* ** Add a new column to the table currently being constructed. ** ** The parser calls this routine once for each column declaration -** in a CREATE TABLE statement. sqliteStartTable() gets called +** in a CREATE TABLE statement. sqlite3StartTable() gets called ** first to get things going. Then this routine is called for each ** column. */ -void sqliteAddColumn(Parse *pParse, Token *pName){ +void sqlite3AddColumn(Parse *pParse, Token *pName){ Table *p; int i; - char *z = 0; + char *z; Column *pCol; if( (p = pParse->pNewTable)==0 ) return; - sqliteSetNString(&z, pName->z, pName->n, 0); + z = sqlite3NameFromToken(pName); 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); + if( STRICMP(z, p->aCol[i].zName) ){ + sqlite3ErrorMsg(pParse, "duplicate column name: %s", z); sqliteFree(z); return; } @@ -573,13 +923,21 @@ void sqliteAddColumn(Parse *pParse, Token *pName){ if( (p->nCol & 0x7)==0 ){ Column *aNew; aNew = sqliteRealloc( p->aCol, (p->nCol+8)*sizeof(p->aCol[0])); - if( aNew==0 ) return; + if( aNew==0 ){ + sqliteFree(z); + return; + } p->aCol = aNew; } pCol = &p->aCol[p->nCol]; memset(pCol, 0, sizeof(p->aCol[0])); pCol->zName = z; - pCol->sortOrder = SQLITE_SO_NUM; + + /* If there is no type specified, columns have the default affinity + ** 'NONE'. If there is a type specified, then sqlite3AddColumnType() will + ** be called next to set pCol->affinity correctly. + */ + pCol->affinity = SQLITE_AFF_NONE; p->nCol++; } @@ -589,7 +947,7 @@ void sqliteAddColumn(Parse *pParse, Token *pName){ ** been seen on a column. This routine sets the notNull flag on ** the column currently under construction. */ -void sqliteAddNotNull(Parse *pParse, int onError){ +void sqlite3AddNotNull(Parse *pParse, int onError){ Table *p; int i; if( (p = pParse->pNewTable)==0 ) return; @@ -597,6 +955,69 @@ void sqliteAddNotNull(Parse *pParse, int onError){ if( i>=0 ) p->aCol[i].notNull = onError; } +/* +** Scan the column type name zType (length nType) and return the +** associated affinity type. +** +** This routine does a case-independent search of zType for the +** substrings in the following table. If one of the substrings is +** found, the corresponding affinity is returned. If zType contains +** more than one of the substrings, entries toward the top of +** the table take priority. For example, if zType is 'BLOBINT', +** SQLITE_AFF_INTEGER is returned. +** +** Substring | Affinity +** -------------------------------- +** 'INT' | SQLITE_AFF_INTEGER +** 'CHAR' | SQLITE_AFF_TEXT +** 'CLOB' | SQLITE_AFF_TEXT +** 'TEXT' | SQLITE_AFF_TEXT +** 'BLOB' | SQLITE_AFF_NONE +** 'REAL' | SQLITE_AFF_REAL +** 'FLOA' | SQLITE_AFF_REAL +** 'DOUB' | SQLITE_AFF_REAL +** +** If none of the substrings in the above table are found, +** SQLITE_AFF_NUMERIC is returned. +*/ +char sqlite3AffinityType(const Token *pType){ + u32 h = 0; + char aff = SQLITE_AFF_NUMERIC; + const unsigned char *zIn = pType->z; + const unsigned char *zEnd = &pType->z[pType->n]; + + while( zIn!=zEnd ){ + h = (h<<8) + sqlite3UpperToLower[*zIn]; + zIn++; + if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */ + && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){ + aff = SQLITE_AFF_NONE; +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; + }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; + }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; +#endif + }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */ + aff = SQLITE_AFF_INTEGER; + break; + } + } + + return aff; +} + /* ** This routine is called by the parser while in the middle of ** parsing a CREATE TABLE statement. The pFirst token is the first @@ -606,56 +1027,44 @@ void sqliteAddNotNull(Parse *pParse, int onError){ ** that contains the typename of the column and store that string ** in zType. */ -void sqliteAddColumnType(Parse *pParse, Token *pFirst, Token *pLast){ +void sqlite3AddColumnType(Parse *pParse, Token *pType){ Table *p; - int i, j; - int n; - char *z, **pz; + int i; 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; - } + sqliteFree(pCol->zType); + pCol->zType = sqlite3NameFromToken(pType); + pCol->affinity = sqlite3AffinityType(pType); } /* -** 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. +** The expression is the default value for the most recently added column +** of the table currently under construction. +** +** Default value expressions must be constant. Raise an exception if this +** is not the case. ** ** This routine is called by the parser while in the middle of ** parsing a CREATE TABLE statement. */ -void sqliteAddDefaultValue(Parse *pParse, Token *pVal, int minusFlag){ +void sqlite3AddDefaultValue(Parse *pParse, Expr *pExpr){ 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); + Column *pCol; + if( (p = pParse->pNewTable)!=0 ){ + pCol = &(p->aCol[p->nCol-1]); + if( !sqlite3ExprIsConstantOrFunction(pExpr) ){ + sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant", + pCol->zName); + }else{ + sqlite3ExprDelete(pCol->pDflt); + pCol->pDflt = sqlite3ExprDup(pExpr); + } } - sqliteDequote(*pz); + sqlite3ExprDelete(pExpr); } /* @@ -668,9 +1077,7 @@ void sqliteAddDefaultValue(Parse *pParse, Token *pVal, int minusFlag){ ** 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 +** then we will try to use that column as the rowid. Set the Table.iPKey ** field of the table under construction to be the index of the ** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is ** no INTEGER PRIMARY KEY. @@ -678,13 +1085,19 @@ void sqliteAddDefaultValue(Parse *pParse, Token *pVal, int minusFlag){ ** 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){ +void sqlite3AddPrimaryKey( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List of field names to be indexed */ + int onError, /* What to do with a uniqueness conflict */ + int autoInc, /* True if the AUTOINCREMENT keyword is present */ + int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */ +){ Table *pTab = pParse->pNewTable; char *zType = 0; int iCol = -1, i; if( pTab==0 ) goto primary_key_exit; if( pTab->hasPrimKey ){ - sqliteErrorMsg(pParse, + sqlite3ErrorMsg(pParse, "table \"%s\" has more than one primary key", pTab->zName); goto primary_key_exit; } @@ -693,73 +1106,126 @@ void sqliteAddPrimaryKey(Parse *pParse, IdList *pList, int onError){ iCol = pTab->nCol - 1; pTab->aCol[iCol].isPrimKey = 1; }else{ - for(i=0; inId; i++){ + for(i=0; inExpr; i++){ for(iCol=0; iColnCol; iCol++){ - if( sqliteStrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ) break; + if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){ + break; + } + } + if( iColnCol ){ + pTab->aCol[iCol].isPrimKey = 1; } - if( iColnCol ) pTab->aCol[iCol].isPrimKey = 1; } - if( pList->nId>1 ) iCol = -1; + if( pList->nExpr>1 ) iCol = -1; } if( iCol>=0 && iColnCol ){ zType = pTab->aCol[iCol].zType; } - if( pParse->db->file_format>=1 && - zType && sqliteStrICmp(zType, "INTEGER")==0 ){ + if( zType && sqlite3StrICmp(zType, "INTEGER")==0 + && sortOrder==SQLITE_SO_ASC ){ pTab->iPKey = iCol; pTab->keyConf = onError; + pTab->autoInc = autoInc; + }else if( autoInc ){ +#ifndef SQLITE_OMIT_AUTOINCREMENT + sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an " + "INTEGER PRIMARY KEY"); +#endif }else{ - sqliteCreateIndex(pParse, 0, 0, pList, onError, 0, 0); + sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, 0, sortOrder, 0); pList = 0; } primary_key_exit: - sqliteIdListDelete(pList); + sqlite3ExprListDelete(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). +** Add a new CHECK constraint to the table currently under construction. */ -int sqliteCollateType(const char *zType, int nType){ - int i; - for(i=0; ipNewTable; + if( pTab ){ + /* The CHECK expression must be duplicated so that tokens refer + ** to malloced space and not the (ephemeral) text of the CREATE TABLE + ** statement */ + pTab->pCheck = sqlite3ExprAnd(pTab->pCheck, sqlite3ExprDup(pCheckExpr)); } - return SQLITE_SO_NUM; +#endif + sqlite3ExprDelete(pCheckExpr); } /* -** This routine is called by the parser while in the middle of -** parsing a CREATE TABLE statement. A "COLLATE" clause has -** been seen on a column. This routine sets the Column.sortOrder on -** the column currently under construction. +** Set the collation function of the most recently parsed table column +** to the CollSeq given. */ -void sqliteAddCollateType(Parse *pParse, int collType){ +void sqlite3AddCollateType(Parse *pParse, const char *zType, int nType){ Table *p; int i; + if( (p = pParse->pNewTable)==0 ) return; i = p->nCol-1; - if( i>=0 ) p->aCol[i].sortOrder = collType; + + if( sqlite3LocateCollSeq(pParse, zType, nType) ){ + Index *pIdx; + p->aCol[i].zColl = sqliteStrNDup(zType, nType); + + /* If the column is declared as " PRIMARY KEY COLLATE ", + ** then an index may have been created on this column before the + ** collation type was added. Correct this if it is the case. + */ + for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->nColumn==1 ); + if( pIdx->aiColumn[0]==i ){ + pIdx->azColl[0] = p->aCol[i].zColl; + } + } + } } /* -** Come up with a new random value for the schema cookie. Make sure -** the new value is different from the old. +** This function returns the collation sequence for database native text +** encoding identified by the string zName, length nName. +** +** If the requested collation sequence is not available, or not available +** in the database native encoding, the collation factory is invoked to +** request it. If the collation factory does not supply such a sequence, +** and the sequence is available in another text encoding, then that is +** returned instead. +** +** If no versions of the requested collations sequence are available, or +** another error occurs, NULL is returned and an error message written into +** pParse. +*/ +CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName, int nName){ + sqlite3 *db = pParse->db; + u8 enc = ENC(db); + u8 initbusy = db->init.busy; + CollSeq *pColl; + + pColl = sqlite3FindCollSeq(db, enc, zName, nName, initbusy); + if( !initbusy && (!pColl || !pColl->xCmp) ){ + pColl = sqlite3GetCollSeq(db, pColl, zName, nName); + if( !pColl ){ + if( nName<0 ){ + nName = strlen(zName); + } + sqlite3ErrorMsg(pParse, "no such collation sequence: %.*s", nName, zName); + pColl = 0; + } + } + + return pColl; +} + + +/* +** Generate code that will increment the schema cookie. ** ** The schema cookie is used to determine when the schema for the ** database changes. After each schema change, the cookie value @@ -774,49 +1240,46 @@ void sqliteAddCollateType(Parse *pParse, int collType){ ** 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); - } +void sqlite3ChangeCookie(sqlite3 *db, Vdbe *v, int iDb){ + sqlite3VdbeAddOp(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, 0); + sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 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. +** +** The estimate is conservative. It might be larger that what is +** really needed. */ static int identLength(const char *z){ int n; - int needQuote = 0; for(n=0; *z; n++, z++){ - if( *z=='\'' ){ n++; needQuote=1; } + if( *z=='"' ){ n++; } } - return n + needQuote*2; + return n + 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){ +static void identPut(char *z, int *pIdx, char *zSignedIdent){ + unsigned char *zIdent = (unsigned char*)zSignedIdent; int i, j, needQuote; i = *pIdx; for(j=0; zIdent[j]; j++){ if( !isalnum(zIdent[j]) && zIdent[j]!='_' ) break; } needQuote = zIdent[j]!=0 || isdigit(zIdent[0]) - || sqliteKeywordCode(zIdent, j)!=TK_ID; - if( needQuote ) z[i++] = '\''; + || sqlite3KeywordCode(zIdent, j)!=TK_ID; + if( needQuote ) z[i++] = '"'; for(j=0; zIdent[j]; j++){ z[i++] = zIdent[j]; - if( zIdent[j]=='\'' ) z[i++] = '\''; + if( zIdent[j]=='"' ) z[i++] = '"'; } - if( needQuote ) z[i++] = '\''; + if( needQuote ) z[i++] = '"'; z[i] = 0; *pIdx = i; } @@ -826,16 +1289,21 @@ static void identPut(char *z, int *pIdx, char *zIdent){ ** 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){ +static char *createTableStmt(Table *p, int isTemp){ int i, k, n; char *zStmt; - char *zSep, *zSep2, *zEnd; + char *zSep, *zSep2, *zEnd, *z; + Column *pCol; n = 0; - for(i=0; inCol; i++){ - n += identLength(p->aCol[i].zName); + for(pCol = p->aCol, i=0; inCol; i++, pCol++){ + n += identLength(pCol->zName); + z = pCol->zType; + if( z ){ + n += (strlen(z) + 1); + } } n += identLength(p->zName); - if( n<40 ){ + if( n<50 ){ zSep = ""; zSep2 = ","; zEnd = ")"; @@ -847,15 +1315,20 @@ static char *createTableStmt(Table *p){ n += 35 + 6*p->nCol; zStmt = sqliteMallocRaw( n ); if( zStmt==0 ) return 0; - strcpy(zStmt, p->iDb==1 ? "CREATE TEMP TABLE " : "CREATE TABLE "); + strcpy(zStmt, !OMIT_TEMPDB&&isTemp ? "CREATE TEMP TABLE ":"CREATE TABLE "); k = strlen(zStmt); identPut(zStmt, &k, p->zName); zStmt[k++] = '('; - for(i=0; inCol; i++){ + for(pCol=p->aCol, i=0; inCol; i++, pCol++){ strcpy(&zStmt[k], zSep); k += strlen(&zStmt[k]); zSep = zSep2; - identPut(zStmt, &k, p->aCol[i].zName); + identPut(zStmt, &k, pCol->zName); + if( (z = pCol->zType)!=0 ){ + zStmt[k++] = ' '; + strcpy(&zStmt[k], z); + k += strlen(z); + } } strcpy(&zStmt[k], zEnd); return zStmt; @@ -873,7 +1346,7 @@ static char *createTableStmt(Table *p){ ** 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 +** recently changed, so the entry for this table already exists in ** the sqlite_master table. We do not want to create it again. ** ** If the pSelect argument is not NULL, it means that this routine @@ -881,27 +1354,47 @@ static char *createTableStmt(Table *p){ ** "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){ +void sqlite3EndTable( + Parse *pParse, /* Parse context */ + Token *pCons, /* The ',' token after the last column defn. */ + Token *pEnd, /* The final ')' token in the CREATE TABLE */ + Select *pSelect /* Select from a "CREATE ... AS SELECT" */ +){ Table *p; - sqlite *db = pParse->db; + sqlite3 *db = pParse->db; + int iDb; - if( (pEnd==0 && pSelect==0) || pParse->nErr || sqlite_malloc_failed ) return; + if( (pEnd==0 && pSelect==0) || pParse->nErr || sqlite3MallocFailed() ) { + 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. + assert( !db->init.busy || !pSelect ); + + iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema); + +#ifndef SQLITE_OMIT_CHECK + /* Resolve names in all CHECK constraint expressions. */ - 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( p->pCheck ){ + SrcList sSrc; /* Fake SrcList for pParse->pNewTable */ + NameContext sNC; /* Name context for pParse->pNewTable */ + + memset(&sNC, 0, sizeof(sNC)); + memset(&sSrc, 0, sizeof(sSrc)); + sSrc.nSrc = 1; + sSrc.a[0].zName = p->zName; + sSrc.a[0].pTab = p; + sSrc.a[0].iCursor = -1; + sNC.pParse = pParse; + sNC.pSrcList = &sSrc; + sNC.isCheck = 1; + if( sqlite3ExprResolveNames(&sNC, p->pCheck) ){ + return; + } } +#endif /* !defined(SQLITE_OMIT_CHECK) */ /* 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. @@ -923,108 +1416,201 @@ void sqliteEndTable(Parse *pParse, Token *pEnd, Select *pSelect){ if( !db->init.busy ){ int n; Vdbe *v; + char *zType; /* "view" or "table" */ + char *zType2; /* "VIEW" or "TABLE" */ + char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */ - v = sqliteGetVdbe(pParse); + v = sqlite3GetVdbe(pParse); if( v==0 ) return; + + sqlite3VdbeAddOp(v, OP_Close, 0, 0); + + /* Create the rootpage for the new table and push it onto the stack. + ** A view has no rootpage, so just push a zero onto the stack for + ** views. Initialize zType at the same time. + */ if( p->pSelect==0 ){ /* A regular table */ - sqliteVdbeOp3(v, OP_CreateTable, 0, p->iDb, (char*)&p->tnum, P3_POINTER); + zType = "table"; + zType2 = "TABLE"; +#ifndef SQLITE_OMIT_VIEW }else{ /* A view */ - sqliteVdbeAddOp(v, OP_Integer, 0, 0); + zType = "view"; + zType2 = "VIEW"; +#endif } - 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 this is a CREATE TABLE xx AS SELECT ..., execute the SELECT + ** statement to populate the new table. The root-page number for the + ** new table is on the top of the vdbe stack. + ** + ** Once the SELECT has been coded by sqlite3Select(), it is in a + ** suitable state to query for the column names and types to be used + ** by the new table. + ** + ** A shared-cache write-lock is not required to write to the new table, + ** as a schema-lock must have already been obtained to create it. Since + ** a schema-lock excludes all other database users, the write-lock would + ** be redundant. + */ if( pSelect ){ - 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); + Table *pSelTab; + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + sqlite3VdbeAddOp(v, OP_OpenWrite, 1, 0); pParse->nTab = 2; - sqliteSelect(pParse, pSelect, SRT_Table, 1, 0, 0, 0); + sqlite3Select(pParse, pSelect, SRT_Table, 1, 0, 0, 0, 0); + sqlite3VdbeAddOp(v, OP_Close, 1, 0); + if( pParse->nErr==0 ){ + pSelTab = sqlite3ResultSetOfSelect(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; + sqlite3DeleteTable(0, pSelTab); + } } - sqliteEndWriteOperation(pParse); + + /* Compute the complete text of the CREATE statement */ + if( pSelect ){ + zStmt = createTableStmt(p, p->pSchema==pParse->db->aDb[1].pSchema); + }else{ + n = pEnd->z - pParse->sNameToken.z + 1; + zStmt = sqlite3MPrintf("CREATE %s %.*s", zType2, n, pParse->sNameToken.z); + } + + /* A slot for the record has already been allocated in the + ** SQLITE_MASTER table. We just need to update that slot with all + ** the information we've collected. The rowid for the preallocated + ** slot is the 2nd item on the stack. The top of the stack is the + ** root page for the new table (or a 0 if this is a view). + */ + sqlite3NestedParse(pParse, + "UPDATE %Q.%s " + "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#0, sql=%Q " + "WHERE rowid=#1", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), + zType, + p->zName, + p->zName, + zStmt + ); + sqliteFree(zStmt); + sqlite3ChangeCookie(db, v, iDb); + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Check to see if we need to create an sqlite_sequence table for + ** keeping track of autoincrement keys. + */ + if( p->autoInc ){ + Db *pDb = &db->aDb[iDb]; + if( pDb->pSchema->pSeqTab==0 ){ + sqlite3NestedParse(pParse, + "CREATE TABLE %Q.sqlite_sequence(name,seq)", + pDb->zName + ); + } + } +#endif + + /* Reparse everything to update our internal data structures */ + sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, + sqlite3MPrintf("tbl_name='%q'",p->zName), P3_DYNAMIC); } + /* Add the table to the in-memory representation of the database. */ - if( pParse->explain==0 && pParse->nErr==0 ){ + if( db->init.busy && pParse->nErr==0 ){ Table *pOld; - FKey *pFKey; - pOld = sqliteHashInsert(&db->aDb[p->iDb].tblHash, - p->zName, strlen(p->zName)+1, p); + FKey *pFKey; + Schema *pSchema = p->pSchema; + pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, strlen(p->zName)+1,p); if( pOld ){ assert( p==pOld ); /* Malloc must have failed inside HashInsert() */ return; } +#ifndef SQLITE_OMIT_FOREIGN_KEY 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); + pFKey->pNextTo = sqlite3HashFind(&pSchema->aFKey, pFKey->zTo, nTo); + sqlite3HashInsert(&pSchema->aFKey, pFKey->zTo, nTo, pFKey); } +#endif pParse->pNewTable = 0; db->nTable++; db->flags |= SQLITE_InternChanges; + +#ifndef SQLITE_OMIT_ALTERTABLE + if( !p->pSelect ){ + const char *zName = (const char *)pParse->sNameToken.z; + int nName; + assert( !pSelect && pCons && pEnd ); + if( pCons->z==0 ){ + pCons = pEnd; + } + nName = (const char *)pCons->z - zName; + p->addColOffset = 13 + sqlite3utf8CharLen(zName, nName); + } +#endif } } +#ifndef SQLITE_OMIT_VIEW /* ** The parser calls this routine in order to create a new VIEW */ -void sqliteCreateView( +void sqlite3CreateView( 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 */ + Token *pName1, /* The token that holds the name of the view */ + Token *pName2, /* 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; + const unsigned char *z; Token sEnd; DbFixer sFix; + Token *pName; + int iDb; - sqliteStartTable(pParse, pBegin, pName, isTemp, 1); - p = pParse->pNewTable; - if( p==0 || pParse->nErr ){ - sqliteSelectDelete(pSelect); + if( pParse->nVar>0 ){ + sqlite3ErrorMsg(pParse, "parameters are not allowed in views"); + sqlite3SelectDelete(pSelect); return; } - if( sqliteFixInit(&sFix, pParse, p->iDb, "view", pName) - && sqliteFixSelect(&sFix, pSelect) + sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0); + p = pParse->pNewTable; + if( p==0 || pParse->nErr ){ + sqlite3SelectDelete(pSelect); + return; + } + sqlite3TwoPartName(pParse, pName1, pName2, &pName); + iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema); + if( sqlite3FixInit(&sFix, pParse, iDb, "view", pName) + && sqlite3FixSelect(&sFix, pSelect) ){ - sqliteSelectDelete(pSelect); + sqlite3SelectDelete(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. + ** they will persist after the current sqlite3_exec() call returns. */ - p->pSelect = sqliteSelectDup(pSelect); - sqliteSelectDelete(pSelect); + p->pSelect = sqlite3SelectDup(pSelect); + sqlite3SelectDelete(pSelect); + if( sqlite3MallocFailed() ){ + return; + } if( !pParse->db->init.busy ){ - sqliteViewGetColumnNames(pParse, p); + sqlite3ViewGetColumnNames(pParse, p); } /* Locate the end of the CREATE VIEW statement. Make sEnd point to @@ -1035,27 +1621,29 @@ void sqliteCreateView( sEnd.z += sEnd.n; } sEnd.n = 0; - n = ((int)sEnd.z) - (int)pBegin->z; - z = pBegin->z; + n = sEnd.z - pBegin->z; + z = (const unsigned char*)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); + /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */ + sqlite3EndTable(pParse, 0, &sEnd, 0); return; } +#endif /* SQLITE_OMIT_VIEW */ +#ifndef SQLITE_OMIT_VIEW /* ** 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; +int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){ + Table *pSelTab; /* A fake table from which we get the result set */ + Select *pSel; /* Copy of the SELECT that implements the view */ + int nErr = 0; /* Number of errors encountered */ + int n; /* Temporarily holds the number of cursors assigned */ assert( pTable ); @@ -1075,258 +1663,318 @@ int sqliteViewGetColumnNames(Parse *pParse, Table *pTable){ ** 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); + sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName); return 1; } + assert( pTable->nCol>=0 ); /* If we get this far, it means we need to compute the table names. + ** Note that the call to sqlite3ResultSetOfSelect() will expand any + ** "*" elements in the results set of the view and will assign cursors + ** to the elements of the FROM clause. But we do not want these changes + ** to be permanent. So the computation is done on a copy of the SELECT + ** statement that defines the view. */ - assert( pTable->pSelect ); /* 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; + assert( pTable->pSelect ); + pSel = sqlite3SelectDup(pTable->pSelect); + if( pSel ){ + n = pParse->nTab; + sqlite3SrcListAssignCursors(pParse, pSel->pSrc); + pTable->nCol = -1; + pSelTab = sqlite3ResultSetOfSelect(pParse, 0, pSel); + pParse->nTab = n; + if( pSelTab ){ + assert( pTable->aCol==0 ); + pTable->nCol = pSelTab->nCol; + pTable->aCol = pSelTab->aCol; + pSelTab->nCol = 0; + pSelTab->aCol = 0; + sqlite3DeleteTable(0, pSelTab); + pTable->pSchema->flags |= DB_UnresetViews; + }else{ + pTable->nCol = 0; + nErr++; + } + sqlite3SelectDelete(pSel); + } else { nErr++; } - sqliteSelectUnbind(pSel); - sqliteExprListDelete(pSel->pEList); - pSel->pEList = pEList; return nErr; } +#endif /* SQLITE_OMIT_VIEW */ -/* -** 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; -} - +#ifndef SQLITE_OMIT_VIEW /* ** Clear the column names from every VIEW in database idx. */ -static void sqliteViewResetAll(sqlite *db, int idx){ +static void sqliteViewResetAll(sqlite3 *db, int idx){ HashElem *i; if( !DbHasProperty(db, idx, DB_UnresetViews) ) return; - for(i=sqliteHashFirst(&db->aDb[idx].tblHash); i; i=sqliteHashNext(i)){ + for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){ Table *pTab = sqliteHashData(i); if( pTab->pSelect ){ - sqliteViewResetColumnNames(pTab); + sqliteResetColumnNames(pTab); } } DbClearProperty(db, idx, DB_UnresetViews); } +#else +# define sqliteViewResetAll(A,B) +#endif /* SQLITE_OMIT_VIEW */ /* -** Given a token, look up a table with that name. If not found, leave -** an error for the parser to find and return NULL. +** This function is called by the VDBE to adjust the internal schema +** used by SQLite when the btree layer moves a table root page. The +** root-page of a table or index in database iDb has changed from iFrom +** to iTo. +** +** Ticket #1728: The symbol table might still contain information +** on tables and/or indices that are the process of being deleted. +** If you are unlucky, one of those deleted indices or tables might +** have the same rootpage number as the real table or index that is +** being moved. So we cannot stop searching after the first match +** because the first match might be for one of the deleted indices +** or tables and not the table/index that is actually being moved. +** We must continue looping until all tables and indices with +** rootpage==iFrom have been converted to have a rootpage of iTo +** in order to be certain that we got the right one. */ -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); +#ifndef SQLITE_OMIT_AUTOVACUUM +void sqlite3RootPageMoved(Db *pDb, int iFrom, int iTo){ + HashElem *pElem; + Hash *pHash; + + pHash = &pDb->pSchema->tblHash; + for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = sqliteHashData(pElem); + if( pTab->tnum==iFrom ){ + pTab->tnum = iTo; + } } - return pTab; + pHash = &pDb->pSchema->idxHash; + for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){ + Index *pIdx = sqliteHashData(pElem); + if( pIdx->tnum==iFrom ){ + pIdx->tnum = iTo; + } + } +} +#endif + +/* +** Write code to erase the table with root-page iTable from database iDb. +** Also write code to modify the sqlite_master table and internal schema +** if a root-page of another table is moved by the btree-layer whilst +** erasing iTable (this can happen with an auto-vacuum database). +*/ +static void destroyRootPage(Parse *pParse, int iTable, int iDb){ + Vdbe *v = sqlite3GetVdbe(pParse); + sqlite3VdbeAddOp(v, OP_Destroy, iTable, iDb); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* OP_Destroy pushes an integer onto the stack. If this integer + ** is non-zero, then it is the root page number of a table moved to + ** location iTable. The following code modifies the sqlite_master table to + ** reflect this. + ** + ** The "#0" in the SQL is a special constant that means whatever value + ** is on the top of the stack. See sqlite3RegisterExpr(). + */ + sqlite3NestedParse(pParse, + "UPDATE %Q.%s SET rootpage=%d WHERE #0 AND rootpage=#0", + pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable); +#endif +} + +/* +** Write VDBE code to erase table pTab and all associated indices on disk. +** Code to update the sqlite_master tables and internal schema definitions +** in case a root-page belonging to another table is moved by the btree layer +** is also added (this can happen with an auto-vacuum database). +*/ +static void destroyTable(Parse *pParse, Table *pTab){ +#ifdef SQLITE_OMIT_AUTOVACUUM + Index *pIdx; + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + destroyRootPage(pParse, pTab->tnum, iDb); + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + destroyRootPage(pParse, pIdx->tnum, iDb); + } +#else + /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM + ** is not defined), then it is important to call OP_Destroy on the + ** table and index root-pages in order, starting with the numerically + ** largest root-page number. This guarantees that none of the root-pages + ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the + ** following were coded: + ** + ** OP_Destroy 4 0 + ** ... + ** OP_Destroy 5 0 + ** + ** and root page 5 happened to be the largest root-page number in the + ** database, then root page 5 would be moved to page 4 by the + ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit + ** a free-list page. + */ + int iTab = pTab->tnum; + int iDestroyed = 0; + + while( 1 ){ + Index *pIdx; + int iLargest = 0; + + if( iDestroyed==0 || iTabpIndex; pIdx; pIdx=pIdx->pNext){ + int iIdx = pIdx->tnum; + assert( pIdx->pSchema==pTab->pSchema ); + if( (iDestroyed==0 || (iIdxiLargest ){ + iLargest = iIdx; + } + } + if( iLargest==0 ){ + return; + }else{ + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + destroyRootPage(pParse, iLargest, iDb); + iDestroyed = iLargest; + } + } +#endif } /* ** 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; +void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){ + Table *pTab; Vdbe *v; - int base; - sqlite *db = pParse->db; + sqlite3 *db = pParse->db; int iDb; - if( pParse->nErr || sqlite_malloc_failed ) return; - pTable = sqliteTableFromToken(pParse, pName); - if( pTable==0 ) return; - iDb = pTable->iDb; + if( pParse->nErr || sqlite3MallocFailed() ){ + goto exit_drop_table; + } + assert( pName->nSrc==1 ); + pTab = sqlite3LocateTable(pParse, pName->a[0].zName, pName->a[0].zDatabase); + + if( pTab==0 ){ + if( noErr ){ + sqlite3ErrorClear(pParse); + } + goto exit_drop_table; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); 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; + const char *zTab = SCHEMA_TABLE(iDb); + const char *zDb = db->aDb[iDb].zName; + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){ + goto exit_drop_table; } if( isView ){ - if( iDb==1 ){ + if( !OMIT_TEMPDB && iDb==1 ){ code = SQLITE_DROP_TEMP_VIEW; }else{ code = SQLITE_DROP_VIEW; } }else{ - if( iDb==1 ){ + if( !OMIT_TEMPDB && iDb==1 ){ code = SQLITE_DROP_TEMP_TABLE; }else{ code = SQLITE_DROP_TABLE; } } - if( sqliteAuthCheck(pParse, code, pTable->zName, 0, zDb) ){ - return; + if( sqlite3AuthCheck(pParse, code, pTab->zName, 0, zDb) ){ + goto exit_drop_table; } - if( sqliteAuthCheck(pParse, SQLITE_DELETE, pTable->zName, 0, zDb) ){ - return; + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){ + goto exit_drop_table; } } #endif - if( pTable->readOnly ){ - sqliteErrorMsg(pParse, "table %s may not be dropped", pTable->zName); - pParse->nErr++; - return; + if( pTab->readOnly || pTab==db->aDb[iDb].pSchema->pSeqTab ){ + sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName); + goto exit_drop_table; } - if( isView && pTable->pSelect==0 ){ - sqliteErrorMsg(pParse, "use DROP TABLE to delete table %s", pTable->zName); - return; + +#ifndef SQLITE_OMIT_VIEW + /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used + ** on a table. + */ + if( isView && pTab->pSelect==0 ){ + sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName); + goto exit_drop_table; } - if( !isView && pTable->pSelect ){ - sqliteErrorMsg(pParse, "use DROP VIEW to delete view %s", pTable->zName); - return; + if( !isView && pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName); + goto exit_drop_table; } +#endif /* Generate code to remove the table from the master table ** on disk. */ - v = sqliteGetVdbe(pParse); + v = sqlite3GetVdbe(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); + Db *pDb = &db->aDb[iDb]; + sqlite3BeginWriteOperation(pParse, 0, iDb); - /* Drop all triggers associated with the table being dropped */ - pTrigger = pTable->pTrigger; + /* Drop all triggers associated with the table being dropped. Code + ** is generated to remove entries from sqlite_master and/or + ** sqlite_temp_master if required. + */ + pTrigger = pTab->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; - } + assert( pTrigger->pSchema==pTab->pSchema || + pTrigger->pSchema==db->aDb[1].pSchema ); + sqlite3DropTriggerPtr(pParse, pTrigger); + pTrigger = pTrigger->pNext; } - /* 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); +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Remove any entries of the sqlite_sequence table associated with + ** the table being dropped. This is done before the table is dropped + ** at the btree level, in case the sqlite_sequence table needs to + ** move as a result of the drop (can happen in auto-vacuum mode). + */ + if( pTab->autoInc ){ + sqlite3NestedParse(pParse, + "DELETE FROM %s.sqlite_sequence WHERE name=%Q", + pDb->zName, pTab->zName + ); } +#endif - if( pTable->iDb==0 ){ - sqliteChangeCookie(db, v); - } - sqliteVdbeAddOp(v, OP_Close, 0, 0); + /* Drop all SQLITE_MASTER table and index entries that refer to the + ** table. The program name loops through the master table and deletes + ** every row that refers to a table of the same name as the one being + ** dropped. Triggers are handled seperately because a trigger can be + ** created in the temp database that refers to a table in another + ** database. + */ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'", + pDb->zName, SCHEMA_TABLE(iDb), pTab->zName); if( !isView ){ - sqliteVdbeAddOp(v, OP_Destroy, pTable->tnum, pTable->iDb); - for(pIdx=pTable->pIndex; pIdx; pIdx=pIdx->pNext){ - sqliteVdbeAddOp(v, OP_Destroy, pIdx->tnum, pIdx->iDb); - } + destroyTable(pParse, pTab); } - 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; + /* Remove the table entry from SQLite's internal schema and modify + ** the schema cookie. + */ + sqlite3VdbeOp3(v, OP_DropTable, iDb, 0, pTab->zName, 0); + sqlite3ChangeCookie(db, v, iDb); } 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); +exit_drop_table: + sqlite3SrcListDelete(pName); } /* @@ -1342,48 +1990,49 @@ void sqliteAddIdxKeyType(Vdbe *v, Index *pIdx){ ** 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(). +** until sqlite3EndTable(). ** ** The foreign key is set for IMMEDIATE processing. A subsequent call -** to sqliteDeferForeignKey() might change this to DEFERRED. +** to sqlite3DeferForeignKey() might change this to DEFERRED. */ -void sqliteCreateForeignKey( +void sqlite3CreateForeignKey( Parse *pParse, /* Parsing context */ - IdList *pFromCol, /* Columns in this table that point to other table */ + ExprList *pFromCol, /* Columns in this table that point to other table */ Token *pTo, /* Name of the other table */ - IdList *pToCol, /* Columns in the other table */ + ExprList *pToCol, /* Columns in the other table */ int flags /* Conflict resolution algorithms. */ ){ +#ifndef SQLITE_OMIT_FOREIGN_KEY + FKey *pFKey = 0; 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" + if( pToCol && pToCol->nExpr!=1 ){ + sqlite3ErrorMsg(pParse, "foreign key on %s" " should reference only one column of table %T", p->aCol[iCol].zName, pTo); goto fk_end; } nCol = 1; - }else if( pToCol && pToCol->nId!=pFromCol->nId ){ - sqliteErrorMsg(pParse, + }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){ + sqlite3ErrorMsg(pParse, "number of columns in foreign key does not match the number of " "columns in the referenced table"); goto fk_end; }else{ - nCol = pFromCol->nId; + nCol = pFromCol->nExpr; } nByte = sizeof(*pFKey) + nCol*sizeof(pFKey->aCol[0]) + pTo->n + 1; if( pToCol ){ - for(i=0; inId; i++){ + for(i=0; inExpr; i++){ nByte += strlen(pToCol->a[i].zName) + 1; } } @@ -1406,13 +2055,13 @@ void sqliteCreateForeignKey( for(i=0; inCol; j++){ - if( sqliteStrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){ + if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){ pFKey->aCol[i].iFrom = j; break; } } if( j>=p->nCol ){ - sqliteErrorMsg(pParse, + sqlite3ErrorMsg(pParse, "unknown column \"%s\" in foreign key definition", pFromCol->a[i].zName); goto fk_end; @@ -1440,8 +2089,9 @@ void sqliteCreateForeignKey( fk_end: sqliteFree(pFKey); - sqliteIdListDelete(pFromCol); - sqliteIdListDelete(pToCol); +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + sqlite3ExprListDelete(pFromCol); + sqlite3ExprListDelete(pToCol); } /* @@ -1451,16 +2101,82 @@ fk_end: ** The behavior of the most recently created foreign key is adjusted ** accordingly. */ -void sqliteDeferForeignKey(Parse *pParse, int isDeferred){ +void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){ +#ifndef SQLITE_OMIT_FOREIGN_KEY Table *pTab; FKey *pFKey; if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return; pFKey->isDeferred = isDeferred; +#endif } /* -** 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 +** Generate code that will erase and refill index *pIdx. This is +** used to initialize a newly created index or to recompute the +** content of an index in response to a REINDEX command. +** +** if memRootPage is not negative, it means that the index is newly +** created. The memory cell specified by memRootPage contains the +** root page number of the index. If memRootPage is negative, then +** the index already exists and must be cleared before being refilled and +** the root page number of the index is taken from pIndex->tnum. +*/ +static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){ + Table *pTab = pIndex->pTable; /* The table that is indexed */ + int iTab = pParse->nTab; /* Btree cursor used for pTab */ + int iIdx = pParse->nTab+1; /* Btree cursor used for pIndex */ + int addr1; /* Address of top of loop */ + int tnum; /* Root page of index */ + Vdbe *v; /* Generate code into this virtual machine */ + KeyInfo *pKey; /* KeyInfo for index */ + int iDb = sqlite3SchemaToIndex(pParse->db, pIndex->pSchema); + +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0, + pParse->db->aDb[iDb].zName ) ){ + return; + } +#endif + + /* Require a write-lock on the table to perform this operation */ + sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName); + + v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + if( memRootPage>=0 ){ + sqlite3VdbeAddOp(v, OP_MemLoad, memRootPage, 0); + tnum = 0; + }else{ + tnum = pIndex->tnum; + sqlite3VdbeAddOp(v, OP_Clear, tnum, iDb); + } + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + pKey = sqlite3IndexKeyinfo(pParse, pIndex); + sqlite3VdbeOp3(v, OP_OpenWrite, iIdx, tnum, (char *)pKey, P3_KEYINFO_HANDOFF); + sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead); + addr1 = sqlite3VdbeAddOp(v, OP_Rewind, iTab, 0); + sqlite3GenerateIndexKey(v, pIndex, iTab); + if( pIndex->onError!=OE_None ){ + int curaddr = sqlite3VdbeCurrentAddr(v); + int addr2 = curaddr+4; + sqlite3VdbeChangeP2(v, curaddr-1, addr2); + sqlite3VdbeAddOp(v, OP_Rowid, iTab, 0); + sqlite3VdbeAddOp(v, OP_AddImm, 1, 0); + sqlite3VdbeAddOp(v, OP_IsUnique, iIdx, addr2); + sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, OE_Abort, + "indexed columns are not unique", P3_STATIC); + assert( addr2==sqlite3VdbeCurrentAddr(v) ); + } + sqlite3VdbeAddOp(v, OP_IdxInsert, iIdx, 0); + sqlite3VdbeAddOp(v, OP_Next, iTab, addr1+1); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp(v, OP_Close, iTab, 0); + sqlite3VdbeAddOp(v, OP_Close, iIdx, 0); +} + +/* +** Create a new index for an SQL table. pName1.pName2 is the name of the index +** and pTblList is the name of the table that is to be indexed. Both will ** be NULL for a primary key or an index that is created to satisfy a ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable ** as the table to be indexed. pParse->pNewTable is a table that is @@ -1470,57 +2186,92 @@ void sqliteDeferForeignKey(Parse *pParse, int isDeferred){ ** 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 */ +void sqlite3CreateIndex( + Parse *pParse, /* All information about this parse */ + Token *pName1, /* First part of index name. May be NULL */ + Token *pName2, /* Second part of index name. May be NULL */ + SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */ + ExprList *pList, /* A list of columns to be indexed */ + int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + Token *pStart, /* The CREATE token that begins a CREATE TABLE statement */ + Token *pEnd, /* The ")" that closes the CREATE INDEX statement */ + int sortOrder, /* Sort order of primary key when pList==NULL */ + int ifNotExist /* Omit error if index already exists */ ){ - Table *pTab; /* Table to be indexed */ - Index *pIndex; /* The index to be created */ - char *zName = 0; + Table *pTab = 0; /* Table to be indexed */ + Index *pIndex = 0; /* The index to be created */ + char *zName = 0; /* Name of the index */ + int nName; /* Number of characters in zName */ int i, j; - 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; + Token nullId; /* Fake token for an empty ID list */ + DbFixer sFix; /* For assigning database names to pTable */ + int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */ + sqlite3 *db = pParse->db; + Db *pDb; /* The specific table containing the indexed database */ + int iDb; /* Index of the database that is being written */ + Token *pName = 0; /* Unqualified name of the index to create */ + struct ExprList_item *pListItem; /* For looping over pList */ + int nCol; + int nExtra = 0; + char *zExtra; - 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) - ){ + if( pParse->nErr || sqlite3MallocFailed() ){ 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); + if( pTblName!=0 ){ + + /* Use the two-part index name to determine the database + ** to search for the table. 'Fix' the table name to this db + ** before looking up the table. + */ + assert( pName1 && pName2 ); + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ) goto exit_create_index; + +#ifndef SQLITE_OMIT_TEMPDB + /* If the index name was unqualified, check if the the table + ** is a temp table. If so, set the database to 1. + */ + pTab = sqlite3SrcListLookup(pParse, pTblName); + if( pName2 && pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){ + iDb = 1; + } +#endif + + if( sqlite3FixInit(&sFix, pParse, iDb, "index", pName) && + sqlite3FixSrcList(&sFix, pTblName) + ){ + /* Because the parser constructs pTblName from a single identifier, + ** sqlite3FixSrcList can never fail. */ + assert(0); + } + pTab = sqlite3LocateTable(pParse, pTblName->a[0].zName, + pTblName->a[0].zDatabase); + if( !pTab ) goto exit_create_index; + assert( db->aDb[iDb].pSchema==pTab->pSchema ); }else{ assert( pName==0 ); - pTab = pParse->pNewTable; + pTab = pParse->pNewTable; + if( !pTab ) goto exit_create_index; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); } + pDb = &db->aDb[iDb]; + 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); + sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName); goto exit_create_index; } +#ifndef SQLITE_OMIT_VIEW if( pTab->pSelect ){ - sqliteErrorMsg(pParse, "views may not be indexed"); + sqlite3ErrorMsg(pParse, "views may not be indexed"); goto exit_create_index; } - isTemp = pTab->iDb==1; +#endif /* ** Find the name of the index. Make sure there is not already another @@ -1535,45 +2286,48 @@ void sqliteCreateIndex( ** 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 = sqliteStrNDup(pName->z, pName->n); + if( pName ){ + zName = sqlite3NameFromToken(pName); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto exit_create_index; if( zName==0 ) goto exit_create_index; - if( (pISameName = sqliteFindIndex(db, zName, 0))!=0 ){ - sqliteErrorMsg(pParse, "index %s already exists", zName); + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, 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; + if( !db->init.busy ){ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto exit_create_index; + if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){ + if( !ifNotExist ){ + sqlite3ErrorMsg(pParse, "index %s already exists", zName); + } + goto exit_create_index; + } + if( sqlite3FindTable(db, zName, 0)!=0 ){ + sqlite3ErrorMsg(pParse, "there is already a table named %s", zName); + goto exit_create_index; + } } - }else if( pName==0 ){ + }else{ char zBuf[30]; int n; Index *pLoop; for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){} - sprintf(zBuf,"%d)",n); + sprintf(zBuf,"_%d",n); zName = 0; - sqliteSetString(&zName, "(", pTab->zName, " autoindex ", zBuf, (char*)0); + sqlite3SetString(&zName, "sqlite_autoindex_", pTab->zName, zBuf, (char*)0); if( zName==0 ) goto exit_create_index; - }else{ - zName = sqliteStrNDup(pName->z, pName->n); } /* 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) ){ + const char *zDb = pDb->zName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 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) ){ + if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX; + if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){ goto exit_create_index; } } @@ -1584,83 +2338,164 @@ void sqliteCreateIndex( ** 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); + nullId.z = (u8*)pTab->aCol[pTab->nCol-1].zName; + nullId.n = strlen((char*)nullId.z); + pList = sqlite3ExprListAppend(0, 0, &nullId); if( pList==0 ) goto exit_create_index; + pList->a[0].sortOrder = sortOrder; + } + + /* Figure out how many bytes of space are required to store explicitly + ** specified collation sequence names. + */ + for(i=0; inExpr; i++){ + Expr *pExpr = pList->a[i].pExpr; + if( pExpr ){ + nExtra += (1 + strlen(pExpr->pColl->zName)); + } } /* ** 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]; + nName = strlen(zName); + nCol = pList->nExpr; + pIndex = sqliteMalloc( + sizeof(Index) + /* Index structure */ + sizeof(int)*nCol + /* Index.aiColumn */ + sizeof(int)*(nCol+1) + /* Index.aiRowEst */ + sizeof(char *)*nCol + /* Index.azColl */ + sizeof(u8)*nCol + /* Index.aSortOrder */ + nName + 1 + /* Index.zName */ + nExtra /* Collation sequence names */ + ); + if( sqlite3MallocFailed() ) goto exit_create_index; + pIndex->azColl = (char**)(&pIndex[1]); + pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]); + pIndex->aiRowEst = (unsigned *)(&pIndex->aiColumn[nCol]); + pIndex->aSortOrder = (u8 *)(&pIndex->aiRowEst[nCol+1]); + pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]); + zExtra = (char *)(&pIndex->zName[nName+1]); strcpy(pIndex->zName, zName); pIndex->pTable = pTab; - pIndex->nColumn = pList->nId; + pIndex->nColumn = pList->nExpr; pIndex->onError = onError; pIndex->autoIndex = pName==0; - pIndex->iDb = isTemp ? 1 : db->init.iDb; + pIndex->pSchema = db->aDb[iDb].pSchema; + + /* Check to see if we should honor DESC requests on index columns + */ + if( pDb->pSchema->file_format>=4 ){ + sortOrderMask = -1; /* Honor DESC */ + }else{ + sortOrderMask = 0; /* Ignore DESC */ + } /* 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; + for(i=0, pListItem=pList->a; inExpr; i++, pListItem++){ + const char *zColName = pListItem->zName; + Column *pTabCol; + int requestedSortOrder; + char *zColl; /* Collation sequence */ + + for(j=0, pTabCol=pTab->aCol; jnCol; j++, pTabCol++){ + if( sqlite3StrICmp(zColName, pTabCol->zName)==0 ) break; } if( j>=pTab->nCol ){ - sqliteErrorMsg(pParse, "table %s has no column named %s", - pTab->zName, pList->a[i].zName); - sqliteFree(pIndex); + sqlite3ErrorMsg(pParse, "table %s has no column named %s", + pTab->zName, zColName); goto exit_create_index; } pIndex->aiColumn[i] = j; + if( pListItem->pExpr ){ + assert( pListItem->pExpr->pColl ); + zColl = zExtra; + strcpy(zExtra, pListItem->pExpr->pColl->zName); + zExtra += (strlen(zColl) + 1); + }else{ + zColl = pTab->aCol[j].zColl; + if( !zColl ){ + zColl = db->pDfltColl->zName; + } + } + if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl, -1) ){ + goto exit_create_index; + } + pIndex->azColl[i] = zColl; + requestedSortOrder = pListItem->sortOrder & sortOrderMask; + pIndex->aSortOrder[i] = requestedSortOrder; + } + sqlite3DefaultRowEst(pIndex); + + if( pTab==pParse->pNewTable ){ + /* This routine has been called to create an automatic index as a + ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or + ** a PRIMARY KEY or UNIQUE clause following the column definitions. + ** i.e. one of: + ** + ** CREATE TABLE t(x PRIMARY KEY, y); + ** CREATE TABLE t(x, y, UNIQUE(x, y)); + ** + ** Either way, check to see if the table already has such an index. If + ** so, don't bother creating this one. This only applies to + ** automatically created indices. Users can do as they wish with + ** explicit indices. + */ + Index *pIdx; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int k; + assert( pIdx->onError!=OE_None ); + assert( pIdx->autoIndex ); + assert( pIndex->onError!=OE_None ); + + if( pIdx->nColumn!=pIndex->nColumn ) continue; + for(k=0; knColumn; k++){ + const char *z1 = pIdx->azColl[k]; + const char *z2 = pIndex->azColl[k]; + if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break; + if( pIdx->aSortOrder[k]!=pIndex->aSortOrder[k] ) break; + if( z1!=z2 && sqlite3StrICmp(z1, z2) ) break; + } + if( k==pIdx->nColumn ){ + if( pIdx->onError!=pIndex->onError ){ + /* This constraint creates the same index as a previous + ** constraint specified somewhere in the CREATE TABLE statement. + ** However the ON CONFLICT clauses are different. If both this + ** constraint and the previous equivalent constraint have explicit + ** ON CONFLICT clauses this is an error. Otherwise, use the + ** explicitly specified behaviour for the index. + */ + if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){ + sqlite3ErrorMsg(pParse, + "conflicting ON CONFLICT clauses specified", 0); + } + if( pIdx->onError==OE_Default ){ + pIdx->onError = pIndex->onError; + } + } + goto exit_create_index; + } + } } /* Link the new Index structure to its table and to the other ** in-memory database structures. */ - if( !pParse->explain ){ + if( db->init.busy ){ Index *p; - p = sqliteHashInsert(&db->aDb[pIndex->iDb].idxHash, + p = sqlite3HashInsert(&pIndex->pSchema->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; + if( pTblName!=0 ){ + pIndex->tnum = db->init.newTnum; } - 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 @@ -1673,163 +2508,247 @@ void sqliteCreateIndex( ** 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 + ** If pTblName==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; + char *zStmt; + int iMem = pParse->nMem++; - v = sqliteGetVdbe(pParse); + v = sqlite3GetVdbe(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); + + + /* Create the rootpage for the index + */ + sqlite3BeginWriteOperation(pParse, 1, iDb); + sqlite3VdbeAddOp(v, OP_CreateIndex, iDb, 0); + sqlite3VdbeAddOp(v, OP_MemStore, iMem, 0); + + /* Gather the complete text of the CREATE INDEX statement into + ** the zStmt variable + */ if( pStart && pEnd ){ - n = Addr(pEnd->z) - Addr(pStart->z) + 1; - sqliteVdbeChangeP3(v, addr, pStart->z, n); + /* A named index with an explicit CREATE INDEX statement */ + zStmt = sqlite3MPrintf("CREATE%s INDEX %.*s", + onError==OE_None ? "" : " UNIQUE", + pEnd->z - pName->z + 1, + pName->z); + }else{ + /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */ + /* zStmt = sqlite3MPrintf(""); */ + zStmt = 0; } - 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); - } + + /* Add an entry in sqlite_master for this index + */ + sqlite3NestedParse(pParse, + "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#0,%Q);", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), + pIndex->zName, + pTab->zName, + zStmt + ); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqliteFree(zStmt); + + /* Fill the index with data and reparse the schema. Code an OP_Expire + ** to invalidate all pre-compiled statements. + */ + if( pTblName ){ + sqlite3RefillIndex(pParse, pIndex, iMem); + sqlite3ChangeCookie(db, v, iDb); + sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, + sqlite3MPrintf("name='%q'", pIndex->zName), P3_DYNAMIC); + sqlite3VdbeAddOp(v, OP_Expire, 0, 0); + } + } + + /* 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( db->init.busy || pTblName==0 ){ + if( onError!=OE_Replace || pTab->pIndex==0 + || pTab->pIndex->onError==OE_Replace){ + pIndex->pNext = pTab->pIndex; + pTab->pIndex = pIndex; + }else{ + Index *pOther = pTab->pIndex; + while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){ + pOther = pOther->pNext; } - 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); + pIndex->pNext = pOther->pNext; + pOther->pNext = pIndex; } + pIndex = 0; } /* Clean up before exiting */ exit_create_index: - sqliteIdListDelete(pList); - sqliteSrcListDelete(pTable); + if( pIndex ){ + freeIndex(pIndex); + } + sqlite3ExprListDelete(pList); + sqlite3SrcListDelete(pTblName); sqliteFree(zName); return; } +/* +** Generate code to make sure the file format number is at least minFormat. +** The generated code will increase the file format number if necessary. +*/ +void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){ + Vdbe *v; + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 1); + sqlite3VdbeAddOp(v, OP_Integer, minFormat, 0); + sqlite3VdbeAddOp(v, OP_Ge, 0, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp(v, OP_Integer, minFormat, 0); + sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 1); + } +} + +/* +** Fill the Index.aiRowEst[] array with default information - information +** to be used when we have not run the ANALYZE command. +** +** aiRowEst[0] is suppose to contain the number of elements in the index. +** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the +** number of rows in the table that match any particular value of the +** first column of the index. aiRowEst[2] is an estimate of the number +** of rows that match any particular combiniation of the first 2 columns +** of the index. And so forth. It must always be the case that +* +** aiRowEst[N]<=aiRowEst[N-1] +** aiRowEst[N]>=1 +** +** Apart from that, we have little to go on besides intuition as to +** how aiRowEst[] should be initialized. The numbers generated here +** are based on typical values found in actual indices. +*/ +void sqlite3DefaultRowEst(Index *pIdx){ + unsigned *a = pIdx->aiRowEst; + int i; + assert( a!=0 ); + a[0] = 1000000; + for(i=pIdx->nColumn; i>=1; i--){ + a[i] = 10; + } + if( pIdx->onError!=OE_None ){ + a[pIdx->nColumn] = 1; + } +} + /* ** This routine will drop an existing named index. This routine ** implements the DROP INDEX statement. */ -void sqliteDropIndex(Parse *pParse, SrcList *pName){ +void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){ Index *pIndex; Vdbe *v; - sqlite *db = pParse->db; + sqlite3 *db = pParse->db; + int iDb; - if( pParse->nErr || sqlite_malloc_failed ) return; + if( pParse->nErr || sqlite3MallocFailed() ){ + goto exit_drop_index; + } assert( pName->nSrc==1 ); - pIndex = sqliteFindIndex(db, pName->a[0].zName, pName->a[0].zDatabase); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto exit_drop_index; + } + pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase); if( pIndex==0 ){ - sqliteErrorMsg(pParse, "no such index: %S", pName, 0); + if( !ifExists ){ + sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0); + } + pParse->checkSchema = 1; goto exit_drop_index; } if( pIndex->autoIndex ){ - sqliteErrorMsg(pParse, "index associated with UNIQUE " + sqlite3ErrorMsg(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; - } + iDb = sqlite3SchemaToIndex(db, pIndex->pSchema); #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) ){ + const char *zDb = db->aDb[iDb].zName; + const char *zTab = SCHEMA_TABLE(iDb); + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ goto exit_drop_index; } - if( pIndex->iDb ) code = SQLITE_DROP_TEMP_INDEX; - if( sqliteAuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){ + if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX; + if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){ goto exit_drop_index; } } #endif /* Generate code to remove the index and from the master table */ - v = sqliteGetVdbe(pParse); + v = sqlite3GetVdbe(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; + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE name=%Q", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), + pIndex->zName + ); + sqlite3ChangeCookie(db, v, iDb); + destroyRootPage(pParse, pIndex->tnum, iDb); + sqlite3VdbeOp3(v, OP_DropIndex, iDb, 0, pIndex->zName, 0); } exit_drop_index: - sqliteSrcListDelete(pName); + sqlite3SrcListDelete(pName); +} + +/* +** ppArray points into a structure where there is an array pointer +** followed by two integers. The first integer is the +** number of elements in the structure array. The second integer +** is the number of allocated slots in the array. +** +** In other words, the structure looks something like this: +** +** struct Example1 { +** struct subElem *aEntry; +** int nEntry; +** int nAlloc; +** } +** +** The pnEntry parameter points to the equivalent of Example1.nEntry. +** +** This routine allocates a new slot in the array, zeros it out, +** and returns its index. If malloc fails a negative number is returned. +** +** szEntry is the sizeof of a single array entry. initSize is the +** number of array entries allocated on the initial allocation. +*/ +int sqlite3ArrayAllocate(void **ppArray, int szEntry, int initSize){ + char *p; + int *an = (int*)&ppArray[1]; + if( an[0]>=an[1] ){ + void *pNew; + int newSize; + newSize = an[1]*2 + initSize; + pNew = sqliteRealloc(*ppArray, newSize*szEntry); + if( pNew==0 ){ + return -1; + } + an[1] = newSize; + *ppArray = pNew; + } + p = *ppArray; + memset(&p[an[0]*szEntry], 0, szEntry); + return an[0]++; } /* @@ -1838,37 +2757,48 @@ exit_drop_index: ** ** A new IdList is returned, or NULL if malloc() fails. */ -IdList *sqliteIdListAppend(IdList *pList, Token *pToken){ +IdList *sqlite3IdListAppend(IdList *pList, Token *pToken){ + int i; 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; + i = sqlite3ArrayAllocate((void**)&pList->a, sizeof(pList->a[0]), 5); + if( i<0 ){ + sqlite3IdListDelete(pList); + return 0; } - 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++; + pList->a[i].zName = sqlite3NameFromToken(pToken); return pList; } +/* +** Delete an IdList. +*/ +void sqlite3IdListDelete(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 sqlite3IdListIndex(IdList *pList, const char *zName){ + int i; + if( pList==0 ) return -1; + for(i=0; inId; i++){ + if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i; + } + return -1; +} + /* ** 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. @@ -1885,16 +2815,17 @@ IdList *sqliteIdListAppend(IdList *pList, Token *pToken){ ** ** In other words, if call like this: ** -** sqliteSrcListAppend(A,B,0); +** sqlite3SrcListAppend(A,B,0); ** ** Then B is a table name and the database name is unspecified. If called ** like this: ** -** sqliteSrcListAppend(A,B,C); +** sqlite3SrcListAppend(A,B,C); ** ** Then C is the table name and B is the database name. */ -SrcList *sqliteSrcListAppend(SrcList *pList, Token *pTable, Token *pDatabase){ +SrcList *sqlite3SrcListAppend(SrcList *pList, Token *pTable, Token *pDatabase){ + struct SrcList_item *pItem; if( pList==0 ){ pList = sqliteMalloc( sizeof(SrcList) ); if( pList==0 ) return 0; @@ -1906,12 +2837,13 @@ SrcList *sqliteSrcListAppend(SrcList *pList, Token *pTable, Token *pDatabase){ pNew = sqliteRealloc(pList, sizeof(*pList) + (pList->nAlloc-1)*sizeof(pList->a[0]) ); if( pNew==0 ){ - sqliteSrcListDelete(pList); + sqlite3SrcListDelete(pList); return 0; } pList = pNew; } - memset(&pList->a[pList->nSrc], 0, sizeof(pList->a[0])); + pItem = &pList->a[pList->nSrc]; + memset(pItem, 0, sizeof(pList->a[0])); if( pDatabase && pDatabase->z==0 ){ pDatabase = 0; } @@ -1920,27 +2852,10 @@ SrcList *sqliteSrcListAppend(SrcList *pList, Token *pTable, Token *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; + pItem->zName = sqlite3NameFromToken(pTable); + pItem->zDatabase = sqlite3NameFromToken(pDatabase); + pItem->iCursor = -1; + pItem->isPopulated = 0; pList->nSrc++; return pList; } @@ -1948,11 +2863,17 @@ SrcList *sqliteSrcListAppend(SrcList *pList, Token *pTable, Token *pDatabase){ /* ** Assign cursors to all tables in a SrcList */ -void sqliteSrcListAssignCursors(Parse *pParse, SrcList *pList){ +void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){ int i; - for(i=0; inSrc; i++){ - if( pList->a[i].iCursor<0 ){ - pList->a[i].iCursor = pParse->nTab++; + struct SrcList_item *pItem; + assert(pList || sqlite3MallocFailed() ); + if( pList ){ + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pItem->iCursor>=0 ) break; + pItem->iCursor = pParse->nTab++; + if( pItem->pSelect ){ + sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc); + } } } } @@ -1960,56 +2881,27 @@ void sqliteSrcListAssignCursors(Parse *pParse, SrcList *pList){ /* ** Add an alias to the last identifier on the given identifier list. */ -void sqliteSrcListAddAlias(SrcList *pList, Token *pToken){ +void sqlite3SrcListAddAlias(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); + pList->a[pList->nSrc-1].zAlias = sqlite3NameFromToken(pToken); } } -/* -** 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){ +void sqlite3SrcListDelete(SrcList *pList){ int i; + struct SrcList_item *pItem; 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); + for(pItem=pList->a, i=0; inSrc; i++, pItem++){ + sqliteFree(pItem->zDatabase); + sqliteFree(pItem->zName); + sqliteFree(pItem->zAlias); + sqlite3DeleteTable(0, pItem->pTab); + sqlite3SelectDelete(pItem->pSelect); + sqlite3ExprDelete(pItem->pOn); + sqlite3IdListDelete(pItem->pUsing); } sqliteFree(pList); } @@ -2017,81 +2909,132 @@ void sqliteSrcListDelete(SrcList *pList){ /* ** Begin a transaction */ -void sqliteBeginTransaction(Parse *pParse, int onError){ - sqlite *db; +void sqlite3BeginTransaction(Parse *pParse, int type){ + sqlite3 *db; + Vdbe *v; + int i; 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; + if( pParse->nErr || sqlite3MallocFailed() ) return; + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ) return; + + v = sqlite3GetVdbe(pParse); + if( !v ) return; + if( type!=TK_DEFERRED ){ + for(i=0; inDb; i++){ + sqlite3VdbeAddOp(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1); + } } + sqlite3VdbeAddOp(v, OP_AutoCommit, 0, 0); } /* ** Commit a transaction */ -void sqliteCommitTransaction(Parse *pParse){ - sqlite *db; +void sqlite3CommitTransaction(Parse *pParse){ + sqlite3 *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, "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; + if( pParse->nErr || sqlite3MallocFailed() ) return; + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ) return; + + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp(v, OP_AutoCommit, 1, 0); } } /* ** Rollback a transaction */ -void sqliteRollbackTransaction(Parse *pParse){ - sqlite *db; +void sqlite3RollbackTransaction(Parse *pParse){ + sqlite3 *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( pParse->nErr || sqlite3MallocFailed() ) return; + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ) return; + + v = sqlite3GetVdbe(pParse); if( v ){ - sqliteVdbeAddOp(v, OP_Rollback, 0, 0); - } - if( !pParse->explain ){ - db->flags &= ~SQLITE_InTrans; - db->onError = OE_Default; + sqlite3VdbeAddOp(v, OP_AutoCommit, 1, 1); } } /* -** Generate VDBE code that will verify the schema cookie for all -** named database files. +** Make sure the TEMP database is open and available for use. Return +** the number of errors. Leave any error messages in the pParse structure. */ -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); +int sqlite3OpenTempDatabase(Parse *pParse){ + sqlite3 *db = pParse->db; + if( db->aDb[1].pBt==0 && !pParse->explain ){ + int rc = sqlite3BtreeFactory(db, 0, 0, MAX_PAGES, &db->aDb[1].pBt); + if( rc!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "unable to open a temporary database " + "file for storing temporary tables"); + pParse->rc = rc; + return 1; + } + if( db->flags & !db->autoCommit ){ + rc = sqlite3BtreeBeginTrans(db->aDb[1].pBt, 1); + if( rc!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "unable to get a write lock on " + "the temporary database file"); + pParse->rc = rc; + return 1; + } + } + assert( db->aDb[1].pSchema ); + } + return 0; +} + +/* +** Generate VDBE code that will verify the schema cookie and start +** a read-transaction for all named database files. +** +** It is important that all schema cookies be verified and all +** read transactions be started before anything else happens in +** the VDBE program. But this routine can be called after much other +** code has been generated. So here is what we do: +** +** The first time this routine is called, we code an OP_Goto that +** will jump to a subroutine at the end of the program. Then we +** record every database that needs its schema verified in the +** pParse->cookieMask field. Later, after all other code has been +** generated, the subroutine that does the cookie verifications and +** starts the transactions will be coded and the OP_Goto P2 value +** will be made to point to that subroutine. The generation of the +** cookie verification subroutine code happens in sqlite3FinishCoding(). +** +** If iDb<0 then code the OP_Goto only - don't set flag to verify the +** schema on any databases. This can be used to position the OP_Goto +** early in the code, before we know if any database tables will be used. +*/ +void sqlite3CodeVerifySchema(Parse *pParse, int iDb){ + sqlite3 *db; + Vdbe *v; + int mask; + + v = sqlite3GetVdbe(pParse); + if( v==0 ) return; /* This only happens if there was a prior error */ + db = pParse->db; + if( pParse->cookieGoto==0 ){ + pParse->cookieGoto = sqlite3VdbeAddOp(v, OP_Goto, 0, 0)+1; + } + if( iDb>=0 ){ + assert( iDbnDb ); + assert( db->aDb[iDb].pBt!=0 || iDb==1 ); + assert( iDbcookieMask & mask)==0 ){ + pParse->cookieMask |= mask; + pParse->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie; + if( !OMIT_TEMPDB && iDb==1 ){ + sqlite3OpenTempDatabase(pParse); + } + } } } @@ -2101,7 +3044,7 @@ void sqliteCodeVerifySchema(Parse *pParse, int iDb){ ** ** 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 +** is set if the setStatement parameter is true. A checkpoint should ** be set for operations that might fail (due to a constraint) part of ** the way through and which will need to undo some writes without having to ** rollback the whole transaction. For operations where all constraints @@ -2113,45 +3056,174 @@ void sqliteCodeVerifySchema(Parse *pParse, int iDb){ ** 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); +void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){ + Vdbe *v = sqlite3GetVdbe(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); + sqlite3CodeVerifySchema(pParse, iDb); + pParse->writeMask |= 1<nested==0 ){ + sqlite3VdbeAddOp(v, OP_Statement, iDb, 0); + } + if( (OMIT_TEMPDB || iDb!=1) && pParse->db->aDb[1].pBt!=0 ){ + sqlite3BeginWriteOperation(pParse, setStatement, 1); } } /* -** 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. +** Check to see if pIndex uses the collating sequence pColl. Return +** true if it does and false if it does not. */ -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); +#ifndef SQLITE_OMIT_REINDEX +static int collationMatch(const char *zColl, Index *pIndex){ + int i; + for(i=0; inColumn; i++){ + const char *z = pIndex->azColl[i]; + if( z==zColl || (z && zColl && 0==sqlite3StrICmp(z, zColl)) ){ + return 1; + } + } + return 0; +} +#endif + +/* +** Recompute all indices of pTab that use the collating sequence pColl. +** If pColl==0 then recompute all indices of pTab. +*/ +#ifndef SQLITE_OMIT_REINDEX +static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){ + Index *pIndex; /* An index associated with pTab */ + + for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){ + if( zColl==0 || collationMatch(zColl, pIndex) ){ + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3RefillIndex(pParse, pIndex, -1); + } } } +#endif + +/* +** Recompute all indices of all tables in all databases where the +** indices use the collating sequence pColl. If pColl==0 then recompute +** all indices everywhere. +*/ +#ifndef SQLITE_OMIT_REINDEX +static void reindexDatabases(Parse *pParse, char const *zColl){ + Db *pDb; /* A single database */ + int iDb; /* The database index number */ + sqlite3 *db = pParse->db; /* The database connection */ + HashElem *k; /* For looping over tables in pDb */ + Table *pTab; /* A table in the database */ + + for(iDb=0, pDb=db->aDb; iDbnDb; iDb++, pDb++){ + assert( pDb!=0 ); + for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){ + pTab = (Table*)sqliteHashData(k); + reindexTable(pParse, pTab, zColl); + } + } +} +#endif + +/* +** Generate code for the REINDEX command. +** +** REINDEX -- 1 +** REINDEX -- 2 +** REINDEX ?.? -- 3 +** REINDEX ?.? -- 4 +** +** Form 1 causes all indices in all attached databases to be rebuilt. +** Form 2 rebuilds all indices in all databases that use the named +** collating function. Forms 3 and 4 rebuild the named index or all +** indices associated with the named table. +*/ +#ifndef SQLITE_OMIT_REINDEX +void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){ + CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */ + char *z; /* Name of a table or index */ + const char *zDb; /* Name of the database */ + Table *pTab; /* A table in the database */ + Index *pIndex; /* An index associated with pTab */ + int iDb; /* The database index number */ + sqlite3 *db = pParse->db; /* The database connection */ + Token *pObjName; /* Name of the table or index to be reindexed */ + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return; + } + + if( pName1==0 || pName1->z==0 ){ + reindexDatabases(pParse, 0); + return; + }else if( pName2==0 || pName2->z==0 ){ + assert( pName1->z ); + pColl = sqlite3FindCollSeq(db, ENC(db), (char*)pName1->z, pName1->n, 0); + if( pColl ){ + char *zColl = sqliteStrNDup((const char *)pName1->z, pName1->n); + if( zColl ){ + reindexDatabases(pParse, zColl); + sqliteFree(zColl); + } + return; + } + } + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName); + if( iDb<0 ) return; + z = sqlite3NameFromToken(pObjName); + zDb = db->aDb[iDb].zName; + pTab = sqlite3FindTable(db, z, zDb); + if( pTab ){ + reindexTable(pParse, pTab, 0); + sqliteFree(z); + return; + } + pIndex = sqlite3FindIndex(db, z, zDb); + sqliteFree(z); + if( pIndex ){ + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3RefillIndex(pParse, pIndex, -1); + return; + } + sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed"); +} +#endif + +/* +** Return a dynamicly allocated KeyInfo structure that can be used +** with OP_OpenRead or OP_OpenWrite to access database index pIdx. +** +** If successful, a pointer to the new structure is returned. In this case +** the caller is responsible for calling sqliteFree() on the returned +** pointer. If an error occurs (out of memory or missing collation +** sequence), NULL is returned and the state of pParse updated to reflect +** the error. +*/ +KeyInfo *sqlite3IndexKeyinfo(Parse *pParse, Index *pIdx){ + int i; + int nCol = pIdx->nColumn; + int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol; + KeyInfo *pKey = (KeyInfo *)sqliteMalloc(nBytes); + + if( pKey ){ + pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]); + assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) ); + for(i=0; iazColl[i]; + assert( zColl ); + pKey->aColl[i] = sqlite3LocateCollSeq(pParse, zColl, -1); + pKey->aSortOrder[i] = pIdx->aSortOrder[i]; + } + pKey->nField = nCol; + } + + if( pParse->nErr ){ + sqliteFree(pKey); + pKey = 0; + } + return pKey; +} diff --git a/sqlite/callback.c b/sqlite/callback.c new file mode 100755 index 000000000..6327e81b4 --- /dev/null +++ b/sqlite/callback.c @@ -0,0 +1,367 @@ +/* +** 2005 May 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains functions used to access the internal hash tables +** of user defined functions and collation sequences. +** +** $Id: callback.c,v 1.1 2006-04-13 12:44:29 guy Exp $ +*/ + +#include "sqliteInt.h" + +/* +** Invoke the 'collation needed' callback to request a collation sequence +** in the database text encoding of name zName, length nName. +** If the collation sequence +*/ +static void callCollNeeded(sqlite3 *db, const char *zName, int nName){ + assert( !db->xCollNeeded || !db->xCollNeeded16 ); + if( nName<0 ) nName = strlen(zName); + if( db->xCollNeeded ){ + char *zExternal = sqliteStrNDup(zName, nName); + if( !zExternal ) return; + db->xCollNeeded(db->pCollNeededArg, db, (int)ENC(db), zExternal); + sqliteFree(zExternal); + } +#ifndef SQLITE_OMIT_UTF16 + if( db->xCollNeeded16 ){ + char const *zExternal; + sqlite3_value *pTmp = sqlite3ValueNew(); + sqlite3ValueSetStr(pTmp, nName, zName, SQLITE_UTF8, SQLITE_STATIC); + zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE); + if( zExternal ){ + db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal); + } + sqlite3ValueFree(pTmp); + } +#endif +} + +/* +** This routine is called if the collation factory fails to deliver a +** collation function in the best encoding but there may be other versions +** of this collation function (for other text encodings) available. Use one +** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if +** possible. +*/ +static int synthCollSeq(sqlite3 *db, CollSeq *pColl){ + CollSeq *pColl2; + char *z = pColl->zName; + int n = strlen(z); + int i; + static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 }; + for(i=0; i<3; i++){ + pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, n, 0); + if( pColl2->xCmp!=0 ){ + memcpy(pColl, pColl2, sizeof(CollSeq)); + return SQLITE_OK; + } + } + return SQLITE_ERROR; +} + +/* +** This function is responsible for invoking the collation factory callback +** or substituting a collation sequence of a different encoding when the +** requested collation sequence is not available in the database native +** encoding. +** +** If it is not NULL, then pColl must point to the database native encoding +** collation sequence with name zName, length nName. +** +** The return value is either the collation sequence to be used in database +** db for collation type name zName, length nName, or NULL, if no collation +** sequence can be found. +*/ +CollSeq *sqlite3GetCollSeq( + sqlite3* db, + CollSeq *pColl, + const char *zName, + int nName +){ + CollSeq *p; + + p = pColl; + if( !p ){ + p = sqlite3FindCollSeq(db, ENC(db), zName, nName, 0); + } + if( !p || !p->xCmp ){ + /* No collation sequence of this type for this encoding is registered. + ** Call the collation factory to see if it can supply us with one. + */ + callCollNeeded(db, zName, nName); + p = sqlite3FindCollSeq(db, ENC(db), zName, nName, 0); + } + if( p && !p->xCmp && synthCollSeq(db, p) ){ + p = 0; + } + assert( !p || p->xCmp ); + return p; +} + +/* +** This routine is called on a collation sequence before it is used to +** check that it is defined. An undefined collation sequence exists when +** a database is loaded that contains references to collation sequences +** that have not been defined by sqlite3_create_collation() etc. +** +** If required, this routine calls the 'collation needed' callback to +** request a definition of the collating sequence. If this doesn't work, +** an equivalent collating sequence that uses a text encoding different +** from the main database is substituted, if one is available. +*/ +int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){ + if( pColl ){ + const char *zName = pColl->zName; + CollSeq *p = sqlite3GetCollSeq(pParse->db, pColl, zName, -1); + if( !p ){ + if( pParse->nErr==0 ){ + sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName); + } + pParse->nErr++; + return SQLITE_ERROR; + } + assert( p==pColl ); + } + return SQLITE_OK; +} + + + +/* +** Locate and return an entry from the db.aCollSeq hash table. If the entry +** specified by zName and nName is not found and parameter 'create' is +** true, then create a new entry. Otherwise return NULL. +** +** Each pointer stored in the sqlite3.aCollSeq hash table contains an +** array of three CollSeq structures. The first is the collation sequence +** prefferred for UTF-8, the second UTF-16le, and the third UTF-16be. +** +** Stored immediately after the three collation sequences is a copy of +** the collation sequence name. A pointer to this string is stored in +** each collation sequence structure. +*/ +static CollSeq *findCollSeqEntry( + sqlite3 *db, + const char *zName, + int nName, + int create +){ + CollSeq *pColl; + if( nName<0 ) nName = strlen(zName); + pColl = sqlite3HashFind(&db->aCollSeq, zName, nName); + + if( 0==pColl && create ){ + pColl = sqliteMalloc( 3*sizeof(*pColl) + nName + 1 ); + if( pColl ){ + CollSeq *pDel = 0; + pColl[0].zName = (char*)&pColl[3]; + pColl[0].enc = SQLITE_UTF8; + pColl[1].zName = (char*)&pColl[3]; + pColl[1].enc = SQLITE_UTF16LE; + pColl[2].zName = (char*)&pColl[3]; + pColl[2].enc = SQLITE_UTF16BE; + memcpy(pColl[0].zName, zName, nName); + pColl[0].zName[nName] = 0; + pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl); + + /* If a malloc() failure occured in sqlite3HashInsert(), it will + ** return the pColl pointer to be deleted (because it wasn't added + ** to the hash table). + */ + assert( !pDel || (sqlite3MallocFailed() && pDel==pColl) ); + if( pDel ){ + sqliteFree(pDel); + pColl = 0; + } + } + } + return pColl; +} + +/* +** Parameter zName points to a UTF-8 encoded string nName bytes long. +** Return the CollSeq* pointer for the collation sequence named zName +** for the encoding 'enc' from the database 'db'. +** +** If the entry specified is not found and 'create' is true, then create a +** new entry. Otherwise return NULL. +*/ +CollSeq *sqlite3FindCollSeq( + sqlite3 *db, + u8 enc, + const char *zName, + int nName, + int create +){ + CollSeq *pColl; + if( zName ){ + pColl = findCollSeqEntry(db, zName, nName, create); + }else{ + pColl = db->pDfltColl; + } + assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE ); + if( pColl ) pColl += enc-1; + return pColl; +} + +/* +** Locate a user function given a name, a number of arguments and a flag +** indicating whether the function prefers UTF-16 over UTF-8. Return a +** pointer to the FuncDef structure that defines that function, or return +** NULL if the function does not exist. +** +** If the createFlag argument is true, then a new (blank) FuncDef +** structure is created and liked into the "db" structure if a +** no matching function previously existed. 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. +** +** If createFlag is false, then a function with the required name and +** number of arguments may be returned even if the eTextRep flag does not +** match that requested. +*/ +FuncDef *sqlite3FindFunction( + sqlite3 *db, /* An open database */ + const char *zName, /* Name of the function. Not null-terminated */ + int nName, /* Number of characters in the name */ + int nArg, /* Number of arguments. -1 means any number */ + u8 enc, /* Preferred text encoding */ + int createFlag /* Create new entry if true and does not otherwise exist */ +){ + FuncDef *p; /* Iterator variable */ + FuncDef *pFirst; /* First function with this name */ + FuncDef *pBest = 0; /* Best match found so far */ + int bestmatch = 0; + + + assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); + if( nArg<-1 ) nArg = -1; + + pFirst = (FuncDef*)sqlite3HashFind(&db->aFunc, zName, nName); + for(p=pFirst; p; p=p->pNext){ + /* During the search for the best function definition, bestmatch is set + ** as follows to indicate the quality of the match with the definition + ** pointed to by pBest: + ** + ** 0: pBest is NULL. No match has been found. + ** 1: A variable arguments function that prefers UTF-8 when a UTF-16 + ** encoding is requested, or vice versa. + ** 2: A variable arguments function that uses UTF-16BE when UTF-16LE is + ** requested, or vice versa. + ** 3: A variable arguments function using the same text encoding. + ** 4: A function with the exact number of arguments requested that + ** prefers UTF-8 when a UTF-16 encoding is requested, or vice versa. + ** 5: A function with the exact number of arguments requested that + ** prefers UTF-16LE when UTF-16BE is requested, or vice versa. + ** 6: An exact match. + ** + ** A larger value of 'matchqual' indicates a more desirable match. + */ + if( p->nArg==-1 || p->nArg==nArg || nArg==-1 ){ + int match = 1; /* Quality of this match */ + if( p->nArg==nArg || nArg==-1 ){ + match = 4; + } + if( enc==p->iPrefEnc ){ + match += 2; + } + else if( (enc==SQLITE_UTF16LE && p->iPrefEnc==SQLITE_UTF16BE) || + (enc==SQLITE_UTF16BE && p->iPrefEnc==SQLITE_UTF16LE) ){ + match += 1; + } + + if( match>bestmatch ){ + pBest = p; + bestmatch = match; + } + } + } + + /* If the createFlag parameter is true, and the seach did not reveal an + ** exact match for the name, number of arguments and encoding, then add a + ** new entry to the hash table and return it. + */ + if( createFlag && bestmatch<6 && + (pBest = sqliteMalloc(sizeof(*pBest)+nName))!=0 ){ + pBest->nArg = nArg; + pBest->pNext = pFirst; + pBest->iPrefEnc = enc; + memcpy(pBest->zName, zName, nName); + pBest->zName[nName] = 0; + if( pBest==sqlite3HashInsert(&db->aFunc,pBest->zName,nName,(void*)pBest) ){ + sqliteFree(pBest); + return 0; + } + } + + if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){ + return pBest; + } + return 0; +} + +/* +** Free all resources held by the schema structure. The void* argument points +** at a Schema struct. This function does not call sqliteFree() on the +** pointer itself, it just cleans up subsiduary resources (i.e. the contents +** of the schema hash tables). +*/ +void sqlite3SchemaFree(void *p){ + Hash temp1; + Hash temp2; + HashElem *pElem; + Schema *pSchema = (Schema *)p; + + temp1 = pSchema->tblHash; + temp2 = pSchema->trigHash; + sqlite3HashInit(&pSchema->trigHash, SQLITE_HASH_STRING, 0); + sqlite3HashClear(&pSchema->aFKey); + sqlite3HashClear(&pSchema->idxHash); + for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){ + sqlite3DeleteTrigger((Trigger*)sqliteHashData(pElem)); + } + sqlite3HashClear(&temp2); + sqlite3HashInit(&pSchema->tblHash, SQLITE_HASH_STRING, 0); + for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = sqliteHashData(pElem); + sqlite3DeleteTable(0, pTab); + } + sqlite3HashClear(&temp1); + pSchema->pSeqTab = 0; + pSchema->flags &= ~DB_SchemaLoaded; +} + +/* +** Find and return the schema associated with a BTree. Create +** a new one if necessary. +*/ +Schema *sqlite3SchemaGet(Btree *pBt){ + Schema * p; + if( pBt ){ + p = (Schema *)sqlite3BtreeSchema(pBt,sizeof(Schema),sqlite3SchemaFree); + }else{ + p = (Schema *)sqliteMalloc(sizeof(Schema)); + } + if( p && 0==p->file_format ){ + sqlite3HashInit(&p->tblHash, SQLITE_HASH_STRING, 0); + sqlite3HashInit(&p->idxHash, SQLITE_HASH_STRING, 0); + sqlite3HashInit(&p->trigHash, SQLITE_HASH_STRING, 0); + sqlite3HashInit(&p->aFKey, SQLITE_HASH_STRING, 1); + } + return p; +} diff --git a/sqlite/complete.c b/sqlite/complete.c new file mode 100755 index 000000000..6e0970c05 --- /dev/null +++ b/sqlite/complete.c @@ -0,0 +1,263 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** An tokenizer for SQL +** +** This file contains C code that implements the sqlite3_complete() API. +** This code used to be part of the tokenizer.c source file. But by +** separating it out, the code will be automatically omitted from +** static links that do not use it. +** +** $Id: complete.c,v 1.1 2006-04-13 12:44:29 guy Exp $ +*/ +#include "sqliteInt.h" +#ifndef SQLITE_OMIT_COMPLETE + +/* +** This is defined in tokenize.c. We just have to import the definition. +*/ +extern const char sqlite3IsIdChar[]; +#define IdChar(C) (((c=C)&0x80)!=0 || (c>0x1f && sqlite3IsIdChar[c-0x20])) + + +/* +** Token types used by the sqlite3_complete() routine. See the header +** comments on that procedure for additional information. +*/ +#define tkSEMI 0 +#define tkWS 1 +#define tkOTHER 2 +#define tkEXPLAIN 3 +#define tkCREATE 4 +#define tkTEMP 5 +#define tkTRIGGER 6 +#define tkEND 7 + +/* +** Return TRUE if the given SQL string ends in a semicolon. +** +** Special handling is require for CREATE TRIGGER statements. +** Whenever the CREATE TRIGGER keywords are seen, the statement +** must end with ";END;". +** +** This implementation uses a state machine with 7 states: +** +** (0) START At the beginning or end of an SQL statement. This routine +** returns 1 if it ends in the START state and 0 if it ends +** in any other state. +** +** (1) NORMAL We are in the middle of statement which ends with a single +** semicolon. +** +** (2) EXPLAIN The keyword EXPLAIN has been seen at the beginning of +** a statement. +** +** (3) CREATE The keyword CREATE has been seen at the beginning of a +** statement, possibly preceeded by EXPLAIN and/or followed by +** TEMP or TEMPORARY +** +** (4) TRIGGER We are in the middle of a trigger definition that must be +** ended by a semicolon, the keyword END, and another semicolon. +** +** (5) SEMI We've seen the first semicolon in the ";END;" that occurs at +** the end of a trigger definition. +** +** (6) END We've seen the ";END" of the ";END;" that occurs at the end +** of a trigger difinition. +** +** Transitions between states above are determined by tokens extracted +** from the input. The following tokens are significant: +** +** (0) tkSEMI A semicolon. +** (1) tkWS Whitespace +** (2) tkOTHER Any other SQL token. +** (3) tkEXPLAIN The "explain" keyword. +** (4) tkCREATE The "create" keyword. +** (5) tkTEMP The "temp" or "temporary" keyword. +** (6) tkTRIGGER The "trigger" keyword. +** (7) tkEND The "end" keyword. +** +** Whitespace never causes a state transition and is always ignored. +** +** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed +** to recognize the end of a trigger can be omitted. All we have to do +** is look for a semicolon that is not part of an string or comment. +*/ +int sqlite3_complete(const char *zSql){ + u8 state = 0; /* Current state, using numbers defined in header comment */ + u8 token; /* Value of the next token */ + +#ifndef SQLITE_OMIT_TRIGGER + /* A complex statement machine used to detect the end of a CREATE TRIGGER + ** statement. This is the normal case. + */ + static const u8 trans[7][8] = { + /* Token: */ + /* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */ + /* 0 START: */ { 0, 0, 1, 2, 3, 1, 1, 1, }, + /* 1 NORMAL: */ { 0, 1, 1, 1, 1, 1, 1, 1, }, + /* 2 EXPLAIN: */ { 0, 2, 1, 1, 3, 1, 1, 1, }, + /* 3 CREATE: */ { 0, 3, 1, 1, 1, 3, 4, 1, }, + /* 4 TRIGGER: */ { 5, 4, 4, 4, 4, 4, 4, 4, }, + /* 5 SEMI: */ { 5, 5, 4, 4, 4, 4, 4, 6, }, + /* 6 END: */ { 0, 6, 4, 4, 4, 4, 4, 4, }, + }; +#else + /* If triggers are not suppored by this compile then the statement machine + ** used to detect the end of a statement is much simplier + */ + static const u8 trans[2][3] = { + /* Token: */ + /* State: ** SEMI WS OTHER */ + /* 0 START: */ { 0, 0, 1, }, + /* 1 NORMAL: */ { 0, 1, 1, }, + }; +#endif /* SQLITE_OMIT_TRIGGER */ + + while( *zSql ){ + switch( *zSql ){ + case ';': { /* A semicolon */ + token = tkSEMI; + break; + } + case ' ': + case '\r': + case '\t': + case '\n': + case '\f': { /* White space is ignored */ + token = tkWS; + break; + } + case '/': { /* C-style comments */ + if( zSql[1]!='*' ){ + token = tkOTHER; + break; + } + zSql += 2; + while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; } + if( zSql[0]==0 ) return 0; + zSql++; + token = tkWS; + break; + } + case '-': { /* SQL-style comments from "--" to end of line */ + if( zSql[1]!='-' ){ + token = tkOTHER; + break; + } + while( *zSql && *zSql!='\n' ){ zSql++; } + if( *zSql==0 ) return state==0; + token = tkWS; + break; + } + case '[': { /* Microsoft-style identifiers in [...] */ + zSql++; + while( *zSql && *zSql!=']' ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + case '`': /* Grave-accent quoted symbols used by MySQL */ + case '"': /* single- and double-quoted strings */ + case '\'': { + int c = *zSql; + zSql++; + while( *zSql && *zSql!=c ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + default: { + int c; + if( IdChar((u8)*zSql) ){ + /* Keywords and unquoted identifiers */ + int nId; + for(nId=1; IdChar(zSql[nId]); nId++){} +#ifdef SQLITE_OMIT_TRIGGER + token = tkOTHER; +#else + switch( *zSql ){ + case 'c': case 'C': { + if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){ + token = tkCREATE; + }else{ + token = tkOTHER; + } + break; + } + case 't': case 'T': { + if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){ + token = tkTRIGGER; + }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){ + token = tkTEMP; + }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){ + token = tkTEMP; + }else{ + token = tkOTHER; + } + break; + } + case 'e': case 'E': { + if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){ + token = tkEND; + }else +#ifndef SQLITE_OMIT_EXPLAIN + if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){ + token = tkEXPLAIN; + }else +#endif + { + token = tkOTHER; + } + break; + } + default: { + token = tkOTHER; + break; + } + } +#endif /* SQLITE_OMIT_TRIGGER */ + zSql += nId-1; + }else{ + /* Operators and special symbols */ + token = tkOTHER; + } + break; + } + } + state = trans[state][token]; + zSql++; + } + return state==0; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** This routine is the same as the sqlite3_complete() routine described +** above, except that the parameter is required to be UTF-16 encoded, not +** UTF-8. +*/ +int sqlite3_complete16(const void *zSql){ + sqlite3_value *pVal; + char const *zSql8; + int rc = 0; + + pVal = sqlite3ValueNew(); + sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC); + zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8); + if( zSql8 ){ + rc = sqlite3_complete(zSql8); + } + sqlite3ValueFree(pVal); + return sqlite3ApiExit(0, rc); +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_OMIT_COMPLETE */ diff --git a/sqlite/config.h b/sqlite/config.h deleted file mode 100755 index 877f75ba5..000000000 --- a/sqlite/config.h +++ /dev/null @@ -1 +0,0 @@ -#define SQLITE_PTR_SZ 4 diff --git a/sqlite/copy.c b/sqlite/copy.c deleted file mode 100755 index 1795ebb23..000000000 --- a/sqlite/copy.c +++ /dev/null @@ -1,110 +0,0 @@ -/* -** 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: copy.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ -*/ -#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; -} diff --git a/sqlite/date.c b/sqlite/date.c index ac3fc1297..f55d5d6a8 100755 --- a/sqlite/date.c +++ b/sqlite/date.c @@ -13,10 +13,10 @@ ** functions for SQLite. ** ** There is only one exported symbol in this file - the function -** sqliteRegisterDateTimeFunctions() found at the bottom of the file. +** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. ** All other code has file scope. ** -** $Id: date.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** $Id: date.c,v 1.2 2006-04-13 12:44:29 guy Exp $ ** ** NOTES: ** @@ -47,8 +47,8 @@ ** Willmann-Bell, Inc ** Richmond, Virginia (USA) */ -#include "os.h" #include "sqliteInt.h" +#include "os.h" #include #include #include @@ -104,19 +104,21 @@ static int getDigits(const char *zDate, ...){ pVal = va_arg(ap, int*); val = 0; while( N-- ){ - if( !isdigit(*zDate) ){ - return cnt; + if( !isdigit(*(u8*)zDate) ){ + goto end_getDigits; } val = val*10 + *zDate - '0'; zDate++; } if( valmax || (nextC!=0 && nextC!=*zDate) ){ - return cnt; + goto end_getDigits; } *pVal = val; zDate++; cnt++; }while( nextC ); +end_getDigits: + va_end(ap); return cnt; } @@ -124,11 +126,7 @@ static int getDigits(const char *zDate, ...){ ** 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; -} +#define getValue sqlite3AtoF /* ** Parse a timezone extension on the end of a date-time. @@ -145,7 +143,7 @@ static int getValue(const char *z, double *pR){ static int parseTimezone(const char *zDate, DateTime *p){ int sgn = 0; int nHr, nMn; - while( isspace(*zDate) ){ zDate++; } + while( isspace(*(u8*)zDate) ){ zDate++; } p->tz = 0; if( *zDate=='-' ){ sgn = -1; @@ -160,7 +158,7 @@ static int parseTimezone(const char *zDate, DateTime *p){ } zDate += 5; p->tz = sgn*(nMn + nHr*60); - while( isspace(*zDate) ){ zDate++; } + while( isspace(*(u8*)zDate) ){ zDate++; } return *zDate!=0; } @@ -184,10 +182,10 @@ static int parseHhMmSs(const char *zDate, DateTime *p){ return 1; } zDate += 2; - if( *zDate=='.' && isdigit(zDate[1]) ){ + if( *zDate=='.' && isdigit((u8)zDate[1]) ){ double rScale = 1.0; zDate++; - while( isdigit(*zDate) ){ + while( isdigit(*(u8*)zDate) ){ ms = ms*10.0 + *zDate - '0'; rScale *= 10.0; zDate++; @@ -240,7 +238,7 @@ static void computeJD(DateTime *p){ 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->rJD -= p->tz*60/86400.0; p->validHMS = 0; p->validTZ = 0; } @@ -272,7 +270,7 @@ static int parseYyyyMmDd(const char *zDate, DateTime *p){ return 1; } zDate += 10; - while( isspace(*zDate) ){ zDate++; } + while( isspace(*(u8*)zDate) || 'T'==*(u8*)zDate ){ zDate++; } if( parseHhMmSs(zDate, p)==0 ){ /* We got the time */ }else if( *zDate==0 ){ @@ -313,16 +311,14 @@ static int parseDateOrTime(const char *zDate, DateTime *p){ return 0; }else if( parseHhMmSs(zDate, p)==0 ){ return 0; - }else if( sqliteStrICmp(zDate,"now")==0){ + }else if( sqlite3StrICmp(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); + sqlite3OsCurrentTime(&r); + p->rJD = r; + p->validJD = 1; + return 0; + }else if( sqlite3IsNumber(zDate, 0, SQLITE_UTF8) ){ + getValue(zDate, &p->rJD); p->validJD = 1; return 0; } @@ -415,7 +411,7 @@ static double localtimeOffset(DateTime *p){ x.validJD = 0; computeJD(&x); t = (x.rJD-2440587.5)*86400.0 + 0.5; - sqliteOsEnterMutex(); + sqlite3OsEnterMutex(); pTm = localtime(&t); y.Y = pTm->tm_year + 1900; y.M = pTm->tm_mon + 1; @@ -423,7 +419,7 @@ static double localtimeOffset(DateTime *p){ y.h = pTm->tm_hour; y.m = pTm->tm_min; y.s = pTm->tm_sec; - sqliteOsLeaveMutex(); + sqlite3OsLeaveMutex(); y.validYMD = 1; y.validHMS = 1; y.validJD = 0; @@ -504,7 +500,7 @@ static int parseModifier(const char *zMod, DateTime *p){ /* ** weekday N ** - ** Move the date to the same time on the next occurrance of + ** Move the date to the same time on the next occurrence of ** weekday N where 0==Sunday, 1==Monday, and so forth. If the ** date is already on the appropriate weekday, this is a no-op. */ @@ -575,7 +571,7 @@ static int parseModifier(const char *zMod, DateTime *p){ const char *z2 = z; DateTime tx; int day; - if( !isdigit(*z2) ) z2++; + if( !isdigit(*(u8*)z2) ) z2++; memset(&tx, 0, sizeof(tx)); if( parseHhMmSs(z2, &tx) ) break; computeJD(&tx); @@ -590,7 +586,7 @@ static int parseModifier(const char *zMod, DateTime *p){ break; } z += n; - while( isspace(z[0]) ) z++; + while( isspace(*(u8*)z) ) z++; n = strlen(z); if( n>10 || n<3 ) break; if( z[n-1]=='s' ){ z[n-1] = 0; n--; } @@ -641,12 +637,14 @@ static int parseModifier(const char *zMod, DateTime *p){ ** 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){ +static int isDate(int argc, sqlite3_value **argv, DateTime *p){ int i; if( argc==0 ) return 1; - if( argv[0]==0 || parseDateOrTime(argv[0], p) ) return 1; + if( SQLITE_NULL==sqlite3_value_type(argv[0]) || + parseDateOrTime((char*)sqlite3_value_text(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 *sqlite3SrcListLookup(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; + struct SrcList_item *pItem; + for(i=0, pItem=pSrc->a; inSrc; i++, pItem++){ + pTab = sqlite3LocateTable(pParse, pItem->zName, pItem->zDatabase); + sqlite3DeleteTable(pParse->db, pItem->pTab); + pItem->pTab = pTab; + if( pTab ){ + pTab->nRef++; + } } return pTab; } @@ -38,22 +41,49 @@ Table *sqliteSrcListLookup(Parse *pParse, SrcList *pSrc){ ** 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); +int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){ + if( pTab->readOnly && (pParse->db->flags & SQLITE_WriteSchema)==0 + && pParse->nested==0 ){ + sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName); return 1; } +#ifndef SQLITE_OMIT_VIEW if( !viewOk && pTab->pSelect ){ - sqliteErrorMsg(pParse, "cannot modify %s because it is a view",pTab->zName); + sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName); return 1; } +#endif return 0; } /* -** Process a DELETE FROM statement. +** Generate code that will open a table for reading. */ -void sqliteDeleteFrom( +void sqlite3OpenTable( + Parse *p, /* Generate code into this VDBE */ + int iCur, /* The cursor number of the table */ + int iDb, /* The database index in sqlite3.aDb[] */ + Table *pTab, /* The table to be opened */ + int opcode /* OP_OpenRead or OP_OpenWrite */ +){ + Vdbe *v = sqlite3GetVdbe(p); + assert( opcode==OP_OpenWrite || opcode==OP_OpenRead ); + sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite), pTab->zName); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + VdbeComment((v, "# %s", pTab->zName)); + sqlite3VdbeAddOp(v, opcode, iCur, pTab->tnum); + sqlite3VdbeAddOp(v, OP_SetNumColumns, iCur, pTab->nCol); +} + + +/* +** Generate code for a DELETE FROM statement. +** +** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL; +** \________/ \________________/ +** pTabList pWhere +*/ +void sqlite3DeleteFrom( Parse *pParse, /* The parser context */ SrcList *pTabList, /* The table from which we should delete things */ Expr *pWhere /* The WHERE clause. May be null */ @@ -61,23 +91,24 @@ void sqliteDeleteFrom( 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 end, addr = 0; /* 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 */ + sqlite3 *db; /* Main database structure */ AuthContext sContext; /* Authorization context */ + int oldIdx = -1; /* Cursor for the OLD table of AFTER triggers */ + NameContext sNC; /* Name context to resolve expressions in */ + int iDb; - 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 */ +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True if attempting to delete from a view */ + int triggers_exist = 0; /* True if any triggers exist */ +#endif sContext.pParse = 0; - if( pParse->nErr || sqlite_malloc_failed ){ - pTabList = 0; + if( pParse->nErr || sqlite3MallocFailed() ){ goto delete_from_cleanup; } db = pParse->db; @@ -88,102 +119,115 @@ void sqliteDeleteFrom( ** 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); + pTab = sqlite3SrcListLookup(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; + + /* Figure out if we have any triggers and if the table being + ** deleted from is a view + */ +#ifndef SQLITE_OMIT_TRIGGER + triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0); isView = pTab->pSelect!=0; - if( sqliteIsReadOnly(pParse, pTab, before_triggers) ){ +#else +# define triggers_exist 0 +# define isView 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + + if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){ goto delete_from_cleanup; } - assert( pTab->iDbnDb ); - zDb = db->aDb[pTab->iDb].zName; - if( sqliteAuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){ + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDbnDb ); + zDb = db->aDb[iDb].zName; + if( sqlite3AuthCheck(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) ){ + if( isView && sqlite3ViewGetColumnNames(pParse, pTab) ){ goto delete_from_cleanup; } /* Allocate a cursor used to store the old.* data for a trigger. */ - if( row_triggers_exist ){ + if( triggers_exist ){ oldIdx = pParse->nTab++; } - /* Resolve the column names in all the expressions. + /* Resolve the column names in the WHERE clause. */ 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; - } + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + if( sqlite3ExprResolveNames(&sNC, pWhere) ){ + goto delete_from_cleanup; } /* Start the view context */ if( isView ){ - sqliteAuthContextPush(pParse, &sContext, pTab->zName); + sqlite3AuthContextPush(pParse, &sContext, pTab->zName); } /* Begin generating code. */ - v = sqliteGetVdbe(pParse); + v = sqlite3GetVdbe(pParse); if( v==0 ){ goto delete_from_cleanup; } - sqliteBeginWriteOperation(pParse, row_triggers_exist, pTab->iDb); + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, triggers_exist, iDb); - /* If we are trying to delete from a view, construct that view into - ** a temporary table. + /* If we are trying to delete from a view, realize that view into + ** a ephemeral table. */ if( isView ){ - Select *pView = sqliteSelectDup(pTab->pSelect); - sqliteSelect(pParse, pView, SRT_TempTable, iCur, 0, 0, 0); - sqliteSelectDelete(pView); + Select *pView = sqlite3SelectDup(pTab->pSelect); + sqlite3Select(pParse, pView, SRT_VirtualTab, iCur, 0, 0, 0, 0); + sqlite3SelectDelete(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); + sqlite3VdbeAddOp(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( pWhere==0 && !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; + int endOfLoop = sqlite3VdbeMakeLabel(v); + int addr2; if( !isView ){ - sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); - sqliteVdbeAddOp(v, OP_OpenRead, iCur, pTab->tnum); + sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead); } - 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); + sqlite3VdbeAddOp(v, OP_Rewind, iCur, sqlite3VdbeCurrentAddr(v)+2); + addr2 = sqlite3VdbeAddOp(v, OP_AddImm, 1, 0); + sqlite3VdbeAddOp(v, OP_Next, iCur, addr2); + sqlite3VdbeResolveLabel(v, endOfLoop); + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); } if( !isView ){ - sqliteVdbeAddOp(v, OP_Clear, pTab->tnum, pTab->iDb); + sqlite3VdbeAddOp(v, OP_Clear, pTab->tnum, iDb); + if( !pParse->nested ){ + sqlite3VdbeChangeP3(v, -1, pTab->zName, P3_STATIC); + } for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ - sqliteVdbeAddOp(v, OP_Clear, pIdx->tnum, pIdx->iDb); + assert( pIdx->pSchema==pTab->pSchema ); + sqlite3VdbeAddOp(v, OP_Clear, pIdx->tnum, iDb); } } } @@ -194,122 +238,118 @@ void sqliteDeleteFrom( else{ /* Begin the database scan */ - pWInfo = sqliteWhereBegin(pParse, pTabList, pWhere, 1, 0); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0); if( pWInfo==0 ) goto delete_from_cleanup; - /* Remember the key of every item to be deleted. + /* Remember the rowid of every item to be deleted. */ - sqliteVdbeAddOp(v, OP_ListWrite, 0, 0); + sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0); + sqlite3VdbeAddOp(v, OP_FifoWrite, 0, 0); if( db->flags & SQLITE_CountRows ){ - sqliteVdbeAddOp(v, OP_AddImm, 1, 0); + sqlite3VdbeAddOp(v, OP_AddImm, 1, 0); } /* End the database scan loop. */ - sqliteWhereEnd(pWInfo); + sqlite3WhereEnd(pWInfo); /* Open the pseudo-table used to store OLD if there are triggers. */ - if( row_triggers_exist ){ - sqliteVdbeAddOp(v, OP_OpenPseudo, oldIdx, 0); + if( triggers_exist ){ + sqlite3VdbeAddOp(v, OP_OpenPseudo, oldIdx, 0); + sqlite3VdbeAddOp(v, OP_SetNumColumns, oldIdx, pTab->nCol); } /* 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); + end = sqlite3VdbeMakeLabel(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( triggers_exist ){ + addr = sqlite3VdbeAddOp(v, OP_FifoRead, 0, end); if( !isView ){ - sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); - sqliteVdbeAddOp(v, OP_OpenRead, iCur, pTab->tnum); + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead); } - sqliteVdbeAddOp(v, OP_MoveTo, iCur, 0); - - sqliteVdbeAddOp(v, OP_Recno, iCur, 0); - sqliteVdbeAddOp(v, OP_RowData, iCur, 0); - sqliteVdbeAddOp(v, OP_PutIntKey, oldIdx, 0); + sqlite3VdbeAddOp(v, OP_MoveGe, iCur, 0); + sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0); + sqlite3VdbeAddOp(v, OP_RowData, iCur, 0); + sqlite3VdbeAddOp(v, OP_Insert, oldIdx, 0); if( !isView ){ - sqliteVdbeAddOp(v, OP_Close, iCur, 0); + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); } - sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_BEFORE, pTab, -1, - oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default, - addr); + (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_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 + ** OP_FifoRead 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); + sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite); /* 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); + if( !triggers_exist ){ + addr = sqlite3VdbeAddOp(v, OP_FifoRead, 0, end); } /* Delete the row */ - sqliteGenerateRowDelete(db, v, pTab, iCur, pParse->trigStack==0); + sqlite3GenerateRowDelete(db, v, pTab, iCur, pParse->nested==0); } /* If there are row triggers, close all cursors then invoke ** the AFTER triggers */ - if( row_triggers_exist ){ + if( triggers_exist ){ if( !isView ){ for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ - sqliteVdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum); + sqlite3VdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum); } - sqliteVdbeAddOp(v, OP_Close, iCur, 0); + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); } - sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_AFTER, pTab, -1, + (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_AFTER, pTab, -1, oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default, - addr); + addr); } /* End of the delete loop */ - sqliteVdbeAddOp(v, OP_Goto, 0, addr); - sqliteVdbeResolveLabel(v, end); - sqliteVdbeAddOp(v, OP_ListReset, 0, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, addr); + sqlite3VdbeResolveLabel(v, end); /* Close the cursors after the loop if there are no row triggers */ - if( !row_triggers_exist ){ + if( !triggers_exist ){ for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ - sqliteVdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum); + sqlite3VdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum); } - sqliteVdbeAddOp(v, OP_Close, iCur, 0); - pParse->nTab = iCur; + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); } } - sqliteVdbeAddOp(v, OP_SetCounts, 0, 0); - sqliteEndWriteOperation(pParse); /* - ** Return the number of rows that were deleted. + ** Return the number of rows that were deleted. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. */ - if( db->flags & SQLITE_CountRows ){ - sqliteVdbeAddOp(v, OP_ColumnName, 0, 1); - sqliteVdbeChangeP3(v, -1, "rows deleted", P3_STATIC); - sqliteVdbeAddOp(v, OP_Callback, 1, 0); + if( db->flags & SQLITE_CountRows && pParse->nested==0 && !pParse->trigStack ){ + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", P3_STATIC); } delete_from_cleanup: - sqliteAuthContextPop(&sContext); - sqliteSrcListDelete(pTabList); - sqliteExprDelete(pWhere); + sqlite3AuthContextPop(&sContext); + sqlite3SrcListDelete(pTabList); + sqlite3ExprDelete(pWhere); return; } @@ -333,19 +373,21 @@ delete_from_cleanup: ** 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 */ +void sqlite3GenerateRowDelete( + sqlite3 *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)); + addr = sqlite3VdbeAddOp(v, OP_NotExists, iCur, 0); + sqlite3GenerateRowIndexDelete(v, pTab, iCur, 0); + sqlite3VdbeAddOp(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0)); + if( count ){ + sqlite3VdbeChangeP3(v, -1, pTab->zName, P3_STATIC); + } + sqlite3VdbeJumpHere(v, addr); } /* @@ -364,8 +406,7 @@ void sqliteGenerateRowDelete( ** 3. The "iCur" cursor must be pointing to the row that is to be ** deleted. */ -void sqliteGenerateRowIndexDelete( - sqlite *db, /* The database containing the index */ +void sqlite3GenerateRowIndexDelete( Vdbe *v, /* Generate code into this VDBE */ Table *pTab, /* Table containing the row to be deleted */ int iCur, /* Cursor number for the table */ @@ -375,19 +416,36 @@ void sqliteGenerateRowIndexDelete( 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); + sqlite3GenerateIndexKey(v, pIdx, iCur); + sqlite3VdbeAddOp(v, OP_IdxDelete, iCur+i, 0); } } + +/* +** Generate code that will assemble an index key and put it on the top +** of the tack. The key with be for index pIdx which is an index on pTab. +** iCur is the index of a cursor open on the pTab table and pointing to +** the entry that needs indexing. +*/ +void sqlite3GenerateIndexKey( + Vdbe *v, /* Generate code into this VDBE */ + Index *pIdx, /* The index for which to generate a key */ + int iCur /* Cursor number for the pIdx->pTable table */ +){ + int j; + Table *pTab = pIdx->pTable; + + sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0); + for(j=0; jnColumn; j++){ + int idx = pIdx->aiColumn[j]; + if( idx==pTab->iPKey ){ + sqlite3VdbeAddOp(v, OP_Dup, j, 0); + }else{ + sqlite3VdbeAddOp(v, OP_Column, iCur, idx); + sqlite3ColumnDefault(v, pTab, idx); + } + } + sqlite3VdbeAddOp(v, OP_MakeIdxRec, pIdx->nColumn, 0); + sqlite3IndexAffinityStr(v, pIdx); +} diff --git a/sqlite/expr.c b/sqlite/expr.c index d56d4e44e..10db6c6fc 100755 --- a/sqlite/expr.c +++ b/sqlite/expr.c @@ -12,55 +12,262 @@ ** This file contains routines used for analyzing expressions and ** for generating VDBE code that evaluates expressions in SQLite. ** -** $Id: expr.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** $Id: expr.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #include "sqliteInt.h" #include +/* +** Return the 'affinity' of the expression pExpr if any. +** +** If pExpr is a column, a reference to a column via an 'AS' alias, +** or a sub-select with a column as the return value, then the +** affinity of that column is returned. Otherwise, 0x00 is returned, +** indicating no affinity for the expression. +** +** i.e. the WHERE clause expresssions in the following statements all +** have an affinity: +** +** CREATE TABLE t1(a); +** SELECT * FROM t1 WHERE a; +** SELECT a AS b FROM t1 WHERE b; +** SELECT * FROM t1 WHERE (select a from t1); +*/ +char sqlite3ExprAffinity(Expr *pExpr){ + int op = pExpr->op; + if( op==TK_AS ){ + return sqlite3ExprAffinity(pExpr->pLeft); + } + if( op==TK_SELECT ){ + return sqlite3ExprAffinity(pExpr->pSelect->pEList->a[0].pExpr); + } +#ifndef SQLITE_OMIT_CAST + if( op==TK_CAST ){ + return sqlite3AffinityType(&pExpr->token); + } +#endif + return pExpr->affinity; +} + +/* +** Return the default collation sequence for the expression pExpr. If +** there is no default collation type, return 0. +*/ +CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){ + CollSeq *pColl = 0; + if( pExpr ){ + pColl = pExpr->pColl; + if( (pExpr->op==TK_AS || pExpr->op==TK_CAST) && !pColl ){ + return sqlite3ExprCollSeq(pParse, pExpr->pLeft); + } + } + if( sqlite3CheckCollSeq(pParse, pColl) ){ + pColl = 0; + } + return pColl; +} + +/* +** pExpr is an operand of a comparison operator. aff2 is the +** type affinity of the other operand. This routine returns the +** type affinity that should be used for the comparison operator. +*/ +char sqlite3CompareAffinity(Expr *pExpr, char aff2){ + char aff1 = sqlite3ExprAffinity(pExpr); + if( aff1 && aff2 ){ + /* Both sides of the comparison are columns. If one has numeric + ** affinity, use that. Otherwise use no affinity. + */ + if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){ + return SQLITE_AFF_NUMERIC; + }else{ + return SQLITE_AFF_NONE; + } + }else if( !aff1 && !aff2 ){ + /* Neither side of the comparison is a column. Compare the + ** results directly. + */ + return SQLITE_AFF_NONE; + }else{ + /* One side is a column, the other is not. Use the columns affinity. */ + assert( aff1==0 || aff2==0 ); + return (aff1 + aff2); + } +} + +/* +** pExpr is a comparison operator. Return the type affinity that should +** be applied to both operands prior to doing the comparison. +*/ +static char comparisonAffinity(Expr *pExpr){ + char aff; + assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT || + pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE || + pExpr->op==TK_NE ); + assert( pExpr->pLeft ); + aff = sqlite3ExprAffinity(pExpr->pLeft); + if( pExpr->pRight ){ + aff = sqlite3CompareAffinity(pExpr->pRight, aff); + } + else if( pExpr->pSelect ){ + aff = sqlite3CompareAffinity(pExpr->pSelect->pEList->a[0].pExpr, aff); + } + else if( !aff ){ + aff = SQLITE_AFF_NUMERIC; + } + return aff; +} + +/* +** pExpr is a comparison expression, eg. '=', '<', IN(...) etc. +** idx_affinity is the affinity of an indexed column. Return true +** if the index with affinity idx_affinity may be used to implement +** the comparison in pExpr. +*/ +int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){ + char aff = comparisonAffinity(pExpr); + switch( aff ){ + case SQLITE_AFF_NONE: + return 1; + case SQLITE_AFF_TEXT: + return idx_affinity==SQLITE_AFF_TEXT; + default: + return sqlite3IsNumericAffinity(idx_affinity); + } +} + +/* +** Return the P1 value that should be used for a binary comparison +** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2. +** If jumpIfNull is true, then set the low byte of the returned +** P1 value to tell the opcode to jump if either expression +** evaluates to NULL. +*/ +static int binaryCompareP1(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){ + char aff = sqlite3ExprAffinity(pExpr2); + return ((int)sqlite3CompareAffinity(pExpr1, aff))+(jumpIfNull?0x100:0); +} + +/* +** Return a pointer to the collation sequence that should be used by +** a binary comparison operator comparing pLeft and pRight. +** +** If the left hand expression has a collating sequence type, then it is +** used. Otherwise the collation sequence for the right hand expression +** is used, or the default (BINARY) if neither expression has a collating +** type. +*/ +static CollSeq* binaryCompareCollSeq(Parse *pParse, Expr *pLeft, Expr *pRight){ + CollSeq *pColl = sqlite3ExprCollSeq(pParse, pLeft); + if( !pColl ){ + pColl = sqlite3ExprCollSeq(pParse, pRight); + } + return pColl; +} + +/* +** Generate code for a comparison operator. +*/ +static int codeCompare( + Parse *pParse, /* The parsing (and code generating) context */ + Expr *pLeft, /* The left operand */ + Expr *pRight, /* The right operand */ + int opcode, /* The comparison opcode */ + int dest, /* Jump here if true. */ + int jumpIfNull /* If true, jump if either operand is NULL */ +){ + int p1 = binaryCompareP1(pLeft, pRight, jumpIfNull); + CollSeq *p3 = binaryCompareCollSeq(pParse, pLeft, pRight); + return sqlite3VdbeOp3(pParse->pVdbe, opcode, p1, dest, (void*)p3, P3_COLLSEQ); +} + /* ** 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 *sqlite3Expr(int op, Expr *pLeft, Expr *pRight, const Token *pToken){ Expr *pNew; pNew = sqliteMalloc( sizeof(Expr) ); if( pNew==0 ){ - /* When malloc fails, we leak memory from pLeft and pRight */ + /* When malloc fails, delete pLeft and pRight. Expressions passed to + ** this function must always be allocated with sqlite3Expr() for this + ** reason. + */ + sqlite3ExprDelete(pLeft); + sqlite3ExprDelete(pRight); return 0; } pNew->op = op; pNew->pLeft = pLeft; pNew->pRight = pRight; + pNew->iAgg = -1; 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; - } + pNew->span = pNew->token = *pToken; + }else if( pLeft && pRight ){ + sqlite3ExprSpan(pNew, &pLeft->span, &pRight->span); } return pNew; } +/* +** When doing a nested parse, you can include terms in an expression +** that look like this: #0 #1 #2 ... These terms refer to elements +** on the stack. "#0" means the top of the stack. +** "#1" means the next down on the stack. And so forth. +** +** This routine is called by the parser to deal with on of those terms. +** It immediately generates code to store the value in a memory location. +** The returns an expression that will code to extract the value from +** that memory location as needed. +*/ +Expr *sqlite3RegisterExpr(Parse *pParse, Token *pToken){ + Vdbe *v = pParse->pVdbe; + Expr *p; + int depth; + if( pParse->nested==0 ){ + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", pToken); + return 0; + } + if( v==0 ) return 0; + p = sqlite3Expr(TK_REGISTER, 0, 0, pToken); + if( p==0 ){ + return 0; /* Malloc failed */ + } + depth = atoi((char*)&pToken->z[1]); + p->iTable = pParse->nMem++; + sqlite3VdbeAddOp(v, OP_Dup, depth, 0); + sqlite3VdbeAddOp(v, OP_MemStore, p->iTable, 1); + return p; +} + +/* +** Join two expressions using an AND operator. If either expression is +** NULL, then just return the other expression. +*/ +Expr *sqlite3ExprAnd(Expr *pLeft, Expr *pRight){ + if( pLeft==0 ){ + return pRight; + }else if( pRight==0 ){ + return pLeft; + }else{ + return sqlite3Expr(TK_AND, pLeft, pRight, 0); + } +} + /* ** 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){ +void sqlite3ExprSpan(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( !sqlite3MallocFailed() && pRight->z && pLeft->z ){ + assert( pLeft->dyn==0 || pLeft->z[pLeft->n]==0 ); if( pLeft->dyn==0 && pRight->dyn==0 ){ pExpr->span.z = pLeft->z; - pExpr->span.n = pRight->n + Addr(pRight->z) - Addr(pLeft->z); + pExpr->span.n = pRight->n + (pRight->z - pLeft->z); }else{ pExpr->span.z = 0; } @@ -71,39 +278,120 @@ void sqliteExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){ ** Construct a new expression node for a function with multiple ** arguments. */ -Expr *sqliteExprFunction(ExprList *pList, Token *pToken){ +Expr *sqlite3ExprFunction(ExprList *pList, Token *pToken){ Expr *pNew; + assert( pToken ); pNew = sqliteMalloc( sizeof(Expr) ); if( pNew==0 ){ - /* sqliteExprListDelete(pList); // Leak pList when malloc fails */ + sqlite3ExprListDelete(pList); /* Avoid leaking memory 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; - } + assert( pToken->dyn==0 ); + pNew->token = *pToken; pNew->span = pNew->token; return pNew; } +/* +** Assign a variable number to an expression that encodes a wildcard +** in the original SQL statement. +** +** Wildcards consisting of a single "?" are assigned the next sequential +** variable number. +** +** Wildcards of the form "?nnn" are assigned the number "nnn". We make +** sure "nnn" is not too be to avoid a denial of service attack when +** the SQL statement comes from an external source. +** +** Wildcards of the form ":aaa" or "$aaa" are assigned the same number +** as the previous instance of the same wildcard. Or if this is the first +** instance of the wildcard, the next sequenial variable number is +** assigned. +*/ +void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){ + Token *pToken; + if( pExpr==0 ) return; + pToken = &pExpr->token; + assert( pToken->n>=1 ); + assert( pToken->z!=0 ); + assert( pToken->z[0]!=0 ); + if( pToken->n==1 ){ + /* Wildcard of the form "?". Assign the next variable number */ + pExpr->iTable = ++pParse->nVar; + }else if( pToken->z[0]=='?' ){ + /* Wildcard of the form "?nnn". Convert "nnn" to an integer and + ** use it as the variable number */ + int i; + pExpr->iTable = i = atoi((char*)&pToken->z[1]); + if( i<1 || i>SQLITE_MAX_VARIABLE_NUMBER ){ + sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d", + SQLITE_MAX_VARIABLE_NUMBER); + } + if( i>pParse->nVar ){ + pParse->nVar = i; + } + }else{ + /* Wildcards of the form ":aaa" or "$aaa". Reuse the same variable + ** number as the prior appearance of the same name, or if the name + ** has never appeared before, reuse the same variable number + */ + int i, n; + n = pToken->n; + for(i=0; inVarExpr; i++){ + Expr *pE; + if( (pE = pParse->apVarExpr[i])!=0 + && pE->token.n==n + && memcmp(pE->token.z, pToken->z, n)==0 ){ + pExpr->iTable = pE->iTable; + break; + } + } + if( i>=pParse->nVarExpr ){ + pExpr->iTable = ++pParse->nVar; + if( pParse->nVarExpr>=pParse->nVarExprAlloc-1 ){ + pParse->nVarExprAlloc += pParse->nVarExprAlloc + 10; + sqliteReallocOrFree((void**)&pParse->apVarExpr, + pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0]) ); + } + if( !sqlite3MallocFailed() ){ + assert( pParse->apVarExpr!=0 ); + pParse->apVarExpr[pParse->nVarExpr++] = pExpr; + } + } + } +} + /* ** Recursively delete an expression tree. */ -void sqliteExprDelete(Expr *p){ +void sqlite3ExprDelete(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); + sqlite3ExprDelete(p->pLeft); + sqlite3ExprDelete(p->pRight); + sqlite3ExprListDelete(p->pList); + sqlite3SelectDelete(p->pSelect); sqliteFree(p); } +/* +** The Expr.token field might be a string literal that is quoted. +** If so, remove the quotation marks. +*/ +void sqlite3DequoteExpr(Expr *p){ + if( ExprHasAnyProperty(p, EP_Dequoted) ){ + return; + } + ExprSetProperty(p, EP_Dequoted); + if( p->token.dyn==0 ){ + sqlite3TokenCopy(&p->token, &p->token); + } + sqlite3Dequote((char*)p->token.z); +} + /* ** The following group of routines make deep copies of expressions, @@ -111,69 +399,85 @@ void sqliteExprDelete(Expr *p){ ** 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 +** The expression list, ID, and source lists return by sqlite3ExprListDup(), +** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded ** by subsequent calls to sqlite*ListAppend() routines. ** ** Any tables that the SrcList might point to are not duplicated. */ -Expr *sqliteExprDup(Expr *p){ +Expr *sqlite3ExprDup(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 = sqliteStrDup(p->token.z); + pNew->token.z = (u8*)sqliteStrNDup((char*)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); + pNew->pLeft = sqlite3ExprDup(p->pLeft); + pNew->pRight = sqlite3ExprDup(p->pRight); + pNew->pList = sqlite3ExprListDup(p->pList); + pNew->pSelect = sqlite3SelectDup(p->pSelect); + pNew->pTab = p->pTab; return pNew; } -void sqliteTokenCopy(Token *pTo, Token *pFrom){ +void sqlite3TokenCopy(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->z = (u8*)sqliteStrNDup((char*)pFrom->z, pFrom->n); pTo->dyn = 1; }else{ pTo->z = 0; } } -ExprList *sqliteExprListDup(ExprList *p){ +ExprList *sqlite3ExprListDup(ExprList *p){ ExprList *pNew; - struct ExprList_item *pItem; + struct ExprList_item *pItem, *pOldItem; 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]) ); - for(i=0; pItem && inExpr; i++, pItem++){ + if( pItem==0 ){ + sqliteFree(pNew); + return 0; + } + pOldItem = p->a; + for(i=0; inExpr; i++, pItem++, pOldItem++){ Expr *pNewExpr, *pOldExpr; - pItem->pExpr = pNewExpr = sqliteExprDup(pOldExpr = p->a[i].pExpr); + pItem->pExpr = pNewExpr = sqlite3ExprDup(pOldExpr = pOldItem->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); + sqlite3TokenCopy(&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; + || pOldExpr->span.z==0 + || sqlite3MallocFailed() ); + pItem->zName = sqliteStrDup(pOldItem->zName); + pItem->sortOrder = pOldItem->sortOrder; + pItem->isAgg = pOldItem->isAgg; pItem->done = 0; } return pNew; } -SrcList *sqliteSrcListDup(SrcList *p){ + +/* +** If cursors, triggers, views and subqueries are all omitted from +** the build, then none of the following routines, except for +** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes +** called with a NULL argument. +*/ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \ + || !defined(SQLITE_OMIT_SUBQUERY) +SrcList *sqlite3SrcListDup(SrcList *p){ SrcList *pNew; int i; int nByte; @@ -185,19 +489,25 @@ SrcList *sqliteSrcListDup(SrcList *p){ for(i=0; inSrc; i++){ struct SrcList_item *pNewItem = &pNew->a[i]; struct SrcList_item *pOldItem = &p->a[i]; + Table *pTab; 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); + pNewItem->isPopulated = pOldItem->isPopulated; + pTab = pNewItem->pTab = pOldItem->pTab; + if( pTab ){ + pTab->nRef++; + } + pNewItem->pSelect = sqlite3SelectDup(pOldItem->pSelect); + pNewItem->pOn = sqlite3ExprDup(pOldItem->pOn); + pNewItem->pUsing = sqlite3IdListDup(pOldItem->pUsing); + pNewItem->colUsed = pOldItem->colUsed; } return pNew; } -IdList *sqliteIdListDup(IdList *p){ +IdList *sqlite3IdListDup(IdList *p){ IdList *pNew; int i; if( p==0 ) return 0; @@ -205,7 +515,10 @@ IdList *sqliteIdListDup(IdList *p){ 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; + if( pNew->a==0 ){ + sqliteFree(pNew); + return 0; + } for(i=0; inId; i++){ struct IdList_item *pNewItem = &pNew->a[i]; struct IdList_item *pOldItem = &p->a[i]; @@ -214,146 +527,241 @@ IdList *sqliteIdListDup(IdList *p){ } return pNew; } -Select *sqliteSelectDup(Select *p){ +Select *sqlite3SelectDup(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->pEList = sqlite3ExprListDup(p->pEList); + pNew->pSrc = sqlite3SrcListDup(p->pSrc); + pNew->pWhere = sqlite3ExprDup(p->pWhere); + pNew->pGroupBy = sqlite3ExprListDup(p->pGroupBy); + pNew->pHaving = sqlite3ExprDup(p->pHaving); + pNew->pOrderBy = sqlite3ExprListDup(p->pOrderBy); pNew->op = p->op; - pNew->pPrior = sqliteSelectDup(p->pPrior); - pNew->nLimit = p->nLimit; - pNew->nOffset = p->nOffset; - pNew->zSelect = 0; + pNew->pPrior = sqlite3SelectDup(p->pPrior); + pNew->pLimit = sqlite3ExprDup(p->pLimit); + pNew->pOffset = sqlite3ExprDup(p->pOffset); pNew->iLimit = -1; pNew->iOffset = -1; + pNew->isResolved = p->isResolved; + pNew->isAgg = p->isAgg; + pNew->usesVirt = 0; + pNew->disallowOrderBy = 0; + pNew->pRightmost = 0; + pNew->addrOpenVirt[0] = -1; + pNew->addrOpenVirt[1] = -1; + pNew->addrOpenVirt[2] = -1; return pNew; } +#else +Select *sqlite3SelectDup(Select *p){ + assert( p==0 ); + return 0; +} +#endif /* ** Add a new element to the end of an expression list. If pList is ** initially NULL, then create a new expression list. */ -ExprList *sqliteExprListAppend(ExprList *pList, Expr *pExpr, Token *pName){ +ExprList *sqlite3ExprListAppend(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; + goto no_mem; } 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; + struct ExprList_item *a; + int n = pList->nAlloc*2 + 4; + a = sqliteRealloc(pList->a, n*sizeof(pList->a[0])); + if( a==0 ){ + goto no_mem; } + pList->a = a; + pList->nAlloc = n; } assert( pList->a!=0 ); if( pExpr || pName ){ struct ExprList_item *pItem = &pList->a[pList->nExpr++]; memset(pItem, 0, sizeof(*pItem)); + pItem->zName = sqlite3NameFromToken(pName); pItem->pExpr = pExpr; - if( pName ){ - sqliteSetNString(&pItem->zName, pName->z, pName->n, 0); - sqliteDequote(pItem->zName); - } } return pList; + +no_mem: + /* Avoid leaking memory if malloc has failed. */ + sqlite3ExprDelete(pExpr); + sqlite3ExprListDelete(pList); + return 0; } /* ** Delete an entire expression list. */ -void sqliteExprListDelete(ExprList *pList){ +void sqlite3ExprListDelete(ExprList *pList){ int i; + struct ExprList_item *pItem; if( pList==0 ) return; - for(i=0; inExpr; i++){ - sqliteExprDelete(pList->a[i].pExpr); - sqliteFree(pList->a[i].zName); + assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) ); + assert( pList->nExpr<=pList->nAlloc ); + for(pItem=pList->a, i=0; inExpr; i++, pItem++){ + sqlite3ExprDelete(pItem->pExpr); + sqliteFree(pItem->zName); } sqliteFree(pList->a); sqliteFree(pList); } /* -** Walk an expression tree. Return 1 if the expression is constant -** and 0 if it involves variables. +** Walk an expression tree. Call xFunc for each node visited. ** -** 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. +** The return value from xFunc determines whether the tree walk continues. +** 0 means continue walking the tree. 1 means do not walk children +** of the current node but continue with siblings. 2 means abandon +** the tree walk completely. +** +** The return value from this routine is 1 to abandon the tree walk +** and 0 to continue. +** +** NOTICE: This routine does *not* descend into subqueries. */ -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); - } +static int walkExprList(ExprList *, int (*)(void *, Expr*), void *); +static int walkExprTree(Expr *pExpr, int (*xFunc)(void*,Expr*), void *pArg){ + int rc; + if( pExpr==0 ) return 0; + rc = (*xFunc)(pArg, pExpr); + if( rc==0 ){ + if( walkExprTree(pExpr->pLeft, xFunc, pArg) ) return 1; + if( walkExprTree(pExpr->pRight, xFunc, pArg) ) return 1; + if( walkExprList(pExpr->pList, xFunc, pArg) ) return 1; + } + return rc>1; +} + +/* +** Call walkExprTree() for every expression in list p. +*/ +static int walkExprList(ExprList *p, int (*xFunc)(void *, Expr*), void *pArg){ + int i; + struct ExprList_item *pItem; + if( !p ) return 0; + for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){ + if( walkExprTree(pItem->pExpr, xFunc, pArg) ) return 1; } return 0; } /* -** If the given expression codes a constant integer that is small enough +** Call walkExprTree() for every expression in Select p, not including +** expressions that are part of sub-selects in any FROM clause or the LIMIT +** or OFFSET expressions.. +*/ +static int walkSelectExpr(Select *p, int (*xFunc)(void *, Expr*), void *pArg){ + walkExprList(p->pEList, xFunc, pArg); + walkExprTree(p->pWhere, xFunc, pArg); + walkExprList(p->pGroupBy, xFunc, pArg); + walkExprTree(p->pHaving, xFunc, pArg); + walkExprList(p->pOrderBy, xFunc, pArg); + return 0; +} + + +/* +** This routine is designed as an xFunc for walkExprTree(). +** +** pArg is really a pointer to an integer. If we can tell by looking +** at pExpr that the expression that contains pExpr is not a constant +** expression, then set *pArg to 0 and return 2 to abandon the tree walk. +** If pExpr does does not disqualify the expression from being a constant +** then do nothing. +** +** After walking the whole tree, if no nodes are found that disqualify +** the expression as constant, then we assume the whole expression +** is constant. See sqlite3ExprIsConstant() for additional information. +*/ +static int exprNodeIsConstant(void *pArg, Expr *pExpr){ + switch( pExpr->op ){ + /* Consider functions to be constant if all their arguments are constant + ** and *pArg==2 */ + case TK_FUNCTION: + if( *((int*)pArg)==2 ) return 0; + /* Fall through */ + case TK_ID: + case TK_COLUMN: + case TK_DOT: + case TK_AGG_FUNCTION: + case TK_AGG_COLUMN: +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: + case TK_EXISTS: +#endif + *((int*)pArg) = 0; + return 2; + case TK_IN: + if( pExpr->pSelect ){ + *((int*)pArg) = 0; + return 2; + } + default: + return 0; + } +} + +/* +** Walk an expression tree. Return 1 if the expression is constant +** and 0 if it involves variables or function calls. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +int sqlite3ExprIsConstant(Expr *p){ + int isConst = 1; + walkExprTree(p, exprNodeIsConstant, &isConst); + return isConst; +} + +/* +** Walk an expression tree. Return 1 if the expression is constant +** or a function call with constant arguments. Return and 0 if there +** are any variables. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +int sqlite3ExprIsConstantOrFunction(Expr *p){ + int isConst = 2; + walkExprTree(p, exprNodeIsConstant, &isConst); + return isConst!=0; +} + +/* +** If the expression p codes a constant integer that is small enough ** to fit in a 32-bit integer, return 1 and put the value of the integer ** in *pValue. If the expression is not an integer or if it is too big ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged. */ -int sqliteExprIsInteger(Expr *p, int *pValue){ +int sqlite3ExprIsInteger(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); + if( sqlite3GetInt32((char*)p->token.z, pValue) ){ return 1; } break; } case TK_UPLUS: { - return sqliteExprIsInteger(p->pLeft, pValue); + return sqlite3ExprIsInteger(p->pLeft, pValue); } case TK_UMINUS: { int v; - if( sqliteExprIsInteger(p->pLeft, &v) ){ + if( sqlite3ExprIsInteger(p->pLeft, &v) ){ *pValue = -v; return 1; } @@ -367,10 +775,10 @@ int sqliteExprIsInteger(Expr *p, int *pValue){ /* ** 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; +int sqlite3IsRowid(const char *z){ + if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1; + if( sqlite3StrICmp(z, "ROWID")==0 ) return 1; + if( sqlite3StrICmp(z, "OID")==0 ) return 1; return 0; } @@ -385,7 +793,6 @@ int sqliteIsRowid(const char *z){ ** 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. @@ -401,12 +808,11 @@ int sqliteIsRowid(const char *z){ ** in pParse and return non-zero. Return zero on success. */ static int lookupName( - Parse *pParse, /* The parsing context */ + 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" */ + NameContext *pNC, /* The name context used to resolve the name */ Expr *pExpr /* Make this EXPR node point to the selected column */ ){ char *zDb = 0; /* Name of the database. The "X" in X.Y.Z */ @@ -415,133 +821,168 @@ static int lookupName( 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 */ + sqlite3 *db = pParse->db; /* The database */ + struct SrcList_item *pItem; /* Use for looping over pSrcList items */ + struct SrcList_item *pMatch = 0; /* The matching pSrcList item */ + NameContext *pTopNC = pNC; /* First namecontext in the list */ 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; + zDb = sqlite3NameFromToken(pDbToken); + zTab = sqlite3NameFromToken(pTableToken); + zCol = sqlite3NameFromToken(pColumnToken); + if( sqlite3MallocFailed() ){ + goto lookupname_end; } - 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; + while( pNC && cnt==0 ){ + ExprList *pEList; + SrcList *pSrcList = pNC->pSrcList; - 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( pSrcList ){ + for(i=0, pItem=pSrcList->a; inSrc; i++, pItem++){ + Table *pTab; + int iDb; + Column *pCol; + + pTab = pItem->pTab; + assert( pTab!=0 ); + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( pTab->nCol>0 ); + if( zTab ){ + if( pItem->zAlias ){ + char *zTabName = pItem->zAlias; + if( sqlite3StrICmp(zTabName, zTab)!=0 ) continue; + }else{ + char *zTabName = pTab->zName; + if( zTabName==0 || sqlite3StrICmp(zTabName, zTab)!=0 ) continue; + if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){ + continue; + } + } + } + if( 0==(cntTab++) ){ + pExpr->iTable = pItem->iCursor; + pExpr->pSchema = pTab->pSchema; + pMatch = pItem; + } + for(j=0, pCol=pTab->aCol; jnCol; j++, pCol++){ + if( sqlite3StrICmp(pCol->zName, zCol)==0 ){ + const char *zColl = pTab->aCol[j].zColl; + IdList *pUsing; + cnt++; + pExpr->iTable = pItem->iCursor; + pMatch = pItem; + pExpr->pSchema = pTab->pSchema; + /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ + pExpr->iColumn = j==pTab->iPKey ? -1 : j; + pExpr->affinity = pTab->aCol[j].affinity; + pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0); + if( pItem->jointype & JT_NATURAL ){ + /* If this match occurred in the left table of a natural join, + ** then skip the right table to avoid a duplicate match */ + pItem++; + i++; + } + if( (pUsing = pItem->pUsing)!=0 ){ + /* If this match occurs on a column that is in the USING clause + ** of a join, skip the search of the right table of the join + ** to avoid a duplicate match there. */ + int k; + for(k=0; knId; k++){ + if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ){ + pItem++; + i++; + break; + } + } + } + break; + } } } } - 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; + +#ifndef SQLITE_OMIT_TRIGGER + /* If we have not already resolved the name, then maybe + ** it is a new.* or old.* trigger argument reference + */ + if( zDb==0 && zTab!=0 && cnt==0 && pParse->trigStack!=0 ){ + TriggerStack *pTriggerStack = pParse->trigStack; + Table *pTab = 0; + if( pTriggerStack->newIdx != -1 && sqlite3StrICmp("new", zTab) == 0 ){ + pExpr->iTable = pTriggerStack->newIdx; + assert( pTriggerStack->pTab ); + pTab = pTriggerStack->pTab; + }else if( pTriggerStack->oldIdx != -1 && sqlite3StrICmp("old", zTab)==0 ){ + pExpr->iTable = pTriggerStack->oldIdx; + assert( pTriggerStack->pTab ); + pTab = pTriggerStack->pTab; } - } - } - /* 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 iCol; + Column *pCol = pTab->aCol; - 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; + pExpr->pSchema = pTab->pSchema; + cntTab++; + for(iCol=0; iCol < pTab->nCol; iCol++, pCol++) { + if( sqlite3StrICmp(pCol->zName, zCol)==0 ){ + const char *zColl = pTab->aCol[iCol].zColl; + cnt++; + pExpr->iColumn = iCol==pTab->iPKey ? -1 : iCol; + pExpr->affinity = pTab->aCol[iCol].affinity; + pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0); + pExpr->pTab = pTab; + break; + } } } } - } +#endif /* !defined(SQLITE_OMIT_TRIGGER) */ - /* - ** 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; - } + /* + ** Perhaps the name is a reference to the ROWID + */ + if( cnt==0 && cntTab==1 && sqlite3IsRowid(zCol) ){ + cnt = 1; + pExpr->iColumn = -1; + pExpr->affinity = SQLITE_AFF_INTEGER; + } - /* - ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z - ** might refer to an result-set alias. This happens, for example, when - ** we are resolving names in the WHERE clause of the following command: - ** - ** SELECT a+b AS x FROM table WHERE x<10; - ** - ** In cases like this, replace pExpr with a copy of the expression that - ** forms the result set entry ("a+b" in the example) and return immediately. - ** Note that the expression in the result set should have already been - ** resolved by the time the WHERE clause is resolved. - */ - 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 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 = pNC->pEList)!=0 && zTab==0 ){ + for(j=0; jnExpr; j++){ + char *zAs = pEList->a[j].zName; + if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){ + assert( pExpr->pLeft==0 && pExpr->pRight==0 ); + pExpr->op = TK_AS; + pExpr->iColumn = j; + pExpr->pLeft = sqlite3ExprDup(pEList->a[j].pExpr); + cnt = 1; + assert( zTab==0 && zDb==0 ); + goto lookupname_end_2; + } + } + } + + /* Advance to the next name context. The loop will exit when either + ** we have a match (cnt>0) or when we run out of name contexts. + */ + if( cnt==0 ){ + pNC = pNC->pNext; + } } /* @@ -550,6 +991,9 @@ static int lookupName( ** Z is a string literal if it doesn't match any column names. In that ** case, we need to return right away and not make any changes to ** pExpr. + ** + ** Because no reference was made to outer contexts, the pNC->nRef + ** fields are not changed in any context. */ if( cnt==0 && zTab==0 && pColumnToken->z[0]=='"' ){ sqliteFree(zCol); @@ -565,28 +1009,219 @@ static int lookupName( char *zErr; zErr = cnt==0 ? "no such column: %s" : "ambiguous column name: %s"; if( zDb ){ - sqliteSetString(&z, zDb, ".", zTab, ".", zCol, 0); + sqlite3SetString(&z, zDb, ".", zTab, ".", zCol, (char*)0); }else if( zTab ){ - sqliteSetString(&z, zTab, ".", zCol, 0); + sqlite3SetString(&z, zTab, ".", zCol, (char*)0); }else{ z = sqliteStrDup(zCol); } - sqliteErrorMsg(pParse, zErr, z); + sqlite3ErrorMsg(pParse, zErr, z); sqliteFree(z); + pTopNC->nErr++; } + /* If a column from a table in pSrcList is referenced, then record + ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes + ** bit 0 to be set. Column 1 sets bit 1. And so forth. If the + ** column number is greater than the number of bits in the bitmask + ** then set the high-order bit of the bitmask. + */ + if( pExpr->iColumn>=0 && pMatch!=0 ){ + int n = pExpr->iColumn; + if( n>=sizeof(Bitmask)*8 ){ + n = sizeof(Bitmask)*8-1; + } + assert( pMatch->iCursor==pExpr->iTable ); + pMatch->colUsed |= 1<pLeft); + sqlite3ExprDelete(pExpr->pLeft); pExpr->pLeft = 0; - sqliteExprDelete(pExpr->pRight); + sqlite3ExprDelete(pExpr->pRight); pExpr->pRight = 0; pExpr->op = TK_COLUMN; - sqliteAuthRead(pParse, pExpr, pSrcList); - return cnt!=1; +lookupname_end_2: + sqliteFree(zCol); + if( cnt==1 ){ + assert( pNC!=0 ); + sqlite3AuthRead(pParse, pExpr, pNC->pSrcList); + if( pMatch && !pMatch->pSelect ){ + pExpr->pTab = pMatch->pTab; + } + /* Increment the nRef value on all name contexts from TopNC up to + ** the point where the name matched. */ + for(;;){ + assert( pTopNC!=0 ); + pTopNC->nRef++; + if( pTopNC==pNC ) break; + pTopNC = pTopNC->pNext; + } + return 0; + } else { + return 1; + } +} + +/* +** This routine is designed as an xFunc for walkExprTree(). +** +** Resolve symbolic names into TK_COLUMN operators for the current +** node in the expression tree. Return 0 to continue the search down +** the tree or 2 to abort the tree walk. +** +** This routine also does error checking and name resolution for +** function names. The operator for aggregate functions is changed +** to TK_AGG_FUNCTION. +*/ +static int nameResolverStep(void *pArg, Expr *pExpr){ + NameContext *pNC = (NameContext*)pArg; + Parse *pParse; + + if( pExpr==0 ) return 1; + assert( pNC!=0 ); + pParse = pNC->pParse; + + if( ExprHasAnyProperty(pExpr, EP_Resolved) ) return 1; + ExprSetProperty(pExpr, EP_Resolved); +#ifndef NDEBUG + if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){ + SrcList *pSrcList = pNC->pSrcList; + int i; + for(i=0; ipSrcList->nSrc; i++){ + assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursornTab); + } + } +#endif + switch( pExpr->op ){ + /* 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 column. + */ + case TK_ID: { + lookupName(pParse, 0, 0, &pExpr->token, pNC, pExpr); + return 1; + } + + /* 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; + + /* if( pSrcList==0 ) break; */ + 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; + } + lookupName(pParse, pDb, pTable, pColumn, pNC, pExpr); + return 1; + } + + /* Resolve function names + */ + case TK_CONST_FUNC: + case TK_FUNCTION: { + ExprList *pList = pExpr->pList; /* The argument list */ + int n = pList ? pList->nExpr : 0; /* Number of arguments */ + int no_such_func = 0; /* True if no such function exists */ + int wrong_num_args = 0; /* True if wrong number of arguments */ + int is_agg = 0; /* True if is an aggregate function */ + int i; + int nId; /* Number of characters in function name */ + const char *zId; /* The function name. */ + FuncDef *pDef; /* Information about the function */ + int enc = ENC(pParse->db); /* The database encoding */ + + zId = (char*)pExpr->token.z; + nId = pExpr->token.n; + pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0); + if( pDef==0 ){ + pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, enc, 0); + if( pDef==0 ){ + no_such_func = 1; + }else{ + wrong_num_args = 1; + } + }else{ + is_agg = pDef->xFunc==0; + } + if( is_agg && !pNC->allowAgg ){ + sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId); + pNC->nErr++; + is_agg = 0; + }else if( no_such_func ){ + sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId); + pNC->nErr++; + }else if( wrong_num_args ){ + sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()", + nId, zId); + pNC->nErr++; + } + if( is_agg ){ + pExpr->op = TK_AGG_FUNCTION; + pNC->hasAgg = 1; + } + if( is_agg ) pNC->allowAgg = 0; + for(i=0; pNC->nErr==0 && ia[i].pExpr, nameResolverStep, pNC); + } + if( is_agg ) pNC->allowAgg = 1; + /* FIX ME: Compute pExpr->affinity based on the expected return + ** type of the function + */ + return is_agg; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: + case TK_EXISTS: +#endif + case TK_IN: { + if( pExpr->pSelect ){ + int nRef = pNC->nRef; +#ifndef SQLITE_OMIT_CHECK + if( pNC->isCheck ){ + sqlite3ErrorMsg(pParse,"subqueries prohibited in CHECK constraints"); + } +#endif + sqlite3SelectResolve(pParse, pExpr->pSelect, pNC); + assert( pNC->nRef>=nRef ); + if( nRef!=pNC->nRef ){ + ExprSetProperty(pExpr, EP_VarSelect); + } + } + break; + } +#ifndef SQLITE_OMIT_CHECK + case TK_VARIABLE: { + if( pNC->isCheck ){ + sqlite3ErrorMsg(pParse,"parameters prohibited in CHECK constraints"); + } + break; + } +#endif + } + return 0; } /* @@ -602,477 +1237,346 @@ static int lookupName( ** 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: +** Also resolve function names and check the functions for proper +** usage. 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. ** -** 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. +** If the expression contains aggregate functions then set the EP_Agg +** property on the expression. */ -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 sqlite3ExprResolveNames( + NameContext *pNC, /* Namespace to resolve expressions in. */ + 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 ); + int savedHasAgg; + if( pExpr==0 ) return 0; + savedHasAgg = pNC->hasAgg; + pNC->hasAgg = 0; + walkExprTree(pExpr, nameResolverStep, pNC); + if( pNC->nErr>0 ){ + ExprSetProperty(pExpr, EP_Error); } + if( pNC->hasAgg ){ + ExprSetProperty(pExpr, EP_Agg); + }else if( savedHasAgg ){ + pNC->hasAgg = 1; + } + return ExprHasProperty(pExpr, EP_Error); +} + +/* +** A pointer instance of this structure is used to pass information +** through walkExprTree into codeSubqueryStep(). +*/ +typedef struct QueryCoder QueryCoder; +struct QueryCoder { + Parse *pParse; /* The parsing context */ + NameContext *pNC; /* Namespace of first enclosing query */ +}; + + +/* +** Generate code for scalar subqueries used as an expression +** and IN operators. Examples: +** +** (SELECT a FROM b) -- subquery +** EXISTS (SELECT a FROM b) -- EXISTS subquery +** x IN (4,5,11) -- IN operator with list on right-hand side +** x IN (SELECT a FROM b) -- IN operator with subquery on the right +** +** The pExpr parameter describes the expression that contains the IN +** operator or subquery. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +void sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ + int testAddr = 0; /* One-time test address */ + Vdbe *v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + + /* This code must be run in its entirety every time it is encountered + ** if any of the following is true: + ** + ** * The right-hand side is a correlated subquery + ** * The right-hand side is an expression list containing variables + ** * We are inside a trigger + ** + ** If all of the above are false, then we can run this code just once + ** save the results, and reuse the same result on subsequent invocations. + */ + if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->trigStack ){ + int mem = pParse->nMem++; + sqlite3VdbeAddOp(v, OP_MemLoad, mem, 0); + testAddr = sqlite3VdbeAddOp(v, OP_If, 0, 0); + assert( testAddr>0 || sqlite3MallocFailed() ); + sqlite3VdbeAddOp(v, OP_MemInt, 1, mem); + } + 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; - } + char affinity; + KeyInfo keyInfo; + int addr; /* Address of OP_OpenVirtual instruction */ + + affinity = sqlite3ExprAffinity(pExpr->pLeft); + + /* Whether this is an 'x IN(SELECT...)' or an 'x IN()' + ** expression it is handled the same way. A virtual table is + ** filled with single-field index keys representing the results + ** from the SELECT or the . + ** + ** If the 'x' expression is a column value, or the SELECT... + ** statement returns a column value, then the affinity of that + ** column is used to build the index keys. If both 'x' and the + ** SELECT... statement are columns, then numeric affinity is used + ** if either column has NUMERIC or INTEGER affinity. If neither + ** 'x' nor the SELECT... statement are columns, then numeric affinity + ** is used. + */ + pExpr->iTable = pParse->nTab++; + addr = sqlite3VdbeAddOp(v, OP_OpenVirtual, pExpr->iTable, 0); + memset(&keyInfo, 0, sizeof(keyInfo)); + keyInfo.nField = 1; + sqlite3VdbeAddOp(v, OP_SetNumColumns, pExpr->iTable, 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(). + ** Generate code to write the results of the select into the temporary + ** table allocated and opened above. */ - pExpr->iTable = pParse->nTab++; - sqliteVdbeAddOp(v, OP_OpenTemp, pExpr->iTable, 1); - sqliteSelect(pParse, pExpr->pSelect, SRT_Set, pExpr->iTable, 0,0,0); + int iParm = pExpr->iTable + (((int)affinity)<<16); + ExprList *pEList; + assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable ); + sqlite3Select(pParse, pExpr->pSelect, SRT_Set, iParm, 0, 0, 0, 0); + pEList = pExpr->pSelect->pEList; + if( pEList && pEList->nExpr>0 ){ + keyInfo.aColl[0] = binaryCompareCollSeq(pParse, pExpr->pLeft, + pEList->a[0].pExpr); + } }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. + ** For each expression, build an index key from the evaluation and + ** store it in the temporary table. If is a column, then use + ** that columns affinity when building index keys. If is not + ** a column, use numeric affinity. */ - int i, 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; - } + int i; + ExprList *pList = pExpr->pList; + struct ExprList_item *pItem; + + if( !affinity ){ + affinity = SQLITE_AFF_NUMERIC; } - 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; - } + keyInfo.aColl[0] = pExpr->pLeft->pColl; + + /* Loop through each expression in . */ + for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){ + Expr *pE2 = pItem->pExpr; + + /* If the expression is not constant then we will need to + ** disable the test that was generated above that makes sure + ** this code only executes once. Because for a non-constant + ** expression we need to rerun this code each time. + */ + if( testAddr>0 && !sqlite3ExprIsConstant(pE2) ){ + sqlite3VdbeChangeToNoop(v, testAddr-1, 3); + testAddr = 0; } + + /* Evaluate the expression and insert it into the temp table */ + sqlite3ExprCode(pParse, pE2); + sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &affinity, 1); + sqlite3VdbeAddOp(v, OP_IdxInsert, pExpr->iTable, 0); } } + sqlite3VdbeChangeP3(v, addr, (void *)&keyInfo, P3_KEYINFO); break; } + case TK_EXISTS: 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; - } + static const Token one = { (u8*)"1", 0, 1 }; + Select *pSel; + int iMem; + int sop; - /* 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; - } + pExpr->iColumn = iMem = pParse->nMem++; + pSel = pExpr->pSelect; + if( pExpr->op==TK_SELECT ){ + sop = SRT_Mem; + sqlite3VdbeAddOp(v, OP_MemNull, iMem, 0); + VdbeComment((v, "# Init subquery result")); }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); - } + sop = SRT_Exists; + sqlite3VdbeAddOp(v, OP_MemInt, 0, iMem); + VdbeComment((v, "# Init EXISTS result")); } + sqlite3ExprDelete(pSel->pLimit); + pSel->pLimit = sqlite3Expr(TK_INTEGER, 0, 0, &one); + sqlite3Select(pParse, pSel, sop, iMem, 0, 0, 0, 0); break; } } - return nErr; + + if( testAddr ){ + sqlite3VdbeJumpHere(v, testAddr); + } + return; } +#endif /* SQLITE_OMIT_SUBQUERY */ /* -** 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. +** Generate an instruction that will put the integer describe by +** text z[0..n-1] on the stack. */ -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; +static void codeInteger(Vdbe *v, const char *z, int n){ + int i; + if( sqlite3GetInt32(z, &i) ){ + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + }else if( sqlite3FitsIn64Bits(z) ){ + sqlite3VdbeOp3(v, OP_Int64, 0, 0, z, n); + }else{ + sqlite3VdbeOp3(v, OP_Real, 0, 0, z, n); } - return SQLITE_SO_NUM; } /* ** Generate code into the current Vdbe to evaluate the given ** expression and leave the result on the top of stack. +** +** This code depends on the fact that certain token values (ex: TK_EQ) +** are the same as opcode values (ex: OP_Eq) that implement the corresponding +** operation. Special comments in vdbe.c and the mkopcodeh.awk script in +** the make process cause these values to align. Assert()s in the code +** below verify that the numbers are aligned correctly. */ -void sqliteExprCode(Parse *pParse, Expr *pExpr){ +void sqlite3ExprCode(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; + int stackChng = 1; /* Amount of change to stack depth */ + + if( v==0 ) return; + if( pExpr==0 ){ + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + return; } - switch( pExpr->op ){ + op = pExpr->op; + switch( op ){ + case TK_AGG_COLUMN: { + AggInfo *pAggInfo = pExpr->pAggInfo; + struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg]; + if( !pAggInfo->directMode ){ + sqlite3VdbeAddOp(v, OP_MemLoad, pCol->iMem, 0); + break; + }else if( pAggInfo->useSortingIdx ){ + sqlite3VdbeAddOp(v, OP_Column, pAggInfo->sortingIdx, + pCol->iSorterColumn); + break; + } + /* Otherwise, fall thru into the TK_COLUMN case */ + } case TK_COLUMN: { - if( pParse->useAgg ){ - sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); + if( pExpr->iTable<0 ){ + /* This only happens when coding check constraints */ + assert( pParse->ckOffset>0 ); + sqlite3VdbeAddOp(v, OP_Dup, pParse->ckOffset-pExpr->iColumn-1, 1); }else if( pExpr->iColumn>=0 ){ - sqliteVdbeAddOp(v, OP_Column, pExpr->iTable, pExpr->iColumn); + Table *pTab = pExpr->pTab; + int iCol = pExpr->iColumn; + sqlite3VdbeAddOp(v, OP_Column, pExpr->iTable, iCol); + sqlite3ColumnDefault(v, pTab, iCol); +#ifndef SQLITE_OMIT_FLOATING_POINT + if( pTab && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp(v, OP_RealAffinity, 0, 0); + } +#endif }else{ - sqliteVdbeAddOp(v, OP_Recno, pExpr->iTable, 0); + sqlite3VdbeAddOp(v, OP_Rowid, 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); + codeInteger(v, (char*)pExpr->token.z, pExpr->token.n); + break; + } + case TK_FLOAT: + case TK_STRING: { + assert( TK_FLOAT==OP_Real ); + assert( TK_STRING==OP_String8 ); + sqlite3DequoteExpr(pExpr); + sqlite3VdbeOp3(v, op, 0, 0, (char*)pExpr->token.z, pExpr->token.n); break; } case TK_NULL: { - sqliteVdbeAddOp(v, OP_String, 0, 0); + sqlite3VdbeAddOp(v, OP_Null, 0, 0); break; } +#ifndef SQLITE_OMIT_BLOB_LITERAL + case TK_BLOB: { + int n; + const char *z; + assert( TK_BLOB==OP_HexBlob ); + n = pExpr->token.n - 3; + z = (char*)pExpr->token.z + 2; + assert( n>=0 ); + if( n==0 ){ + z = ""; + } + sqlite3VdbeOp3(v, op, 0, 0, z, n); + break; + } +#endif case TK_VARIABLE: { - sqliteVdbeAddOp(v, OP_Variable, pExpr->iTable, 0); + sqlite3VdbeAddOp(v, OP_Variable, pExpr->iTable, 0); + if( pExpr->token.n>1 ){ + sqlite3VdbeChangeP3(v, -1, (char*)pExpr->token.z, pExpr->token.n); + } break; } + case TK_REGISTER: { + sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iTable, 0); + break; + } +#ifndef SQLITE_OMIT_CAST + case TK_CAST: { + /* Expressions of the form: CAST(pLeft AS token) */ + int aff, to_op; + sqlite3ExprCode(pParse, pExpr->pLeft); + aff = sqlite3AffinityType(&pExpr->token); + to_op = aff - SQLITE_AFF_TEXT + OP_ToText; + assert( to_op==OP_ToText || aff!=SQLITE_AFF_TEXT ); + assert( to_op==OP_ToBlob || aff!=SQLITE_AFF_NONE ); + assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC ); + assert( to_op==OP_ToInt || aff!=SQLITE_AFF_INTEGER ); + assert( to_op==OP_ToReal || aff!=SQLITE_AFF_REAL ); + sqlite3VdbeAddOp(v, to_op, 0, 0); + stackChng = 0; + break; + } +#endif /* SQLITE_OMIT_CAST */ 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 */ + assert( TK_LT==OP_Lt ); + assert( TK_LE==OP_Le ); + assert( TK_GT==OP_Gt ); + assert( TK_GE==OP_Ge ); + assert( TK_EQ==OP_Eq ); + assert( TK_NE==OP_Ne ); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3ExprCode(pParse, pExpr->pRight); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, 0, 0); + stackChng = -1; + break; } case TK_AND: case TK_OR: @@ -1082,37 +1586,38 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){ 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_SLASH: case TK_LSHIFT: - case TK_RSHIFT: { - sqliteExprCode(pParse, pExpr->pRight); - sqliteExprCode(pParse, pExpr->pLeft); - sqliteVdbeAddOp(v, op, 0, 0); - break; - } + case TK_RSHIFT: case TK_CONCAT: { - sqliteExprCode(pParse, pExpr->pLeft); - sqliteExprCode(pParse, pExpr->pRight); - sqliteVdbeAddOp(v, OP_Concat, 2, 0); + assert( TK_AND==OP_And ); + assert( TK_OR==OP_Or ); + assert( TK_PLUS==OP_Add ); + assert( TK_MINUS==OP_Subtract ); + assert( TK_REM==OP_Remainder ); + assert( TK_BITAND==OP_BitAnd ); + assert( TK_BITOR==OP_BitOr ); + assert( TK_SLASH==OP_Divide ); + assert( TK_LSHIFT==OP_ShiftLeft ); + assert( TK_RSHIFT==OP_ShiftRight ); + assert( TK_CONCAT==OP_Concat ); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3ExprCode(pParse, pExpr->pRight); + sqlite3VdbeAddOp(v, op, 0, 0); + stackChng = -1; 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); + Expr *pLeft = pExpr->pLeft; + assert( pLeft ); + if( pLeft->op==TK_FLOAT || pLeft->op==TK_INTEGER ){ + Token *p = &pLeft->token; + char *z = sqlite3MPrintf("-%.*s", p->n, p->z); + if( pLeft->op==TK_FLOAT ){ + sqlite3VdbeOp3(v, OP_Real, 0, 0, z, p->n+1); }else{ - sqliteVdbeAddOp(v, OP_String, 0, 0); + codeInteger(v, z, p->n+1); } - sqliteVdbeChangeP3(v, -1, z, p->n+1); sqliteFree(z); break; } @@ -1120,167 +1625,251 @@ void sqliteExprCode(Parse *pParse, Expr *pExpr){ } case TK_BITNOT: case TK_NOT: { - sqliteExprCode(pParse, pExpr->pLeft); - sqliteVdbeAddOp(v, op, 0, 0); + assert( TK_BITNOT==OP_BitNot ); + assert( TK_NOT==OP_Not ); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3VdbeAddOp(v, op, 0, 0); + stackChng = 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); + assert( TK_ISNULL==OP_IsNull ); + assert( TK_NOTNULL==OP_NotNull ); + sqlite3VdbeAddOp(v, OP_Integer, 1, 0); + sqlite3ExprCode(pParse, pExpr->pLeft); + dest = sqlite3VdbeCurrentAddr(v) + 2; + sqlite3VdbeAddOp(v, op, 1, dest); + sqlite3VdbeAddOp(v, OP_AddImm, -1, 0); + stackChng = 0; break; } case TK_AGG_FUNCTION: { - sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); + AggInfo *pInfo = pExpr->pAggInfo; + if( pInfo==0 ){ + sqlite3ErrorMsg(pParse, "misuse of aggregate: %T", + &pExpr->span); + }else{ + sqlite3VdbeAddOp(v, OP_MemLoad, pInfo->aFunc[pExpr->iAgg].iMem, 0); + } break; } - case TK_GLOB: - case TK_LIKE: + case TK_CONST_FUNC: 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); + int constMask = 0; + int i; + u8 enc = ENC(pParse->db); + CollSeq *pColl = 0; + zId = (char*)pExpr->token.z; + nId = pExpr->token.n; + pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, enc, 0); assert( pDef!=0 ); - nExpr = sqliteExprCodeExprList(pParse, pList, pDef->includeTypes); - sqliteVdbeOp3(v, OP_Function, nExpr, 0, (char*)pDef, P3_POINTER); + nExpr = sqlite3ExprCodeExprList(pParse, pList); + for(i=0; ia[i].pExpr) ){ + constMask |= (1<needCollSeq && !pColl ){ + pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr); + } + } + if( pDef->needCollSeq ){ + if( !pColl ) pColl = pParse->db->pDfltColl; + sqlite3VdbeOp3(v, OP_CollSeq, 0, 0, (char *)pColl, P3_COLLSEQ); + } + sqlite3VdbeOp3(v, OP_Function, constMask, nExpr, (char*)pDef, P3_FUNCDEF); + stackChng = 1-nExpr; break; } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_EXISTS: case TK_SELECT: { - sqliteVdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0); + if( pExpr->iColumn==0 ){ + sqlite3CodeSubselect(pParse, pExpr); + } + sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0); + VdbeComment((v, "# load subquery result")); 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, 1, 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); + char affinity; + int ckOffset = pParse->ckOffset; + sqlite3CodeSubselect(pParse, pExpr); + + /* Figure out the affinity to use to create a key from the results + ** of the expression. affinityStr stores a static string suitable for + ** P3 of OP_MakeRecord. + */ + affinity = comparisonAffinity(pExpr); + + sqlite3VdbeAddOp(v, OP_Integer, 1, 0); + pParse->ckOffset = ckOffset+1; + + /* Code the from " IN (...)". The temporary table + ** pExpr->iTable contains the values that make up the (...) set. + */ + sqlite3ExprCode(pParse, pExpr->pLeft); + addr = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp(v, OP_NotNull, -1, addr+4); /* addr + 0 */ + sqlite3VdbeAddOp(v, OP_Pop, 2, 0); + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, addr+7); + sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &affinity, 1); /* addr + 4 */ + sqlite3VdbeAddOp(v, OP_Found, pExpr->iTable, addr+7); + sqlite3VdbeAddOp(v, OP_AddImm, -1, 0); /* addr + 6 */ + break; } +#endif 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); + Expr *pLeft = pExpr->pLeft; + struct ExprList_item *pLItem = pExpr->pList->a; + Expr *pRight = pLItem->pExpr; + sqlite3ExprCode(pParse, pLeft); + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3ExprCode(pParse, pRight); + codeCompare(pParse, pLeft, pRight, OP_Ge, 0, 0); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + pLItem++; + pRight = pLItem->pExpr; + sqlite3ExprCode(pParse, pRight); + codeCompare(pParse, pLeft, pRight, OP_Le, 0, 0); + sqlite3VdbeAddOp(v, OP_And, 0, 0); break; } case TK_UPLUS: case TK_AS: { - sqliteExprCode(pParse, pExpr->pLeft); + sqlite3ExprCode(pParse, pExpr->pLeft); + stackChng = 0; break; } case TK_CASE: { int expr_end_label; int jumpInst; - int addr; int nExpr; int i; + ExprList *pEList; + struct ExprList_item *aListelem; assert(pExpr->pList); assert((pExpr->pList->nExpr % 2) == 0); assert(pExpr->pList->nExpr > 0); - nExpr = pExpr->pList->nExpr; - expr_end_label = sqliteVdbeMakeLabel(v); + pEList = pExpr->pList; + aListelem = pEList->a; + nExpr = pEList->nExpr; + expr_end_label = sqlite3VdbeMakeLabel(v); if( pExpr->pLeft ){ - sqliteExprCode(pParse, pExpr->pLeft); + sqlite3ExprCode(pParse, pExpr->pLeft); } for(i=0; ipList->a[i].pExpr); + sqlite3ExprCode(pParse, aListelem[i].pExpr); if( pExpr->pLeft ){ - sqliteVdbeAddOp(v, OP_Dup, 1, 1); - jumpInst = sqliteVdbeAddOp(v, OP_Ne, 1, 0); - sqliteVdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_Dup, 1, 1); + jumpInst = codeCompare(pParse, pExpr->pLeft, aListelem[i].pExpr, + OP_Ne, 0, 1); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); }else{ - jumpInst = sqliteVdbeAddOp(v, OP_IfNot, 1, 0); + jumpInst = sqlite3VdbeAddOp(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); + sqlite3ExprCode(pParse, aListelem[i+1].pExpr); + sqlite3VdbeAddOp(v, OP_Goto, 0, expr_end_label); + sqlite3VdbeJumpHere(v, jumpInst); } if( pExpr->pLeft ){ - sqliteVdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); } if( pExpr->pRight ){ - sqliteExprCode(pParse, pExpr->pRight); + sqlite3ExprCode(pParse, pExpr->pRight); }else{ - sqliteVdbeAddOp(v, OP_String, 0, 0); + sqlite3VdbeAddOp(v, OP_Null, 0, 0); } - sqliteVdbeResolveLabel(v, expr_end_label); + sqlite3VdbeResolveLabel(v, expr_end_label); break; } +#ifndef SQLITE_OMIT_TRIGGER case TK_RAISE: { if( !pParse->trigStack ){ - sqliteErrorMsg(pParse, + sqlite3ErrorMsg(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); + if( pExpr->iColumn!=OE_Ignore ){ + assert( pExpr->iColumn==OE_Rollback || + pExpr->iColumn == OE_Abort || + pExpr->iColumn == OE_Fail ); + sqlite3DequoteExpr(pExpr); + sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, + (char*)pExpr->token.z, pExpr->token.n); } else { - assert( pExpr->iColumn == OE_Ignore ); - sqliteVdbeOp3(v, OP_Goto, 0, pParse->trigStack->ignoreJump, - "(IGNORE jump)", 0); + assert( pExpr->iColumn == OE_Ignore ); + sqlite3VdbeAddOp(v, OP_ContextPop, 0, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, pParse->trigStack->ignoreJump); + VdbeComment((v, "# raise(IGNORE)")); } + stackChng = 0; + break; } - break; +#endif + } + + if( pParse->ckOffset ){ + pParse->ckOffset += stackChng; + assert( pParse->ckOffset ); } } +#ifndef SQLITE_OMIT_TRIGGER +/* +** Generate code that evalutes the given expression and leaves the result +** on the stack. See also sqlite3ExprCode(). +** +** This routine might also cache the result and modify the pExpr tree +** so that it will make use of the cached result on subsequent evaluations +** rather than evaluate the whole expression again. Trivial expressions are +** not cached. If the expression is cached, its result is stored in a +** memory location. +*/ +void sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr){ + Vdbe *v = pParse->pVdbe; + int iMem; + int addr1, addr2; + if( v==0 ) return; + addr1 = sqlite3VdbeCurrentAddr(v); + sqlite3ExprCode(pParse, pExpr); + addr2 = sqlite3VdbeCurrentAddr(v); + if( addr2>addr1+1 || sqlite3VdbeGetOp(v, addr1)->opcode==OP_Function ){ + iMem = pExpr->iTable = pParse->nMem++; + sqlite3VdbeAddOp(v, OP_MemStore, iMem, 0); + pExpr->op = TK_REGISTER; + } +} +#endif + /* ** 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. +** expression list onto the stack. ** ** Return the number of elements pushed onto the stack. */ -int sqliteExprCodeExprList( +int sqlite3ExprCodeExprList( Parse *pParse, /* Parsing context */ - ExprList *pList, /* The expression list to be coded */ - int includeTypes /* TRUE to put datatypes on the stack too */ + ExprList *pList /* The expression list to be coded */ ){ 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); - } + for(pItem=pList->a, i=n; i>0; i--, pItem++){ + sqlite3ExprCode(pParse, pItem->pExpr); } - return includeTypes ? n*2 : n; + return n; } /* @@ -1290,37 +1879,34 @@ int sqliteExprCodeExprList( ** ** If the expression evaluates to NULL (neither true nor false), then ** take the jump if the jumpIfNull flag is true. +** +** This code depends on the fact that certain token values (ex: TK_EQ) +** are the same as opcode values (ex: OP_Eq) that implement the corresponding +** operation. Special comments in vdbe.c and the mkopcodeh.awk script in +** the make process cause these values to align. Assert()s in the code +** below verify that the numbers are aligned correctly. */ -void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ +void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ Vdbe *v = pParse->pVdbe; int op = 0; + int ckOffset = pParse->ckOffset; 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 ){ + op = pExpr->op; + switch( op ){ case TK_AND: { - int d2 = sqliteVdbeMakeLabel(v); - sqliteExprIfFalse(pParse, pExpr->pLeft, d2, !jumpIfNull); - sqliteExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); - sqliteVdbeResolveLabel(v, d2); + int d2 = sqlite3VdbeMakeLabel(v); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2, !jumpIfNull); + sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3VdbeResolveLabel(v, d2); break; } case TK_OR: { - sqliteExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); - sqliteExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); break; } case TK_NOT: { - sqliteExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); break; } case TK_LT: @@ -1329,53 +1915,56 @@ void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ 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); + assert( TK_LT==OP_Lt ); + assert( TK_LE==OP_Le ); + assert( TK_GT==OP_Gt ); + assert( TK_GE==OP_Ge ); + assert( TK_EQ==OP_Eq ); + assert( TK_NE==OP_Ne ); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3ExprCode(pParse, pExpr->pRight); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, dest, jumpIfNull); 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); - } + assert( TK_ISNULL==OP_IsNull ); + assert( TK_NOTNULL==OP_NotNull ); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3VdbeAddOp(v, op, 1, dest); break; } case TK_BETWEEN: { + /* The expression "x BETWEEN y AND z" is implemented as: + ** + ** 1 IF (x < y) GOTO 3 + ** 2 IF (x <= z) GOTO + ** 3 ... + */ 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); + Expr *pLeft = pExpr->pLeft; + Expr *pRight = pExpr->pList->a[0].pExpr; + sqlite3ExprCode(pParse, pLeft); + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3ExprCode(pParse, pRight); + addr = codeCompare(pParse, pLeft, pRight, OP_Lt, 0, !jumpIfNull); + + pRight = pExpr->pList->a[1].pExpr; + sqlite3ExprCode(pParse, pRight); + codeCompare(pParse, pLeft, pRight, OP_Le, dest, jumpIfNull); + + sqlite3VdbeAddOp(v, OP_Integer, 0, 0); + sqlite3VdbeJumpHere(v, addr); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); break; } default: { - sqliteExprCode(pParse, pExpr); - sqliteVdbeAddOp(v, OP_If, jumpIfNull, dest); + sqlite3ExprCode(pParse, pExpr); + sqlite3VdbeAddOp(v, OP_If, jumpIfNull, dest); break; } } + pParse->ckOffset = ckOffset; } /* @@ -1386,36 +1975,58 @@ void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ ** 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){ +void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ Vdbe *v = pParse->pVdbe; int op = 0; + int ckOffset = pParse->ckOffset; 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; - } + + /* The value of pExpr->op and op are related as follows: + ** + ** pExpr->op op + ** --------- ---------- + ** TK_ISNULL OP_NotNull + ** TK_NOTNULL OP_IsNull + ** TK_NE OP_Eq + ** TK_EQ OP_Ne + ** TK_GT OP_Le + ** TK_LE OP_Gt + ** TK_GE OP_Lt + ** TK_LT OP_Ge + ** + ** For other values of pExpr->op, op is undefined and unused. + ** The value of TK_ and OP_ constants are arranged such that we + ** can compute the mapping above using the following expression. + ** Assert()s verify that the computation is correct. + */ + op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1); + + /* Verify correct alignment of TK_ and OP_ constants + */ + assert( pExpr->op!=TK_ISNULL || op==OP_NotNull ); + assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull ); + assert( pExpr->op!=TK_NE || op==OP_Eq ); + assert( pExpr->op!=TK_EQ || op==OP_Ne ); + assert( pExpr->op!=TK_LT || op==OP_Ge ); + assert( pExpr->op!=TK_LE || op==OP_Gt ); + assert( pExpr->op!=TK_GT || op==OP_Le ); + assert( pExpr->op!=TK_GE || op==OP_Lt ); + switch( pExpr->op ){ case TK_AND: { - sqliteExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); - sqliteExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprIfFalse(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); + int d2 = sqlite3VdbeMakeLabel(v); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, !jumpIfNull); + sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3VdbeResolveLabel(v, d2); break; } case TK_NOT: { - sqliteExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); break; } case TK_LT: @@ -1424,80 +2035,67 @@ void sqliteExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ 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); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3ExprCode(pParse, pExpr->pRight); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, dest, jumpIfNull); 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); - } + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3VdbeAddOp(v, op, 1, dest); break; } case TK_BETWEEN: { + /* The expression is "x BETWEEN y AND z". It is implemented as: + ** + ** 1 IF (x >= y) GOTO 3 + ** 2 GOTO + ** 3 IF (x > z) GOTO + */ 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); + Expr *pLeft = pExpr->pLeft; + Expr *pRight = pExpr->pList->a[0].pExpr; + sqlite3ExprCode(pParse, pLeft); + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3ExprCode(pParse, pRight); + addr = sqlite3VdbeCurrentAddr(v); + codeCompare(pParse, pLeft, pRight, OP_Ge, addr+3, !jumpIfNull); + + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, dest); + pRight = pExpr->pList->a[1].pExpr; + sqlite3ExprCode(pParse, pRight); + codeCompare(pParse, pLeft, pRight, OP_Gt, dest, jumpIfNull); break; } default: { - sqliteExprCode(pParse, pExpr); - sqliteVdbeAddOp(v, OP_IfNot, jumpIfNull, dest); + sqlite3ExprCode(pParse, pExpr); + sqlite3VdbeAddOp(v, OP_IfNot, jumpIfNull, dest); break; } } + pParse->ckOffset = ckOffset; } /* ** 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 sqlite3ExprCompare(Expr *pA, Expr *pB){ int i; - if( pA==0 ){ - return pB==0; - }else if( pB==0 ){ - return 0; + if( pA==0||pB==0 ){ + return pB==pA; } 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->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 0; + if( !sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 0; + if( !sqlite3ExprCompare(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) ){ + if( !sqlite3ExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){ return 0; } } @@ -1509,25 +2107,167 @@ int sqliteExprCompare(Expr *pA, Expr *pB){ 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; + if( sqlite3StrNICmp((char*)pA->token.z,(char*)pB->token.z,pB->token.n)!=0 ){ + return 0; + } } return 1; } + /* -** Add a new element to the pParse->aAgg[] array and return its index. +** Add a new element to the pAggInfo->aCol[] array. Return the index of +** the new element. Return a negative number if malloc fails. */ -static int 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; +static int addAggInfoColumn(AggInfo *pInfo){ + int i; + i = sqlite3ArrayAllocate((void**)&pInfo->aCol, sizeof(pInfo->aCol[0]), 3); + if( i<0 ){ + return -1; } - memset(&pParse->aAgg[pParse->nAgg], 0, sizeof(pParse->aAgg[0])); - return pParse->nAgg++; + return i; +} + +/* +** Add a new element to the pAggInfo->aFunc[] array. Return the index of +** the new element. Return a negative number if malloc fails. +*/ +static int addAggInfoFunc(AggInfo *pInfo){ + int i; + i = sqlite3ArrayAllocate((void**)&pInfo->aFunc, sizeof(pInfo->aFunc[0]), 2); + if( i<0 ){ + return -1; + } + return i; +} + +/* +** This is an xFunc for walkExprTree() used to implement +** sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates +** for additional information. +** +** This routine analyzes the aggregate function at pExpr. +*/ +static int analyzeAggregate(void *pArg, Expr *pExpr){ + int i; + NameContext *pNC = (NameContext *)pArg; + Parse *pParse = pNC->pParse; + SrcList *pSrcList = pNC->pSrcList; + AggInfo *pAggInfo = pNC->pAggInfo; + + + switch( pExpr->op ){ + case TK_COLUMN: { + /* Check to see if the column is in one of the tables in the FROM + ** clause of the aggregate query */ + if( pSrcList ){ + struct SrcList_item *pItem = pSrcList->a; + for(i=0; inSrc; i++, pItem++){ + struct AggInfo_col *pCol; + if( pExpr->iTable==pItem->iCursor ){ + /* If we reach this point, it means that pExpr refers to a table + ** that is in the FROM clause of the aggregate query. + ** + ** Make an entry for the column in pAggInfo->aCol[] if there + ** is not an entry there already. + */ + pCol = pAggInfo->aCol; + for(i=0; inColumn; i++, pCol++){ + if( pCol->iTable==pExpr->iTable && + pCol->iColumn==pExpr->iColumn ){ + break; + } + } + if( i>=pAggInfo->nColumn && (i = addAggInfoColumn(pAggInfo))>=0 ){ + pCol = &pAggInfo->aCol[i]; + pCol->iTable = pExpr->iTable; + pCol->iColumn = pExpr->iColumn; + pCol->iMem = pParse->nMem++; + pCol->iSorterColumn = -1; + pCol->pExpr = pExpr; + if( pAggInfo->pGroupBy ){ + int j, n; + ExprList *pGB = pAggInfo->pGroupBy; + struct ExprList_item *pTerm = pGB->a; + n = pGB->nExpr; + for(j=0; jpExpr; + if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable && + pE->iColumn==pExpr->iColumn ){ + pCol->iSorterColumn = j; + break; + } + } + } + if( pCol->iSorterColumn<0 ){ + pCol->iSorterColumn = pAggInfo->nSortingColumn++; + } + } + /* There is now an entry for pExpr in pAggInfo->aCol[] (either + ** because it was there before or because we just created it). + ** Convert the pExpr to be a TK_AGG_COLUMN referring to that + ** pAggInfo->aCol[] entry. + */ + pExpr->pAggInfo = pAggInfo; + pExpr->op = TK_AGG_COLUMN; + pExpr->iAgg = i; + break; + } /* endif pExpr->iTable==pItem->iCursor */ + } /* end loop over pSrcList */ + } + return 1; + } + case TK_AGG_FUNCTION: { + /* The pNC->nDepth==0 test causes aggregate functions in subqueries + ** to be ignored */ + if( pNC->nDepth==0 ){ + /* Check to see if pExpr is a duplicate of another aggregate + ** function that is already in the pAggInfo structure + */ + struct AggInfo_func *pItem = pAggInfo->aFunc; + for(i=0; inFunc; i++, pItem++){ + if( sqlite3ExprCompare(pItem->pExpr, pExpr) ){ + break; + } + } + if( i>=pAggInfo->nFunc ){ + /* pExpr is original. Make a new entry in pAggInfo->aFunc[] + */ + u8 enc = ENC(pParse->db); + i = addAggInfoFunc(pAggInfo); + if( i>=0 ){ + pItem = &pAggInfo->aFunc[i]; + pItem->pExpr = pExpr; + pItem->iMem = pParse->nMem++; + pItem->pFunc = sqlite3FindFunction(pParse->db, + (char*)pExpr->token.z, pExpr->token.n, + pExpr->pList ? pExpr->pList->nExpr : 0, enc, 0); + if( pExpr->flags & EP_Distinct ){ + pItem->iDistinct = pParse->nTab++; + }else{ + pItem->iDistinct = -1; + } + } + } + /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry + */ + pExpr->iAgg = i; + pExpr->pAggInfo = pAggInfo; + return 1; + } + } + } + + /* Recursively walk subqueries looking for TK_COLUMN nodes that need + ** to be changed to TK_AGG_COLUMN. But increment nDepth so that + ** TK_AGG_FUNCTION nodes in subqueries will be unchanged. + */ + if( pExpr->pSelect ){ + pNC->nDepth++; + walkSelectExpr(pExpr->pSelect, analyzeAggregate, pNC); + pNC->nDepth--; + } + return 0; } /* @@ -1536,121 +2276,31 @@ static int appendAggInfo(Parse *pParse){ ** 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(). +** analyzed by sqlite3ExprResolveNames(). ** ** 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; +int sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){ + int nErr = pNC->pParse->nErr; + walkExprTree(pExpr, analyzeAggregate, pNC); + return pNC->pParse->nErr - nErr; +} - 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; +/* +** Call sqlite3ExprAnalyzeAggregates() for every expression in an +** expression list. Return the number of errors. +** +** If an error is found, the analysis is cut short. +*/ +int sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){ + struct ExprList_item *pItem; + int i; + int nErr = 0; + if( pList ){ + for(pItem=pList->a, i=0; nErr==0 && inExpr; i++, pItem++){ + nErr += sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr); } } 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; -} diff --git a/sqlite/func.c b/sqlite/func.c index 8854a5697..57b7d727b 100755 --- a/sqlite/func.c +++ b/sqlite/func.c @@ -16,100 +16,153 @@ ** sqliteRegisterBuildinFunctions() found at the bottom of the file. ** All other code has file scope. ** -** $Id: func.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** $Id: func.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ +#include "sqliteInt.h" #include -#include +/* #include */ #include #include -#include "sqliteInt.h" +#include "vdbeInt.h" #include "os.h" +/* +** Return the collating function associated with a function. +*/ +static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){ + return context->pColl; +} + /* ** Implementation of the non-aggregate min() and max() functions */ -static void minmaxFunc(sqlite_func *context, int argc, const char **argv){ - const char *zBest; +static void minmaxFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ int i; - int (*xCompare)(const char*, const char*); int mask; /* 0 for min() or 0xffffffff for max() */ + int iBest; + CollSeq *pColl; 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; i=0 ){ + iBest = i; } } - sqlite_set_result_string(context, zBest, -1); + sqlite3_result_value(context, argv[iBest]); } /* ** Return the type of the argument. */ -static void typeofFunc(sqlite_func *context, int argc, const char **argv){ - assert( argc==2 ); - sqlite_set_result_string(context, argv[1], -1); +static void typeofFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *z = 0; + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_NULL: z = "null"; break; + case SQLITE_INTEGER: z = "integer"; break; + case SQLITE_TEXT: z = "text"; break; + case SQLITE_FLOAT: z = "real"; break; + case SQLITE_BLOB: z = "blob"; break; + } + sqlite3_result_text(context, z, -1, SQLITE_STATIC); } + /* ** Implementation of the length() function */ -static void lengthFunc(sqlite_func *context, int argc, const char **argv){ - const char *z; +static void lengthFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ int len; assert( argc==1 ); - z = argv[0]; - if( z==0 ) return; -#ifdef SQLITE_UTF8 - for(len=0; *z; z++){ if( (0xc0&*z)!=0x80 ) len++; } -#else - len = strlen(z); -#endif - sqlite_set_result_int(context, len); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_BLOB: + case SQLITE_INTEGER: + case SQLITE_FLOAT: { + sqlite3_result_int(context, sqlite3_value_bytes(argv[0])); + break; + } + case SQLITE_TEXT: { + const unsigned char *z = sqlite3_value_text(argv[0]); + for(len=0; *z; z++){ if( (0xc0&*z)!=0x80 ) len++; } + sqlite3_result_int(context, len); + break; + } + default: { + sqlite3_result_null(context); + break; + } + } } /* ** Implementation of the abs() function */ -static void absFunc(sqlite_func *context, int argc, const char **argv){ - const char *z; +static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ assert( argc==1 ); - z = argv[0]; - if( z==0 ) return; - if( z[0]=='-' && isdigit(z[1]) ) z++; - sqlite_set_result_string(context, z, -1); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_INTEGER: { + i64 iVal = sqlite3_value_int64(argv[0]); + if( iVal<0 ){ + if( (iVal<<1)==0 ){ + sqlite3_result_error(context, "integer overflow", -1); + return; + } + iVal = -iVal; + } + sqlite3_result_int64(context, iVal); + break; + } + case SQLITE_NULL: { + sqlite3_result_null(context); + break; + } + default: { + double rVal = sqlite3_value_double(argv[0]); + if( rVal<0 ) rVal = -rVal; + sqlite3_result_double(context, rVal); + break; + } + } } /* ** Implementation of the substr() function */ -static void substrFunc(sqlite_func *context, int argc, const char **argv){ - const char *z; -#ifdef SQLITE_UTF8 - const char *z2; +static void substrFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *z; + const unsigned char *z2; int i; -#endif int p1, p2, len; + assert( argc==3 ); - z = argv[0]; + z = sqlite3_value_text(argv[0]); if( z==0 ) return; - p1 = atoi(argv[1]?argv[1]:0); - p2 = atoi(argv[2]?argv[2]:0); -#ifdef SQLITE_UTF8 + p1 = sqlite3_value_int(argv[1]); + p2 = sqlite3_value_int(argv[2]); for(len=0, z2=z; *z2; z2++){ if( (0xc0&*z2)!=0x80 ) len++; } -#else - len = strlen(z); -#endif if( p1<0 ){ p1 += len; if( p1<0 ){ @@ -122,7 +175,6 @@ static void substrFunc(sqlite_func *context, int argc, const char **argv){ 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); + if( argc==2 ){ + if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return; + n = sqlite3_value_int(argv[1]); + if( n>30 ) n = 30; + if( n<0 ) n = 0; + } + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + r = sqlite3_value_double(argv[0]); + sqlite3_snprintf(sizeof(zBuf),zBuf,"%.*f",n,r); + sqlite3_result_double(context, atof(zBuf)); } /* ** Implementation of the upper() and lower() SQL functions. */ -static void upperFunc(sqlite_func *context, int argc, const char **argv){ - char *z; +static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + unsigned char *z; int i; - if( argc<1 || argv[0]==0 ) return; - z = sqlite_set_result_string(context, argv[0], -1); + if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return; + z = sqliteMalloc(sqlite3_value_bytes(argv[0])+1); if( z==0 ) return; + strcpy((char*)z, (char*)sqlite3_value_text(argv[0])); for(i=0; z[i]; i++){ - if( islower(z[i]) ) z[i] = toupper(z[i]); + z[i] = toupper(z[i]); } + sqlite3_result_text(context, (char*)z, -1, SQLITE_TRANSIENT); + sqliteFree(z); } -static void lowerFunc(sqlite_func *context, int argc, const char **argv){ - char *z; +static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + unsigned char *z; int i; - if( argc<1 || argv[0]==0 ) return; - z = sqlite_set_result_string(context, argv[0], -1); + if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return; + z = sqliteMalloc(sqlite3_value_bytes(argv[0])+1); if( z==0 ) return; + strcpy((char*)z, (char*)sqlite3_value_text(argv[0])); for(i=0; z[i]; i++){ - if( isupper(z[i]) ) z[i] = tolower(z[i]); + z[i] = tolower(z[i]); } + sqlite3_result_text(context, (char*)z, -1, SQLITE_TRANSIENT); + sqliteFree(z); } /* @@ -182,11 +242,15 @@ static void lowerFunc(sqlite_func *context, int argc, const char **argv){ ** All three do the same thing. They return the first non-NULL ** argument. */ -static void ifnullFunc(sqlite_func *context, int argc, const char **argv){ +static void ifnullFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ int i; for(i=0; imatchOne; + u8 matchAll = pInfo->matchAll; + u8 matchSet = pInfo->matchSet; + u8 noCase = pInfo->noCase; + int prevEscape = 0; /* True if the previous character was 'escape' */ + + while( (c = *zPattern)!=0 ){ + if( !prevEscape && c==matchAll ){ + while( (c=zPattern[1]) == matchAll || c == matchOne ){ + if( c==matchOne ){ + if( *zString==0 ) return 0; + sqliteNextChar(zString); + } + zPattern++; + } + if( c && esc && sqlite3ReadUtf8(&zPattern[1])==esc ){ + u8 const *zTemp = &zPattern[1]; + sqliteNextChar(zTemp); + c = *zTemp; + } + if( c==0 ) return 1; + if( c==matchSet ){ + assert( esc==0 ); /* This is GLOB, not LIKE */ + while( *zString && patternCompare(&zPattern[1],zString,pInfo,esc)==0 ){ + sqliteNextChar(zString); + } + return *zString!=0; + }else{ + while( (c2 = *zString)!=0 ){ + if( noCase ){ + c2 = sqlite3UpperToLower[c2]; + c = sqlite3UpperToLower[c]; + while( c2 != 0 && c2 != c ){ c2 = sqlite3UpperToLower[*++zString]; } + }else{ + while( c2 != 0 && c2 != c ){ c2 = *++zString; } + } + if( c2==0 ) return 0; + if( patternCompare(&zPattern[1],zString,pInfo,esc) ) return 1; + sqliteNextChar(zString); + } + return 0; + } + }else if( !prevEscape && c==matchOne ){ + if( *zString==0 ) return 0; + sqliteNextChar(zString); + zPattern++; + }else if( c==matchSet ){ + int prior_c = 0; + assert( esc==0 ); /* This only occurs for GLOB, not LIKE */ + seen = 0; + invert = 0; + c = sqliteCharVal(zString); + if( c==0 ) return 0; + c2 = *++zPattern; + if( c2=='^' ){ invert = 1; c2 = *++zPattern; } + if( c2==']' ){ + if( c==']' ) seen = 1; + c2 = *++zPattern; + } + while( (c2 = sqliteCharVal(zPattern))!=0 && c2!=']' ){ + if( c2=='-' && zPattern[1]!=']' && zPattern[1]!=0 && prior_c>0 ){ + zPattern++; + c2 = sqliteCharVal(zPattern); + if( c>=prior_c && c<=c2 ) seen = 1; + prior_c = 0; + }else if( c==c2 ){ + seen = 1; + prior_c = c2; + }else{ + prior_c = c2; + } + sqliteNextChar(zPattern); + } + if( c2==0 || (seen ^ invert)==0 ) return 0; + sqliteNextChar(zString); + zPattern++; + }else if( esc && !prevEscape && sqlite3ReadUtf8(zPattern)==esc){ + prevEscape = 1; + sqliteNextChar(zPattern); + }else{ + if( noCase ){ + if( sqlite3UpperToLower[c] != sqlite3UpperToLower[*zString] ) return 0; + }else{ + if( c != *zString ) return 0; + } + zPattern++; + zString++; + prevEscape = 0; + } + } + return *zString==0; +} + +/* +** Count the number of times that the LIKE operator (or GLOB which is +** just a variation of LIKE) gets called. This is used for testing +** only. +*/ +#ifdef SQLITE_TEST +int sqlite3_like_count = 0; +#endif + + /* ** Implementation of the like() SQL function. This function implements ** the build-in LIKE operator. The first argument to the function is the -** string and the second argument is the pattern. So, the SQL statements: +** pattern and the second argument is the string. So, the SQL statements: ** ** A LIKE B ** -** is implemented as like(A,B). -*/ -static void likeFunc(sqlite_func *context, int arg, const char **argv){ - if( argv[0]==0 || argv[1]==0 ) return; - sqlite_set_result_int(context, - sqliteLikeCompare((const unsigned char*)argv[0], - (const unsigned char*)argv[1])); -} - -/* -** Implementation of the glob() SQL function. This function implements -** the build-in GLOB operator. The first argument to the function is the -** string and the second argument is the pattern. So, the SQL statements: +** is implemented as like(B,A). ** -** A GLOB B -** -** is implemented as glob(A,B). +** This same function (with a different compareInfo structure) computes +** the GLOB operator. */ -static void globFunc(sqlite_func *context, int arg, const char **argv){ - if( argv[0]==0 || argv[1]==0 ) return; - sqlite_set_result_int(context, - sqliteGlobCompare((const unsigned char*)argv[0], - (const unsigned char*)argv[1])); +static void likeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zA = sqlite3_value_text(argv[0]); + const unsigned char *zB = sqlite3_value_text(argv[1]); + int escape = 0; + if( argc==3 ){ + /* The escape character string must consist of a single UTF-8 character. + ** Otherwise, return an error. + */ + const unsigned char *zEsc = sqlite3_value_text(argv[2]); + if( sqlite3utf8CharLen((char*)zEsc, -1)!=1 ){ + sqlite3_result_error(context, + "ESCAPE expression must be a single character", -1); + return; + } + escape = sqlite3ReadUtf8(zEsc); + } + if( zA && zB ){ + struct compareInfo *pInfo = sqlite3_user_data(context); +#ifdef SQLITE_TEST + sqlite3_like_count++; +#endif + sqlite3_result_int(context, patternCompare(zA, zB, pInfo, escape)); + } } /* @@ -266,9 +524,14 @@ static void globFunc(sqlite_func *context, int arg, const char **argv){ ** argument if the arguments are different. The result is NULL if the ** arguments are equal to each other. */ -static void nullifFunc(sqlite_func *context, int argc, const char **argv){ - if( argv[0]!=0 && sqliteCompare(argv[0],argv[1])!=0 ){ - sqlite_set_result_string(context, argv[0], -1); +static void nullifFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + CollSeq *pColl = sqlite3GetFuncCollSeq(context); + if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ + sqlite3_result_value(context, argv[0]); } } @@ -276,10 +539,15 @@ static void nullifFunc(sqlite_func *context, int argc, const char **argv){ ** Implementation of the VERSION(*) function. The result is the version ** of the SQLite library that is running. */ -static void versionFunc(sqlite_func *context, int argc, const char **argv){ - sqlite_set_result_string(context, sqlite_version, -1); +static void versionFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + sqlite3_result_text(context, sqlite3_version, -1, SQLITE_STATIC); } + /* ** EXPERIMENTAL - This is not an official function. The interface may ** change. This function may disappear. Do not write code that depends @@ -291,29 +559,65 @@ static void versionFunc(sqlite_func *context, int argc, const char **argv){ ** "NULL". Otherwise, the argument is enclosed in single quotes with ** single-quote escapes. */ -static void quoteFunc(sqlite_func *context, int argc, const char **argv){ +static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ if( argc<1 ) return; - if( argv[0]==0 ){ - sqlite_set_result_string(context, "NULL", 4); - }else if( sqliteIsNumber(argv[0]) ){ - sqlite_set_result_string(context, argv[0], -1); - }else{ - int i,j,n; - char *z; - for(i=n=0; argv[0][i]; i++){ if( argv[0][i]=='\'' ) n++; } - z = sqliteMalloc( i+n+3 ); - if( z==0 ) return; - z[0] = '\''; - for(i=0, j=1; argv[0][i]; i++){ - z[j++] = argv[0][i]; - if( argv[0][i]=='\'' ){ - z[j++] = '\''; - } + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_NULL: { + sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC); + break; + } + case SQLITE_INTEGER: + case SQLITE_FLOAT: { + sqlite3_result_value(context, argv[0]); + break; + } + case SQLITE_BLOB: { + static const char hexdigits[] = { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' + }; + char *zText = 0; + int nBlob = sqlite3_value_bytes(argv[0]); + char const *zBlob = sqlite3_value_blob(argv[0]); + + zText = (char *)sqliteMalloc((2*nBlob)+4); + if( !zText ){ + sqlite3_result_error(context, "out of memory", -1); + }else{ + int i; + for(i=0; i>4)&0x0F]; + zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; + } + zText[(nBlob*2)+2] = '\''; + zText[(nBlob*2)+3] = '\0'; + zText[0] = 'X'; + zText[1] = '\''; + sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); + sqliteFree(zText); + } + break; + } + case SQLITE_TEXT: { + int i,j,n; + const unsigned char *zArg = sqlite3_value_text(argv[0]); + char *z; + + for(i=n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; } + z = sqliteMalloc( i+n+3 ); + if( z==0 ) return; + z[0] = '\''; + for(i=0, j=1; zArg[i]; i++){ + z[j++] = zArg[i]; + if( zArg[i]=='\'' ){ + z[j++] = '\''; + } + } + z[j++] = '\''; + z[j] = 0; + sqlite3_result_text(context, z, j, SQLITE_TRANSIENT); + sqliteFree(z); } - z[j++] = '\''; - z[j] = 0; - sqlite_set_result_string(context, z, j); - sqliteFree(z); } } @@ -321,9 +625,9 @@ static void quoteFunc(sqlite_func *context, int argc, const char **argv){ /* ** Compute the soundex encoding of a word. */ -static void soundexFunc(sqlite_func *context, int argc, const char **argv){ +static void soundexFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ char zResult[8]; - const char *zIn; + const u8 *zIn; int i, j; static const unsigned char iCode[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -336,7 +640,7 @@ static void soundexFunc(sqlite_func *context, int argc, const char **argv){ 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, }; assert( argc==1 ); - zIn = argv[0]; + zIn = (u8*)sqlite3_value_text(argv[0]); for(i=0; zIn[i] && !isalpha(zIn[i]); i++){} if( zIn[i] ){ zResult[0] = toupper(zIn[i]); @@ -350,9 +654,9 @@ static void soundexFunc(sqlite_func *context, int argc, const char **argv){ zResult[j++] = '0'; } zResult[j] = 0; - sqlite_set_result_string(context, zResult, 4); + sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); }else{ - sqlite_set_result_string(context, "?000", 4); + sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); } } #endif @@ -362,7 +666,7 @@ static void soundexFunc(sqlite_func *context, int argc, const char **argv){ ** 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 void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){ static const unsigned char zSrc[] = "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" @@ -371,14 +675,14 @@ static void randStr(sqlite_func *context, int argc, const char **argv){ int iMin, iMax, n, r, i; unsigned char zBuf[1000]; if( argc>=1 ){ - iMin = atoi(argv[0]); + iMin = sqlite3_value_int(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]); + iMax = sqlite3_value_int(argv[1]); if( iMax=sizeof(zBuf) ) iMax = sizeof(zBuf)-1; }else{ @@ -386,19 +690,134 @@ static void randStr(sqlite_func *context, int argc, const char **argv){ } n = iMin; if( iMax>iMin ){ - sqliteRandomness(sizeof(r), &r); + sqlite3Randomness(sizeof(r), &r); r &= 0x7fffffff; n += r%(iMax + 1 - iMin); } assert( nsum += sqliteAtoF(argv[0], 0); + int type; + assert( argc==1 ); + p = sqlite3_aggregate_context(context, sizeof(*p)); + type = sqlite3_value_numeric_type(argv[0]); + if( p && type!=SQLITE_NULL ){ p->cnt++; + if( type==SQLITE_INTEGER ){ + i64 v = sqlite3_value_int64(argv[0]); + p->rSum += v; + if( (p->approx|p->overflow)==0 ){ + i64 iNewSum = p->iSum + v; + int s1 = p->iSum >> (sizeof(i64)*8-1); + int s2 = v >> (sizeof(i64)*8-1); + int s3 = iNewSum >> (sizeof(i64)*8-1); + p->overflow = (s1&s2&~s3) | (~s1&~s2&s3); + p->iSum = iNewSum; + } + }else{ + p->rSum += sqlite3_value_double(argv[0]); + p->approx = 1; + } } } -static void sumFinalize(sqlite_func *context){ +static void sumFinalize(sqlite3_context *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)); + p = sqlite3_aggregate_context(context, 0); if( p && p->cnt>0 ){ - sqlite_set_result_double(context, p->sum/(double)p->cnt); + if( p->overflow ){ + sqlite3_result_error(context,"integer overflow",-1); + }else if( p->approx ){ + sqlite3_result_double(context, p->rSum); + }else{ + sqlite3_result_int64(context, p->iSum); + } } } - -/* -** 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 avgFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + if( p && p->cnt>0 ){ + sqlite3_result_double(context, p->rSum/(double)p->cnt); } } -static void 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))); - } +static void totalFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + sqlite3_result_double(context, p ? p->rSum : 0.0); } -#endif /* ** The following structure keeps track of state information for the @@ -479,168 +907,248 @@ static void stdDevFinalize(sqlite_func *context){ */ typedef struct CountCtx CountCtx; struct CountCtx { - int n; + i64 n; }; /* ** Routines to implement the count() aggregate function. */ -static void countStep(sqlite_func *context, int argc, const char **argv){ +static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ CountCtx *p; - p = sqlite_aggregate_context(context, sizeof(*p)); - if( (argc==0 || argv[0]) && p ){ + p = sqlite3_aggregate_context(context, sizeof(*p)); + if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ p->n++; } } -static void countFinalize(sqlite_func *context){ +static void countFinalize(sqlite3_context *context){ CountCtx *p; - p = sqlite_aggregate_context(context, sizeof(*p)); - sqlite_set_result_int(context, p ? p->n : 0); + p = sqlite3_aggregate_context(context, 0); + sqlite3_result_int64(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() */ +static void minmaxStep(sqlite3_context *context, int argc, sqlite3_value **argv){ + Mem *pArg = (Mem *)argv[0]; + Mem *pBest; - assert( argc==2 ); - if( argv[1][0]=='n' ){ - xCompare = sqliteCompare; + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); + if( !pBest ) return; + + if( pBest->flags ){ + int max; + int cmp; + CollSeq *pColl = sqlite3GetFuncCollSeq(context); + /* This step function is used for both the min() and max() aggregates, + ** the only difference between the two being that the sense of the + ** comparison is inverted. For the max() aggregate, the + ** sqlite3_user_data() function returns (void *)-1. For min() it + ** returns (void *)db, where db is the sqlite3* database pointer. + ** Therefore the next statement sets variable 'max' to 1 for the max() + ** aggregate, or 0 for min(). + */ + max = ((sqlite3_user_data(context)==(void *)-1)?1:0); + cmp = sqlite3MemCompare(pBest, pArg, pColl); + if( (max && cmp<0) || (!max && cmp>0) ){ + sqlite3VdbeMemCopy(pBest, pArg); + } }else{ - xCompare = strcmp; - } - mask = (int)sqlite_user_data(context); - p = sqlite_aggregate_context(context, sizeof(*p)); - if( p==0 || argc<1 || argv[0]==0 ) 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] = 1; - }else{ - p->z = sqliteMalloc( len+1 ); - p->zBuf[0] = 0; - if( p->z==0 ) return; - } - strcpy(p->z, argv[0]); + sqlite3VdbeMemCopy(pBest, pArg); } } -static void minMaxFinalize(sqlite_func *context){ - MinMaxCtx *p; - p = sqlite_aggregate_context(context, sizeof(*p)); - if( p && p->z ){ - sqlite_set_result_string(context, p->z, strlen(p->z)); - } - if( p && !p->zBuf[0] ){ - sqliteFree(p->z); +static void minMaxFinalize(sqlite3_context *context){ + sqlite3_value *pRes; + pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); + if( pRes ){ + if( pRes->flags ){ + sqlite3_result_value(context, pRes); + } + sqlite3VdbeMemRelease(pRes); } } + /* ** 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 { +void sqlite3RegisterBuiltinFunctions(sqlite3 *db){ + static const struct { char *zName; signed char nArg; - signed char dataType; - u8 argType; /* 0: none. 1: db 2: (-1) */ - void (*xFunc)(sqlite_func*,int,const char**); + u8 argType; /* 0: none. 1: db 2: (-1) */ + u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */ + u8 needCollSeq; + void (*xFunc)(sqlite3_context*,int,sqlite3_value **); } 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 }, + { "min", -1, 0, SQLITE_UTF8, 1, minmaxFunc }, + { "min", 0, 0, SQLITE_UTF8, 1, 0 }, + { "max", -1, 2, SQLITE_UTF8, 1, minmaxFunc }, + { "max", 0, 2, SQLITE_UTF8, 1, 0 }, + { "typeof", 1, 0, SQLITE_UTF8, 0, typeofFunc }, + { "length", 1, 0, SQLITE_UTF8, 0, lengthFunc }, + { "substr", 3, 0, SQLITE_UTF8, 0, substrFunc }, +#ifndef SQLITE_OMIT_UTF16 + { "substr", 3, 0, SQLITE_UTF16LE, 0, sqlite3utf16Substr }, +#endif + { "abs", 1, 0, SQLITE_UTF8, 0, absFunc }, + { "round", 1, 0, SQLITE_UTF8, 0, roundFunc }, + { "round", 2, 0, SQLITE_UTF8, 0, roundFunc }, + { "upper", 1, 0, SQLITE_UTF8, 0, upperFunc }, + { "lower", 1, 0, SQLITE_UTF8, 0, lowerFunc }, + { "coalesce", -1, 0, SQLITE_UTF8, 0, ifnullFunc }, + { "coalesce", 0, 0, SQLITE_UTF8, 0, 0 }, + { "coalesce", 1, 0, SQLITE_UTF8, 0, 0 }, + { "ifnull", 2, 0, SQLITE_UTF8, 1, ifnullFunc }, + { "random", -1, 0, SQLITE_UTF8, 0, randomFunc }, + { "nullif", 2, 0, SQLITE_UTF8, 1, nullifFunc }, + { "sqlite_version", 0, 0, SQLITE_UTF8, 0, versionFunc}, + { "quote", 1, 0, SQLITE_UTF8, 0, quoteFunc }, + { "last_insert_rowid", 0, 1, SQLITE_UTF8, 0, last_insert_rowid }, + { "changes", 0, 1, SQLITE_UTF8, 0, changes }, + { "total_changes", 0, 1, SQLITE_UTF8, 0, total_changes }, #ifdef SQLITE_SOUNDEX - { "soundex", 1, SQLITE_TEXT, 0, soundexFunc}, + { "soundex", 1, 0, SQLITE_UTF8, 0, soundexFunc}, #endif #ifdef SQLITE_TEST - { "randstr", 2, SQLITE_TEXT, 0, randStr }, + { "randstr", 2, 0, SQLITE_UTF8, 0, randStr }, + { "test_destructor", 1, 1, SQLITE_UTF8, 0, test_destructor}, + { "test_destructor_count", 0, 0, SQLITE_UTF8, 0, test_destructor_count}, + { "test_auxdata", -1, 0, SQLITE_UTF8, 0, test_auxdata}, + { "test_error", 1, 0, SQLITE_UTF8, 0, test_error}, #endif }; - static struct { + static const struct { char *zName; signed char nArg; - signed char dataType; u8 argType; - void (*xStep)(sqlite_func*,int,const char**); - void (*xFinalize)(sqlite_func*); + u8 needCollSeq; + void (*xStep)(sqlite3_context*,int,sqlite3_value**); + void (*xFinalize)(sqlite3_context*); } 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 + { "min", 1, 0, 1, minmaxStep, minMaxFinalize }, + { "max", 1, 2, 1, minmaxStep, minMaxFinalize }, + { "sum", 1, 0, 0, sumStep, sumFinalize }, + { "total", 1, 0, 0, sumStep, totalFinalize }, + { "avg", 1, 0, 0, sumStep, avgFinalize }, + { "count", 0, 0, 0, countStep, countFinalize }, + { "count", 1, 0, 0, countStep, countFinalize }, }; - static const char *azTypeFuncs[] = { "min", "max", "typeof" }; int i; for(i=0; ineedCollSeq = 1; + } } } +#ifndef SQLITE_OMIT_ALTERTABLE + sqlite3AlterFunctions(db); +#endif +#ifndef SQLITE_OMIT_PARSER + sqlite3AttachFunctions(db); +#endif for(i=0; iaFunc, azTypeFuncs[i], n); - while( p ){ - p->includeTypes = 1; - p = p->pNext; + void *pArg = 0; + switch( aAggs[i].argType ){ + case 1: pArg = db; break; + case 2: pArg = (void *)(-1); break; + } + sqlite3CreateFunc(db, aAggs[i].zName, aAggs[i].nArg, SQLITE_UTF8, + pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize); + if( aAggs[i].needCollSeq ){ + FuncDef *pFunc = sqlite3FindFunction( db, aAggs[i].zName, + strlen(aAggs[i].zName), aAggs[i].nArg, SQLITE_UTF8, 0); + if( pFunc && aAggs[i].needCollSeq ){ + pFunc->needCollSeq = 1; + } } } - sqliteRegisterDateTimeFunctions(db); + sqlite3RegisterDateTimeFunctions(db); +#ifdef SQLITE_SSE + (void)sqlite3SseFunctions(db); +#endif +#ifdef SQLITE_CASE_SENSITIVE_LIKE + sqlite3RegisterLikeFunctions(db, 1); +#else + sqlite3RegisterLikeFunctions(db, 0); +#endif +} + +/* +** Set the LIKEOPT flag on the 2-argument function with the given name. +*/ +static void setLikeOptFlag(sqlite3 *db, const char *zName, int flagVal){ + FuncDef *pDef; + pDef = sqlite3FindFunction(db, zName, strlen(zName), 2, SQLITE_UTF8, 0); + if( pDef ){ + pDef->flags = flagVal; + } +} + +/* +** Register the built-in LIKE and GLOB functions. The caseSensitive +** parameter determines whether or not the LIKE operator is case +** sensitive. GLOB is always case sensitive. +*/ +void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ + struct compareInfo *pInfo; + if( caseSensitive ){ + pInfo = (struct compareInfo*)&likeInfoAlt; + }else{ + pInfo = (struct compareInfo*)&likeInfoNorm; + } + sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0); + sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0); + sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8, + (struct compareInfo*)&globInfo, likeFunc, 0,0); + setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE); + setLikeOptFlag(db, "like", + caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE); +} + +/* +** pExpr points to an expression which implements a function. If +** it is appropriate to apply the LIKE optimization to that function +** then set aWc[0] through aWc[2] to the wildcard characters and +** return TRUE. If the function is not a LIKE-style function then +** return FALSE. +*/ +int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ + FuncDef *pDef; + if( pExpr->op!=TK_FUNCTION ){ + return 0; + } + if( pExpr->pList->nExpr!=2 ){ + return 0; + } + pDef = sqlite3FindFunction(db, (char*)pExpr->token.z, pExpr->token.n, 2, + SQLITE_UTF8, 0); + if( pDef==0 || (pDef->flags & SQLITE_FUNC_LIKE)==0 ){ + return 0; + } + + /* The memcpy() statement assumes that the wildcard characters are + ** the first three statements in the compareInfo structure. The + ** asserts() that follow verify that assumption + */ + memcpy(aWc, pDef->pUserData, 3); + assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); + assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); + assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); + *pIsNocase = (pDef->flags & SQLITE_FUNC_CASE)==0; + return 1; } diff --git a/sqlite/hash.c b/sqlite/hash.c index 1590cd12b..1f64d1d74 100755 --- a/sqlite/hash.c +++ b/sqlite/hash.c @@ -12,7 +12,7 @@ ** This is the implementation of generic hash-tables ** used in SQLite. ** -** $Id: hash.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** $Id: hash.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #include "sqliteInt.h" #include @@ -20,7 +20,7 @@ /* 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. +** "pNew" 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 @@ -29,42 +29,47 @@ ** 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; +void sqlite3HashInit(Hash *pNew, int keyClass, int copyKey){ + assert( pNew!=0 ); + assert( keyClass>=SQLITE_HASH_STRING && keyClass<=SQLITE_HASH_BINARY ); + pNew->keyClass = keyClass; +#if 0 + if( keyClass==SQLITE_HASH_POINTER || keyClass==SQLITE_HASH_INT ) copyKey = 0; +#endif + pNew->copyKey = copyKey; + pNew->first = 0; + pNew->count = 0; + pNew->htsize = 0; + pNew->ht = 0; + pNew->xMalloc = sqlite3MallocX; + pNew->xFree = sqlite3FreeX; } /* 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){ +void sqlite3HashClear(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); + if( pH->ht ) pH->xFree(pH->ht); pH->ht = 0; pH->htsize = 0; while( elem ){ HashElem *next_elem = elem->next; if( pH->copyKey && elem->pKey ){ - sqliteFree(elem->pKey); + pH->xFree(elem->pKey); } - sqliteFree(elem); + pH->xFree(elem); elem = next_elem; } pH->count = 0; } +#if 0 /* NOT USED */ /* ** Hash and comparison functions when the mode is SQLITE_HASH_INT */ @@ -74,6 +79,7 @@ static int intHash(const void *pKey, int nKey){ static int intCompare(const void *pKey1, int n1, const void *pKey2, int n2){ return n2 - n1; } +#endif #if 0 /* NOT USED */ /* @@ -94,11 +100,18 @@ static int ptrCompare(const void *pKey1, int n1, const void *pKey2, int n2){ ** Hash and comparison functions when the mode is SQLITE_HASH_STRING */ static int strHash(const void *pKey, int nKey){ - return sqliteHashNoCase((const char*)pKey, nKey); + const char *z = (const char *)pKey; + int h = 0; + if( nKey<=0 ) nKey = strlen(z); + while( nKey > 0 ){ + h = (h<<3) ^ h ^ sqlite3UpperToLower[(unsigned char)*z++]; + nKey--; + } + return h & 0x7fffffff; } static int strCompare(const void *pKey1, int n1, const void *pKey2, int n2){ - if( n1!=n2 ) return n2-n1; - return sqliteStrNICmp((const char*)pKey1,(const char*)pKey2,n1); + if( n1!=n2 ) return 1; + return sqlite3StrNICmp((const char*)pKey1,(const char*)pKey2,n1); } /* @@ -113,7 +126,7 @@ static int binHash(const void *pKey, int nKey){ return h & 0x7fffffff; } static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){ - if( n1!=n2 ) return n2-n1; + if( n1!=n2 ) return 1; return memcmp(pKey1,pKey2,n1); } @@ -130,14 +143,23 @@ static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){ ** with types "const void*" and "int" and returns an "int". */ static int (*hashFunction(int keyClass))(const void*,int){ +#if 0 /* HASH_INT and HASH_POINTER are never used */ switch( keyClass ){ case SQLITE_HASH_INT: return &intHash; - /* case SQLITE_HASH_POINTER: return &ptrHash; // NOT USED */ + case SQLITE_HASH_POINTER: return &ptrHash; case SQLITE_HASH_STRING: return &strHash; case SQLITE_HASH_BINARY: return &binHash;; default: break; } return 0; +#else + if( keyClass==SQLITE_HASH_STRING ){ + return &strHash; + }else{ + assert( keyClass==SQLITE_HASH_BINARY ); + return &binHash; + } +#endif } /* @@ -147,14 +169,48 @@ static int (*hashFunction(int keyClass))(const void*,int){ ** see the header comment on the previous function. */ static int (*compareFunction(int keyClass))(const void*,int,const void*,int){ +#if 0 /* HASH_INT and HASH_POINTER are never used */ switch( keyClass ){ case SQLITE_HASH_INT: return &intCompare; - /* case SQLITE_HASH_POINTER: return &ptrCompare; // NOT USED */ + case SQLITE_HASH_POINTER: return &ptrCompare; case SQLITE_HASH_STRING: return &strCompare; case SQLITE_HASH_BINARY: return &binCompare; default: break; } return 0; +#else + if( keyClass==SQLITE_HASH_STRING ){ + return &strCompare; + }else{ + assert( keyClass==SQLITE_HASH_BINARY ); + return &binCompare; + } +#endif +} + +/* Link an element into the hash table +*/ +static void insertElement( + Hash *pH, /* The complete hash table */ + struct _ht *pEntry, /* The entry into which pNew is inserted */ + HashElem *pNew /* The element to be inserted */ +){ + HashElem *pHead; /* First element already in pEntry */ + pHead = pEntry->chain; + if( pHead ){ + pNew->next = pHead; + pNew->prev = pHead->prev; + if( pHead->prev ){ pHead->prev->next = pNew; } + else { pH->first = pNew; } + pHead->prev = pNew; + }else{ + pNew->next = pH->first; + if( pH->first ){ pH->first->prev = pNew; } + pNew->prev = 0; + pH->first = pNew; + } + pEntry->count++; + pEntry->chain = pNew; } @@ -165,34 +221,19 @@ static int (*compareFunction(int keyClass))(const void*,int,const void*,int){ 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) ); + new_ht = (struct _ht *)pH->xMalloc( new_size*sizeof(struct _ht) ); if( new_ht==0 ) return; - if( pH->ht ) sqliteFree(pH->ht); + if( pH->ht ) pH->xFree(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++; + insertElement(pH, &new_ht[h], elem); } } @@ -211,8 +252,9 @@ static HashElem *findElementGivenHash( int (*xCompare)(const void*,int,const void*,int); /* comparison function */ if( pH->ht ){ - elem = pH->ht[h].chain; - count = pH->ht[h].count; + struct _ht *pEntry = &pH->ht[h]; + elem = pEntry->chain; + count = pEntry->count; xCompare = compareFunction(pH->keyClass); while( count-- && elem ){ if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ @@ -232,6 +274,7 @@ static void removeElementGivenHash( HashElem* elem, /* The element to be removed from the pH */ int h /* Hash value for the element */ ){ + struct _ht *pEntry; if( elem->prev ){ elem->prev->next = elem->next; }else{ @@ -240,25 +283,31 @@ static void removeElementGivenHash( if( elem->next ){ elem->next->prev = elem->prev; } - if( pH->ht[h].chain==elem ){ - pH->ht[h].chain = elem->next; + pEntry = &pH->ht[h]; + if( pEntry->chain==elem ){ + pEntry->chain = elem->next; } - pH->ht[h].count--; - if( pH->ht[h].count<=0 ){ - pH->ht[h].chain = 0; + pEntry->count--; + if( pEntry->count<=0 ){ + pEntry->chain = 0; } if( pH->copyKey && elem->pKey ){ - sqliteFree(elem->pKey); + pH->xFree(elem->pKey); } - sqliteFree( elem ); + pH->xFree( elem ); pH->count--; + if( pH->count<=0 ){ + assert( pH->first==0 ); + assert( pH->count==0 ); + sqlite3HashClear(pH); + } } /* Attempt to locate an element of the hash table pH with a key ** that matches pKey,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){ +void *sqlite3HashFind(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 */ @@ -287,7 +336,7 @@ void *sqliteHashFind(const Hash *pH, const void *pKey, int nKey){ ** 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){ +void *sqlite3HashInsert(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 */ @@ -311,12 +360,12 @@ void *sqliteHashInsert(Hash *pH, const void *pKey, int nKey, void *data){ return old_data; } if( data==0 ) return 0; - new_elem = (HashElem*)sqliteMalloc( sizeof(HashElem) ); + new_elem = (HashElem*)pH->xMalloc( sizeof(HashElem) ); if( new_elem==0 ) return data; if( pH->copyKey && pKey!=0 ){ - new_elem->pKey = sqliteMallocRaw( nKey ); + new_elem->pKey = pH->xMalloc( nKey ); if( new_elem->pKey==0 ){ - sqliteFree(new_elem); + pH->xFree(new_elem); return data; } memcpy((void*)new_elem->pKey, pKey, nKey); @@ -325,32 +374,21 @@ void *sqliteHashInsert(Hash *pH, const void *pKey, int nKey, void *data){ } 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; + rehash(pH,8); + if( pH->htsize==0 ){ + pH->count = 0; + pH->xFree(new_elem); + return data; + } } if( pH->count > pH->htsize ){ rehash(pH,pH->htsize*2); } + assert( pH->htsize>0 ); 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; + insertElement(pH, &pH->ht[h], new_elem); new_elem->data = data; return 0; } diff --git a/sqlite/hash.h b/sqlite/hash.h index 6c860c44e..8bc3125e3 100755 --- a/sqlite/hash.h +++ b/sqlite/hash.h @@ -12,7 +12,7 @@ ** This is the header file for the generic hash-table implemenation ** used in SQLite. ** -** $Id: hash.h,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** $Id: hash.h,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #ifndef _SQLITE_HASH_H_ #define _SQLITE_HASH_H_ @@ -34,6 +34,8 @@ struct Hash { 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 */ + void *(*xMalloc)(int); /* malloc() function to use */ + void (*xFree)(void *); /* free() function to use */ int htsize; /* Number of buckets in the hash table */ struct _ht { /* the hash table */ int count; /* Number of entries with this hash */ @@ -70,7 +72,7 @@ struct HashElem { ** 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_INT 1 // NOT USED */ /* #define SQLITE_HASH_POINTER 2 // NOT USED */ #define SQLITE_HASH_STRING 3 #define SQLITE_HASH_BINARY 4 @@ -78,10 +80,10 @@ struct HashElem { /* ** 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*); +void sqlite3HashInit(Hash*, int keytype, int copyKey); +void *sqlite3HashInsert(Hash*, const void *pKey, int nKey, void *pData); +void *sqlite3HashFind(const Hash*, const void *pKey, int nKey); +void sqlite3HashClear(Hash*); /* ** Macros for looping over all elements of a hash table. The idiom is diff --git a/sqlite/insert.c b/sqlite/insert.c index 0ab30bc8e..214f5bd6b 100755 --- a/sqlite/insert.c +++ b/sqlite/insert.c @@ -12,10 +12,112 @@ ** This file contains C code routines that are called by the parser ** to handle INSERT statements in SQLite. ** -** $Id: insert.c,v 1.1.1.1 2004-03-11 22:22:24 alex Exp $ +** $Id: insert.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #include "sqliteInt.h" +/* +** Set P3 of the most recently inserted opcode to a column affinity +** string for index pIdx. A column affinity string has one character +** for each column in the table, according to the affinity of the column: +** +** Character Column affinity +** ------------------------------ +** 'a' TEXT +** 'b' NONE +** 'c' NUMERIC +** 'd' INTEGER +** 'e' REAL +*/ +void sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){ + if( !pIdx->zColAff ){ + /* The first time a column affinity string for a particular index is + ** required, it is allocated and populated here. It is then stored as + ** a member of the Index structure for subsequent use. + ** + ** The column affinity string will eventually be deleted by + ** sqliteDeleteIndex() when the Index structure itself is cleaned + ** up. + */ + int n; + Table *pTab = pIdx->pTable; + pIdx->zColAff = (char *)sqliteMalloc(pIdx->nColumn+1); + if( !pIdx->zColAff ){ + return; + } + for(n=0; nnColumn; n++){ + pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity; + } + pIdx->zColAff[pIdx->nColumn] = '\0'; + } + + sqlite3VdbeChangeP3(v, -1, pIdx->zColAff, 0); +} + +/* +** Set P3 of the most recently inserted opcode to a column affinity +** string for table pTab. A column affinity string has one character +** for each column indexed by the index, according to the affinity of the +** column: +** +** Character Column affinity +** ------------------------------ +** 'a' TEXT +** 'b' NONE +** 'c' NUMERIC +** 'd' INTEGER +** 'e' REAL +*/ +void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){ + /* The first time a column affinity string for a particular table + ** is required, it is allocated and populated here. It is then + ** stored as a member of the Table structure for subsequent use. + ** + ** The column affinity string will eventually be deleted by + ** sqlite3DeleteTable() when the Table structure itself is cleaned up. + */ + if( !pTab->zColAff ){ + char *zColAff; + int i; + + zColAff = (char *)sqliteMalloc(pTab->nCol+1); + if( !zColAff ){ + return; + } + + for(i=0; inCol; i++){ + zColAff[i] = pTab->aCol[i].affinity; + } + zColAff[pTab->nCol] = '\0'; + + pTab->zColAff = zColAff; + } + + sqlite3VdbeChangeP3(v, -1, pTab->zColAff, 0); +} + +/* +** Return non-zero if SELECT statement p opens the table with rootpage +** iTab in database iDb. This is used to see if a statement of the form +** "INSERT INTO SELECT ..." can run without using temporary +** table for the results of the SELECT. +** +** No checking is done for sub-selects that are part of expressions. +*/ +static int selectReadsTable(Select *p, Schema *pSchema, int iTab){ + int i; + struct SrcList_item *pItem; + if( p->pSrc==0 ) return 0; + for(i=0, pItem=p->pSrc->a; ipSrc->nSrc; i++, pItem++){ + if( pItem->pSelect ){ + if( selectReadsTable(pItem->pSelect, pSchema, iTab) ) return 1; + }else{ + if( pItem->pTab->pSchema==pSchema && pItem->pTab->tnum==iTab ) return 1; + } + } + return 0; +} + /* ** This routine is call to handle SQL of the following forms: ** @@ -83,7 +185,7 @@ ** end the loop ** cleanup */ -void sqliteInsert( +void sqlite3Insert( Parse *pParse, /* Parser context */ SrcList *pTabList, /* Name of table into which we are inserting */ ExprList *pList, /* List of values to be inserted */ @@ -98,25 +200,34 @@ void sqliteInsert( 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 base = 0; /* VDBE Cursor number for pTab */ + int iCont=0,iBreak=0; /* Beginning and end of the loop over srcTab */ + sqlite3 *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 useTempTable = 0; /* Store SELECT results in intermediate table */ + int srcTab = 0; /* Data comes from this temporary cursor if >=0 */ + int iSelectLoop = 0; /* Address of code that implements the SELECT */ + int iCleanup = 0; /* Address of the cleanup code */ + int iInsertBlock = 0; /* Address of the subroutine used to insert data */ + int iCntMem = 0; /* Memory cell used for the row counter */ + int newIdx = -1; /* Cursor for the NEW table */ + Db *pDb; /* The database containing table being inserted into */ + int counterMem = 0; /* Memory cell holding AUTOINCREMENT counter */ + int iDb; - 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 */ +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True if attempting to insert into a view */ + int triggers_exist = 0; /* True if there are FOR EACH ROW triggers */ +#endif - if( pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup; +#ifndef SQLITE_OMIT_AUTOINCREMENT + int counterRowid = 0; /* Memory cell holding rowid of autoinc counter */ +#endif + + if( pParse->nErr || sqlite3MallocFailed() ){ + goto insert_cleanup; + } db = pParse->db; /* Locate the table into which we will be inserting new information. @@ -124,48 +235,86 @@ void sqliteInsert( assert( pTabList->nSrc==1 ); zTab = pTabList->a[0].zName; if( zTab==0 ) goto insert_cleanup; - pTab = sqliteSrcListLookup(pParse, pTabList); + pTab = sqlite3SrcListLookup(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) ){ + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDbnDb ); + pDb = &db->aDb[iDb]; + zDb = pDb->zName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){ goto insert_cleanup; } + /* Figure out if we have any triggers and if the table being + ** inserted into is a view + */ +#ifndef SQLITE_OMIT_TRIGGER + triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0); + isView = pTab->pSelect!=0; +#else +# define triggers_exist 0 +# define isView 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + /* 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) ){ + if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){ goto insert_cleanup; } - if( pTab==0 ) goto insert_cleanup; + assert( pTab!=0 ); /* If pTab is really a view, make sure it has been initialized. */ - if( isView && sqliteViewGetColumnNames(pParse, pTab) ){ + if( isView && sqlite3ViewGetColumnNames(pParse, pTab) ){ goto insert_cleanup; } /* Allocate a VDBE */ - v = sqliteGetVdbe(pParse); + v = sqlite3GetVdbe(pParse); if( v==0 ) goto insert_cleanup; - sqliteBeginWriteOperation(pParse, pSelect || row_triggers_exist, pTab->iDb); + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, pSelect || triggers_exist, iDb); /* if there are row triggers, allocate a temp table for new.* references. */ - if( row_triggers_exist ){ + if( triggers_exist ){ newIdx = pParse->nTab++; } +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* If this is an AUTOINCREMENT table, look up the sequence number in the + ** sqlite_sequence table and store it in memory cell counterMem. Also + ** remember the rowid of the sqlite_sequence table entry in memory cell + ** counterRowid. + */ + if( pTab->autoInc ){ + int iCur = pParse->nTab; + int addr = sqlite3VdbeCurrentAddr(v); + counterRowid = pParse->nMem++; + counterMem = pParse->nMem++; + sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenRead); + sqlite3VdbeAddOp(v, OP_Rewind, iCur, addr+13); + sqlite3VdbeAddOp(v, OP_Column, iCur, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->zName, 0); + sqlite3VdbeAddOp(v, OP_Ne, 0x100, addr+12); + sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0); + sqlite3VdbeAddOp(v, OP_MemStore, counterRowid, 1); + sqlite3VdbeAddOp(v, OP_Column, iCur, 1); + sqlite3VdbeAddOp(v, OP_MemStore, counterMem, 1); + sqlite3VdbeAddOp(v, OP_Goto, 0, addr+13); + sqlite3VdbeAddOp(v, OP_Next, iCur, addr+4); + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); + } +#endif /* SQLITE_OMIT_AUTOINCREMENT */ + /* 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 @@ -178,13 +327,18 @@ void sqliteInsert( /* 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); + iInitCode = sqlite3VdbeAddOp(v, OP_Goto, 0, 0); + iSelectLoop = sqlite3VdbeCurrentAddr(v); + iInsertBlock = sqlite3VdbeMakeLabel(v); + + /* Resolve the expressions in the SELECT statement and execute it. */ + rc = sqlite3Select(pParse, pSelect, SRT_Subroutine, iInsertBlock,0,0,0,0); + if( rc || pParse->nErr || sqlite3MallocFailed() ){ + goto insert_cleanup; + } + + iCleanup = sqlite3VdbeMakeLabel(v); + sqlite3VdbeAddOp(v, OP_Goto, 0, iCleanup); assert( pSelect->pEList ); nColumn = pSelect->pEList->nExpr; @@ -196,17 +350,8 @@ void sqliteInsert( ** of the tables being read by the SELECT statement. Also use a ** temp table in the case of row triggers. */ - if( row_triggers_exist ){ + if( triggers_exist || selectReadsTable(pSelect,pTab->pSchema,pTab->tnum) ){ 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 ){ @@ -214,40 +359,39 @@ void sqliteInsert( ** 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); + sqlite3VdbeResolveLabel(v, iInsertBlock); + sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0); + sqlite3VdbeAddOp(v, OP_NewRowid, srcTab, 0); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + sqlite3VdbeAddOp(v, OP_Insert, srcTab, 0); + sqlite3VdbeAddOp(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); + sqlite3VdbeJumpHere(v, iInitCode); + sqlite3VdbeAddOp(v, OP_OpenVirtual, srcTab, 0); + sqlite3VdbeAddOp(v, OP_SetNumColumns, srcTab, nColumn); + sqlite3VdbeAddOp(v, OP_Goto, 0, iSelectLoop); + sqlite3VdbeResolveLabel(v, iCleanup); }else{ - sqliteVdbeChangeP2(v, iInitCode, sqliteVdbeCurrentAddr(v)); + sqlite3VdbeJumpHere(v, iInitCode); } }else{ /* This is the case if the data for the INSERT is coming from a VALUES ** clause */ - SrcList dummy; + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; 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) ){ + if( sqlite3ExprResolveNames(&sNC, pList->a[i].pExpr) ){ goto insert_cleanup; } } @@ -257,13 +401,13 @@ void sqliteInsert( ** of columns to be inserted into the table. */ if( pColumn==0 && nColumn!=pTab->nCol ){ - sqliteErrorMsg(pParse, + sqlite3ErrorMsg(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); + sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId); goto insert_cleanup; } @@ -284,7 +428,7 @@ void sqliteInsert( } for(i=0; inId; i++){ for(j=0; jnCol; j++){ - if( sqliteStrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){ + if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){ pColumn->a[i].idx = j; if( j==pTab->iPKey ){ keyColumn = i; @@ -293,10 +437,10 @@ void sqliteInsert( } } if( j>=pTab->nCol ){ - if( sqliteIsRowid(pColumn->a[i].zName) ){ + if( sqlite3IsRowid(pColumn->a[i].zName) ){ keyColumn = i; }else{ - sqliteErrorMsg(pParse, "table %S has no column named %s", + sqlite3ErrorMsg(pParse, "table %S has no column named %s", pTabList, 0, pColumn->a[i].zName); pParse->nErr++; goto insert_cleanup; @@ -315,23 +459,22 @@ void sqliteInsert( /* Open the temp table for FOR EACH ROW triggers */ - if( row_triggers_exist ){ - sqliteVdbeAddOp(v, OP_OpenPseudo, newIdx, 0); + if( triggers_exist ){ + sqlite3VdbeAddOp(v, OP_OpenPseudo, newIdx, 0); + sqlite3VdbeAddOp(v, OP_SetNumColumns, newIdx, pTab->nCol); } /* 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); + sqlite3VdbeAddOp(v, OP_MemInt, 0, iCntMem); } /* Open tables and indices if there are no row triggers */ - if( !row_triggers_exist ){ + if( !triggers_exist ){ base = pParse->nTab; - idx = sqliteOpenTableAndIndices(pParse, pTab, base); - pParse->nTab += idx; + sqlite3OpenTableAndIndices(pParse, pTab, base, OP_OpenWrite); } /* If the data source is a temporary table, then we have to create @@ -340,18 +483,18 @@ void sqliteInsert( ** to launch the SELECT statement processing. */ if( useTempTable ){ - iBreak = sqliteVdbeMakeLabel(v); - sqliteVdbeAddOp(v, OP_Rewind, srcTab, iBreak); - iCont = sqliteVdbeCurrentAddr(v); + iBreak = sqlite3VdbeMakeLabel(v); + sqlite3VdbeAddOp(v, OP_Rewind, srcTab, iBreak); + iCont = sqlite3VdbeCurrentAddr(v); }else if( pSelect ){ - sqliteVdbeAddOp(v, OP_Goto, 0, iSelectLoop); - sqliteVdbeResolveLabel(v, iInsertBlock); + sqlite3VdbeAddOp(v, OP_Goto, 0, iSelectLoop); + sqlite3VdbeResolveLabel(v, iInsertBlock); } /* Run the BEFORE and INSTEAD OF triggers, if there are any */ - endOfLoop = sqliteVdbeMakeLabel(v); - if( before_triggers ){ + endOfLoop = sqlite3VdbeMakeLabel(v); + if( triggers_exist & TRIGGER_BEFORE ){ /* 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 @@ -360,17 +503,16 @@ void sqliteInsert( ** not happened yet) so we substitute a rowid of -1 */ if( keyColumn<0 ){ - sqliteVdbeAddOp(v, OP_Integer, -1, 0); + sqlite3VdbeAddOp(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); + sqlite3VdbeAddOp(v, OP_Column, srcTab, keyColumn); }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); + assert( pSelect==0 ); /* Otherwise useTempTable is true */ + sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr); + sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_Integer, -1, 0); + sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0); } /* Create the new column data @@ -384,20 +526,28 @@ void sqliteInsert( } } if( pColumn && j>=pColumn->nId ){ - sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zDflt, P3_STATIC); + sqlite3ExprCode(pParse, pTab->aCol[i].pDflt); }else if( useTempTable ){ - sqliteVdbeAddOp(v, OP_Column, srcTab, j); - }else if( pSelect ){ - sqliteVdbeAddOp(v, OP_Dup, nColumn-j-1, 1); + sqlite3VdbeAddOp(v, OP_Column, srcTab, j); }else{ - sqliteExprCode(pParse, pList->a[j].pExpr); + assert( pSelect==0 ); /* Otherwise useTempTable is true */ + sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr); } } - sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); - sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0); + sqlite3VdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); + + /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger, + ** do not attempt any conversions before assembling the record. + ** If this is a real table, attempt conversions as required by the + ** table column affinities. + */ + if( !isView ){ + sqlite3TableAffinityStr(v, pTab); + } + sqlite3VdbeAddOp(v, OP_Insert, newIdx, 0); /* Fire BEFORE or INSTEAD OF triggers */ - if( sqliteCodeRowTrigger(pParse, TK_INSERT, 0, TK_BEFORE, pTab, + if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_BEFORE, pTab, newIdx, -1, onError, endOfLoop) ){ goto insert_cleanup; } @@ -406,36 +556,40 @@ void sqliteInsert( /* If any triggers exists, the opening of tables and indices is deferred ** until now. */ - if( row_triggers_exist && !isView ){ + if( triggers_exist && !isView ){ base = pParse->nTab; - idx = sqliteOpenTableAndIndices(pParse, pTab, base); - pParse->nTab += idx; + sqlite3OpenTableAndIndices(pParse, pTab, base, OP_OpenWrite); } /* Push the record number for the new entry onto the stack. The - ** record number is a randomly generate integer created by NewRecno + ** record number is a randomly generate integer created by NewRowid ** 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); + sqlite3VdbeAddOp(v, OP_Column, srcTab, keyColumn); }else if( pSelect ){ - sqliteVdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1); + sqlite3VdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1); }else{ - sqliteExprCode(pParse, pList->a[keyColumn].pExpr); + sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr); } - /* If the PRIMARY KEY expression is NULL, then use OP_NewRecno + /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid ** 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); + sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_NewRowid, base, counterMem); + sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0); }else{ - sqliteVdbeAddOp(v, OP_NewRecno, base, 0); + sqlite3VdbeAddOp(v, OP_NewRowid, base, counterMem); } +#ifndef SQLITE_OMIT_AUTOINCREMENT + if( pTab->autoInc ){ + sqlite3VdbeAddOp(v, OP_MemMax, counterMem, 0); + } +#endif /* SQLITE_OMIT_AUTOINCREMENT */ /* Push onto the stack, data for all columns of the new entry, beginning ** with the first column. @@ -446,7 +600,7 @@ void sqliteInsert( ** 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); + sqlite3VdbeAddOp(v, OP_Null, 0, 0); continue; } if( pColumn==0 ){ @@ -457,85 +611,106 @@ void sqliteInsert( } } if( pColumn && j>=pColumn->nId ){ - sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zDflt, P3_STATIC); + sqlite3ExprCode(pParse, pTab->aCol[i].pDflt); }else if( useTempTable ){ - sqliteVdbeAddOp(v, OP_Column, srcTab, j); + sqlite3VdbeAddOp(v, OP_Column, srcTab, j); }else if( pSelect ){ - sqliteVdbeAddOp(v, OP_Dup, i+nColumn-j, 1); + sqlite3VdbeAddOp(v, OP_Dup, i+nColumn-j, 1); }else{ - sqliteExprCode(pParse, pList->a[j].pExpr); + sqlite3ExprCode(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, + sqlite3GenerateConstraintChecks(pParse, pTab, base, 0, keyColumn>=0, 0, onError, endOfLoop); - sqliteCompleteInsertion(pParse, pTab, base, 0,0,0, - after_triggers ? newIdx : -1); + sqlite3CompleteInsertion(pParse, pTab, base, 0,0,0, + (triggers_exist & TRIGGER_AFTER)!=0 ? newIdx : -1); } /* Update the count of rows that are inserted */ if( (db->flags & SQLITE_CountRows)!=0 ){ - sqliteVdbeAddOp(v, OP_MemIncr, iCntMem, 0); + sqlite3VdbeAddOp(v, OP_MemIncr, 1, iCntMem); } - if( row_triggers_exist ){ + if( triggers_exist ){ /* Close all tables opened */ if( !isView ){ - sqliteVdbeAddOp(v, OP_Close, base, 0); + sqlite3VdbeAddOp(v, OP_Close, base, 0); for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){ - sqliteVdbeAddOp(v, OP_Close, idx+base, 0); + sqlite3VdbeAddOp(v, OP_Close, idx+base, 0); } } /* Code AFTER triggers */ - if( sqliteCodeRowTrigger(pParse, TK_INSERT, 0, TK_AFTER, pTab, newIdx, -1, - onError, endOfLoop) ){ + if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_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); + sqlite3VdbeResolveLabel(v, endOfLoop); if( useTempTable ){ - sqliteVdbeAddOp(v, OP_Next, srcTab, iCont); - sqliteVdbeResolveLabel(v, iBreak); - sqliteVdbeAddOp(v, OP_Close, srcTab, 0); + sqlite3VdbeAddOp(v, OP_Next, srcTab, iCont); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp(v, OP_Close, srcTab, 0); }else if( pSelect ){ - sqliteVdbeAddOp(v, OP_Pop, nColumn, 0); - sqliteVdbeAddOp(v, OP_Return, 0, 0); - sqliteVdbeResolveLabel(v, iCleanup); + sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0); + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + sqlite3VdbeResolveLabel(v, iCleanup); } - if( !row_triggers_exist ){ + if( !triggers_exist ){ /* Close all tables opened */ - sqliteVdbeAddOp(v, OP_Close, base, 0); + sqlite3VdbeAddOp(v, OP_Close, base, 0); for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){ - sqliteVdbeAddOp(v, OP_Close, idx+base, 0); + sqlite3VdbeAddOp(v, OP_Close, idx+base, 0); } } - sqliteVdbeAddOp(v, OP_SetCounts, 0, 0); - sqliteEndWriteOperation(pParse); +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Update the sqlite_sequence table by storing the content of the + ** counter value in memory counterMem back into the sqlite_sequence + ** table. + */ + if( pTab->autoInc ){ + int iCur = pParse->nTab; + int addr = sqlite3VdbeCurrentAddr(v); + sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenWrite); + sqlite3VdbeAddOp(v, OP_MemLoad, counterRowid, 0); + sqlite3VdbeAddOp(v, OP_NotNull, -1, addr+7); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_NewRowid, iCur, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->zName, 0); + sqlite3VdbeAddOp(v, OP_MemLoad, counterMem, 0); + sqlite3VdbeAddOp(v, OP_MakeRecord, 2, 0); + sqlite3VdbeAddOp(v, OP_Insert, iCur, 0); + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); + } +#endif /* - ** Return the number of rows inserted. + ** Return the number of rows inserted. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. */ - if( db->flags & SQLITE_CountRows ){ - sqliteVdbeOp3(v, OP_ColumnName, 0, 1, "rows inserted", P3_STATIC); - sqliteVdbeAddOp(v, OP_MemLoad, iCntMem, 0); - sqliteVdbeAddOp(v, OP_Callback, 1, 0); + if( db->flags & SQLITE_CountRows && pParse->nested==0 && !pParse->trigStack ){ + sqlite3VdbeAddOp(v, OP_MemLoad, iCntMem, 0); + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", P3_STATIC); } insert_cleanup: - sqliteSrcListDelete(pTabList); - if( pList ) sqliteExprListDelete(pList); - if( pSelect ) sqliteSelectDelete(pSelect); - sqliteIdListDelete(pColumn); + sqlite3SrcListDelete(pTabList); + sqlite3ExprListDelete(pList); + sqlite3SelectDelete(pSelect); + sqlite3IdListDelete(pColumn); } /* @@ -544,11 +719,11 @@ insert_cleanup: ** 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 +** 1. The rowid 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. +** 2. The rowid of the row after the update. ** ** 3. The data in the first column of the entry after the update. ** @@ -556,9 +731,9 @@ insert_cleanup: ** ** 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 old rowid shown as entry (1) above is omitted unless both isUpdate +** and rowidChng are 1. isUpdate is true for UPDATEs and false for +** INSERTs and rowidChng 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. @@ -574,12 +749,12 @@ insert_cleanup: ** Constraint type Action What Happens ** --------------- ---------- ---------------------------------------- ** any ROLLBACK The current transaction is rolled back and -** sqlite_exec() returns immediately with a +** sqlite3_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 +** cause sqlite3_exec() to return immediately ** with SQLITE_CONSTRAINT. ** ** any FAIL Sqlite_exec() returns immediately with a @@ -617,12 +792,12 @@ insert_cleanup: ** is still pointing at the same entry after the routine returns. ** Without the isUpdate flag, the "base" cursor might be moved. */ -void sqliteGenerateConstraintChecks( +void sqlite3GenerateConstraintChecks( 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 rowidChng, /* 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 */ @@ -636,11 +811,10 @@ void sqliteGenerateConstraintChecks( int iCur; Index *pIdx; int seenReplace = 0; - int jumpInst1, jumpInst2; - int contAddr; - int hasTwoRecnos = (isUpdate && recnoChng); + int jumpInst1=0, jumpInst2; + int hasTwoRowids = (isUpdate && rowidChng); - v = sqliteGetVdbe(pParse); + v = sqlite3GetVdbe(pParse); assert( v!=0 ); assert( pTab->pSelect==0 ); /* This table is not a VIEW */ nCol = pTab->nCol; @@ -655,67 +829,81 @@ void sqliteGenerateConstraintChecks( 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 ){ + if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){ onError = OE_Abort; } - sqliteVdbeAddOp(v, OP_Dup, nCol-1-i, 1); - addr = sqliteVdbeAddOp(v, OP_NotNull, 1, 0); + sqlite3VdbeAddOp(v, OP_Dup, nCol-1-i, 1); + addr = sqlite3VdbeAddOp(v, OP_NotNull, 1, 0); + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail + || onError==OE_Ignore || onError==OE_Replace ); switch( onError ){ case OE_Rollback: case OE_Abort: case OE_Fail: { char *zMsg = 0; - sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError); - sqliteSetString(&zMsg, pTab->zName, ".", pTab->aCol[i].zName, + sqlite3VdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError); + sqlite3SetString(&zMsg, pTab->zName, ".", pTab->aCol[i].zName, " may not be NULL", (char*)0); - sqliteVdbeChangeP3(v, -1, zMsg, P3_DYNAMIC); + sqlite3VdbeChangeP3(v, -1, zMsg, P3_DYNAMIC); break; } case OE_Ignore: { - sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0); - sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest); + sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0); + sqlite3VdbeAddOp(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); + sqlite3ExprCode(pParse, pTab->aCol[i].pDflt); + sqlite3VdbeAddOp(v, OP_Push, nCol-i, 0); break; } - default: assert(0); } - sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v)); + sqlite3VdbeJumpHere(v, addr); } /* Test all CHECK constraints */ - /**** TBD ****/ +#ifndef SQLITE_OMIT_CHECK + if( pTab->pCheck && (pParse->db->flags & SQLITE_IgnoreChecks)==0 ){ + int allOk = sqlite3VdbeMakeLabel(v); + assert( pParse->ckOffset==0 ); + pParse->ckOffset = nCol; + sqlite3ExprIfTrue(pParse, pTab->pCheck, allOk, 1); + assert( pParse->ckOffset==nCol ); + pParse->ckOffset = 0; + onError = overrideError!=OE_Default ? overrideError : OE_Abort; + if( onError==OE_Ignore || onError==OE_Replace ){ + sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest); + }else{ + sqlite3VdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError); + } + sqlite3VdbeResolveLabel(v, allOk); + } +#endif /* !defined(SQLITE_OMIT_CHECK) */ /* 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 ){ + if( rowidChng ){ 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); + sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1); + sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1); + jumpInst1 = sqlite3VdbeAddOp(v, OP_Eq, 0, 0); } - sqliteVdbeAddOp(v, OP_Dup, nCol, 1); - jumpInst2 = sqliteVdbeAddOp(v, OP_NotExists, base, 0); + sqlite3VdbeAddOp(v, OP_Dup, nCol, 1); + jumpInst2 = sqlite3VdbeAddOp(v, OP_NotExists, base, 0); switch( onError ){ default: { onError = OE_Abort; @@ -724,32 +912,31 @@ void sqliteGenerateConstraintChecks( case OE_Rollback: case OE_Abort: case OE_Fail: { - sqliteVdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, + sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, "PRIMARY KEY must be unique", P3_STATIC); break; } case OE_Replace: { - sqliteGenerateRowIndexDelete(pParse->db, v, pTab, base, 0); + sqlite3GenerateRowIndexDelete(v, pTab, base, 0); if( isUpdate ){ - sqliteVdbeAddOp(v, OP_Dup, nCol+hasTwoRecnos, 1); - sqliteVdbeAddOp(v, OP_MoveTo, base, 0); + sqlite3VdbeAddOp(v, OP_Dup, nCol+hasTwoRowids, 1); + sqlite3VdbeAddOp(v, OP_MoveGe, 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); + sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest); break; } } - contAddr = sqliteVdbeCurrentAddr(v); - sqliteVdbeChangeP2(v, jumpInst2, contAddr); + sqlite3VdbeJumpHere(v, jumpInst2); if( isUpdate ){ - sqliteVdbeChangeP2(v, jumpInst1, contAddr); - sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1); - sqliteVdbeAddOp(v, OP_MoveTo, base, 0); + sqlite3VdbeJumpHere(v, jumpInst1); + sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1); + sqlite3VdbeAddOp(v, OP_MoveGe, base, 0); } } @@ -763,25 +950,23 @@ void sqliteGenerateConstraintChecks( extra++; /* Create a key for accessing the index entry */ - sqliteVdbeAddOp(v, OP_Dup, nCol+extra, 1); + sqlite3VdbeAddOp(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); + sqlite3VdbeAddOp(v, OP_Dup, i+extra+nCol+1, 1); }else{ - sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol-idx, 1); + sqlite3VdbeAddOp(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); + jumpInst1 = sqlite3VdbeAddOp(v, OP_MakeIdxRec, pIdx->nColumn, 0); + sqlite3IndexAffinityStr(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; } @@ -792,10 +977,12 @@ void sqliteGenerateConstraintChecks( /* 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); + sqlite3VdbeAddOp(v, OP_Dup, extra+nCol+1+hasTwoRowids, 1); + jumpInst2 = sqlite3VdbeAddOp(v, OP_IsUnique, base+iCur+1, 0); /* Generate code that executes if the new index entry is not unique */ + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail + || onError==OE_Ignore || onError==OE_Replace ); switch( onError ){ case OE_Rollback: case OE_Abort: @@ -822,50 +1009,48 @@ void sqliteGenerateConstraintChecks( } strcpy(&zErrMsg[n1], pIdx->nColumn>1 ? " are not unique" : " is not unique"); - sqliteVdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, zErrMsg, 0); + sqlite3VdbeOp3(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); + sqlite3VdbeAddOp(v, OP_Pop, nCol+extra+3+hasTwoRowids, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest); break; } case OE_Replace: { - sqliteGenerateRowDelete(pParse->db, v, pTab, base, 0); + sqlite3GenerateRowDelete(pParse->db, v, pTab, base, 0); if( isUpdate ){ - sqliteVdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRecnos, 1); - sqliteVdbeAddOp(v, OP_MoveTo, base, 0); + sqlite3VdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRowids, 1); + sqlite3VdbeAddOp(v, OP_MoveGe, base, 0); } seenReplace = 1; break; } - default: assert(0); } - contAddr = sqliteVdbeCurrentAddr(v); #if NULL_DISTINCT_FOR_UNIQUE - sqliteVdbeChangeP2(v, jumpInst1, contAddr); + sqlite3VdbeJumpHere(v, jumpInst1); #endif - sqliteVdbeChangeP2(v, jumpInst2, contAddr); + sqlite3VdbeJumpHere(v, jumpInst2); } } /* ** This routine generates code to finish the INSERT or UPDATE operation -** that was started by a prior call to sqliteGenerateConstraintChecks. +** that was started by a prior call to sqlite3GenerateConstraintChecks. ** The stack must contain keys for all active indices followed by data -** and the recno for the new entry. This routine creates the new +** and the rowid 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. +** arguments to sqlite3GenerateConstraintChecks. */ -void sqliteCompleteInsertion( +void sqlite3CompleteInsertion( 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 rowidChng, /* 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 */ ){ @@ -873,47 +1058,66 @@ void sqliteCompleteInsertion( Vdbe *v; int nIdx; Index *pIdx; + int pik_flags; - v = sqliteGetVdbe(pParse); + v = sqlite3GetVdbe(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); + sqlite3VdbeAddOp(v, OP_IdxInsert, base+i+1, 0); } - sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); + sqlite3VdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); + sqlite3TableAffinityStr(v, pTab); +#ifndef SQLITE_OMIT_TRIGGER if( newIdx>=0 ){ - sqliteVdbeAddOp(v, OP_Dup, 1, 0); - sqliteVdbeAddOp(v, OP_Dup, 1, 0); - sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0); + sqlite3VdbeAddOp(v, OP_Dup, 1, 0); + sqlite3VdbeAddOp(v, OP_Dup, 1, 0); + sqlite3VdbeAddOp(v, OP_Insert, 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); +#endif + if( pParse->nested ){ + pik_flags = 0; + }else{ + pik_flags = OPFLAG_NCHANGE; + pik_flags |= (isUpdate?OPFLAG_ISUPDATE:OPFLAG_LASTROWID); + } + sqlite3VdbeAddOp(v, OP_Insert, base, pik_flags); + if( !pParse->nested ){ + sqlite3VdbeChangeP3(v, -1, pTab->zName, P3_STATIC); + } + + if( isUpdate && rowidChng ){ + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); } } /* -** Generate code that will open write cursors for a table and for all +** Generate code that will open 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){ +void sqlite3OpenTableAndIndices( + Parse *pParse, /* Parsing context */ + Table *pTab, /* Table to be opened */ + int base, /* Cursor number assigned to the table */ + int op /* OP_OpenRead or OP_OpenWrite */ +){ int i; + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); Index *pIdx; - Vdbe *v = sqliteGetVdbe(pParse); + Vdbe *v = sqlite3GetVdbe(pParse); assert( v!=0 ); - sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); - sqliteVdbeOp3(v, OP_OpenWrite, base, pTab->tnum, pTab->zName, P3_STATIC); + sqlite3OpenTable(pParse, base, iDb, pTab, op); 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); + KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx); + assert( pIdx->pSchema==pTab->pSchema ); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + VdbeComment((v, "# %s", pIdx->zName)); + sqlite3VdbeOp3(v, op, i+base, pIdx->tnum, (char*)pKey, P3_KEYINFO_HANDOFF); + } + if( pParse->nTab<=base+i ){ + pParse->nTab = base+i; } - return i; } diff --git a/sqlite/keywordhash.h b/sqlite/keywordhash.h new file mode 100755 index 000000000..53a4bf191 --- /dev/null +++ b/sqlite/keywordhash.h @@ -0,0 +1,98 @@ +/* Hash score: 159 */ +static int keywordCode(const char *z, int n){ + static const char zText[537] = + "ABORTABLEFTEMPORARYADDATABASELECTHENDEFAULTRANSACTIONATURALTER" + "AISEACHECKEYAFTEREFERENCESCAPELSEXCEPTRIGGEREGEXPLAINITIALLYANALYZE" + "XCLUSIVEXISTSTATEMENTANDEFERRABLEATTACHAVINGLOBEFOREIGNOREINDEX" + "AUTOINCREMENTBEGINNERENAMEBETWEENOTNULLIKEBYCASCADEFERREDELETE" + "CASECASTCOLLATECOLUMNCOMMITCONFLICTCONSTRAINTERSECTCREATECROSS" + "CURRENT_DATECURRENT_TIMESTAMPLANDESCDETACHDISTINCTDROPRAGMATCH" + "FAILIMITFROMFULLGROUPDATEIFIMMEDIATEINSERTINSTEADINTOFFSETISNULL" + "JOINORDEREPLACEOUTERESTRICTPRIMARYQUERYRIGHTROLLBACKROWHENUNION" + "UNIQUEUSINGVACUUMVALUESVIEWHERE"; + static const unsigned char aHash[127] = { + 92, 80, 107, 91, 0, 4, 0, 0, 114, 0, 83, 0, 0, + 95, 44, 76, 93, 0, 106, 109, 97, 90, 0, 10, 0, 0, + 113, 0, 110, 103, 0, 28, 48, 0, 41, 0, 0, 65, 71, + 0, 63, 19, 0, 105, 36, 104, 0, 108, 74, 0, 0, 33, + 0, 61, 37, 0, 8, 0, 115, 38, 12, 0, 77, 40, 25, + 66, 0, 0, 31, 81, 53, 30, 50, 20, 88, 0, 34, 0, + 75, 26, 0, 72, 0, 0, 0, 64, 47, 67, 22, 87, 29, + 69, 86, 0, 1, 0, 9, 101, 58, 18, 0, 112, 82, 99, + 54, 6, 85, 0, 0, 49, 94, 0, 102, 0, 70, 0, 0, + 15, 0, 116, 51, 56, 0, 2, 55, 0, 111, + }; + static const unsigned char aNext[116] = { + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, + 0, 11, 0, 0, 0, 0, 5, 13, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 43, 0, 0, 0, 0, 0, + 0, 0, 16, 0, 23, 52, 0, 0, 0, 0, 45, 0, 59, + 0, 0, 0, 0, 0, 0, 0, 0, 73, 42, 0, 24, 60, + 21, 0, 79, 0, 0, 68, 0, 0, 84, 46, 0, 0, 0, + 0, 0, 0, 0, 0, 39, 96, 98, 0, 0, 100, 0, 32, + 0, 14, 27, 78, 0, 57, 89, 0, 35, 0, 62, 0, + }; + static const unsigned char aLen[116] = { + 5, 5, 4, 4, 9, 2, 3, 8, 2, 6, 4, 3, 7, + 11, 2, 7, 5, 5, 4, 5, 3, 5, 10, 6, 4, 6, + 7, 6, 7, 9, 3, 7, 9, 6, 9, 3, 10, 6, 6, + 4, 6, 3, 7, 6, 7, 5, 13, 2, 2, 5, 5, 6, + 7, 3, 7, 4, 4, 2, 7, 3, 8, 6, 4, 4, 7, + 6, 6, 8, 10, 9, 6, 5, 12, 12, 17, 4, 4, 6, + 8, 2, 4, 6, 5, 4, 5, 4, 4, 5, 6, 2, 9, + 6, 7, 4, 2, 6, 3, 6, 4, 5, 7, 5, 8, 7, + 5, 5, 8, 3, 4, 5, 6, 5, 6, 6, 4, 5, + }; + static const unsigned short int aOffset[116] = { + 0, 4, 7, 10, 10, 14, 19, 21, 26, 27, 32, 34, 36, + 42, 51, 52, 57, 61, 65, 67, 71, 74, 78, 86, 91, 94, + 99, 105, 108, 113, 118, 122, 128, 136, 141, 150, 152, 162, 167, + 172, 175, 177, 177, 181, 185, 187, 192, 194, 196, 205, 208, 212, + 218, 224, 224, 227, 230, 234, 236, 237, 241, 248, 254, 258, 262, + 269, 275, 281, 289, 296, 305, 311, 316, 328, 328, 344, 348, 352, + 358, 359, 366, 369, 373, 378, 381, 386, 390, 394, 397, 403, 405, + 414, 420, 427, 430, 430, 433, 436, 442, 446, 450, 457, 461, 469, + 476, 481, 486, 494, 496, 500, 505, 511, 516, 522, 528, 531, + }; + static const unsigned char aCode[116] = { + TK_ABORT, TK_TABLE, TK_JOIN_KW, TK_TEMP, TK_TEMP, + TK_OR, TK_ADD, TK_DATABASE, TK_AS, TK_SELECT, + TK_THEN, TK_END, TK_DEFAULT, TK_TRANSACTION,TK_ON, + TK_JOIN_KW, TK_ALTER, TK_RAISE, TK_EACH, TK_CHECK, + TK_KEY, TK_AFTER, TK_REFERENCES, TK_ESCAPE, TK_ELSE, + TK_EXCEPT, TK_TRIGGER, TK_LIKE_KW, TK_EXPLAIN, TK_INITIALLY, + TK_ALL, TK_ANALYZE, TK_EXCLUSIVE, TK_EXISTS, TK_STATEMENT, + TK_AND, TK_DEFERRABLE, TK_ATTACH, TK_HAVING, TK_LIKE_KW, + TK_BEFORE, TK_FOR, TK_FOREIGN, TK_IGNORE, TK_REINDEX, + TK_INDEX, TK_AUTOINCR, TK_TO, TK_IN, TK_BEGIN, + TK_JOIN_KW, TK_RENAME, TK_BETWEEN, TK_NOT, TK_NOTNULL, + TK_NULL, TK_LIKE_KW, TK_BY, TK_CASCADE, TK_ASC, + TK_DEFERRED, TK_DELETE, TK_CASE, TK_CAST, TK_COLLATE, + TK_COLUMNKW, TK_COMMIT, TK_CONFLICT, TK_CONSTRAINT, TK_INTERSECT, + TK_CREATE, TK_JOIN_KW, TK_CTIME_KW, TK_CTIME_KW, TK_CTIME_KW, + TK_PLAN, TK_DESC, TK_DETACH, TK_DISTINCT, TK_IS, + TK_DROP, TK_PRAGMA, TK_MATCH, TK_FAIL, TK_LIMIT, + TK_FROM, TK_JOIN_KW, TK_GROUP, TK_UPDATE, TK_IF, + TK_IMMEDIATE, TK_INSERT, TK_INSTEAD, TK_INTO, TK_OF, + TK_OFFSET, TK_SET, TK_ISNULL, TK_JOIN, TK_ORDER, + TK_REPLACE, TK_JOIN_KW, TK_RESTRICT, TK_PRIMARY, TK_QUERY, + TK_JOIN_KW, TK_ROLLBACK, TK_ROW, TK_WHEN, TK_UNION, + TK_UNIQUE, TK_USING, TK_VACUUM, TK_VALUES, TK_VIEW, + TK_WHERE, + }; + int h, i; + if( n<2 ) return TK_ID; + h = ((charMap(z[0])*4) ^ + (charMap(z[n-1])*3) ^ + n) % 127; + for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){ + if( aLen[i]==n && sqlite3StrNICmp(&zText[aOffset[i]],z,n)==0 ){ + return aCode[i]; + } + } + return TK_ID; +} +int sqlite3KeywordCode(const unsigned char *z, int n){ + return keywordCode((char*)z, n); +} diff --git a/sqlite/legacy.c b/sqlite/legacy.c new file mode 100755 index 000000000..a17329612 --- /dev/null +++ b/sqlite/legacy.c @@ -0,0 +1,135 @@ +/* +** 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: legacy.c,v 1.1 2006-04-13 12:44:29 guy Exp $ +*/ + +#include "sqliteInt.h" +#include "os.h" +#include + +/* +** 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 sqlite3_exec( + sqlite3 *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + sqlite3_callback xCallback, /* Invoke this callback routine */ + void *pArg, /* First argument to xCallback() */ + char **pzErrMsg /* Write error messages here */ +){ + int rc = SQLITE_OK; + const char *zLeftover; + sqlite3_stmt *pStmt = 0; + char **azCols = 0; + + int nRetry = 0; + int nChange = 0; + int nCallback; + + if( zSql==0 ) return SQLITE_OK; + while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0] ){ + int nCol; + char **azVals = 0; + + pStmt = 0; + rc = sqlite3_prepare(db, zSql, -1, &pStmt, &zLeftover); + assert( rc==SQLITE_OK || pStmt==0 ); + if( rc!=SQLITE_OK ){ + continue; + } + if( !pStmt ){ + /* this happens for a comment or white-space */ + zSql = zLeftover; + continue; + } + + db->nChange += nChange; + nCallback = 0; + + nCol = sqlite3_column_count(pStmt); + azCols = sqliteMalloc(2*nCol*sizeof(const char *) + 1); + if( azCols==0 ){ + goto exec_out; + } + + while( 1 ){ + int i; + rc = sqlite3_step(pStmt); + + /* Invoke the callback function if required */ + if( xCallback && (SQLITE_ROW==rc || + (SQLITE_DONE==rc && !nCallback && db->flags&SQLITE_NullCallback)) ){ + if( 0==nCallback ){ + for(i=0; ipVdbe==0 ){ + nChange = db->nChange; + } + if( rc!=SQLITE_SCHEMA ){ + nRetry = 0; + zSql = zLeftover; + while( isspace((unsigned char)zSql[0]) ) zSql++; + } + break; + } + } + + sqliteFree(azCols); + azCols = 0; + } + +exec_out: + if( pStmt ) sqlite3_finalize(pStmt); + if( azCols ) sqliteFree(azCols); + + rc = sqlite3ApiExit(0, rc); + if( rc!=SQLITE_OK && rc==sqlite3_errcode(db) && pzErrMsg ){ + *pzErrMsg = malloc(1+strlen(sqlite3_errmsg(db))); + if( *pzErrMsg ){ + strcpy(*pzErrMsg, sqlite3_errmsg(db)); + } + }else if( pzErrMsg ){ + *pzErrMsg = 0; + } + + return rc; +} diff --git a/sqlite/main.c b/sqlite/main.c index 8d379ae42..7bea8e6b5 100755 --- a/sqlite/main.c +++ b/sqlite/main.c @@ -14,567 +14,136 @@ ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** -** $Id: main.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** $Id: main.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #include "sqliteInt.h" #include "os.h" #include /* -** A pointer to this structure is used to communicate information -** from sqliteInit into the sqliteInitCallback. +** The following constant value is used by the SQLITE_BIGENDIAN and +** SQLITE_LITTLEENDIAN macros. */ -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 *azArg[6]; - char zDbNum[30]; - int meta[SQLITE_N_BTREE_META]; - InitData initData; - - /* - ** 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" - ")" - ; - - /* 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.) - */ - static char init_script[] = - "SELECT type, name, rootpage, sql, 1 FROM sqlite_temp_master " - "UNION ALL " - "SELECT type, name, rootpage, sql, 0 FROM sqlite_master"; - static char older_init_script[] = - "SELECT type, name, rootpage, sql, 1 FROM sqlite_temp_master " - "UNION ALL " - "SELECT type, name, rootpage, sql, 0 FROM sqlite_master " - "WHERE type='table' " - "UNION ALL " - "SELECT type, name, rootpage, sql, 0 FROM sqlite_master " - "WHERE type='index'"; - - - assert( iDb>=0 && iDb!=1 && iDbnDb ); - - /* Construct the schema tables: sqlite_master and sqlite_temp_master - */ - sqliteSafetyOff(db); - azArg[0] = "table"; - azArg[1] = MASTER_NAME; - azArg[2] = "2"; - azArg[3] = master_schema; - sprintf(zDbNum, "%d", iDb); - azArg[4] = zDbNum; - azArg[5] = 0; - initData.db = db; - initData.pzErrMsg = pzErrMsg; - sqliteInitCallback(&initData, 5, azArg, 0); - pTab = sqliteFindTable(db, MASTER_NAME, "main"); - if( pTab ){ - pTab->readOnly = 1; - } - if( iDb==0 ){ - azArg[1] = TEMP_MASTER_NAME; - azArg[3] = temp_master_schema; - azArg[4] = "1"; - sqliteInitCallback(&initData, 5, azArg, 0); - pTab = sqliteFindTable(db, TEMP_MASTER_NAME, "temp"); - if( pTab ){ - pTab->readOnly = 1; - } - } - 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( 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( 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); - if( iDb==0 ){ - rc = sqlite_exec(db, - db->file_format>=2 ? init_script : older_init_script, - sqliteInitCallback, &initData, 0); - }else{ - char *zSql = 0; - sqliteSetString(&zSql, - "SELECT type, name, rootpage, sql, ", zDbNum, " FROM \"", - db->aDb[iDb].zName, "\".sqlite_master", (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); - if( iDb==0 ){ - DbSetProperty(db, 1, 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) ) continue; - assert( i!=1 ); /* Should have been initialized together with 0 */ - rc = sqliteInitOne(db, i, pzErrMsg); - if( rc ){ - sqliteResetInternalSchema(db, i); - } - } - 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; -} +const int sqlite3one = 1; /* ** The version of the library */ -const char rcsid[] = "@(#) \044Id: SQLite version " SQLITE_VERSION " $"; -const char sqlite_version[] = SQLITE_VERSION; +const char sqlite3_version[] = SQLITE_VERSION; +const char *sqlite3_libversion(void){ return sqlite3_version; } +int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; } /* -** Does the library expect data to be encoded as UTF-8 or iso8859? The -** following global constant always lets us know. +** This is the default collating function named "BINARY" which is always +** available. */ -#ifdef SQLITE_UTF8 -const char sqlite_encoding[] = "UTF-8"; -#else -const char sqlite_encoding[] = "iso8859"; -#endif +static int binCollFunc( + void *NotUsed, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + int rc, n; + n = nKey1onError = 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); +static int nocaseCollatingFunc( + void *NotUsed, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + int r = sqlite3StrNICmp( + (const char *)pKey1, (const char *)pKey2, (nKey1temp_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 r; } /* ** Return the ROWID of the most recent insert */ -int sqlite_last_insert_rowid(sqlite *db){ +sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){ return db->lastRowid; } /* -** Return the number of changes in the most recent call to sqlite_exec(). +** Return the number of changes in the most recent call to sqlite3_exec(). */ -int sqlite_changes(sqlite *db){ +int sqlite3_changes(sqlite3 *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 +** Return the number of changes since the database handle was opened. */ -int sqlite_last_statement_changes(sqlite *db){ - return db->lsChange; +int sqlite3_total_changes(sqlite3 *db){ + return db->nTotalChange; } /* ** Close an existing SQLite database */ -void sqlite_close(sqlite *db){ +int sqlite3_close(sqlite3 *db){ HashElem *i; int j; - db->want_to_close = 1; - if( sqliteSafetyCheck(db) || sqliteSafetyOn(db) ){ - /* printf("DID NOT CLOSE\n"); fflush(stdout); */ - return; + + if( !db ){ + return SQLITE_OK; } - db->magic = SQLITE_MAGIC_CLOSED; + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + +#ifdef SQLITE_SSE + { + extern void sqlite3SseCleanup(sqlite3*); + sqlite3SseCleanup(db); + } +#endif + + /* If there are any outstanding VMs, return SQLITE_BUSY. */ + if( db->pVdbe ){ + sqlite3Error(db, SQLITE_BUSY, + "Unable to close due to unfinalised statements"); + return SQLITE_BUSY; + } + assert( !sqlite3SafetyCheck(db) ); + + /* FIX ME: db->magic may be set to SQLITE_MAGIC_CLOSED if the database + ** cannot be opened for some reason. So this routine needs to run in + ** that case. But maybe there should be an extra magic value for the + ** "failed to open" state. + */ + if( db->magic!=SQLITE_MAGIC_CLOSED && sqlite3SafetyOn(db) ){ + /* printf("DID NOT CLOSE\n"); fflush(stdout); */ + return SQLITE_ERROR; + } + for(j=0; jnDb; j++){ struct Db *pDb = &db->aDb[j]; if( pDb->pBt ){ - sqliteBtreeClose(pDb->pBt); + sqlite3BtreeClose(pDb->pBt); pDb->pBt = 0; + if( j!=1 ){ + pDb->pSchema = 0; + } } } - sqliteResetInternalSchema(db, 0); + sqlite3ResetInternalSchema(db, 0); assert( db->nDb<=2 ); assert( db->aDb==db->aDbStatic ); for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){ @@ -584,242 +153,69 @@ void sqlite_close(sqlite *db){ sqliteFree(pFunc); } } - sqliteHashClear(&db->aFunc); + + for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){ + CollSeq *pColl = (CollSeq *)sqliteHashData(i); + sqliteFree(pColl); + } + sqlite3HashClear(&db->aCollSeq); + + sqlite3HashClear(&db->aFunc); + sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */ + if( db->pErr ){ + sqlite3ValueFree(db->pErr); + } + + db->magic = SQLITE_MAGIC_ERROR; + + /* The temp-database schema is allocated differently from the other schema + ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()). + ** So it needs to be freed here. Todo: Why not roll the temp schema into + ** the same sqliteMalloc() as the one that allocates the database + ** structure? + */ + sqliteFree(db->aDb[1].pSchema); sqliteFree(db); + sqlite3ReleaseThreadData(); + return SQLITE_OK; } /* ** Rollback all database files. */ -void sqliteRollbackAll(sqlite *db){ +void sqlite3RollbackAll(sqlite3 *db){ int i; + int inTrans = 0; for(i=0; inDb; i++){ if( db->aDb[i].pBt ){ - sqliteBtreeRollback(db->aDb[i].pBt); + if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){ + inTrans = 1; + } + sqlite3BtreeRollback(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; - } - } + if( db->flags&SQLITE_InternChanges ){ + sqlite3ResetInternalSchema(db, 0); } - 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; - } + /* If one has been configured, invoke the rollback-hook callback */ + if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){ + db->xRollbackCallback(db->pRollbackArg); } - 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 ){ - /* 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 *sqlite3ErrStr(int rc){ const char *z; switch( rc ){ + case SQLITE_ROW: + case SQLITE_DONE: 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; @@ -829,20 +225,18 @@ const char *sqlite_error_string(int rc){ 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_FULL: z = "database or disk 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_RANGE: z = "bind or column index out of range"; break; case SQLITE_NOTADB: z = "file is encrypted or is not a database";break; default: z = "unknown error"; break; } @@ -856,53 +250,77 @@ const char *sqlite_error_string(int rc){ ** argument. */ static int sqliteDefaultBusyCallback( - void *Timeout, /* Maximum amount of time to wait */ - const char *NotUsed, /* The name of the table that is busy */ + void *ptr, /* Database connection */ 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}; +#if OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP) + static const u8 delays[] = + { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 }; + static const u8 totals[] = + { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 }; # define NDELAY (sizeof(delays)/sizeof(delays[0])) - int timeout = (int)Timeout; + int timeout = ((sqlite3 *)ptr)->busyTimeout; int delay, prior; - if( count <= NDELAY ){ - delay = delays[count-1]; - prior = totals[count-1]; + assert( count>=0 ); + if( count < NDELAY ){ + delay = delays[count]; + prior = totals[count]; }else{ delay = delays[NDELAY-1]; - prior = totals[NDELAY-1] + delay*(count-NDELAY-1); + prior = totals[NDELAY-1] + delay*(count-(NDELAY-1)); } if( prior + delay > timeout ){ delay = timeout - prior; if( delay<=0 ) return 0; } - sqliteOsSleep(delay); + sqlite3OsSleep(delay); return 1; #else - int timeout = (int)Timeout; + int timeout = ((sqlite3 *)ptr)->busyTimeout; if( (count+1)*1000 > timeout ){ return 0; } - sqliteOsSleep(1000); + sqlite3OsSleep(1000); return 1; #endif } +/* +** Invoke the given busy handler. +** +** This routine is called when an operation failed with a lock. +** If this routine returns non-zero, the lock is retried. If it +** returns 0, the operation aborts with an SQLITE_BUSY error. +*/ +int sqlite3InvokeBusyHandler(BusyHandler *p){ + int rc; + if( p==0 || p->xFunc==0 || p->nBusy<0 ) return 0; + rc = p->xFunc(p->pArg, p->nBusy); + if( rc==0 ){ + p->nBusy = -1; + }else{ + p->nBusy++; + } + return rc; +} + /* ** This routine sets the busy callback for an Sqlite database to the ** given callback function with the given argument. */ -void sqlite_busy_handler( - sqlite *db, - int (*xBusy)(void*,const char*,int), +int sqlite3_busy_handler( + sqlite3 *db, + int (*xBusy)(void*,int), void *pArg ){ - db->xBusyCallback = xBusy; - db->pBusyArg = pArg; + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + db->busyHandler.xFunc = xBusy; + db->busyHandler.pArg = pArg; + db->busyHandler.nBusy = 0; + return SQLITE_OK; } #ifndef SQLITE_OMIT_PROGRESS_CALLBACK @@ -911,20 +329,22 @@ void sqlite_busy_handler( ** given callback function with the given argument. The progress callback will ** be invoked every nOps opcodes. */ -void sqlite_progress_handler( - sqlite *db, +void sqlite3_progress_handler( + sqlite3 *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; + if( !sqlite3SafetyCheck(db) ){ + if( nOps>0 ){ + db->xProgress = xProgress; + db->nProgressOps = nOps; + db->pProgressArg = pArg; + }else{ + db->xProgress = 0; + db->nProgressOps = 0; + db->pProgressArg = 0; + } } } #endif @@ -934,136 +354,204 @@ void sqlite_progress_handler( ** 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){ +int sqlite3_busy_timeout(sqlite3 *db, int ms){ if( ms>0 ){ - sqlite_busy_handler(db, sqliteDefaultBusyCallback, (void*)ms); + db->busyTimeout = ms; + sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db); }else{ - sqlite_busy_handler(db, 0, 0); + sqlite3_busy_handler(db, 0, 0); } + return SQLITE_OK; } /* ** Cause any pending operation to stop at its earliest opportunity. */ -void sqlite_interrupt(sqlite *db){ - db->flags |= SQLITE_Interrupt; +void sqlite3_interrupt(sqlite3 *db){ + if( !sqlite3SafetyCheck(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 +** is returned in the in the errmsg parameter of sqlite3_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(). +** Note that we need to call free() not sqliteFree() here. */ -void sqlite_freemem(void *p){ free(p); } +void sqlite3_free(char *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. +** This function is exactly the same as sqlite3_create_function(), except +** that it is designed to be called by internal code. The difference is +** that if a malloc() fails in sqlite3_create_function(), an error code +** is returned and the mallocFailed flag cleared. */ -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 */ +int sqlite3CreateFunc( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int enc, + void *pUserData, + void (*xFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*) ){ 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; + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + if( zFunctionName==0 || + (xFunc && (xFinal || xStep)) || + (!xFunc && (xFinal && !xStep)) || + (!xFunc && (!xFinal && xStep)) || + (nArg<-1 || nArg>127) || + (255<(nName = strlen(zFunctionName))) ){ + return SQLITE_ERROR; + } + +#ifndef SQLITE_OMIT_UTF16 + /* If SQLITE_UTF16 is specified as the encoding type, transform this + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally. + ** + ** If SQLITE_ANY is specified, add three versions of the function + ** to the hash table. + */ + if( enc==SQLITE_UTF16 ){ + enc = SQLITE_UTF16NATIVE; + }else if( enc==SQLITE_ANY ){ + int rc; + rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8, + pUserData, xFunc, xStep, xFinal); + if( rc!=SQLITE_OK ) return rc; + rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE, + pUserData, xFunc, xStep, xFinal); + if( rc!=SQLITE_OK ) return rc; + enc = SQLITE_UTF16BE; + } +#else + enc = SQLITE_UTF8; +#endif + + /* Check if an existing function is being overridden or deleted. If so, + ** and there are active VMs, then return SQLITE_BUSY. If a function + ** is being overridden/deleted but there are no active VMs, allow the + ** operation to continue but invalidate all precompiled statements. + */ + p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 0); + if( p && p->iPrefEnc==enc && p->nArg==nArg ){ + if( db->activeVdbeCnt ){ + sqlite3Error(db, SQLITE_BUSY, + "Unable to delete/modify user-function due to active statements"); + assert( !sqlite3MallocFailed() ); + return SQLITE_BUSY; + }else{ + sqlite3ExpirePreparedStatements(db); + } + } + + p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1); + if( p ){ + p->flags = 0; + p->xFunc = xFunc; + p->xStep = xStep; + p->xFinalize = xFinal; + p->pUserData = pUserData; } return SQLITE_OK; } +/* +** Create new user functions. +*/ +int sqlite3_create_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int enc, + void *p, + void (*xFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*) +){ + int rc; + assert( !sqlite3MallocFailed() ); + rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal); + + return sqlite3ApiExit(db, rc); +} + +#ifndef SQLITE_OMIT_UTF16 +int sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *p, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +){ + int rc; + char *zFunc8; + assert( !sqlite3MallocFailed() ); + + zFunc8 = sqlite3utf16to8(zFunctionName, -1); + rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal); + sqliteFree(zFunc8); + + return sqlite3ApiExit(db, rc); +} +#endif + +#ifndef SQLITE_OMIT_TRACE /* ** Register a trace function. The pArg from the previously registered trace ** is returned. ** ** A NULL trace function means that no tracing is executes. A non-NULL ** trace is a pointer to a function that is invoked at the start of each -** sqlite_exec(). +** SQL statement. */ -void *sqlite_trace(sqlite *db, void (*xTrace)(void*,const char*), void *pArg){ +void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){ void *pOld = db->pTraceArg; db->xTrace = xTrace; db->pTraceArg = pArg; return pOld; } +/* +** Register a profile function. The pArg from the previously registered +** profile function is returned. +** +** A NULL profile function means that no profiling is executes. A non-NULL +** profile is a pointer to a function that is invoked at the conclusion of +** each SQL statement that is run. +*/ +void *sqlite3_profile( + sqlite3 *db, + void (*xProfile)(void*,const char*,sqlite_uint64), + void *pArg +){ + void *pOld = db->pProfileArg; + db->xProfile = xProfile; + db->pProfileArg = pArg; + return pOld; +} +#endif /* SQLITE_OMIT_TRACE */ /*** EXPERIMENTAL *** ** ** Register a function to be invoked when a transaction comments. -** If either function returns non-zero, then the commit becomes a +** If the invoked function returns non-zero, then the commit becomes a ** rollback. */ -void *sqlite_commit_hook( - sqlite *db, /* Attach the hook to this database */ +void *sqlite3_commit_hook( + sqlite3 *db, /* Attach the hook to this database */ int (*xCallback)(void*), /* Function to invoke on each commit */ void *pArg /* Argument to the function */ ){ @@ -1073,6 +561,35 @@ void *sqlite_commit_hook( return pOld; } +/* +** Register a callback to be invoked each time a row is updated, +** inserted or deleted using this database connection. +*/ +void *sqlite3_update_hook( + sqlite3 *db, /* Attach the hook to this database */ + void (*xCallback)(void*,int,char const *,char const *,sqlite_int64), + void *pArg /* Argument to the function */ +){ + void *pRet = db->pUpdateArg; + db->xUpdateCallback = xCallback; + db->pUpdateArg = pArg; + return pRet; +} + +/* +** Register a callback to be invoked each time a transaction is rolled +** back by this database connection. +*/ +void *sqlite3_rollback_hook( + sqlite3 *db, /* Attach the hook to this database */ + void (*xCallback)(void*), /* Callback function */ + void *pArg /* Argument to the function */ +){ + void *pRet = db->pRollbackArg; + db->xRollbackCallback = xCallback; + db->pRollbackArg = pArg; + return pRet; +} /* ** This routine is called to create a connection to a database BTree @@ -1080,11 +597,11 @@ void *sqlite_commit_hook( ** 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. +** is a "virtual" database for transient 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, +** A virtual database can be either a disk file (that is automatically +** deleted when the file is closed) or it an be held entirely in memory, ** depending on the values of the TEMP_STORE compile-time macro and the ** db->temp_store variable, according to the following chart: ** @@ -1099,38 +616,617 @@ void *sqlite_commit_hook( ** 2 0 memory ** 3 any memory */ -int sqliteBtreeFactory( - const sqlite *db, /* Main database when opening aux otherwise 0 */ +int sqlite3BtreeFactory( + const sqlite3 *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 */ - + Btree **ppBtree /* Pointer to new Btree object written here */ +){ + int btree_flags = 0; + int rc; + assert( ppBtree != 0); - -#ifndef SQLITE_OMIT_INMEMORYDB + if( omitJournal ){ + btree_flags |= BTREE_OMIT_JOURNAL; + } + if( db->flags & SQLITE_NoReadlock ){ + btree_flags |= BTREE_NO_READLOCK; + } 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 +#if TEMP_STORE==0 + /* Do nothing */ #endif - { - return sqliteBtreeOpen(zFilename, omitJournal, nCache, ppBtree); +#ifndef SQLITE_OMIT_MEMORYDB +#if TEMP_STORE==1 + if( db->temp_store==2 ) zFilename = ":memory:"; +#endif +#if TEMP_STORE==2 + if( db->temp_store!=1 ) zFilename = ":memory:"; +#endif +#if TEMP_STORE==3 + zFilename = ":memory:"; +#endif +#endif /* SQLITE_OMIT_MEMORYDB */ + } + + rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btree_flags); + if( rc==SQLITE_OK ){ + sqlite3BtreeSetBusyHandler(*ppBtree, (void*)&db->busyHandler); + sqlite3BtreeSetCacheSize(*ppBtree, nCache); + } + return rc; +} + +/* +** Return UTF-8 encoded English language explanation of the most recent +** error. +*/ +const char *sqlite3_errmsg(sqlite3 *db){ + const char *z; + if( !db || sqlite3MallocFailed() ){ + return sqlite3ErrStr(SQLITE_NOMEM); + } + if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){ + return sqlite3ErrStr(SQLITE_MISUSE); + } + z = (char*)sqlite3_value_text(db->pErr); + if( z==0 ){ + z = sqlite3ErrStr(db->errCode); + } + return z; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Return UTF-16 encoded English language explanation of the most recent +** error. +*/ +const void *sqlite3_errmsg16(sqlite3 *db){ + /* Because all the characters in the string are in the unicode + ** range 0x00-0xFF, if we pad the big-endian string with a + ** zero byte, we can obtain the little-endian string with + ** &big_endian[1]. + */ + static const char outOfMemBe[] = { + 0, 'o', 0, 'u', 0, 't', 0, ' ', + 0, 'o', 0, 'f', 0, ' ', + 0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0 + }; + static const char misuseBe [] = { + 0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ', + 0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ', + 0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ', + 0, 'o', 0, 'u', 0, 't', 0, ' ', + 0, 'o', 0, 'f', 0, ' ', + 0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0 + }; + + const void *z; + if( sqlite3MallocFailed() ){ + return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]); + } + if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){ + return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]); + } + z = sqlite3_value_text16(db->pErr); + if( z==0 ){ + sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode), + SQLITE_UTF8, SQLITE_STATIC); + z = sqlite3_value_text16(db->pErr); + } + sqlite3ApiExit(0, 0); + return z; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the most recent error code generated by an SQLite routine. If NULL is +** passed to this function, we assume a malloc() failed during sqlite3_open(). +*/ +int sqlite3_errcode(sqlite3 *db){ + if( !db || sqlite3MallocFailed() ){ + return SQLITE_NOMEM; + } + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + return db->errCode; +} + +/* +** Create a new collating function for database "db". The name is zName +** and the encoding is enc. +*/ +static int createCollation( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + CollSeq *pColl; + int enc2; + + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + + /* If SQLITE_UTF16 is specified as the encoding type, transform this + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally. + */ + enc2 = enc & ~SQLITE_UTF16_ALIGNED; + if( enc2==SQLITE_UTF16 ){ + enc2 = SQLITE_UTF16NATIVE; + } + + if( (enc2&~3)!=0 ){ + sqlite3Error(db, SQLITE_ERROR, "unknown encoding"); + return SQLITE_ERROR; + } + + /* Check if this call is removing or replacing an existing collation + ** sequence. If so, and there are active VMs, return busy. If there + ** are no active VMs, invalidate any pre-compiled statements. + */ + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 0); + if( pColl && pColl->xCmp ){ + if( db->activeVdbeCnt ){ + sqlite3Error(db, SQLITE_BUSY, + "Unable to delete/modify collation sequence due to active statements"); + return SQLITE_BUSY; + } + sqlite3ExpirePreparedStatements(db); + } + + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 1); + if( pColl ){ + pColl->xCmp = xCompare; + pColl->pUser = pCtx; + pColl->enc = enc2 | (enc & SQLITE_UTF16_ALIGNED); + } + sqlite3Error(db, SQLITE_OK, 0); + return SQLITE_OK; +} + + +/* +** This routine does the work of opening a database on behalf of +** sqlite3_open() and sqlite3_open16(). The database filename "zFilename" +** is UTF-8 encoded. +*/ +static int openDatabase( + const char *zFilename, /* Database filename UTF-8 encoded */ + sqlite3 **ppDb /* OUT: Returned database handle */ +){ + sqlite3 *db; + int rc; + CollSeq *pColl; + + assert( !sqlite3MallocFailed() ); + + /* Allocate the sqlite data structure */ + db = sqliteMalloc( sizeof(sqlite3) ); + if( db==0 ) goto opendb_out; + db->priorNewRowid = 0; + db->magic = SQLITE_MAGIC_BUSY; + db->nDb = 2; + db->aDb = db->aDbStatic; + db->autoCommit = 1; + db->flags |= SQLITE_ShortColNames; + sqlite3HashInit(&db->aFunc, SQLITE_HASH_STRING, 0); + sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0); + + /* Add the default collation sequence BINARY. BINARY works for both UTF-8 + ** and UTF-16, so add a version for each to avoid any unnecessary + ** conversions. The only error that can occur here is a malloc() failure. + */ + if( createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc) || + createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc) || + createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc) || + (db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0))==0 + ){ + assert( sqlite3MallocFailed() ); + db->magic = SQLITE_MAGIC_CLOSED; + goto opendb_out; + } + + /* Also add a UTF-8 case-insensitive collation sequence. */ + createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc); + + /* Set flags on the built-in collating sequences */ + db->pDfltColl->type = SQLITE_COLL_BINARY; + pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0); + if( pColl ){ + pColl->type = SQLITE_COLL_NOCASE; + } + + /* Open the backend database driver */ + rc = sqlite3BtreeFactory(db, zFilename, 0, MAX_PAGES, &db->aDb[0].pBt); + if( rc!=SQLITE_OK ){ + sqlite3Error(db, rc, 0); + db->magic = SQLITE_MAGIC_CLOSED; + goto opendb_out; + } + db->aDb[0].pSchema = sqlite3SchemaGet(db->aDb[0].pBt); + db->aDb[1].pSchema = sqlite3SchemaGet(0); + if( db->aDb[0].pSchema ){ + ENC(db) = SQLITE_UTF8; + } + + + /* The default safety_level for the main database is 'full'; for the temp + ** database it is 'NONE'. This matches the pager layer defaults. + */ + db->aDb[0].zName = "main"; + db->aDb[0].safety_level = 3; +#ifndef SQLITE_OMIT_TEMPDB + db->aDb[1].zName = "temp"; + db->aDb[1].safety_level = 1; +#endif + + /* Register all built-in functions, but do not attempt to read the + ** database schema yet. This is delayed until the first time the database + ** is accessed. + */ + if( !sqlite3MallocFailed() ){ + sqlite3RegisterBuiltinFunctions(db); + sqlite3Error(db, SQLITE_OK, 0); + } + db->magic = SQLITE_MAGIC_OPEN; + +opendb_out: + if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){ + sqlite3_close(db); + db = 0; + } + *ppDb = db; + return sqlite3ApiExit(0, rc); +} + +/* +** Open a new database handle. +*/ +int sqlite3_open( + const char *zFilename, + sqlite3 **ppDb +){ + return openDatabase(zFilename, ppDb); +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Open a new database handle. +*/ +int sqlite3_open16( + const void *zFilename, + sqlite3 **ppDb +){ + char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */ + int rc = SQLITE_OK; + sqlite3_value *pVal; + + assert( zFilename ); + assert( ppDb ); + *ppDb = 0; + pVal = sqlite3ValueNew(); + sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC); + zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8); + if( zFilename8 ){ + rc = openDatabase(zFilename8, ppDb); + if( rc==SQLITE_OK && *ppDb ){ + rc = sqlite3_exec(*ppDb, "PRAGMA encoding = 'UTF-16'", 0, 0, 0); + if( rc!=SQLITE_OK ){ + sqlite3_close(*ppDb); + *ppDb = 0; + } + } + } + sqlite3ValueFree(pVal); + + return sqlite3ApiExit(0, rc); +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** The following routine destroys a virtual machine that is created by +** the sqlite3_compile() routine. The integer returned is an SQLITE_ +** success/failure code that describes the result of executing the virtual +** machine. +** +** This routine sets the error code and string returned by +** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). +*/ +int sqlite3_finalize(sqlite3_stmt *pStmt){ + int rc; + if( pStmt==0 ){ + rc = SQLITE_OK; + }else{ + rc = sqlite3VdbeFinalize((Vdbe*)pStmt); + } + return rc; +} + +/* +** Terminate the current execution of an SQL statement and reset it +** back to its starting state so that it can be reused. A success code from +** the prior execution is returned. +** +** This routine sets the error code and string returned by +** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). +*/ +int sqlite3_reset(sqlite3_stmt *pStmt){ + int rc; + if( pStmt==0 ){ + rc = SQLITE_OK; + }else{ + rc = sqlite3VdbeReset((Vdbe*)pStmt); + sqlite3VdbeMakeReady((Vdbe*)pStmt, -1, 0, 0, 0); + } + return rc; +} + +/* +** Register a new collation sequence with the database handle db. +*/ +int sqlite3_create_collation( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + int rc; + assert( !sqlite3MallocFailed() ); + rc = createCollation(db, zName, enc, pCtx, xCompare); + return sqlite3ApiExit(db, rc); +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Register a new collation sequence with the database handle db. +*/ +int sqlite3_create_collation16( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + int rc = SQLITE_OK; + char *zName8; + assert( !sqlite3MallocFailed() ); + zName8 = sqlite3utf16to8(zName, -1); + if( zName8 ){ + rc = createCollation(db, zName8, enc, pCtx, xCompare); + sqliteFree(zName8); + } + return sqlite3ApiExit(db, rc); +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Register a collation sequence factory callback with the database handle +** db. Replace any previously installed collation sequence factory. +*/ +int sqlite3_collation_needed( + sqlite3 *db, + void *pCollNeededArg, + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*) +){ + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + db->xCollNeeded = xCollNeeded; + db->xCollNeeded16 = 0; + db->pCollNeededArg = pCollNeededArg; + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Register a collation sequence factory callback with the database handle +** db. Replace any previously installed collation sequence factory. +*/ +int sqlite3_collation_needed16( + sqlite3 *db, + void *pCollNeededArg, + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*) +){ + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + db->xCollNeeded = 0; + db->xCollNeeded16 = xCollNeeded16; + db->pCollNeededArg = pCollNeededArg; + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_GLOBALRECOVER +/* +** This function is now an anachronism. It used to be used to recover from a +** malloc() failure, but SQLite now does this automatically. +*/ +int sqlite3_global_recover(){ + return SQLITE_OK; +} +#endif + +/* +** Test to see whether or not the database connection is in autocommit +** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on +** by default. Autocommit is disabled by a BEGIN statement and reenabled +** by the next COMMIT or ROLLBACK. +** +******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** +*/ +int sqlite3_get_autocommit(sqlite3 *db){ + return db->autoCommit; +} + +#ifdef SQLITE_DEBUG +/* +** The following routine is subtituted for constant SQLITE_CORRUPT in +** debugging builds. This provides a way to set a breakpoint for when +** corruption is first detected. +*/ +int sqlite3Corrupt(void){ + return SQLITE_CORRUPT; +} +#endif + + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Enable or disable the shared pager and schema features for the +** current thread. +** +** This routine should only be called when there are no open +** database connections. +*/ +int sqlite3_enable_shared_cache(int enable){ + ThreadData *pTd = sqlite3ThreadData(); + if( pTd ){ + /* It is only legal to call sqlite3_enable_shared_cache() when there + ** are no currently open b-trees that were opened by the calling thread. + ** This condition is only easy to detect if the shared-cache were + ** previously enabled (and is being disabled). + */ + if( pTd->pBtree && !enable ){ + assert( pTd->useSharedData ); + return SQLITE_MISUSE; + } + + pTd->useSharedData = enable; + sqlite3ReleaseThreadData(); + } + return sqlite3ApiExit(0, SQLITE_OK); +} +#endif + +/* +** This is a convenience routine that makes sure that all thread-specific +** data for this thread has been deallocated. +*/ +void sqlite3_thread_cleanup(void){ + ThreadData *pTd = sqlite3OsThreadSpecificData(0); + if( pTd ){ + memset(pTd, 0, sizeof(*pTd)); + sqlite3OsThreadSpecificData(-1); } } + +/* +** Return meta information about a specific column of a database table. +** See comment in sqlite3.h (sqlite.h.in) for details. +*/ +#ifdef SQLITE_ENABLE_COLUMN_METADATA +int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if colums is auto-increment */ +){ + int rc; + char *zErrMsg = 0; + Table *pTab = 0; + Column *pCol = 0; + int iCol; + + char const *zDataType = 0; + char const *zCollSeq = 0; + int notnull = 0; + int primarykey = 0; + int autoinc = 0; + + /* Ensure the database schema has been loaded */ + if( sqlite3SafetyOn(db) ){ + return SQLITE_MISUSE; + } + rc = sqlite3Init(db, &zErrMsg); + if( SQLITE_OK!=rc ){ + goto error_out; + } + + /* Locate the table in question */ + pTab = sqlite3FindTable(db, zTableName, zDbName); + if( !pTab || pTab->pSelect ){ + pTab = 0; + goto error_out; + } + + /* Find the column for which info is requested */ + if( sqlite3IsRowid(zColumnName) ){ + iCol = pTab->iPKey; + if( iCol>=0 ){ + pCol = &pTab->aCol[iCol]; + } + }else{ + for(iCol=0; iColnCol; iCol++){ + pCol = &pTab->aCol[iCol]; + if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){ + break; + } + } + if( iCol==pTab->nCol ){ + pTab = 0; + goto error_out; + } + } + + /* The following block stores the meta information that will be returned + ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey + ** and autoinc. At this point there are two possibilities: + ** + ** 1. The specified column name was rowid", "oid" or "_rowid_" + ** and there is no explicitly declared IPK column. + ** + ** 2. The table is not a view and the column name identified an + ** explicitly declared column. Copy meta information from *pCol. + */ + if( pCol ){ + zDataType = pCol->zType; + zCollSeq = pCol->zColl; + notnull = (pCol->notNull?1:0); + primarykey = (pCol->isPrimKey?1:0); + autoinc = ((pTab->iPKey==iCol && pTab->autoInc)?1:0); + }else{ + zDataType = "INTEGER"; + primarykey = 1; + } + if( !zCollSeq ){ + zCollSeq = "BINARY"; + } + +error_out: + if( sqlite3SafetyOff(db) ){ + rc = SQLITE_MISUSE; + } + + /* Whether the function call succeeded or failed, set the output parameters + ** to whatever their local counterparts contain. If an error did occur, + ** this has the effect of zeroing all output parameters. + */ + if( pzDataType ) *pzDataType = zDataType; + if( pzCollSeq ) *pzCollSeq = zCollSeq; + if( pNotNull ) *pNotNull = notnull; + if( pPrimaryKey ) *pPrimaryKey = primarykey; + if( pAutoinc ) *pAutoinc = autoinc; + + if( SQLITE_OK==rc && !pTab ){ + sqlite3SetString(&zErrMsg, "no such table column: ", zTableName, ".", + zColumnName, 0); + rc = SQLITE_ERROR; + } + sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg); + sqliteFree(zErrMsg); + return sqlite3ApiExit(db, rc); +} +#endif diff --git a/sqlite/opcodes.c b/sqlite/opcodes.c index df5b3c888..9f1bdbaae 100755 --- a/sqlite/opcodes.c +++ b/sqlite/opcodes.c @@ -1,138 +1,147 @@ -/* 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", +/* Automatically generated. Do not edit */ +/* See the mkopcodec.awk script for details. */ +#if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) +const char *const sqlite3OpcodeNames[] = { "?", + /* 1 */ "MemLoad", + /* 2 */ "Column", + /* 3 */ "SetCookie", + /* 4 */ "IfMemPos", + /* 5 */ "Sequence", + /* 6 */ "MoveGt", + /* 7 */ "RowKey", + /* 8 */ "OpenWrite", + /* 9 */ "If", + /* 10 */ "Pop", + /* 11 */ "CollSeq", + /* 12 */ "OpenRead", + /* 13 */ "Expire", + /* 14 */ "AutoCommit", + /* 15 */ "IntegrityCk", + /* 16 */ "Not", + /* 17 */ "Sort", + /* 18 */ "Function", + /* 19 */ "Noop", + /* 20 */ "Return", + /* 21 */ "NewRowid", + /* 22 */ "IfMemNeg", + /* 23 */ "Variable", + /* 24 */ "String", + /* 25 */ "RealAffinity", + /* 26 */ "ParseSchema", + /* 27 */ "Close", + /* 28 */ "CreateIndex", + /* 29 */ "IsUnique", + /* 30 */ "IdxIsNull", + /* 31 */ "NotFound", + /* 32 */ "Int64", + /* 33 */ "MustBeInt", + /* 34 */ "Halt", + /* 35 */ "Rowid", + /* 36 */ "IdxLT", + /* 37 */ "AddImm", + /* 38 */ "Statement", + /* 39 */ "RowData", + /* 40 */ "MemMax", + /* 41 */ "Push", + /* 42 */ "NotExists", + /* 43 */ "MemIncr", + /* 44 */ "Gosub", + /* 45 */ "Integer", + /* 46 */ "MemInt", + /* 47 */ "Prev", + /* 48 */ "CreateTable", + /* 49 */ "Last", + /* 50 */ "IdxRowid", + /* 51 */ "MakeIdxRec", + /* 52 */ "ResetCount", + /* 53 */ "FifoWrite", + /* 54 */ "Callback", + /* 55 */ "ContextPush", + /* 56 */ "DropTrigger", + /* 57 */ "DropIndex", + /* 58 */ "IdxGE", + /* 59 */ "Or", + /* 60 */ "And", + /* 61 */ "IdxDelete", + /* 62 */ "Vacuum", + /* 63 */ "MoveLe", + /* 64 */ "IsNull", + /* 65 */ "NotNull", + /* 66 */ "Ne", + /* 67 */ "Eq", + /* 68 */ "Gt", + /* 69 */ "Le", + /* 70 */ "Lt", + /* 71 */ "Ge", + /* 72 */ "IfNot", + /* 73 */ "BitAnd", + /* 74 */ "BitOr", + /* 75 */ "ShiftLeft", + /* 76 */ "ShiftRight", + /* 77 */ "Add", + /* 78 */ "Subtract", + /* 79 */ "Multiply", + /* 80 */ "Divide", + /* 81 */ "Remainder", + /* 82 */ "Concat", + /* 83 */ "Negative", + /* 84 */ "DropTable", + /* 85 */ "BitNot", + /* 86 */ "String8", + /* 87 */ "MakeRecord", + /* 88 */ "Delete", + /* 89 */ "AggFinal", + /* 90 */ "Dup", + /* 91 */ "Goto", + /* 92 */ "TableLock", + /* 93 */ "FifoRead", + /* 94 */ "Clear", + /* 95 */ "IdxGT", + /* 96 */ "MoveLt", + /* 97 */ "VerifyCookie", + /* 98 */ "AggStep", + /* 99 */ "Pull", + /* 100 */ "SetNumColumns", + /* 101 */ "AbsValue", + /* 102 */ "Transaction", + /* 103 */ "ContextPop", + /* 104 */ "Next", + /* 105 */ "IdxInsert", + /* 106 */ "Distinct", + /* 107 */ "Insert", + /* 108 */ "Destroy", + /* 109 */ "ReadCookie", + /* 110 */ "ForceInt", + /* 111 */ "LoadAnalysis", + /* 112 */ "OpenVirtual", + /* 113 */ "Explain", + /* 114 */ "IfMemZero", + /* 115 */ "OpenPseudo", + /* 116 */ "Null", + /* 117 */ "Blob", + /* 118 */ "MemStore", + /* 119 */ "Rewind", + /* 120 */ "MoveGe", + /* 121 */ "MemMove", + /* 122 */ "MemNull", + /* 123 */ "Found", + /* 124 */ "Real", + /* 125 */ "HexBlob", + /* 126 */ "NullRow", + /* 127 */ "NotUsed_127", + /* 128 */ "NotUsed_128", + /* 129 */ "NotUsed_129", + /* 130 */ "NotUsed_130", + /* 131 */ "NotUsed_131", + /* 132 */ "NotUsed_132", + /* 133 */ "NotUsed_133", + /* 134 */ "NotUsed_134", + /* 135 */ "NotUsed_135", + /* 136 */ "NotUsed_136", + /* 137 */ "ToText", + /* 138 */ "ToBlob", + /* 139 */ "ToNumeric", + /* 140 */ "ToInt", + /* 141 */ "ToReal", }; +#endif diff --git a/sqlite/opcodes.h b/sqlite/opcodes.h index a6bc6d42c..e768d6035 100755 --- a/sqlite/opcodes.h +++ b/sqlite/opcodes.h @@ -1,136 +1,159 @@ -/* 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 +/* Automatically generated. Do not edit */ +/* See the mkopcodeh.awk script for details */ +#define OP_MemLoad 1 +#define OP_HexBlob 125 /* same as TK_BLOB */ +#define OP_Column 2 +#define OP_SetCookie 3 +#define OP_IfMemPos 4 +#define OP_Real 124 /* same as TK_FLOAT */ +#define OP_Sequence 5 +#define OP_MoveGt 6 +#define OP_Ge 71 /* same as TK_GE */ +#define OP_RowKey 7 +#define OP_Eq 67 /* same as TK_EQ */ +#define OP_OpenWrite 8 +#define OP_NotNull 65 /* same as TK_NOTNULL */ +#define OP_If 9 +#define OP_ToInt 140 /* same as TK_TO_INT */ +#define OP_String8 86 /* same as TK_STRING */ +#define OP_Pop 10 +#define OP_CollSeq 11 +#define OP_OpenRead 12 +#define OP_Expire 13 +#define OP_AutoCommit 14 +#define OP_Gt 68 /* same as TK_GT */ +#define OP_IntegrityCk 15 +#define OP_Sort 17 +#define OP_Function 18 +#define OP_And 60 /* same as TK_AND */ +#define OP_Subtract 78 /* same as TK_MINUS */ +#define OP_Noop 19 +#define OP_Return 20 +#define OP_Remainder 81 /* same as TK_REM */ +#define OP_NewRowid 21 +#define OP_Multiply 79 /* same as TK_STAR */ +#define OP_IfMemNeg 22 +#define OP_Variable 23 +#define OP_String 24 +#define OP_RealAffinity 25 +#define OP_ParseSchema 26 +#define OP_Close 27 +#define OP_CreateIndex 28 +#define OP_IsUnique 29 +#define OP_IdxIsNull 30 +#define OP_NotFound 31 +#define OP_Int64 32 +#define OP_MustBeInt 33 +#define OP_Halt 34 +#define OP_Rowid 35 +#define OP_IdxLT 36 +#define OP_AddImm 37 +#define OP_Statement 38 +#define OP_RowData 39 +#define OP_MemMax 40 +#define OP_Push 41 +#define OP_Or 59 /* same as TK_OR */ +#define OP_NotExists 42 +#define OP_MemIncr 43 +#define OP_Gosub 44 +#define OP_Divide 80 /* same as TK_SLASH */ +#define OP_Integer 45 +#define OP_ToNumeric 139 /* same as TK_TO_NUMERIC*/ +#define OP_MemInt 46 +#define OP_Prev 47 +#define OP_Concat 82 /* same as TK_CONCAT */ +#define OP_BitAnd 73 /* same as TK_BITAND */ +#define OP_CreateTable 48 +#define OP_Last 49 +#define OP_IsNull 64 /* same as TK_ISNULL */ +#define OP_IdxRowid 50 +#define OP_MakeIdxRec 51 +#define OP_ShiftRight 76 /* same as TK_RSHIFT */ +#define OP_ResetCount 52 +#define OP_FifoWrite 53 +#define OP_Callback 54 +#define OP_ContextPush 55 +#define OP_DropTrigger 56 +#define OP_DropIndex 57 +#define OP_IdxGE 58 +#define OP_IdxDelete 61 +#define OP_Vacuum 62 +#define OP_MoveLe 63 +#define OP_IfNot 72 +#define OP_DropTable 84 +#define OP_MakeRecord 87 +#define OP_ToBlob 138 /* same as TK_TO_BLOB */ +#define OP_Delete 88 +#define OP_AggFinal 89 +#define OP_ShiftLeft 75 /* same as TK_LSHIFT */ +#define OP_Dup 90 +#define OP_Goto 91 +#define OP_TableLock 92 +#define OP_FifoRead 93 +#define OP_Clear 94 +#define OP_IdxGT 95 +#define OP_MoveLt 96 +#define OP_Le 69 /* same as TK_LE */ +#define OP_VerifyCookie 97 +#define OP_AggStep 98 +#define OP_Pull 99 +#define OP_ToText 137 /* same as TK_TO_TEXT */ +#define OP_Not 16 /* same as TK_NOT */ +#define OP_ToReal 141 /* same as TK_TO_REAL */ +#define OP_SetNumColumns 100 +#define OP_AbsValue 101 +#define OP_Transaction 102 +#define OP_Negative 83 /* same as TK_UMINUS */ +#define OP_Ne 66 /* same as TK_NE */ +#define OP_ContextPop 103 +#define OP_BitOr 74 /* same as TK_BITOR */ +#define OP_Next 104 +#define OP_IdxInsert 105 +#define OP_Distinct 106 +#define OP_Lt 70 /* same as TK_LT */ +#define OP_Insert 107 +#define OP_Destroy 108 +#define OP_ReadCookie 109 +#define OP_ForceInt 110 +#define OP_LoadAnalysis 111 +#define OP_OpenVirtual 112 +#define OP_Explain 113 +#define OP_IfMemZero 114 +#define OP_OpenPseudo 115 +#define OP_Null 116 +#define OP_Blob 117 +#define OP_Add 77 /* same as TK_PLUS */ +#define OP_MemStore 118 +#define OP_Rewind 119 +#define OP_MoveGe 120 +#define OP_BitNot 85 /* same as TK_BITNOT */ +#define OP_MemMove 121 +#define OP_MemNull 122 +#define OP_Found 123 +#define OP_NullRow 126 + +/* The following opcode values are never used */ +#define OP_NotUsed_127 127 +#define OP_NotUsed_128 128 +#define OP_NotUsed_129 129 +#define OP_NotUsed_130 130 +#define OP_NotUsed_131 131 +#define OP_NotUsed_132 132 +#define OP_NotUsed_133 133 +#define OP_NotUsed_134 134 +#define OP_NotUsed_135 135 +#define OP_NotUsed_136 136 + +/* Opcodes that are guaranteed to never push a value onto the stack +** contain a 1 their corresponding position of the following mask +** set. See the opcodeNoPush() function in vdbeaux.c */ +#define NOPUSH_MASK_0 0x7f58 +#define NOPUSH_MASK_1 0xee5b +#define NOPUSH_MASK_2 0x9f76 +#define NOPUSH_MASK_3 0xfff2 +#define NOPUSH_MASK_4 0xffff +#define NOPUSH_MASK_5 0xdb3b +#define NOPUSH_MASK_6 0xcfdf +#define NOPUSH_MASK_7 0x49cd +#define NOPUSH_MASK_8 0x3e00 +#define NOPUSH_MASK_9 0x0000 diff --git a/sqlite/os.c b/sqlite/os.c index b4ae7a107..ec482fe0e 100755 --- a/sqlite/os.c +++ b/sqlite/os.c @@ -1,5 +1,5 @@ /* -** 2001 September 16 +** 2005 November 29 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: @@ -10,1809 +10,83 @@ ** ****************************************************************************** ** -** 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. +** This file contains OS interface code that is common to all +** architectures. */ -#include "os.h" /* Must be first to enable large file support */ +#define _SQLITE_OS_C_ 1 #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 +#include "os.h" /* -** 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? +** The following routines are convenience wrappers around methods +** of the OsFile object. This is mostly just syntactic sugar. All +** of this would be completely automatic if SQLite were coded using +** C++ instead of plain old C. */ -#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 ){ - 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; -} - -/* -** 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[] = { - "/var/tmp", - "/usr/tmp", - "/tmp", - ".", - }; - static unsigned char zChars[] = - "abcdefghijklmnopqrstuvwxyz" - "ABCDEFGHIJKLMNOPQRSTUVWXYZ" - "0123456789"; - int i, j; - struct stat buf; - const char *zDir = "."; - for(i=0; i0 && zTempPath[i-1]=='\\'; i--){} - zTempPath[i] = 0; - for(;;){ - sprintf(zBuf, "%s\\"TEMP_FILE_PREFIX, zTempPath); - 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 zTempPath[SQLITE_TEMPNAME_SIZE]; - char zdirName[32]; - CInfoPBRec infoRec; - Str31 dirName; - memset(&infoRec, 0, sizeof(infoRec)); - memset(zTempPath, 0, SQLITE_TEMPNAME_SIZE); - 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 ); - } - if( *zTempPath == 0 ) - getcwd(zTempPath, SQLITE_TEMPNAME_SIZE-24); - for(;;){ - sprintf(zBuf, "%s"TEMP_FILE_PREFIX, zTempPath); - 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 -} - -/* -** 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; +int sqlite3OsClose(OsFile **pId){ + OsFile *id; + if( pId!=0 && (id = *pId)!=0 ){ + return id->pMethod->xClose(pId); }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 +int sqlite3OsOpenDirectory(OsFile *id, const char *zName){ + return id->pMethod->xOpenDirectory(id, zName); } - -/* -** 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 +int sqlite3OsRead(OsFile *id, void *pBuf, int amt){ + return id->pMethod->xRead(id, pBuf, amt); } - -#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; +int sqlite3OsWrite(OsFile *id, const void *pBuf, int amt){ + return id->pMethod->xWrite(id, pBuf, amt); +} +int sqlite3OsSeek(OsFile *id, i64 offset){ + return id->pMethod->xSeek(id, offset); +} +int sqlite3OsTruncate(OsFile *id, i64 size){ + return id->pMethod->xTruncate(id, size); +} +int sqlite3OsSync(OsFile *id, int fullsync){ + return id->pMethod->xSync(id, fullsync); +} +void sqlite3OsSetFullSync(OsFile *id, int value){ + id->pMethod->xSetFullSync(id, value); +} +#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) +/* This method is currently only used while interactively debugging the +** pager. More specificly, it can only be used when sqlite3DebugPrintf() is +** included in the build. */ +int sqlite3OsFileHandle(OsFile *id){ + return id->pMethod->xFileHandle(id); } #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 +int sqlite3OsFileSize(OsFile *id, i64 *pSize){ + return id->pMethod->xFileSize(id, pSize); +} +int sqlite3OsLock(OsFile *id, int lockType){ + return id->pMethod->xLock(id, lockType); +} +int sqlite3OsUnlock(OsFile *id, int lockType){ + return id->pMethod->xUnlock(id, lockType); +} +int sqlite3OsLockState(OsFile *id){ + return id->pMethod->xLockState(id); +} +int sqlite3OsCheckReservedLock(OsFile *id){ + return id->pMethod->xCheckReservedLock(id); } +#ifdef SQLITE_ENABLE_REDEF_IO /* -** 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. +** A function to return a pointer to the virtual function table. +** This routine really does not accomplish very much since the +** virtual function table is a global variable and anybody who +** can call this function can just as easily access the variable +** for themselves. Nevertheless, we include this routine for +** backwards compatibility with an earlier redefinable I/O +** interface design. */ -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 +struct sqlite3OsVtbl *sqlite3_os_switch(void){ + return &sqlite3Os; } - -/* -** 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]; - 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 now-zero value, become 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; -} diff --git a/sqlite/os.h b/sqlite/os.h index d1395841d..b294346b0 100755 --- a/sqlite/os.h +++ b/sqlite/os.h @@ -18,31 +18,44 @@ #define _SQLITE_OS_H_ /* -** Helpful hint: To get this to compile on HP/UX, add -D_INCLUDE_POSIX_SOURCE -** to the compiler command line. +** Figure out if we are dealing with Unix, Windows, or some other +** operating system. */ +#if !defined(OS_UNIX) && !defined(OS_OTHER) +# define OS_OTHER 0 +# ifndef OS_WIN +# if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__) +# define OS_WIN 1 +# define OS_UNIX 0 +# else +# define OS_WIN 0 +# define OS_UNIX 1 +# endif +# else +# define OS_UNIX 0 +# endif +#else +# ifndef OS_WIN +# define OS_WIN 0 +# endif +#endif + /* -** 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. +** Define the maximum size of a temporary filename */ -#ifndef SQLITE_DISABLE_LFS -# define _LARGE_FILE 1 -# ifndef _FILE_OFFSET_BITS -# define _FILE_OFFSET_BITS 64 -# endif -# define _LARGEFILE_SOURCE 1 +#if OS_WIN +# include +# define SQLITE_TEMPNAME_SIZE (MAX_PATH+50) +#else +# define SQLITE_TEMPNAME_SIZE 200 +#endif + +/* If the SET_FULLSYNC macro is not defined above, then make it +** a no-op +*/ +#ifndef SET_FULLSYNC +# define SET_FULLSYNC(x,y) #endif /* @@ -59,133 +72,369 @@ #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) +** Define the interfaces for Unix and for Windows. */ -#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 +#if OS_UNIX +#define sqlite3OsOpenReadWrite sqlite3UnixOpenReadWrite +#define sqlite3OsOpenExclusive sqlite3UnixOpenExclusive +#define sqlite3OsOpenReadOnly sqlite3UnixOpenReadOnly +#define sqlite3OsDelete sqlite3UnixDelete +#define sqlite3OsFileExists sqlite3UnixFileExists +#define sqlite3OsFullPathname sqlite3UnixFullPathname +#define sqlite3OsIsDirWritable sqlite3UnixIsDirWritable +#define sqlite3OsSyncDirectory sqlite3UnixSyncDirectory +#define sqlite3OsTempFileName sqlite3UnixTempFileName +#define sqlite3OsRandomSeed sqlite3UnixRandomSeed +#define sqlite3OsSleep sqlite3UnixSleep +#define sqlite3OsCurrentTime sqlite3UnixCurrentTime +#define sqlite3OsEnterMutex sqlite3UnixEnterMutex +#define sqlite3OsLeaveMutex sqlite3UnixLeaveMutex +#define sqlite3OsInMutex sqlite3UnixInMutex +#define sqlite3OsThreadSpecificData sqlite3UnixThreadSpecificData +#define sqlite3OsMalloc sqlite3GenericMalloc +#define sqlite3OsRealloc sqlite3GenericRealloc +#define sqlite3OsFree sqlite3GenericFree +#define sqlite3OsAllocationSize sqlite3GenericAllocationSize +#endif +#if OS_WIN +#define sqlite3OsOpenReadWrite sqlite3WinOpenReadWrite +#define sqlite3OsOpenExclusive sqlite3WinOpenExclusive +#define sqlite3OsOpenReadOnly sqlite3WinOpenReadOnly +#define sqlite3OsDelete sqlite3WinDelete +#define sqlite3OsFileExists sqlite3WinFileExists +#define sqlite3OsFullPathname sqlite3WinFullPathname +#define sqlite3OsIsDirWritable sqlite3WinIsDirWritable +#define sqlite3OsSyncDirectory sqlite3WinSyncDirectory +#define sqlite3OsTempFileName sqlite3WinTempFileName +#define sqlite3OsRandomSeed sqlite3WinRandomSeed +#define sqlite3OsSleep sqlite3WinSleep +#define sqlite3OsCurrentTime sqlite3WinCurrentTime +#define sqlite3OsEnterMutex sqlite3WinEnterMutex +#define sqlite3OsLeaveMutex sqlite3WinLeaveMutex +#define sqlite3OsInMutex sqlite3WinInMutex +#define sqlite3OsThreadSpecificData sqlite3WinThreadSpecificData +#define sqlite3OsMalloc sqlite3GenericMalloc +#define sqlite3OsRealloc sqlite3GenericRealloc +#define sqlite3OsFree sqlite3GenericFree +#define sqlite3OsAllocationSize sqlite3GenericAllocationSize #endif /* -** A handle for an open file is stored in an OsFile object. +** If using an alternative OS interface, then we must have an "os_other.h" +** header file available for that interface. Presumably the "os_other.h" +** header file contains #defines similar to those above. */ -#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 +#if OS_OTHER +# include "os_other.h" #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 + + +/* +** Forward declarations +*/ +typedef struct OsFile OsFile; +typedef struct IoMethod IoMethod; + +/* +** An instance of the following structure contains pointers to all +** methods on an OsFile object. +*/ +struct IoMethod { + int (*xClose)(OsFile**); + int (*xOpenDirectory)(OsFile*, const char*); + int (*xRead)(OsFile*, void*, int amt); + int (*xWrite)(OsFile*, const void*, int amt); + int (*xSeek)(OsFile*, i64 offset); + int (*xTruncate)(OsFile*, i64 size); + int (*xSync)(OsFile*, int); + void (*xSetFullSync)(OsFile *id, int setting); + int (*xFileHandle)(OsFile *id); + int (*xFileSize)(OsFile*, i64 *pSize); + int (*xLock)(OsFile*, int); + int (*xUnlock)(OsFile*, int); + int (*xLockState)(OsFile *id); + int (*xCheckReservedLock)(OsFile *id); +}; + +/* +** The OsFile object describes an open disk file in an OS-dependent way. +** The version of OsFile defined here is a generic version. Each OS +** implementation defines its own subclass of this structure that contains +** additional information needed to handle file I/O. But the pMethod +** entry (pointing to the virtual function table) always occurs first +** so that we can always find the appropriate methods. +*/ +struct OsFile { + IoMethod const *pMethod; +}; + +/* +** The following values may be passed as the second argument to +** sqlite3OsLock(). The various locks exhibit the following semantics: +** +** SHARED: Any number of processes may hold a SHARED lock simultaneously. +** RESERVED: A single process may hold a RESERVED lock on a file at +** any time. Other processes may hold and obtain new SHARED locks. +** PENDING: A single process may hold a PENDING lock on a file at +** any one time. Existing SHARED locks may persist, but no new +** SHARED locks may be obtained by other processes. +** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks. +** +** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a +** process that requests an EXCLUSIVE lock may actually obtain a PENDING +** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to +** sqlite3OsLock(). +*/ +#define NO_LOCK 0 +#define SHARED_LOCK 1 +#define RESERVED_LOCK 2 +#define PENDING_LOCK 3 +#define EXCLUSIVE_LOCK 4 + +/* +** File Locking Notes: (Mostly about windows but also some info for Unix) +** +** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because +** those functions are not available. So we use only LockFile() and +** UnlockFile(). +** +** LockFile() prevents not just writing but also reading by other processes. +** A SHARED_LOCK is obtained by locking a single randomly-chosen +** byte out of a specific range of bytes. The lock byte is obtained at +** random so two separate readers can probably access the file at the +** same time, unless they are unlucky and choose the same lock byte. +** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range. +** There can only be one writer. A RESERVED_LOCK is obtained by locking +** a single byte of the file that is designated as the reserved lock byte. +** A PENDING_LOCK is obtained by locking a designated byte different from +** the RESERVED_LOCK byte. +** +** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available, +** which means we can use reader/writer locks. When reader/writer locks +** are used, the lock is placed on the same range of bytes that is used +** for probabilistic locking in Win95/98/ME. Hence, the locking scheme +** will support two or more Win95 readers or two or more WinNT readers. +** But a single Win95 reader will lock out all WinNT readers and a single +** WinNT reader will lock out all other Win95 readers. +** +** The following #defines specify the range of bytes used for locking. +** SHARED_SIZE is the number of bytes available in the pool from which +** a random byte is selected for a shared lock. The pool of bytes for +** shared locks begins at SHARED_FIRST. +** +** These #defines are available in sqlite_aux.h so that adaptors for +** connecting SQLite to other operating systems can use the same byte +** ranges for locking. In particular, the same locking strategy and +** byte ranges are used for Unix. This leaves open the possiblity of having +** clients on win95, winNT, and unix all talking to the same shared file +** and all locking correctly. To do so would require that samba (or whatever +** tool is being used for file sharing) implements locks correctly between +** windows and unix. I'm guessing that isn't likely to happen, but by +** using the same locking range we are at least open to the possibility. +** +** Locking in windows is manditory. For this reason, we cannot store +** actual data in the bytes used for locking. The pager never allocates +** the pages involved in locking therefore. SHARED_SIZE is selected so +** that all locks will fit on a single page even at the minimum page size. +** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE +** is set high so that we don't have to allocate an unused page except +** for very large databases. But one should test the page skipping logic +** by setting PENDING_BYTE low and running the entire regression suite. +** +** Changing the value of PENDING_BYTE results in a subtly incompatible +** file format. Depending on how it is changed, you might not notice +** the incompatibility right away, even running a full regression test. +** The default location of PENDING_BYTE is the first byte past the +** 1GB boundary. +** +*/ +#ifndef SQLITE_TEST +#define PENDING_BYTE 0x40000000 /* First byte past the 1GB boundary */ +#else +extern unsigned int sqlite3_pending_byte; +#define PENDING_BYTE sqlite3_pending_byte #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 +#define RESERVED_BYTE (PENDING_BYTE+1) +#define SHARED_FIRST (PENDING_BYTE+2) +#define SHARED_SIZE 510 + +/* +** Prototypes for operating system interface routines. +*/ +int sqlite3OsClose(OsFile**); +int sqlite3OsOpenDirectory(OsFile*, const char*); +int sqlite3OsRead(OsFile*, void*, int amt); +int sqlite3OsWrite(OsFile*, const void*, int amt); +int sqlite3OsSeek(OsFile*, i64 offset); +int sqlite3OsTruncate(OsFile*, i64 size); +int sqlite3OsSync(OsFile*, int); +void sqlite3OsSetFullSync(OsFile *id, int setting); +int sqlite3OsFileHandle(OsFile *id); +int sqlite3OsFileSize(OsFile*, i64 *pSize); +int sqlite3OsLock(OsFile*, int); +int sqlite3OsUnlock(OsFile*, int); +int sqlite3OsLockState(OsFile *id); +int sqlite3OsCheckReservedLock(OsFile *id); +int sqlite3OsOpenReadWrite(const char*, OsFile**, int*); +int sqlite3OsOpenExclusive(const char*, OsFile**, int); +int sqlite3OsOpenReadOnly(const char*, OsFile**); +int sqlite3OsDelete(const char*); +int sqlite3OsFileExists(const char*); +char *sqlite3OsFullPathname(const char*); +int sqlite3OsIsDirWritable(char*); +int sqlite3OsSyncDirectory(const char*); +int sqlite3OsTempFileName(char*); +int sqlite3OsRandomSeed(char*); +int sqlite3OsSleep(int ms); +int sqlite3OsCurrentTime(double*); +void sqlite3OsEnterMutex(void); +void sqlite3OsLeaveMutex(void); +int sqlite3OsInMutex(int); +ThreadData *sqlite3OsThreadSpecificData(int); +void *sqlite3OsMalloc(int); +void *sqlite3OsRealloc(void *, int); +void sqlite3OsFree(void *); +int sqlite3OsAllocationSize(void *); + +/* +** If the SQLITE_ENABLE_REDEF_IO macro is defined, then the OS-layer +** interface routines are not called directly but are invoked using +** pointers to functions. This allows the implementation of various +** OS-layer interface routines to be modified at run-time. There are +** obscure but legitimate reasons for wanting to do this. But for +** most users, a direct call to the underlying interface is preferable +** so the the redefinable I/O interface is turned off by default. +*/ +#ifdef SQLITE_ENABLE_REDEF_IO + +/* +** When redefinable I/O is enabled, a single global instance of the +** following structure holds pointers to the routines that SQLite +** uses to talk with the underlying operating system. Modify this +** structure (before using any SQLite API!) to accomodate perculiar +** operating system interfaces or behaviors. +*/ +struct sqlite3OsVtbl { + int (*xOpenReadWrite)(const char*, OsFile**, int*); + int (*xOpenExclusive)(const char*, OsFile**, int); + int (*xOpenReadOnly)(const char*, OsFile**); + + int (*xDelete)(const char*); + int (*xFileExists)(const char*); + char *(*xFullPathname)(const char*); + int (*xIsDirWritable)(char*); + int (*xSyncDirectory)(const char*); + int (*xTempFileName)(char*); + + int (*xRandomSeed)(char*); + int (*xSleep)(int ms); + int (*xCurrentTime)(double*); + + void (*xEnterMutex)(void); + void (*xLeaveMutex)(void); + int (*xInMutex)(int); + ThreadData *(*xThreadSpecificData)(int); + + void *(*xMalloc)(int); + void *(*xRealloc)(void *, int); + void (*xFree)(void *); + int (*xAllocationSize)(void *); +}; + +/* Macro used to comment out routines that do not exists when there is +** no disk I/O +*/ +#ifdef SQLITE_OMIT_DISKIO +# define IF_DISKIO(X) 0 +#else +# define IF_DISKIO(X) X #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*); +#ifdef _SQLITE_OS_C_ + /* + ** The os.c file implements the global virtual function table. + */ + struct sqlite3OsVtbl sqlite3Os = { + IF_DISKIO( sqlite3OsOpenReadWrite ), + IF_DISKIO( sqlite3OsOpenExclusive ), + IF_DISKIO( sqlite3OsOpenReadOnly ), + IF_DISKIO( sqlite3OsDelete ), + IF_DISKIO( sqlite3OsFileExists ), + IF_DISKIO( sqlite3OsFullPathname ), + IF_DISKIO( sqlite3OsIsDirWritable ), + IF_DISKIO( sqlite3OsSyncDirectory ), + IF_DISKIO( sqlite3OsTempFileName ), + sqlite3OsRandomSeed, + sqlite3OsSleep, + sqlite3OsCurrentTime, + sqlite3OsEnterMutex, + sqlite3OsLeaveMutex, + sqlite3OsInMutex, + sqlite3OsThreadSpecificData, + sqlite3OsMalloc, + sqlite3OsRealloc, + sqlite3OsFree, + sqlite3OsAllocationSize + }; +#else + /* + ** Files other than os.c just reference the global virtual function table. + */ + extern struct sqlite3OsVtbl sqlite3Os; +#endif /* _SQLITE_OS_C_ */ +/* This additional API routine is available with redefinable I/O */ +struct sqlite3OsVtbl *sqlite3_os_switch(void); + + +/* +** Redefine the OS interface to go through the virtual function table +** rather than calling routines directly. +*/ +#undef sqlite3OsOpenReadWrite +#undef sqlite3OsOpenExclusive +#undef sqlite3OsOpenReadOnly +#undef sqlite3OsDelete +#undef sqlite3OsFileExists +#undef sqlite3OsFullPathname +#undef sqlite3OsIsDirWritable +#undef sqlite3OsSyncDirectory +#undef sqlite3OsTempFileName +#undef sqlite3OsRandomSeed +#undef sqlite3OsSleep +#undef sqlite3OsCurrentTime +#undef sqlite3OsEnterMutex +#undef sqlite3OsLeaveMutex +#undef sqlite3OsInMutex +#undef sqlite3OsThreadSpecificData +#undef sqlite3OsMalloc +#undef sqlite3OsRealloc +#undef sqlite3OsFree +#undef sqlite3OsAllocationSize +#define sqlite3OsOpenReadWrite sqlite3Os.xOpenReadWrite +#define sqlite3OsOpenExclusive sqlite3Os.xOpenExclusive +#define sqlite3OsOpenReadOnly sqlite3Os.xOpenReadOnly +#define sqlite3OsDelete sqlite3Os.xDelete +#define sqlite3OsFileExists sqlite3Os.xFileExists +#define sqlite3OsFullPathname sqlite3Os.xFullPathname +#define sqlite3OsIsDirWritable sqlite3Os.xIsDirWritable +#define sqlite3OsSyncDirectory sqlite3Os.xSyncDirectory +#define sqlite3OsTempFileName sqlite3Os.xTempFileName +#define sqlite3OsRandomSeed sqlite3Os.xRandomSeed +#define sqlite3OsSleep sqlite3Os.xSleep +#define sqlite3OsCurrentTime sqlite3Os.xCurrentTime +#define sqlite3OsEnterMutex sqlite3Os.xEnterMutex +#define sqlite3OsLeaveMutex sqlite3Os.xLeaveMutex +#define sqlite3OsInMutex sqlite3Os.xInMutex +#define sqlite3OsThreadSpecificData sqlite3Os.xThreadSpecificData +#define sqlite3OsMalloc sqlite3Os.xMalloc +#define sqlite3OsRealloc sqlite3Os.xRealloc +#define sqlite3OsFree sqlite3Os.xFree +#define sqlite3OsAllocationSize sqlite3Os.xAllocationSize + +#endif /* SQLITE_ENABLE_REDEF_IO */ #endif /* _SQLITE_OS_H_ */ diff --git a/sqlite/os_common.h b/sqlite/os_common.h new file mode 100755 index 000000000..d65c352dd --- /dev/null +++ b/sqlite/os_common.h @@ -0,0 +1,188 @@ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains macros and a little bit of code that is common to +** all of the platform-specific files (os_*.c) and is #included into those +** files. +** +** This file should be #included by the os_*.c files only. It is not a +** general purpose header file. +*/ + +/* +** At least two bugs have slipped in because we changed the MEMORY_DEBUG +** macro to SQLITE_DEBUG and some older makefiles have not yet made the +** switch. The following code should catch this problem at compile-time. +*/ +#ifdef MEMORY_DEBUG +# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." +#endif + + +/* + * When testing, this global variable stores the location of the + * pending-byte in the database file. + */ +#ifdef SQLITE_TEST +unsigned int sqlite3_pending_byte = 0x40000000; +#endif + +int sqlite3_os_trace = 0; +#ifdef SQLITE_DEBUG +static int last_page = 0; +#define SEEK(X) last_page=(X) +#define TRACE1(X) if( sqlite3_os_trace ) sqlite3DebugPrintf(X) +#define TRACE2(X,Y) if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y) +#define TRACE3(X,Y,Z) if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y,Z) +#define TRACE4(X,Y,Z,A) if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y,Z,A) +#define TRACE5(X,Y,Z,A,B) if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y,Z,A,B) +#define TRACE6(X,Y,Z,A,B,C) if(sqlite3_os_trace) sqlite3DebugPrintf(X,Y,Z,A,B,C) +#define TRACE7(X,Y,Z,A,B,C,D) \ + if(sqlite3_os_trace) sqlite3DebugPrintf(X,Y,Z,A,B,C,D) +#else +#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) +#define TRACE6(X,Y,Z,A,B,C) +#define TRACE7(X,Y,Z,A,B,C,D) +#endif + +/* +** Macros for performance tracing. Normally turned off. Only works +** on i486 hardware. +*/ +#ifdef SQLITE_PERFORMANCE_TRACE +__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 TIMER_ELAPSED elapse +#else +#define TIMER_START +#define TIMER_END +#define TIMER_ELAPSED 0 +#endif + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#ifdef SQLITE_TEST +int sqlite3_io_error_hit = 0; +int sqlite3_io_error_pending = 0; +int sqlite3_diskfull_pending = 0; +int sqlite3_diskfull = 0; +#define SimulateIOError(A) \ + if( sqlite3_io_error_pending ) \ + if( sqlite3_io_error_pending-- == 1 ){ local_ioerr(); return A; } +static void local_ioerr(){ + sqlite3_io_error_hit = 1; /* Really just a place to set a breakpoint */ +} +#define SimulateDiskfullError \ + if( sqlite3_diskfull_pending ){ \ + if( sqlite3_diskfull_pending == 1 ){ \ + local_ioerr(); \ + sqlite3_diskfull = 1; \ + return SQLITE_FULL; \ + }else{ \ + sqlite3_diskfull_pending--; \ + } \ + } +#else +#define SimulateIOError(A) +#define SimulateDiskfullError +#endif + +/* +** When testing, keep a count of the number of open files. +*/ +#ifdef SQLITE_TEST +int sqlite3_open_file_count = 0; +#define OpenCounter(X) sqlite3_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif + +/* +** sqlite3GenericMalloc +** sqlite3GenericRealloc +** sqlite3GenericOsFree +** sqlite3GenericAllocationSize +** +** Implementation of the os level dynamic memory allocation interface in terms +** of the standard malloc(), realloc() and free() found in many operating +** systems. No rocket science here. +** +** There are two versions of these four functions here. The version +** implemented here is only used if memory-management or memory-debugging is +** enabled. This version allocates an extra 8-bytes at the beginning of each +** block and stores the size of the allocation there. +** +** If neither memory-management or debugging is enabled, the second +** set of implementations is used instead. +*/ +#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) || defined (SQLITE_MEMDEBUG) +void *sqlite3GenericMalloc(int n){ + char *p = (char *)malloc(n+8); + assert(n>0); + assert(sizeof(int)<=8); + if( p ){ + *(int *)p = n; + p += 8; + } + return (void *)p; +} +void *sqlite3GenericRealloc(void *p, int n){ + char *p2 = ((char *)p - 8); + assert(n>0); + p2 = (char*)realloc(p2, n+8); + if( p2 ){ + *(int *)p2 = n; + p2 += 8; + } + return (void *)p2; +} +void sqlite3GenericFree(void *p){ + assert(p); + free((void *)((char *)p - 8)); +} +int sqlite3GenericAllocationSize(void *p){ + return p ? *(int *)((char *)p - 8) : 0; +} +#else +void *sqlite3GenericMalloc(int n){ + char *p = (char *)malloc(n); + return (void *)p; +} +void *sqlite3GenericRealloc(void *p, int n){ + assert(n>0); + p = realloc(p, n); + return p; +} +void sqlite3GenericFree(void *p){ + assert(p); + free(p); +} +/* Never actually used, but needed for the linker */ +int sqlite3GenericAllocationSize(void *p){ return 0; } +#endif diff --git a/sqlite/os_unix.c b/sqlite/os_unix.c new file mode 100755 index 000000000..6dcc43ebe --- /dev/null +++ b/sqlite/os_unix.c @@ -0,0 +1,1995 @@ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to Unix systems. +*/ +#include "sqliteInt.h" +#include "os.h" +#if OS_UNIX /* This file is used on unix only */ + +/* +** These #defines should enable >2GB file support on Posix if the +** underlying operating system supports it. If the OS lacks +** large file support, 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. +*/ +#ifndef SQLITE_DISABLE_LFS +# define _LARGE_FILE 1 +# ifndef _FILE_OFFSET_BITS +# define _FILE_OFFSET_BITS 64 +# endif +# define _LARGEFILE_SOURCE 1 +#endif + +/* +** standard include files. +*/ +#include +#include +#include +#include +#include +#include +#include + +/* +** If we are to be thread-safe, include the pthreads header and define +** the SQLITE_UNIX_THREADS macro. +*/ +#if defined(THREADSAFE) && THREADSAFE +# include +# define SQLITE_UNIX_THREADS 1 +#endif + +/* +** Default permissions when creating a new file +*/ +#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS +# define SQLITE_DEFAULT_FILE_PERMISSIONS 0644 +#endif + + + +/* +** The unixFile structure is subclass of OsFile specific for the unix +** protability layer. +*/ +typedef struct unixFile unixFile; +struct unixFile { + IoMethod const *pMethod; /* Always the first entry */ + struct openCnt *pOpen; /* Info about all open fd's on this inode */ + struct lockInfo *pLock; /* Info about locks on this inode */ + int h; /* The file descriptor */ + unsigned char locktype; /* The type of lock held on this fd */ + unsigned char isOpen; /* True if needs to be closed */ + unsigned char fullSync; /* Use F_FULLSYNC if available */ + int dirfd; /* File descriptor for the directory */ + i64 offset; /* Seek offset */ +#ifdef SQLITE_UNIX_THREADS + pthread_t tid; /* The thread that "owns" this OsFile */ +#endif +}; + +/* +** Provide the ability to override some OS-layer functions during +** testing. This is used to simulate OS crashes to verify that +** commits are atomic even in the event of an OS crash. +*/ +#ifdef SQLITE_CRASH_TEST + extern int sqlite3CrashTestEnable; + extern int sqlite3CrashOpenReadWrite(const char*, OsFile**, int*); + extern int sqlite3CrashOpenExclusive(const char*, OsFile**, int); + extern int sqlite3CrashOpenReadOnly(const char*, OsFile**, int); +# define CRASH_TEST_OVERRIDE(X,A,B,C) \ + if(sqlite3CrashTestEnable){ return X(A,B,C); } +#else +# define CRASH_TEST_OVERRIDE(X,A,B,C) /* no-op */ +#endif + + +/* +** Include code that is common to all os_*.c files +*/ +#include "os_common.h" + +/* +** Do not include any of the File I/O interface procedures if the +** SQLITE_OMIT_DISKIO macro is defined (indicating that the database +** will be in-memory only) +*/ +#ifndef SQLITE_OMIT_DISKIO + + +/* +** Define various macros that are missing from some systems. +*/ +#ifndef O_LARGEFILE +# define O_LARGEFILE 0 +#endif +#ifdef SQLITE_DISABLE_LFS +# undef O_LARGEFILE +# define O_LARGEFILE 0 +#endif +#ifndef O_NOFOLLOW +# define O_NOFOLLOW 0 +#endif +#ifndef O_BINARY +# define O_BINARY 0 +#endif + +/* +** The DJGPP compiler environment looks mostly like Unix, but it +** lacks the fcntl() system call. So redefine fcntl() to be something +** that always succeeds. This means that locking does not occur under +** DJGPP. But it's DOS - what did you expect? +*/ +#ifdef __DJGPP__ +# define fcntl(A,B,C) 0 +#endif + +/* +** The threadid macro resolves to the thread-id or to 0. Used for +** testing and debugging only. +*/ +#ifdef SQLITE_UNIX_THREADS +#define threadid pthread_self() +#else +#define threadid 0 +#endif + +/* +** Set or check the OsFile.tid field. This field is set when an OsFile +** is first opened. All subsequent uses of the OsFile verify that the +** same thread is operating on the OsFile. Some operating systems do +** not allow locks to be overridden by other threads and that restriction +** means that sqlite3* database handles cannot be moved from one thread +** to another. This logic makes sure a user does not try to do that +** by mistake. +** +** Version 3.3.1 (2006-01-15): OsFiles can be moved from one thread to +** another as long as we are running on a system that supports threads +** overriding each others locks (which now the most common behavior) +** or if no locks are held. But the OsFile.pLock field needs to be +** recomputed because its key includes the thread-id. See the +** transferOwnership() function below for additional information +*/ +#if defined(SQLITE_UNIX_THREADS) +# define SET_THREADID(X) (X)->tid = pthread_self() +# define CHECK_THREADID(X) (threadsOverrideEachOthersLocks==0 && \ + !pthread_equal((X)->tid, pthread_self())) +#else +# define SET_THREADID(X) +# define CHECK_THREADID(X) 0 +#endif + +/* +** 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. +** +** 2004-Jun-28: +** On some versions of linux, threads can override each others locks. +** On others not. Sometimes you can change the behavior on the same +** system by setting the LD_ASSUME_KERNEL environment variable. The +** POSIX standard is silent as to which behavior is correct, as far +** as I can tell, so other versions of unix might show the same +** inconsistency. There is no little doubt in my mind that posix +** advisory locks and linux threads are profoundly broken. +** +** To work around the inconsistencies, we have to test at runtime +** whether or not threads can override each others locks. This test +** is run once, the first time any lock is attempted. A static +** variable is set to record the results of this test for future +** use. +*/ + +/* +** An instance of the following structure serves as the key used +** to locate a particular lockInfo structure given its inode. +** +** If threads cannot override each others locks, then we set the +** lockKey.tid field to the thread ID. If threads can override +** each others locks then tid is always set to zero. tid is omitted +** if we compile without threading support. +*/ +struct lockKey { + dev_t dev; /* Device number */ + ino_t ino; /* Inode number */ +#ifdef SQLITE_UNIX_THREADS + pthread_t tid; /* Thread ID or zero if threads can override each other */ +#endif +}; + +/* +** 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; /* Number of SHARED locks held */ + int locktype; /* One of SHARED_LOCK, RESERVED_LOCK etc. */ + 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 thread 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 tables map inodes and file descriptors (really, lockKey and +** openKey structures) 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, + sqlite3ThreadSafeMalloc, sqlite3ThreadSafeFree, 0, 0}; +static Hash openHash = {SQLITE_HASH_BINARY, 0, 0, 0, + sqlite3ThreadSafeMalloc, sqlite3ThreadSafeFree, 0, 0}; + +#ifdef SQLITE_UNIX_THREADS +/* +** This variable records whether or not threads can override each others +** locks. +** +** 0: No. Threads cannot override each others locks. +** 1: Yes. Threads can override each others locks. +** -1: We don't know yet. +** +** On some systems, we know at compile-time if threads can override each +** others locks. On those systems, the SQLITE_THREAD_OVERRIDE_LOCK macro +** will be set appropriately. On other systems, we have to check at +** runtime. On these latter systems, SQLTIE_THREAD_OVERRIDE_LOCK is +** undefined. +** +** This variable normally has file scope only. But during testing, we make +** it a global so that the test code can change its value in order to verify +** that the right stuff happens in either case. +*/ +#ifndef SQLITE_THREAD_OVERRIDE_LOCK +# define SQLITE_THREAD_OVERRIDE_LOCK -1 +#endif +#ifdef SQLITE_TEST +int threadsOverrideEachOthersLocks = SQLITE_THREAD_OVERRIDE_LOCK; +#else +static int threadsOverrideEachOthersLocks = SQLITE_THREAD_OVERRIDE_LOCK; +#endif + +/* +** This structure holds information passed into individual test +** threads by the testThreadLockingBehavior() routine. +*/ +struct threadTestData { + int fd; /* File to be locked */ + struct flock lock; /* The locking operation */ + int result; /* Result of the locking operation */ +}; + +#ifdef SQLITE_LOCK_TRACE +/* +** Print out information about all locking operations. +** +** This routine is used for troubleshooting locks on multithreaded +** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE +** command-line option on the compiler. This code is normally +** turned off. +*/ +static int lockTrace(int fd, int op, struct flock *p){ + char *zOpName, *zType; + int s; + int savedErrno; + if( op==F_GETLK ){ + zOpName = "GETLK"; + }else if( op==F_SETLK ){ + zOpName = "SETLK"; + }else{ + s = fcntl(fd, op, p); + sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s); + return s; + } + if( p->l_type==F_RDLCK ){ + zType = "RDLCK"; + }else if( p->l_type==F_WRLCK ){ + zType = "WRLCK"; + }else if( p->l_type==F_UNLCK ){ + zType = "UNLCK"; + }else{ + assert( 0 ); + } + assert( p->l_whence==SEEK_SET ); + s = fcntl(fd, op, p); + savedErrno = errno; + sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n", + threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len, + (int)p->l_pid, s); + if( s && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){ + struct flock l2; + l2 = *p; + fcntl(fd, F_GETLK, &l2); + if( l2.l_type==F_RDLCK ){ + zType = "RDLCK"; + }else if( l2.l_type==F_WRLCK ){ + zType = "WRLCK"; + }else if( l2.l_type==F_UNLCK ){ + zType = "UNLCK"; + }else{ + assert( 0 ); + } + sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n", + zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid); + } + errno = savedErrno; + return s; +} +#define fcntl lockTrace +#endif /* SQLITE_LOCK_TRACE */ + +/* +** The testThreadLockingBehavior() routine launches two separate +** threads on this routine. This routine attempts to lock a file +** descriptor then returns. The success or failure of that attempt +** allows the testThreadLockingBehavior() procedure to determine +** whether or not threads can override each others locks. +*/ +static void *threadLockingTest(void *pArg){ + struct threadTestData *pData = (struct threadTestData*)pArg; + pData->result = fcntl(pData->fd, F_SETLK, &pData->lock); + return pArg; +} + +/* +** This procedure attempts to determine whether or not threads +** can override each others locks then sets the +** threadsOverrideEachOthersLocks variable appropriately. +*/ +static void testThreadLockingBehavior(int fd_orig){ + int fd; + struct threadTestData d[2]; + pthread_t t[2]; + + fd = dup(fd_orig); + if( fd<0 ) return; + memset(d, 0, sizeof(d)); + d[0].fd = fd; + d[0].lock.l_type = F_RDLCK; + d[0].lock.l_len = 1; + d[0].lock.l_start = 0; + d[0].lock.l_whence = SEEK_SET; + d[1] = d[0]; + d[1].lock.l_type = F_WRLCK; + pthread_create(&t[0], 0, threadLockingTest, &d[0]); + pthread_create(&t[1], 0, threadLockingTest, &d[1]); + pthread_join(t[0], 0); + pthread_join(t[1], 0); + close(fd); + threadsOverrideEachOthersLocks = d[0].result==0 && d[1].result==0; +} +#endif /* SQLITE_UNIX_THREADS */ + +/* +** Release a lockInfo structure previously allocated by findLockInfo(). +*/ +static void releaseLockInfo(struct lockInfo *pLock){ + assert( sqlite3OsInMutex(1) ); + pLock->nRef--; + if( pLock->nRef==0 ){ + sqlite3HashInsert(&lockHash, &pLock->key, sizeof(pLock->key), 0); + sqlite3ThreadSafeFree(pLock); + } +} + +/* +** Release a openCnt structure previously allocated by findLockInfo(). +*/ +static void releaseOpenCnt(struct openCnt *pOpen){ + assert( sqlite3OsInMutex(1) ); + pOpen->nRef--; + if( pOpen->nRef==0 ){ + sqlite3HashInsert(&openHash, &pOpen->key, sizeof(pOpen->key), 0); + free(pOpen->aPending); + sqlite3ThreadSafeFree(pOpen); + } +} + +/* +** Given a file descriptor, locate lockInfo and openCnt structures that +** describes that file descriptor. Create new ones if necessary. The +** return values might be uninitialized if an error occurs. +** +** Return the number of errors. +*/ +static 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; + + assert( sqlite3OsInMutex(1) ); + memset(&key1, 0, sizeof(key1)); + key1.dev = statbuf.st_dev; + key1.ino = statbuf.st_ino; +#ifdef SQLITE_UNIX_THREADS + if( threadsOverrideEachOthersLocks<0 ){ + testThreadLockingBehavior(fd); + } + key1.tid = threadsOverrideEachOthersLocks ? 0 : pthread_self(); +#endif + memset(&key2, 0, sizeof(key2)); + key2.dev = statbuf.st_dev; + key2.ino = statbuf.st_ino; + pLock = (struct lockInfo*)sqlite3HashFind(&lockHash, &key1, sizeof(key1)); + if( pLock==0 ){ + struct lockInfo *pOld; + pLock = sqlite3ThreadSafeMalloc( sizeof(*pLock) ); + if( pLock==0 ){ + rc = 1; + goto exit_findlockinfo; + } + pLock->key = key1; + pLock->nRef = 1; + pLock->cnt = 0; + pLock->locktype = 0; + pOld = sqlite3HashInsert(&lockHash, &pLock->key, sizeof(key1), pLock); + if( pOld!=0 ){ + assert( pOld==pLock ); + sqlite3ThreadSafeFree(pLock); + rc = 1; + goto exit_findlockinfo; + } + }else{ + pLock->nRef++; + } + *ppLock = pLock; + if( ppOpen!=0 ){ + pOpen = (struct openCnt*)sqlite3HashFind(&openHash, &key2, sizeof(key2)); + if( pOpen==0 ){ + struct openCnt *pOld; + pOpen = sqlite3ThreadSafeMalloc( sizeof(*pOpen) ); + if( pOpen==0 ){ + releaseLockInfo(pLock); + rc = 1; + goto exit_findlockinfo; + } + pOpen->key = key2; + pOpen->nRef = 1; + pOpen->nLock = 0; + pOpen->nPending = 0; + pOpen->aPending = 0; + pOld = sqlite3HashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen); + if( pOld!=0 ){ + assert( pOld==pOpen ); + sqlite3ThreadSafeFree(pOpen); + releaseLockInfo(pLock); + rc = 1; + goto exit_findlockinfo; + } + }else{ + pOpen->nRef++; + } + *ppOpen = pOpen; + } + +exit_findlockinfo: + return rc; +} + +#ifdef SQLITE_DEBUG +/* +** Helper function for printing out trace information from debugging +** binaries. This returns the string represetation of the supplied +** integer lock-type. +*/ +static const char *locktypeName(int locktype){ + switch( locktype ){ + case NO_LOCK: return "NONE"; + case SHARED_LOCK: return "SHARED"; + case RESERVED_LOCK: return "RESERVED"; + case PENDING_LOCK: return "PENDING"; + case EXCLUSIVE_LOCK: return "EXCLUSIVE"; + } + return "ERROR"; +} +#endif + +/* +** If we are currently in a different thread than the thread that the +** unixFile argument belongs to, then transfer ownership of the unixFile +** over to the current thread. +** +** A unixFile is only owned by a thread on systems where one thread is +** unable to override locks created by a different thread. RedHat9 is +** an example of such a system. +** +** Ownership transfer is only allowed if the unixFile is currently unlocked. +** If the unixFile is locked and an ownership is wrong, then return +** SQLITE_MISUSE. SQLITE_OK is returned if everything works. +*/ +#ifdef SQLITE_UNIX_THREADS +static int transferOwnership(unixFile *pFile){ + int rc; + pthread_t hSelf; + if( threadsOverrideEachOthersLocks ){ + /* Ownership transfers not needed on this system */ + return SQLITE_OK; + } + hSelf = pthread_self(); + if( pthread_equal(pFile->tid, hSelf) ){ + /* We are still in the same thread */ + TRACE1("No-transfer, same thread\n"); + return SQLITE_OK; + } + if( pFile->locktype!=NO_LOCK ){ + /* We cannot change ownership while we are holding a lock! */ + return SQLITE_MISUSE; + } + TRACE4("Transfer ownership of %d from %d to %d\n", pFile->h,pFile->tid,hSelf); + pFile->tid = hSelf; + releaseLockInfo(pFile->pLock); + rc = findLockInfo(pFile->h, &pFile->pLock, 0); + TRACE5("LOCK %d is now %s(%s,%d)\n", pFile->h, + locktypeName(pFile->locktype), + locktypeName(pFile->pLock->locktype), pFile->pLock->cnt); + return rc; +} +#else + /* On single-threaded builds, ownership transfer is a no-op */ +# define transferOwnership(X) SQLITE_OK +#endif + +/* +** Delete the named file +*/ +int sqlite3UnixDelete(const char *zFilename){ + unlink(zFilename); + return SQLITE_OK; +} + +/* +** Return TRUE if the named file exists. +*/ +int sqlite3UnixFileExists(const char *zFilename){ + return access(zFilename, 0)==0; +} + +/* Forward declaration */ +static int allocateUnixFile(unixFile *pInit, OsFile **pId); + +/* +** 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 sqlite3UnixOpenReadWrite( + const char *zFilename, + OsFile **pId, + int *pReadonly +){ + int rc; + unixFile f; + + CRASH_TEST_OVERRIDE(sqlite3CrashOpenReadWrite, zFilename, pId, pReadonly); + assert( 0==*pId ); + f.h = open(zFilename, O_RDWR|O_CREAT|O_LARGEFILE|O_BINARY, + SQLITE_DEFAULT_FILE_PERMISSIONS); + if( f.h<0 ){ +#ifdef EISDIR + if( errno==EISDIR ){ + return SQLITE_CANTOPEN; + } +#endif + f.h = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY); + if( f.h<0 ){ + return SQLITE_CANTOPEN; + } + *pReadonly = 1; + }else{ + *pReadonly = 0; + } + sqlite3OsEnterMutex(); + rc = findLockInfo(f.h, &f.pLock, &f.pOpen); + sqlite3OsLeaveMutex(); + if( rc ){ + close(f.h); + return SQLITE_NOMEM; + } + TRACE3("OPEN %-3d %s\n", f.h, zFilename); + return allocateUnixFile(&f, pId); +} + + +/* +** 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 sqlite3UnixOpenExclusive(const char *zFilename, OsFile **pId, int delFlag){ + int rc; + unixFile f; + + CRASH_TEST_OVERRIDE(sqlite3CrashOpenExclusive, zFilename, pId, delFlag); + assert( 0==*pId ); + if( access(zFilename, 0)==0 ){ + return SQLITE_CANTOPEN; + } + f.h = open(zFilename, + O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW|O_LARGEFILE|O_BINARY, + SQLITE_DEFAULT_FILE_PERMISSIONS); + if( f.h<0 ){ + return SQLITE_CANTOPEN; + } + sqlite3OsEnterMutex(); + rc = findLockInfo(f.h, &f.pLock, &f.pOpen); + sqlite3OsLeaveMutex(); + if( rc ){ + close(f.h); + unlink(zFilename); + return SQLITE_NOMEM; + } + if( delFlag ){ + unlink(zFilename); + } + TRACE3("OPEN-EX %-3d %s\n", f.h, zFilename); + return allocateUnixFile(&f, pId); +} + +/* +** 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 sqlite3UnixOpenReadOnly(const char *zFilename, OsFile **pId){ + int rc; + unixFile f; + + CRASH_TEST_OVERRIDE(sqlite3CrashOpenReadOnly, zFilename, pId, 0); + assert( 0==*pId ); + f.h = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY); + if( f.h<0 ){ + return SQLITE_CANTOPEN; + } + sqlite3OsEnterMutex(); + rc = findLockInfo(f.h, &f.pLock, &f.pOpen); + sqlite3OsLeaveMutex(); + if( rc ){ + close(f.h); + return SQLITE_NOMEM; + } + TRACE3("OPEN-RO %-3d %s\n", f.h, zFilename); + return allocateUnixFile(&f, pId); +} + +/* +** 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 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. +*/ +static int unixOpenDirectory( + OsFile *id, + const char *zDirname +){ + unixFile *pFile = (unixFile*)id; + if( pFile==0 ){ + /* Do not open the directory if the corresponding file is not already + ** open. */ + return SQLITE_CANTOPEN; + } + SET_THREADID(pFile); + assert( pFile->dirfd<0 ); + pFile->dirfd = open(zDirname, O_RDONLY|O_BINARY, 0); + if( pFile->dirfd<0 ){ + return SQLITE_CANTOPEN; + } + TRACE3("OPENDIR %-3d %s\n", pFile->dirfd, zDirname); + 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. +** +** See also the "PRAGMA temp_store_directory" SQL command. +*/ +char *sqlite3_temp_directory = 0; + +/* +** Create a temporary file name in zBuf. zBuf must be big enough to +** hold at least SQLITE_TEMPNAME_SIZE characters. +*/ +int sqlite3UnixTempFileName(char *zBuf){ + static const char *azDirs[] = { + 0, + "/var/tmp", + "/usr/tmp", + "/tmp", + ".", + }; + static const unsigned char zChars[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"; + int i, j; + struct stat buf; + const char *zDir = "."; + azDirs[0] = sqlite3_temp_directory; + for(i=0; ioffset then read cnt bytes into pBuf. +** Return the number of bytes actually read. Update the offset. +*/ +static int seekAndRead(unixFile *id, void *pBuf, int cnt){ + int got; +#ifdef USE_PREAD + got = pread(id->h, pBuf, cnt, id->offset); +#else + lseek(id->h, id->offset, SEEK_SET); + got = read(id->h, pBuf, cnt); +#endif + if( got>0 ){ + id->offset += got; + } + return got; +} + +/* +** Read data from a file into a buffer. Return SQLITE_OK if all +** bytes were read successfully and SQLITE_IOERR if anything goes +** wrong. +*/ +static int unixRead(OsFile *id, void *pBuf, int amt){ + int got; + assert( id ); + SimulateIOError(SQLITE_IOERR); + TIMER_START; + got = seekAndRead((unixFile*)id, pBuf, amt); + TIMER_END; + TRACE5("READ %-3d %5d %7d %d\n", ((unixFile*)id)->h, got, + last_page, TIMER_ELAPSED); + SEEK(0); + /* if( got<0 ) got = 0; */ + if( got==amt ){ + return SQLITE_OK; + }else{ + return SQLITE_IOERR; + } +} + +/* +** Seek to the offset in id->offset then read cnt bytes into pBuf. +** Return the number of bytes actually read. Update the offset. +*/ +static int seekAndWrite(unixFile *id, const void *pBuf, int cnt){ + int got; +#ifdef USE_PREAD + got = pwrite(id->h, pBuf, cnt, id->offset); +#else + lseek(id->h, id->offset, SEEK_SET); + got = write(id->h, pBuf, cnt); +#endif + if( got>0 ){ + id->offset += got; + } + return got; +} + + +/* +** Write data from a buffer into a file. Return SQLITE_OK on success +** or some other error code on failure. +*/ +static int unixWrite(OsFile *id, const void *pBuf, int amt){ + int wrote = 0; + assert( id ); + assert( amt>0 ); + SimulateIOError(SQLITE_IOERR); + SimulateDiskfullError; + TIMER_START; + while( amt>0 && (wrote = seekAndWrite((unixFile*)id, pBuf, amt))>0 ){ + amt -= wrote; + pBuf = &((char*)pBuf)[wrote]; + } + TIMER_END; + TRACE5("WRITE %-3d %5d %7d %d\n", ((unixFile*)id)->h, wrote, + last_page, TIMER_ELAPSED); + SEEK(0); + if( amt>0 ){ + return SQLITE_FULL; + } + return SQLITE_OK; +} + +/* +** Move the read/write pointer in a file. +*/ +static int unixSeek(OsFile *id, i64 offset){ + assert( id ); + SEEK(offset/1024 + 1); +#ifdef SQLITE_TEST + if( offset ) SimulateDiskfullError +#endif + ((unixFile*)id)->offset = offset; + return SQLITE_OK; +} + +#ifdef SQLITE_TEST +/* +** Count the number of fullsyncs and normal syncs. This is used to test +** that syncs and fullsyncs are occuring at the right times. +*/ +int sqlite3_sync_count = 0; +int sqlite3_fullsync_count = 0; +#endif + +/* +** Use the fdatasync() API only if the HAVE_FDATASYNC macro is defined. +** Otherwise use fsync() in its place. +*/ +#ifndef HAVE_FDATASYNC +# define fdatasync fsync +#endif + +/* +** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not +** the F_FULLFSYNC macro is defined. F_FULLFSYNC is currently +** only available on Mac OS X. But that could change. +*/ +#ifdef F_FULLFSYNC +# define HAVE_FULLFSYNC 1 +#else +# define HAVE_FULLFSYNC 0 +#endif + + +/* +** The fsync() system call does not work as advertised on many +** unix systems. The following procedure is an attempt to make +** it work better. +** +** The SQLITE_NO_SYNC macro disables all fsync()s. This is useful +** for testing when we want to run through the test suite quickly. +** You are strongly advised *not* to deploy with SQLITE_NO_SYNC +** enabled, however, since with SQLITE_NO_SYNC enabled, an OS crash +** or power failure will likely corrupt the database file. +*/ +static int full_fsync(int fd, int fullSync, int dataOnly){ + int rc; + + /* Record the number of times that we do a normal fsync() and + ** FULLSYNC. This is used during testing to verify that this procedure + ** gets called with the correct arguments. + */ +#ifdef SQLITE_TEST + if( fullSync ) sqlite3_fullsync_count++; + sqlite3_sync_count++; +#endif + + /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a + ** no-op + */ +#ifdef SQLITE_NO_SYNC + rc = SQLITE_OK; +#else + +#if HAVE_FULLFSYNC + if( fullSync ){ + rc = fcntl(fd, F_FULLFSYNC, 0); + }else{ + rc = 1; + } + /* If the FULLSYNC failed, try to do a normal fsync() */ + if( rc ) rc = fsync(fd); + +#else /* if !defined(F_FULLSYNC) */ + if( dataOnly ){ + rc = fdatasync(fd); + }else{ + rc = fsync(fd); + } +#endif /* defined(F_FULLFSYNC) */ +#endif /* defined(SQLITE_NO_SYNC) */ + + return rc; +} + +/* +** Make sure all writes to a particular file are committed to disk. +** +** If dataOnly==0 then both the file itself and its metadata (file +** size, access time, etc) are synced. If dataOnly!=0 then only the +** file data is synced. +** +** Under Unix, also make sure that the directory entry for the file +** has been created by fsync-ing the directory that contains the file. +** If we do not do this and we encounter a power failure, the directory +** entry for the journal might not exist after we reboot. The next +** SQLite to access the file will not know that the journal exists (because +** the directory entry for the journal was never created) and the transaction +** will not roll back - possibly leading to database corruption. +*/ +static int unixSync(OsFile *id, int dataOnly){ + unixFile *pFile = (unixFile*)id; + assert( pFile ); + SimulateIOError(SQLITE_IOERR); + TRACE2("SYNC %-3d\n", pFile->h); + if( full_fsync(pFile->h, pFile->fullSync, dataOnly) ){ + return SQLITE_IOERR; + } + if( pFile->dirfd>=0 ){ + TRACE4("DIRSYNC %-3d (have_fullfsync=%d fullsync=%d)\n", pFile->dirfd, + HAVE_FULLFSYNC, pFile->fullSync); +#ifndef SQLITE_DISABLE_DIRSYNC + /* The directory sync is only attempted if full_fsync is + ** turned off or unavailable. If a full_fsync occurred above, + ** then the directory sync is superfluous. + */ + if( (!HAVE_FULLFSYNC || !pFile->fullSync) && full_fsync(pFile->dirfd,0,0) ){ + /* + ** We have received multiple reports of fsync() returning + ** errors when applied to directories on certain file systems. + ** A failed directory sync is not a big deal. So it seems + ** better to ignore the error. Ticket #1657 + */ + /* return SQLITE_IOERR; */ + } +#endif + close(pFile->dirfd); /* Only need to sync once, so close the directory */ + pFile->dirfd = -1; /* when we are done. */ + } + return SQLITE_OK; +} + +/* +** Sync the directory zDirname. This is a no-op on operating systems other +** than UNIX. +** +** This is used to make sure the master journal file has truely been deleted +** before making changes to individual journals on a multi-database commit. +** The F_FULLFSYNC option is not needed here. +*/ +int sqlite3UnixSyncDirectory(const char *zDirname){ +#ifdef SQLITE_DISABLE_DIRSYNC + return SQLITE_OK; +#else + int fd; + int r; + SimulateIOError(SQLITE_IOERR); + fd = open(zDirname, O_RDONLY|O_BINARY, 0); + TRACE3("DIRSYNC %-3d (%s)\n", fd, zDirname); + if( fd<0 ){ + return SQLITE_CANTOPEN; + } + r = fsync(fd); + close(fd); + return ((r==0)?SQLITE_OK:SQLITE_IOERR); +#endif +} + +/* +** Truncate an open file to a specified size +*/ +static int unixTruncate(OsFile *id, i64 nByte){ + assert( id ); + SimulateIOError(SQLITE_IOERR); + return ftruncate(((unixFile*)id)->h, nByte)==0 ? SQLITE_OK : SQLITE_IOERR; +} + +/* +** Determine the current size of a file in bytes +*/ +static int unixFileSize(OsFile *id, i64 *pSize){ + struct stat buf; + assert( id ); + SimulateIOError(SQLITE_IOERR); + if( fstat(((unixFile*)id)->h, &buf)!=0 ){ + return SQLITE_IOERR; + } + *pSize = buf.st_size; + return SQLITE_OK; +} + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, return +** non-zero. If the file is unlocked or holds only SHARED locks, then +** return zero. +*/ +static int unixCheckReservedLock(OsFile *id){ + int r = 0; + unixFile *pFile = (unixFile*)id; + + assert( pFile ); + sqlite3OsEnterMutex(); /* Because pFile->pLock is shared across threads */ + + /* Check if a thread in this process holds such a lock */ + if( pFile->pLock->locktype>SHARED_LOCK ){ + r = 1; + } + + /* Otherwise see if some other process holds it. + */ + if( !r ){ + struct flock lock; + lock.l_whence = SEEK_SET; + lock.l_start = RESERVED_BYTE; + lock.l_len = 1; + lock.l_type = F_WRLCK; + fcntl(pFile->h, F_GETLK, &lock); + if( lock.l_type!=F_UNLCK ){ + r = 1; + } + } + + sqlite3OsLeaveMutex(); + TRACE3("TEST WR-LOCK %d %d\n", pFile->h, r); + + return r; +} + +/* +** Lock the file with the lock specified by parameter locktype - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int unixLock(OsFile *id, int locktype){ + /* The following describes the implementation of the various locks and + ** lock transitions in terms of the POSIX advisory shared and exclusive + ** lock primitives (called read-locks and write-locks below, to avoid + ** confusion with SQLite lock names). The algorithms are complicated + ** slightly in order to be compatible with windows systems simultaneously + ** accessing the same database file, in case that is ever required. + ** + ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved + ** byte', each single bytes at well known offsets, and the 'shared byte + ** range', a range of 510 bytes at a well known offset. + ** + ** To obtain a SHARED lock, a read-lock is obtained on the 'pending + ** byte'. If this is successful, a random byte from the 'shared byte + ** range' is read-locked and the lock on the 'pending byte' released. + ** + ** A process may only obtain a RESERVED lock after it has a SHARED lock. + ** A RESERVED lock is implemented by grabbing a write-lock on the + ** 'reserved byte'. + ** + ** A process may only obtain a PENDING lock after it has obtained a + ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock + ** on the 'pending byte'. This ensures that no new SHARED locks can be + ** obtained, but existing SHARED locks are allowed to persist. A process + ** does not have to obtain a RESERVED lock on the way to a PENDING lock. + ** This property is used by the algorithm for rolling back a journal file + ** after a crash. + ** + ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is + ** implemented by obtaining a write-lock on the entire 'shared byte + ** range'. Since all other locks require a read-lock on one of the bytes + ** within this range, this ensures that no other locks are held on the + ** database. + ** + ** The reason a single byte cannot be used instead of the 'shared byte + ** range' is that some versions of windows do not support read-locks. By + ** locking a random byte from a range, concurrent SHARED locks may exist + ** even if the locking primitive used is always a write-lock. + */ + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + struct lockInfo *pLock = pFile->pLock; + struct flock lock; + int s; + + assert( pFile ); + TRACE7("LOCK %d %s was %s(%s,%d) pid=%d\n", pFile->h, + locktypeName(locktype), locktypeName(pFile->locktype), + locktypeName(pLock->locktype), pLock->cnt , getpid()); + + /* If there is already a lock of this type or more restrictive on the + ** OsFile, do nothing. Don't use the end_lock: exit path, as + ** sqlite3OsEnterMutex() hasn't been called yet. + */ + if( pFile->locktype>=locktype ){ + TRACE3("LOCK %d %s ok (already held)\n", pFile->h, + locktypeName(locktype)); + return SQLITE_OK; + } + + /* Make sure the locking sequence is correct + */ + assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK ); + assert( locktype!=PENDING_LOCK ); + assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK ); + + /* This mutex is needed because pFile->pLock is shared across threads + */ + sqlite3OsEnterMutex(); + + /* Make sure the current thread owns the pFile. + */ + rc = transferOwnership(pFile); + if( rc!=SQLITE_OK ){ + sqlite3OsLeaveMutex(); + return rc; + } + pLock = pFile->pLock; + + /* If some thread using this PID has a lock via a different OsFile* + ** handle that precludes the requested lock, return BUSY. + */ + if( (pFile->locktype!=pLock->locktype && + (pLock->locktype>=PENDING_LOCK || locktype>SHARED_LOCK)) + ){ + rc = SQLITE_BUSY; + goto end_lock; + } + + /* If a SHARED lock is requested, and some thread using this PID already + ** has a SHARED or RESERVED lock, then increment reference counts and + ** return SQLITE_OK. + */ + if( locktype==SHARED_LOCK && + (pLock->locktype==SHARED_LOCK || pLock->locktype==RESERVED_LOCK) ){ + assert( locktype==SHARED_LOCK ); + assert( pFile->locktype==0 ); + assert( pLock->cnt>0 ); + pFile->locktype = SHARED_LOCK; + pLock->cnt++; + pFile->pOpen->nLock++; + goto end_lock; + } + + lock.l_len = 1L; + + lock.l_whence = SEEK_SET; + + /* A PENDING lock is needed before acquiring a SHARED lock and before + ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will + ** be released. + */ + if( locktype==SHARED_LOCK + || (locktype==EXCLUSIVE_LOCK && pFile->locktypeh, F_SETLK, &lock); + if( s ){ + rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY; + goto end_lock; + } + } + + + /* If control gets to this point, then actually go ahead and make + ** operating system calls for the specified lock. + */ + if( locktype==SHARED_LOCK ){ + assert( pLock->cnt==0 ); + assert( pLock->locktype==0 ); + + /* Now get the read-lock */ + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + s = fcntl(pFile->h, F_SETLK, &lock); + + /* Drop the temporary PENDING lock */ + lock.l_start = PENDING_BYTE; + lock.l_len = 1L; + lock.l_type = F_UNLCK; + if( fcntl(pFile->h, F_SETLK, &lock)!=0 ){ + rc = SQLITE_IOERR; /* This should never happen */ + goto end_lock; + } + if( s ){ + rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY; + }else{ + pFile->locktype = SHARED_LOCK; + pFile->pOpen->nLock++; + pLock->cnt = 1; + } + }else if( locktype==EXCLUSIVE_LOCK && pLock->cnt>1 ){ + /* We are trying for an exclusive lock but another thread in this + ** same process is still holding a shared lock. */ + rc = SQLITE_BUSY; + }else{ + /* The request was for a RESERVED or EXCLUSIVE lock. It is + ** assumed that there is a SHARED or greater lock on the file + ** already. + */ + assert( 0!=pFile->locktype ); + lock.l_type = F_WRLCK; + switch( locktype ){ + case RESERVED_LOCK: + lock.l_start = RESERVED_BYTE; + break; + case EXCLUSIVE_LOCK: + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + break; + default: + assert(0); + } + s = fcntl(pFile->h, F_SETLK, &lock); + if( s ){ + rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY; + } + } + + if( rc==SQLITE_OK ){ + pFile->locktype = locktype; + pLock->locktype = locktype; + }else if( locktype==EXCLUSIVE_LOCK ){ + pFile->locktype = PENDING_LOCK; + pLock->locktype = PENDING_LOCK; + } + +end_lock: + sqlite3OsLeaveMutex(); + TRACE4("LOCK %d %s %s\n", pFile->h, locktypeName(locktype), + rc==SQLITE_OK ? "ok" : "failed"); + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to locktype. locktype +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int unixUnlock(OsFile *id, int locktype){ + struct lockInfo *pLock; + struct flock lock; + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + + assert( pFile ); + TRACE7("UNLOCK %d %d was %d(%d,%d) pid=%d\n", pFile->h, locktype, + pFile->locktype, pFile->pLock->locktype, pFile->pLock->cnt, getpid()); + + assert( locktype<=SHARED_LOCK ); + if( pFile->locktype<=locktype ){ + return SQLITE_OK; + } + if( CHECK_THREADID(pFile) ){ + return SQLITE_MISUSE; + } + sqlite3OsEnterMutex(); + pLock = pFile->pLock; + assert( pLock->cnt!=0 ); + if( pFile->locktype>SHARED_LOCK ){ + assert( pLock->locktype==pFile->locktype ); + if( locktype==SHARED_LOCK ){ + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + if( fcntl(pFile->h, F_SETLK, &lock)!=0 ){ + /* This should never happen */ + rc = SQLITE_IOERR; + } + } + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = PENDING_BYTE; + lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE ); + if( fcntl(pFile->h, F_SETLK, &lock)==0 ){ + pLock->locktype = SHARED_LOCK; + }else{ + rc = SQLITE_IOERR; /* This should never happen */ + } + } + if( locktype==NO_LOCK ){ + struct openCnt *pOpen; + + /* Decrement the shared lock counter. Release the lock using an + ** OS call only when all threads in this same process have released + ** the lock. + */ + pLock->cnt--; + if( pLock->cnt==0 ){ + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = lock.l_len = 0L; + if( fcntl(pFile->h, F_SETLK, &lock)==0 ){ + pLock->locktype = NO_LOCK; + }else{ + rc = SQLITE_IOERR; /* This should never happen */ + } + } + + /* 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. + */ + pOpen = pFile->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]); + } + free(pOpen->aPending); + pOpen->nPending = 0; + pOpen->aPending = 0; + } + } + sqlite3OsLeaveMutex(); + pFile->locktype = locktype; + return rc; +} + +/* +** Close a file. +*/ +static int unixClose(OsFile **pId){ + unixFile *id = (unixFile*)*pId; + + if( !id ) return SQLITE_OK; + unixUnlock(*pId, NO_LOCK); + if( id->dirfd>=0 ) close(id->dirfd); + id->dirfd = -1; + sqlite3OsEnterMutex(); + + 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; + aNew = realloc( pOpen->aPending, (pOpen->nPending+1)*sizeof(int) ); + if( aNew==0 ){ + /* If a malloc fails, just leak the file descriptor */ + }else{ + pOpen->aPending = aNew; + pOpen->aPending[pOpen->nPending] = id->h; + pOpen->nPending++; + } + }else{ + /* There are no outstanding locks so we can close the file immediately */ + close(id->h); + } + releaseLockInfo(id->pLock); + releaseOpenCnt(id->pOpen); + + sqlite3OsLeaveMutex(); + id->isOpen = 0; + TRACE2("CLOSE %-3d\n", id->h); + OpenCounter(-1); + sqlite3ThreadSafeFree(id); + *pId = 0; + return SQLITE_OK; +} + +/* +** 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 *sqlite3UnixFullPathname(const char *zRelative){ + char *zFull = 0; + if( zRelative[0]=='/' ){ + sqlite3SetString(&zFull, zRelative, (char*)0); + }else{ + char *zBuf = sqliteMalloc(5000); + if( zBuf==0 ){ + return 0; + } + zBuf[0] = 0; + sqlite3SetString(&zFull, getcwd(zBuf, 5000), "/", zRelative, + (char*)0); + sqliteFree(zBuf); + } + +#if 0 + /* + ** Remove "/./" path elements and convert "/A/./" path elements + ** to just "/". + */ + if( zFull ){ + int i, j; + for(i=j=0; zFull[i]; i++){ + if( zFull[i]=='/' ){ + if( zFull[i+1]=='/' ) continue; + if( zFull[i+1]=='.' && zFull[i+2]=='/' ){ + i += 1; + continue; + } + if( zFull[i+1]=='.' && zFull[i+2]=='.' && zFull[i+3]=='/' ){ + while( j>0 && zFull[j-1]!='/' ){ j--; } + i += 3; + continue; + } + } + zFull[j++] = zFull[i]; + } + zFull[j] = 0; + } +#endif + + return zFull; +} + +/* +** Change the value of the fullsync flag in the given file descriptor. +*/ +static void unixSetFullSync(OsFile *id, int v){ + ((unixFile*)id)->fullSync = v; +} + +/* +** Return the underlying file handle for an OsFile +*/ +static int unixFileHandle(OsFile *id){ + return ((unixFile*)id)->h; +} + +/* +** Return an integer that indices the type of lock currently held +** by this handle. (Used for testing and analysis only.) +*/ +static int unixLockState(OsFile *id){ + return ((unixFile*)id)->locktype; +} + +/* +** This vector defines all the methods that can operate on an OsFile +** for unix. +*/ +static const IoMethod sqlite3UnixIoMethod = { + unixClose, + unixOpenDirectory, + unixRead, + unixWrite, + unixSeek, + unixTruncate, + unixSync, + unixSetFullSync, + unixFileHandle, + unixFileSize, + unixLock, + unixUnlock, + unixLockState, + unixCheckReservedLock, +}; + +/* +** Allocate memory for a unixFile. Initialize the new unixFile +** to the value given in pInit and return a pointer to the new +** OsFile. If we run out of memory, close the file and return NULL. +*/ +static int allocateUnixFile(unixFile *pInit, OsFile **pId){ + unixFile *pNew; + pInit->dirfd = -1; + pInit->fullSync = 0; + pInit->locktype = 0; + pInit->offset = 0; + SET_THREADID(pInit); + pNew = sqlite3ThreadSafeMalloc( sizeof(unixFile) ); + if( pNew==0 ){ + close(pInit->h); + sqlite3OsEnterMutex(); + releaseLockInfo(pInit->pLock); + releaseOpenCnt(pInit->pOpen); + sqlite3OsLeaveMutex(); + *pId = 0; + return SQLITE_NOMEM; + }else{ + *pNew = *pInit; + pNew->pMethod = &sqlite3UnixIoMethod; + *pId = (OsFile*)pNew; + OpenCounter(+1); + return SQLITE_OK; + } +} + + +#endif /* SQLITE_OMIT_DISKIO */ +/*************************************************************************** +** Everything above deals with file I/O. Everything that follows deals +** with other miscellanous aspects of the operating system interface +****************************************************************************/ + + +/* +** 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 sqlite3UnixRandomSeed(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 !defined(SQLITE_TEST) + { + int pid, fd; + fd = open("/dev/urandom", O_RDONLY); + if( fd<0 ){ + time_t t; + time(&t); + memcpy(zBuf, &t, sizeof(t)); + pid = getpid(); + memcpy(&zBuf[sizeof(time_t)], &pid, sizeof(pid)); + }else{ + read(fd, zBuf, 256); + close(fd); + } + } +#endif + return SQLITE_OK; +} + +/* +** Sleep for a little while. Return the amount of time slept. +** The argument is the number of milliseconds we want to sleep. +*/ +int sqlite3UnixSleep(int ms){ +#if defined(HAVE_USLEEP) && HAVE_USLEEP + usleep(ms*1000); + return ms; +#else + sleep((ms+999)/1000); + return 1000*((ms+999)/1000); +#endif +} + +/* +** Static variables used for thread synchronization. +** +** inMutex the nesting depth of the recursive mutex. The thread +** holding mutexMain can read this variable at any time. +** But is must hold mutexAux to change this variable. Other +** threads must hold mutexAux to read the variable and can +** never write. +** +** mutexOwner The thread id of the thread holding mutexMain. Same +** access rules as for inMutex. +** +** mutexOwnerValid True if the value in mutexOwner is valid. The same +** access rules apply as for inMutex. +** +** mutexMain The main mutex. Hold this mutex in order to get exclusive +** access to SQLite data structures. +** +** mutexAux An auxiliary mutex needed to access variables defined above. +** +** Mutexes are always acquired in this order: mutexMain mutexAux. It +** is not necessary to acquire mutexMain in order to get mutexAux - just +** do not attempt to acquire them in the reverse order: mutexAux mutexMain. +** Either get the mutexes with mutexMain first or get mutexAux only. +** +** When running on a platform where the three variables inMutex, mutexOwner, +** and mutexOwnerValid can be set atomically, the mutexAux is not required. +** On many systems, all three are 32-bit integers and writing to a 32-bit +** integer is atomic. I think. But there are no guarantees. So it seems +** safer to protect them using mutexAux. +*/ +static int inMutex = 0; +#ifdef SQLITE_UNIX_THREADS +static pthread_t mutexOwner; /* Thread holding mutexMain */ +static int mutexOwnerValid = 0; /* True if mutexOwner is valid */ +static pthread_mutex_t mutexMain = PTHREAD_MUTEX_INITIALIZER; /* The mutex */ +static pthread_mutex_t mutexAux = PTHREAD_MUTEX_INITIALIZER; /* Aux mutex */ +#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. +** +** As of version 3.3.2, this mutex must be recursive. +*/ +void sqlite3UnixEnterMutex(){ +#ifdef SQLITE_UNIX_THREADS + pthread_mutex_lock(&mutexAux); + if( !mutexOwnerValid || !pthread_equal(mutexOwner, pthread_self()) ){ + pthread_mutex_unlock(&mutexAux); + pthread_mutex_lock(&mutexMain); + assert( inMutex==0 ); + assert( !mutexOwnerValid ); + pthread_mutex_lock(&mutexAux); + mutexOwner = pthread_self(); + mutexOwnerValid = 1; + } + inMutex++; + pthread_mutex_unlock(&mutexAux); +#else + inMutex++; +#endif +} +void sqlite3UnixLeaveMutex(){ + assert( inMutex>0 ); +#ifdef SQLITE_UNIX_THREADS + pthread_mutex_lock(&mutexAux); + inMutex--; + assert( pthread_equal(mutexOwner, pthread_self()) ); + if( inMutex==0 ){ + assert( mutexOwnerValid ); + mutexOwnerValid = 0; + pthread_mutex_unlock(&mutexMain); + } + pthread_mutex_unlock(&mutexAux); +#else + inMutex--; +#endif +} + +/* +** Return TRUE if the mutex is currently held. +** +** If the thisThrd parameter is true, return true only if the +** calling thread holds the mutex. If the parameter is false, return +** true if any thread holds the mutex. +*/ +int sqlite3UnixInMutex(int thisThrd){ +#ifdef SQLITE_UNIX_THREADS + int rc; + pthread_mutex_lock(&mutexAux); + rc = inMutex>0 && (thisThrd==0 || pthread_equal(mutexOwner,pthread_self())); + pthread_mutex_unlock(&mutexAux); + return rc; +#else + return inMutex>0; +#endif +} + +/* +** Remember the number of thread-specific-data blocks allocated. +** Use this to verify that we are not leaking thread-specific-data. +** Ticket #1601 +*/ +#ifdef SQLITE_TEST +int sqlite3_tsd_count = 0; +# ifdef SQLITE_UNIX_THREADS + static pthread_mutex_t tsd_counter_mutex = PTHREAD_MUTEX_INITIALIZER; +# define TSD_COUNTER(N) \ + pthread_mutex_lock(&tsd_counter_mutex); \ + sqlite3_tsd_count += N; \ + pthread_mutex_unlock(&tsd_counter_mutex); +# else +# define TSD_COUNTER(N) sqlite3_tsd_count += N +# endif +#else +# define TSD_COUNTER(N) /* no-op */ +#endif + +/* +** If called with allocateFlag>0, then return a pointer to thread +** specific data for the current thread. Allocate and zero the +** thread-specific data if it does not already exist. +** +** If called with allocateFlag==0, then check the current thread +** specific data. Return it if it exists. If it does not exist, +** then return NULL. +** +** If called with allocateFlag<0, check to see if the thread specific +** data is allocated and is all zero. If it is then deallocate it. +** Return a pointer to the thread specific data or NULL if it is +** unallocated or gets deallocated. +*/ +ThreadData *sqlite3UnixThreadSpecificData(int allocateFlag){ + static const ThreadData zeroData = {0}; /* Initializer to silence warnings + ** from broken compilers */ +#ifdef SQLITE_UNIX_THREADS + static pthread_key_t key; + static int keyInit = 0; + ThreadData *pTsd; + + if( !keyInit ){ + sqlite3OsEnterMutex(); + if( !keyInit ){ + int rc; + rc = pthread_key_create(&key, 0); + if( rc ){ + sqlite3OsLeaveMutex(); + return 0; + } + keyInit = 1; + } + sqlite3OsLeaveMutex(); + } + + pTsd = pthread_getspecific(key); + if( allocateFlag>0 ){ + if( pTsd==0 ){ + if( !sqlite3TestMallocFail() ){ + pTsd = sqlite3OsMalloc(sizeof(zeroData)); + } +#ifdef SQLITE_MEMDEBUG + sqlite3_isFail = 0; +#endif + if( pTsd ){ + *pTsd = zeroData; + pthread_setspecific(key, pTsd); + TSD_COUNTER(+1); + } + } + }else if( pTsd!=0 && allocateFlag<0 + && memcmp(pTsd, &zeroData, sizeof(ThreadData))==0 ){ + sqlite3OsFree(pTsd); + pthread_setspecific(key, 0); + TSD_COUNTER(-1); + pTsd = 0; + } + return pTsd; +#else + static ThreadData *pTsd = 0; + if( allocateFlag>0 ){ + if( pTsd==0 ){ + if( !sqlite3TestMallocFail() ){ + pTsd = sqlite3OsMalloc( sizeof(zeroData) ); + } +#ifdef SQLITE_MEMDEBUG + sqlite3_isFail = 0; +#endif + if( pTsd ){ + *pTsd = zeroData; + TSD_COUNTER(+1); + } + } + }else if( pTsd!=0 && allocateFlag<0 + && memcmp(pTsd, &zeroData, sizeof(ThreadData))==0 ){ + sqlite3OsFree(pTsd); + TSD_COUNTER(-1); + pTsd = 0; + } + return pTsd; +#endif +} + +/* +** The following variable, if set to a non-zero value, becomes the result +** returned from sqlite3OsCurrentTime(). This is used for testing. +*/ +#ifdef SQLITE_TEST +int sqlite3_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 sqlite3UnixCurrentTime(double *prNow){ +#ifdef NO_GETTOD + time_t t; + time(&t); + *prNow = t/86400.0 + 2440587.5; +#else + struct timeval sNow; + struct timezone sTz; /* Not used */ + gettimeofday(&sNow, &sTz); + *prNow = 2440587.5 + sNow.tv_sec/86400.0 + sNow.tv_usec/86400000000.0; +#endif +#ifdef SQLITE_TEST + if( sqlite3_current_time ){ + *prNow = sqlite3_current_time/86400.0 + 2440587.5; + } +#endif + return 0; +} + +#endif /* OS_UNIX */ diff --git a/sqlite/os_win.c b/sqlite/os_win.c new file mode 100755 index 000000000..def901e50 --- /dev/null +++ b/sqlite/os_win.c @@ -0,0 +1,1516 @@ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to windows. +*/ +#include "sqliteInt.h" +#include "os.h" +#if OS_WIN /* This file is used for windows only */ + +#include + +#ifdef __CYGWIN__ +# include +#endif + +/* +** Macros used to determine whether or not to use threads. +*/ +#if defined(THREADSAFE) && THREADSAFE +# define SQLITE_W32_THREADS 1 +#endif + +/* +** Include code that is common to all os_*.c files +*/ +#include "os_common.h" + +/* +** Determine if we are dealing with WindowsCE - which has a much +** reduced API. +*/ +#if defined(_WIN32_WCE) +# define OS_WINCE 1 +#else +# define OS_WINCE 0 +#endif + +/* +** WinCE lacks native support for file locking so we have to fake it +** with some code of our own. +*/ +#if OS_WINCE +typedef struct winceLock { + int nReaders; /* Number of reader locks obtained */ + BOOL bPending; /* Indicates a pending lock has been obtained */ + BOOL bReserved; /* Indicates a reserved lock has been obtained */ + BOOL bExclusive; /* Indicates an exclusive lock has been obtained */ +} winceLock; +#endif + +/* +** The winFile structure is a subclass of OsFile specific to the win32 +** portability layer. +*/ +typedef struct winFile winFile; +struct winFile { + IoMethod const *pMethod;/* Must be first */ + HANDLE h; /* Handle for accessing the file */ + unsigned char locktype; /* Type of lock currently held on this file */ + short sharedLockByte; /* Randomly chosen byte used as a shared lock */ +#if OS_WINCE + WCHAR *zDeleteOnClose; /* Name of file to delete when closing */ + HANDLE hMutex; /* Mutex used to control access to shared lock */ + HANDLE hShared; /* Shared memory segment used for locking */ + winceLock local; /* Locks obtained by this instance of winFile */ + winceLock *shared; /* Global shared lock memory for the file */ +#endif +}; + + +/* +** Do not include any of the File I/O interface procedures if the +** SQLITE_OMIT_DISKIO macro is defined (indicating that there database +** will be in-memory only) +*/ +#ifndef SQLITE_OMIT_DISKIO + +/* +** The following variable is (normally) set once and never changes +** thereafter. It records whether the operating system is Win95 +** or WinNT. +** +** 0: Operating system unknown. +** 1: Operating system is Win95. +** 2: Operating system is WinNT. +** +** In order to facilitate testing on a WinNT system, the test fixture +** can manually set this value to 1 to emulate Win98 behavior. +*/ +int sqlite3_os_type = 0; + +/* +** Return true (non-zero) if we are running under WinNT, Win2K, WinXP, +** or WinCE. Return false (zero) for Win95, Win98, or WinME. +** +** Here is an interesting observation: Win95, Win98, and WinME lack +** the LockFileEx() API. But we can still statically link against that +** API as long as we don't call it 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. +*/ +#if OS_WINCE +# define isNT() (1) +#else + static int isNT(void){ + if( sqlite3_os_type==0 ){ + OSVERSIONINFO sInfo; + sInfo.dwOSVersionInfoSize = sizeof(sInfo); + GetVersionEx(&sInfo); + sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1; + } + return sqlite3_os_type==2; + } +#endif /* OS_WINCE */ + +/* +** Convert a UTF-8 string to UTF-32. Space to hold the returned string +** is obtained from sqliteMalloc. +*/ +static WCHAR *utf8ToUnicode(const char *zFilename){ + int nChar; + WCHAR *zWideFilename; + + if( !isNT() ){ + return 0; + } + nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0); + zWideFilename = sqliteMalloc( nChar*sizeof(zWideFilename[0]) ); + if( zWideFilename==0 ){ + return 0; + } + nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar); + if( nChar==0 ){ + sqliteFree(zWideFilename); + zWideFilename = 0; + } + return zWideFilename; +} + +/* +** Convert UTF-32 to UTF-8. Space to hold the returned string is +** obtained from sqliteMalloc(). +*/ +static char *unicodeToUtf8(const WCHAR *zWideFilename){ + int nByte; + char *zFilename; + + nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0); + zFilename = sqliteMalloc( nByte ); + if( zFilename==0 ){ + return 0; + } + nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte, + 0, 0); + if( nByte == 0 ){ + sqliteFree(zFilename); + zFilename = 0; + } + return zFilename; +} + +#if OS_WINCE +/************************************************************************* +** This section contains code for WinCE only. +*/ +/* +** WindowsCE does not have a localtime() function. So create a +** substitute. +*/ +#include +struct tm *__cdecl localtime(const time_t *t) +{ + static struct tm y; + FILETIME uTm, lTm; + SYSTEMTIME pTm; + i64 t64; + t64 = *t; + t64 = (t64 + 11644473600)*10000000; + uTm.dwLowDateTime = t64 & 0xFFFFFFFF; + uTm.dwHighDateTime= t64 >> 32; + FileTimeToLocalFileTime(&uTm,&lTm); + FileTimeToSystemTime(&lTm,&pTm); + y.tm_year = pTm.wYear - 1900; + y.tm_mon = pTm.wMonth - 1; + y.tm_wday = pTm.wDayOfWeek; + y.tm_mday = pTm.wDay; + y.tm_hour = pTm.wHour; + y.tm_min = pTm.wMinute; + y.tm_sec = pTm.wSecond; + return &y; +} + +/* This will never be called, but defined to make the code compile */ +#define GetTempPathA(a,b) + +#define LockFile(a,b,c,d,e) winceLockFile(&a, b, c, d, e) +#define UnlockFile(a,b,c,d,e) winceUnlockFile(&a, b, c, d, e) +#define LockFileEx(a,b,c,d,e,f) winceLockFileEx(&a, b, c, d, e, f) + +#define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-offsetof(winFile,h)] + +/* +** Acquire a lock on the handle h +*/ +static void winceMutexAcquire(HANDLE h){ + DWORD dwErr; + do { + dwErr = WaitForSingleObject(h, INFINITE); + } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED); +} +/* +** Release a lock acquired by winceMutexAcquire() +*/ +#define winceMutexRelease(h) ReleaseMutex(h) + +/* +** Create the mutex and shared memory used for locking in the file +** descriptor pFile +*/ +static BOOL winceCreateLock(const char *zFilename, winFile *pFile){ + WCHAR *zTok; + WCHAR *zName = utf8ToUnicode(zFilename); + BOOL bInit = TRUE; + + /* Initialize the local lockdata */ + ZeroMemory(&pFile->local, sizeof(pFile->local)); + + /* Replace the backslashes from the filename and lowercase it + ** to derive a mutex name. */ + zTok = CharLowerW(zName); + for (;*zTok;zTok++){ + if (*zTok == '\\') *zTok = '_'; + } + + /* Create/open the named mutex */ + pFile->hMutex = CreateMutexW(NULL, FALSE, zName); + if (!pFile->hMutex){ + sqliteFree(zName); + return FALSE; + } + + /* Acquire the mutex before continuing */ + winceMutexAcquire(pFile->hMutex); + + /* Since the names of named mutexes, semaphores, file mappings etc are + ** case-sensitive, take advantage of that by uppercasing the mutex name + ** and using that as the shared filemapping name. + */ + CharUpperW(zName); + pFile->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, + PAGE_READWRITE, 0, sizeof(winceLock), + zName); + + /* Set a flag that indicates we're the first to create the memory so it + ** must be zero-initialized */ + if (GetLastError() == ERROR_ALREADY_EXISTS){ + bInit = FALSE; + } + + sqliteFree(zName); + + /* If we succeeded in making the shared memory handle, map it. */ + if (pFile->hShared){ + pFile->shared = (winceLock*)MapViewOfFile(pFile->hShared, + FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock)); + /* If mapping failed, close the shared memory handle and erase it */ + if (!pFile->shared){ + CloseHandle(pFile->hShared); + pFile->hShared = NULL; + } + } + + /* If shared memory could not be created, then close the mutex and fail */ + if (pFile->hShared == NULL){ + winceMutexRelease(pFile->hMutex); + CloseHandle(pFile->hMutex); + pFile->hMutex = NULL; + return FALSE; + } + + /* Initialize the shared memory if we're supposed to */ + if (bInit) { + ZeroMemory(pFile->shared, sizeof(winceLock)); + } + + winceMutexRelease(pFile->hMutex); + return TRUE; +} + +/* +** Destroy the part of winFile that deals with wince locks +*/ +static void winceDestroyLock(winFile *pFile){ + if (pFile->hMutex){ + /* Acquire the mutex */ + winceMutexAcquire(pFile->hMutex); + + /* The following blocks should probably assert in debug mode, but they + are to cleanup in case any locks remained open */ + if (pFile->local.nReaders){ + pFile->shared->nReaders --; + } + if (pFile->local.bReserved){ + pFile->shared->bReserved = FALSE; + } + if (pFile->local.bPending){ + pFile->shared->bPending = FALSE; + } + if (pFile->local.bExclusive){ + pFile->shared->bExclusive = FALSE; + } + + /* De-reference and close our copy of the shared memory handle */ + UnmapViewOfFile(pFile->shared); + CloseHandle(pFile->hShared); + + /* Done with the mutex */ + winceMutexRelease(pFile->hMutex); + CloseHandle(pFile->hMutex); + pFile->hMutex = NULL; + } +} + +/* +** An implementation of the LockFile() API of windows for wince +*/ +static BOOL winceLockFile( + HANDLE *phFile, + DWORD dwFileOffsetLow, + DWORD dwFileOffsetHigh, + DWORD nNumberOfBytesToLockLow, + DWORD nNumberOfBytesToLockHigh +){ + winFile *pFile = HANDLE_TO_WINFILE(phFile); + BOOL bReturn = FALSE; + + if (!pFile->hMutex) return TRUE; + winceMutexAcquire(pFile->hMutex); + + /* Wanting an exclusive lock? */ + if (dwFileOffsetLow == SHARED_FIRST + && nNumberOfBytesToLockLow == SHARED_SIZE){ + if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){ + pFile->shared->bExclusive = TRUE; + pFile->local.bExclusive = TRUE; + bReturn = TRUE; + } + } + + /* Want a read-only lock? */ + else if ((dwFileOffsetLow >= SHARED_FIRST && + dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE) && + nNumberOfBytesToLockLow == 1){ + if (pFile->shared->bExclusive == 0){ + pFile->local.nReaders ++; + if (pFile->local.nReaders == 1){ + pFile->shared->nReaders ++; + } + bReturn = TRUE; + } + } + + /* Want a pending lock? */ + else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToLockLow == 1){ + /* If no pending lock has been acquired, then acquire it */ + if (pFile->shared->bPending == 0) { + pFile->shared->bPending = TRUE; + pFile->local.bPending = TRUE; + bReturn = TRUE; + } + } + /* Want a reserved lock? */ + else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToLockLow == 1){ + if (pFile->shared->bReserved == 0) { + pFile->shared->bReserved = TRUE; + pFile->local.bReserved = TRUE; + bReturn = TRUE; + } + } + + winceMutexRelease(pFile->hMutex); + return bReturn; +} + +/* +** An implementation of the UnlockFile API of windows for wince +*/ +static BOOL winceUnlockFile( + HANDLE *phFile, + DWORD dwFileOffsetLow, + DWORD dwFileOffsetHigh, + DWORD nNumberOfBytesToUnlockLow, + DWORD nNumberOfBytesToUnlockHigh +){ + winFile *pFile = HANDLE_TO_WINFILE(phFile); + BOOL bReturn = FALSE; + + if (!pFile->hMutex) return TRUE; + winceMutexAcquire(pFile->hMutex); + + /* Releasing a reader lock or an exclusive lock */ + if (dwFileOffsetLow >= SHARED_FIRST && + dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE){ + /* Did we have an exclusive lock? */ + if (pFile->local.bExclusive){ + pFile->local.bExclusive = FALSE; + pFile->shared->bExclusive = FALSE; + bReturn = TRUE; + } + + /* Did we just have a reader lock? */ + else if (pFile->local.nReaders){ + pFile->local.nReaders --; + if (pFile->local.nReaders == 0) + { + pFile->shared->nReaders --; + } + bReturn = TRUE; + } + } + + /* Releasing a pending lock */ + else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToUnlockLow == 1){ + if (pFile->local.bPending){ + pFile->local.bPending = FALSE; + pFile->shared->bPending = FALSE; + bReturn = TRUE; + } + } + /* Releasing a reserved lock */ + else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToUnlockLow == 1){ + if (pFile->local.bReserved) { + pFile->local.bReserved = FALSE; + pFile->shared->bReserved = FALSE; + bReturn = TRUE; + } + } + + winceMutexRelease(pFile->hMutex); + return bReturn; +} + +/* +** An implementation of the LockFileEx() API of windows for wince +*/ +static BOOL winceLockFileEx( + HANDLE *phFile, + DWORD dwFlags, + DWORD dwReserved, + DWORD nNumberOfBytesToLockLow, + DWORD nNumberOfBytesToLockHigh, + LPOVERLAPPED lpOverlapped +){ + /* If the caller wants a shared read lock, forward this call + ** to winceLockFile */ + if (lpOverlapped->Offset == SHARED_FIRST && + dwFlags == 1 && + nNumberOfBytesToLockLow == SHARED_SIZE){ + return winceLockFile(phFile, SHARED_FIRST, 0, 1, 0); + } + return FALSE; +} +/* +** End of the special code for wince +*****************************************************************************/ +#endif /* OS_WINCE */ + +/* +** Delete the named file +*/ +int sqlite3WinDelete(const char *zFilename){ + WCHAR *zWide = utf8ToUnicode(zFilename); + if( zWide ){ + DeleteFileW(zWide); + sqliteFree(zWide); + }else{ +#if OS_WINCE + return SQLITE_NOMEM; +#else + DeleteFileA(zFilename); +#endif + } + TRACE2("DELETE \"%s\"\n", zFilename); + return SQLITE_OK; +} + +/* +** Return TRUE if the named file exists. +*/ +int sqlite3WinFileExists(const char *zFilename){ + int exists = 0; + WCHAR *zWide = utf8ToUnicode(zFilename); + if( zWide ){ + exists = GetFileAttributesW(zWide) != 0xffffffff; + sqliteFree(zWide); + }else{ +#if OS_WINCE + return SQLITE_NOMEM; +#else + exists = GetFileAttributesA(zFilename) != 0xffffffff; +#endif + } + return exists; +} + +/* Forward declaration */ +static int allocateWinFile(winFile *pInit, OsFile **pId); + +/* +** 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 sqlite3WinOpenReadWrite( + const char *zFilename, + OsFile **pId, + int *pReadonly +){ + winFile f; + HANDLE h; + WCHAR *zWide = utf8ToUnicode(zFilename); + assert( *pId==0 ); + if( zWide ){ + h = CreateFileW(zWide, + 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 = CreateFileW(zWide, + GENERIC_READ, + FILE_SHARE_READ, + NULL, + OPEN_ALWAYS, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, + NULL + ); + if( h==INVALID_HANDLE_VALUE ){ + sqliteFree(zWide); + return SQLITE_CANTOPEN; + } + *pReadonly = 1; + }else{ + *pReadonly = 0; + } +#if OS_WINCE + if (!winceCreateLock(zFilename, &f)){ + CloseHandle(h); + sqliteFree(zWide); + return SQLITE_CANTOPEN; + } +#endif + sqliteFree(zWide); + }else{ +#if OS_WINCE + return SQLITE_NOMEM; +#else + h = CreateFileA(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 = CreateFileA(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; + } +#endif /* OS_WINCE */ + } + f.h = h; +#if OS_WINCE + f.zDeleteOnClose = 0; +#endif + TRACE3("OPEN R/W %d \"%s\"\n", h, zFilename); + return allocateWinFile(&f, pId); +} + + +/* +** 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 sqlite3WinOpenExclusive(const char *zFilename, OsFile **pId, int delFlag){ + winFile f; + HANDLE h; + int fileflags; + WCHAR *zWide = utf8ToUnicode(zFilename); + assert( *pId == 0 ); + fileflags = FILE_FLAG_RANDOM_ACCESS; +#if !OS_WINCE + if( delFlag ){ + fileflags |= FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE; + } +#endif + if( zWide ){ + h = CreateFileW(zWide, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + CREATE_ALWAYS, + fileflags, + NULL + ); + sqliteFree(zWide); + }else{ +#if OS_WINCE + return SQLITE_NOMEM; +#else + h = CreateFileA(zFilename, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + CREATE_ALWAYS, + fileflags, + NULL + ); +#endif /* OS_WINCE */ + } + if( h==INVALID_HANDLE_VALUE ){ + return SQLITE_CANTOPEN; + } + f.h = h; +#if OS_WINCE + f.zDeleteOnClose = delFlag ? utf8ToUnicode(zFilename) : 0; + f.hMutex = NULL; +#endif + TRACE3("OPEN EX %d \"%s\"\n", h, zFilename); + return allocateWinFile(&f, pId); +} + +/* +** 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 sqlite3WinOpenReadOnly(const char *zFilename, OsFile **pId){ + winFile f; + HANDLE h; + WCHAR *zWide = utf8ToUnicode(zFilename); + assert( *pId==0 ); + if( zWide ){ + h = CreateFileW(zWide, + GENERIC_READ, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, + NULL + ); + sqliteFree(zWide); + }else{ +#if OS_WINCE + return SQLITE_NOMEM; +#else + h = CreateFileA(zFilename, + GENERIC_READ, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, + NULL + ); +#endif + } + if( h==INVALID_HANDLE_VALUE ){ + return SQLITE_CANTOPEN; + } + f.h = h; +#if OS_WINCE + f.zDeleteOnClose = 0; + f.hMutex = NULL; +#endif + TRACE3("OPEN RO %d \"%s\"\n", h, zFilename); + return allocateWinFile(&f, pId); +} + +/* +** 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. +*/ +static int winOpenDirectory( + OsFile *id, + const char *zDirname +){ + 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. +*/ +char *sqlite3_temp_directory = 0; + +/* +** Create a temporary file name in zBuf. zBuf must be big enough to +** hold at least SQLITE_TEMPNAME_SIZE characters. +*/ +int sqlite3WinTempFileName(char *zBuf){ + static char zChars[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"; + int i, j; + char zTempPath[SQLITE_TEMPNAME_SIZE]; + if( sqlite3_temp_directory ){ + strncpy(zTempPath, sqlite3_temp_directory, SQLITE_TEMPNAME_SIZE-30); + zTempPath[SQLITE_TEMPNAME_SIZE-30] = 0; + }else if( isNT() ){ + char *zMulti; + WCHAR zWidePath[SQLITE_TEMPNAME_SIZE]; + GetTempPathW(SQLITE_TEMPNAME_SIZE-30, zWidePath); + zMulti = unicodeToUtf8(zWidePath); + if( zMulti ){ + strncpy(zTempPath, zMulti, SQLITE_TEMPNAME_SIZE-30); + zTempPath[SQLITE_TEMPNAME_SIZE-30] = 0; + sqliteFree(zMulti); + } + }else{ + GetTempPathA(SQLITE_TEMPNAME_SIZE-30, zTempPath); + } + for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){} + zTempPath[i] = 0; + for(;;){ + sprintf(zBuf, "%s\\"TEMP_FILE_PREFIX, zTempPath); + j = strlen(zBuf); + sqlite3Randomness(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( !sqlite3OsFileExists(zBuf) ) break; + } + TRACE2("TEMP FILENAME: %s\n", zBuf); + return SQLITE_OK; +} + +/* +** Close a file. +*/ +static int winClose(OsFile **pId){ + winFile *pFile; + if( pId && (pFile = (winFile*)*pId)!=0 ){ + TRACE2("CLOSE %d\n", pFile->h); + CloseHandle(pFile->h); +#if OS_WINCE + winceDestroyLock(pFile); + if( pFile->zDeleteOnClose ){ + DeleteFileW(pFile->zDeleteOnClose); + sqliteFree(pFile->zDeleteOnClose); + } +#endif + OpenCounter(-1); + sqliteFree(pFile); + *pId = 0; + } + return SQLITE_OK; +} + +/* +** Read data from a file into a buffer. Return SQLITE_OK if all +** bytes were read successfully and SQLITE_IOERR if anything goes +** wrong. +*/ +static int winRead(OsFile *id, void *pBuf, int amt){ + DWORD got; + assert( id!=0 ); + SimulateIOError(SQLITE_IOERR); + TRACE3("READ %d lock=%d\n", ((winFile*)id)->h, ((winFile*)id)->locktype); + if( !ReadFile(((winFile*)id)->h, pBuf, amt, &got, 0) ){ + got = 0; + } + if( got==(DWORD)amt ){ + return SQLITE_OK; + }else{ + return SQLITE_IOERR; + } +} + +/* +** Write data from a buffer into a file. Return SQLITE_OK on success +** or some other error code on failure. +*/ +static int winWrite(OsFile *id, const void *pBuf, int amt){ + int rc = 0; + DWORD wrote; + assert( id!=0 ); + SimulateIOError(SQLITE_IOERR); + SimulateDiskfullError; + TRACE3("WRITE %d lock=%d\n", ((winFile*)id)->h, ((winFile*)id)->locktype); + assert( amt>0 ); + while( amt>0 && (rc = WriteFile(((winFile*)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; +} + +/* +** Some microsoft compilers lack this definition. +*/ +#ifndef INVALID_SET_FILE_POINTER +# define INVALID_SET_FILE_POINTER ((DWORD)-1) +#endif + +/* +** Move the read/write pointer in a file. +*/ +static int winSeek(OsFile *id, i64 offset){ + LONG upperBits = offset>>32; + LONG lowerBits = offset & 0xffffffff; + DWORD rc; + assert( id!=0 ); +#ifdef SQLITE_TEST + if( offset ) SimulateDiskfullError +#endif + SEEK(offset/1024 + 1); + rc = SetFilePointer(((winFile*)id)->h, lowerBits, &upperBits, FILE_BEGIN); + TRACE3("SEEK %d %lld\n", ((winFile*)id)->h, offset); + if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){ + return SQLITE_FULL; + } + return SQLITE_OK; +} + +/* +** Make sure all writes to a particular file are committed to disk. +*/ +static int winSync(OsFile *id, int dataOnly){ + assert( id!=0 ); + TRACE3("SYNC %d lock=%d\n", ((winFile*)id)->h, ((winFile*)id)->locktype); + if( FlushFileBuffers(((winFile*)id)->h) ){ + return SQLITE_OK; + }else{ + return SQLITE_IOERR; + } +} + +/* +** Sync the directory zDirname. This is a no-op on operating systems other +** than UNIX. +*/ +int sqlite3WinSyncDirectory(const char *zDirname){ + SimulateIOError(SQLITE_IOERR); + return SQLITE_OK; +} + +/* +** Truncate an open file to a specified size +*/ +static int winTruncate(OsFile *id, i64 nByte){ + LONG upperBits = nByte>>32; + assert( id!=0 ); + TRACE3("TRUNCATE %d %lld\n", ((winFile*)id)->h, nByte); + SimulateIOError(SQLITE_IOERR); + SetFilePointer(((winFile*)id)->h, nByte, &upperBits, FILE_BEGIN); + SetEndOfFile(((winFile*)id)->h); + return SQLITE_OK; +} + +/* +** Determine the current size of a file in bytes +*/ +static int winFileSize(OsFile *id, i64 *pSize){ + DWORD upperBits, lowerBits; + assert( id!=0 ); + SimulateIOError(SQLITE_IOERR); + lowerBits = GetFileSize(((winFile*)id)->h, &upperBits); + *pSize = (((i64)upperBits)<<32) + lowerBits; + return SQLITE_OK; +} + +/* +** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems. +*/ +#ifndef LOCKFILE_FAIL_IMMEDIATELY +# define LOCKFILE_FAIL_IMMEDIATELY 1 +#endif + +/* +** Acquire a reader lock. +** Different API routines are called depending on whether or not this +** is Win95 or WinNT. +*/ +static int getReadLock(winFile *id){ + int res; + if( isNT() ){ + OVERLAPPED ovlp; + ovlp.Offset = SHARED_FIRST; + ovlp.OffsetHigh = 0; + ovlp.hEvent = 0; + res = LockFileEx(id->h, LOCKFILE_FAIL_IMMEDIATELY, 0, SHARED_SIZE,0,&ovlp); + }else{ + int lk; + sqlite3Randomness(sizeof(lk), &lk); + id->sharedLockByte = (lk & 0x7fffffff)%(SHARED_SIZE - 1); + res = LockFile(id->h, SHARED_FIRST+id->sharedLockByte, 0, 1, 0); + } + return res; +} + +/* +** Undo a readlock +*/ +static int unlockReadLock(winFile *pFile){ + int res; + if( isNT() ){ + res = UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); + }else{ + res = UnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0); + } + return res; +} + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** Check that a given pathname is a directory and is writable +** +*/ +int sqlite3WinIsDirWritable(char *zDirname){ + int fileAttr; + WCHAR *zWide; + if( zDirname==0 ) return 0; + if( !isNT() && strlen(zDirname)>MAX_PATH ) return 0; + zWide = utf8ToUnicode(zDirname); + if( zWide ){ + fileAttr = GetFileAttributesW(zWide); + sqliteFree(zWide); + }else{ +#if OS_WINCE + return 0; +#else + fileAttr = GetFileAttributesA(zDirname); +#endif + } + if( fileAttr == 0xffffffff ) return 0; + if( (fileAttr & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY ){ + return 0; + } + return 1; +} +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + +/* +** Lock the file with the lock specified by parameter locktype - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. The winUnlock() routine +** erases all locks at once and returns us immediately to locking level 0. +** It is not possible to lower the locking level one step at a time. You +** must go straight to locking level 0. +*/ +static int winLock(OsFile *id, int locktype){ + int rc = SQLITE_OK; /* Return code from subroutines */ + int res = 1; /* Result of a windows lock call */ + int newLocktype; /* Set id->locktype to this value before exiting */ + int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */ + winFile *pFile = (winFile*)id; + + assert( pFile!=0 ); + TRACE5("LOCK %d %d was %d(%d)\n", + pFile->h, locktype, pFile->locktype, pFile->sharedLockByte); + + /* If there is already a lock of this type or more restrictive on the + ** OsFile, do nothing. Don't use the end_lock: exit path, as + ** sqlite3OsEnterMutex() hasn't been called yet. + */ + if( pFile->locktype>=locktype ){ + return SQLITE_OK; + } + + /* Make sure the locking sequence is correct + */ + assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK ); + assert( locktype!=PENDING_LOCK ); + assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK ); + + /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or + ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of + ** the PENDING_LOCK byte is temporary. + */ + newLocktype = pFile->locktype; + if( pFile->locktype==NO_LOCK + || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK) + ){ + int cnt = 3; + while( cnt-->0 && (res = LockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){ + /* Try 3 times to get the pending lock. The pending lock might be + ** held by another reader process who will release it momentarily. + */ + TRACE2("could not get a PENDING lock. cnt=%d\n", cnt); + Sleep(1); + } + gotPendingLock = res; + } + + /* Acquire a shared lock + */ + if( locktype==SHARED_LOCK && res ){ + assert( pFile->locktype==NO_LOCK ); + res = getReadLock(pFile); + if( res ){ + newLocktype = SHARED_LOCK; + } + } + + /* Acquire a RESERVED lock + */ + if( locktype==RESERVED_LOCK && res ){ + assert( pFile->locktype==SHARED_LOCK ); + res = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0); + if( res ){ + newLocktype = RESERVED_LOCK; + } + } + + /* Acquire a PENDING lock + */ + if( locktype==EXCLUSIVE_LOCK && res ){ + newLocktype = PENDING_LOCK; + gotPendingLock = 0; + } + + /* Acquire an EXCLUSIVE lock + */ + if( locktype==EXCLUSIVE_LOCK && res ){ + assert( pFile->locktype>=SHARED_LOCK ); + res = unlockReadLock(pFile); + TRACE2("unreadlock = %d\n", res); + res = LockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); + if( res ){ + newLocktype = EXCLUSIVE_LOCK; + }else{ + TRACE2("error-code = %d\n", GetLastError()); + } + } + + /* If we are holding a PENDING lock that ought to be released, then + ** release it now. + */ + if( gotPendingLock && locktype==SHARED_LOCK ){ + UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0); + } + + /* Update the state of the lock has held in the file descriptor then + ** return the appropriate result code. + */ + if( res ){ + rc = SQLITE_OK; + }else{ + TRACE4("LOCK FAILED %d trying for %d but got %d\n", pFile->h, + locktype, newLocktype); + rc = SQLITE_BUSY; + } + pFile->locktype = newLocktype; + return rc; +} + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, return +** non-zero, otherwise zero. +*/ +static int winCheckReservedLock(OsFile *id){ + int rc; + winFile *pFile = (winFile*)id; + assert( pFile!=0 ); + if( pFile->locktype>=RESERVED_LOCK ){ + rc = 1; + TRACE3("TEST WR-LOCK %d %d (local)\n", pFile->h, rc); + }else{ + rc = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0); + if( rc ){ + UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0); + } + rc = !rc; + TRACE3("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc); + } + return rc; +} + +/* +** Lower the locking level on file descriptor id to locktype. locktype +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** It is not possible for this routine to fail if the second argument +** is NO_LOCK. If the second argument is SHARED_LOCK then this routine +** might return SQLITE_IOERR; +*/ +static int winUnlock(OsFile *id, int locktype){ + int type; + int rc = SQLITE_OK; + winFile *pFile = (winFile*)id; + assert( pFile!=0 ); + assert( locktype<=SHARED_LOCK ); + TRACE5("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype, + pFile->locktype, pFile->sharedLockByte); + type = pFile->locktype; + if( type>=EXCLUSIVE_LOCK ){ + UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); + if( locktype==SHARED_LOCK && !getReadLock(pFile) ){ + /* This should never happen. We should always be able to + ** reacquire the read lock */ + rc = SQLITE_IOERR; + } + } + if( type>=RESERVED_LOCK ){ + UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0); + } + if( locktype==NO_LOCK && type>=SHARED_LOCK ){ + unlockReadLock(pFile); + } + if( type>=PENDING_LOCK ){ + UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0); + } + pFile->locktype = locktype; + return rc; +} + +/* +** 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 *sqlite3WinFullPathname(const char *zRelative){ + char *zFull; +#if defined(__CYGWIN__) + int nByte; + nByte = strlen(zRelative) + MAX_PATH + 1001; + zFull = sqliteMalloc( nByte ); + if( zFull==0 ) return 0; + if( cygwin_conv_to_full_win32_path(zRelative, zFull) ) return 0; +#elif OS_WINCE + /* WinCE has no concept of a relative pathname, or so I am told. */ + zFull = sqliteStrDup(zRelative); +#else + char *zNotUsed; + WCHAR *zWide; + int nByte; + zWide = utf8ToUnicode(zRelative); + if( zWide ){ + WCHAR *zTemp, *zNotUsedW; + nByte = GetFullPathNameW(zWide, 0, 0, &zNotUsedW) + 1; + zTemp = sqliteMalloc( nByte*sizeof(zTemp[0]) ); + if( zTemp==0 ) return 0; + GetFullPathNameW(zWide, nByte, zTemp, &zNotUsedW); + sqliteFree(zWide); + zFull = unicodeToUtf8(zTemp); + sqliteFree(zTemp); + }else{ + nByte = GetFullPathNameA(zRelative, 0, 0, &zNotUsed) + 1; + zFull = sqliteMalloc( nByte*sizeof(zFull[0]) ); + if( zFull==0 ) return 0; + GetFullPathNameA(zRelative, nByte, zFull, &zNotUsed); + } +#endif + return zFull; +} + +/* +** The fullSync option is meaningless on windows. This is a no-op. +*/ +static void winSetFullSync(OsFile *id, int v){ + return; +} + +/* +** Return the underlying file handle for an OsFile +*/ +static int winFileHandle(OsFile *id){ + return (int)((winFile*)id)->h; +} + +/* +** Return an integer that indices the type of lock currently held +** by this handle. (Used for testing and analysis only.) +*/ +static int winLockState(OsFile *id){ + return ((winFile*)id)->locktype; +} + +/* +** This vector defines all the methods that can operate on an OsFile +** for win32. +*/ +static const IoMethod sqlite3WinIoMethod = { + winClose, + winOpenDirectory, + winRead, + winWrite, + winSeek, + winTruncate, + winSync, + winSetFullSync, + winFileHandle, + winFileSize, + winLock, + winUnlock, + winLockState, + winCheckReservedLock, +}; + +/* +** Allocate memory for an OsFile. Initialize the new OsFile +** to the value given in pInit and return a pointer to the new +** OsFile. If we run out of memory, close the file and return NULL. +*/ +static int allocateWinFile(winFile *pInit, OsFile **pId){ + winFile *pNew; + pNew = sqliteMalloc( sizeof(*pNew) ); + if( pNew==0 ){ + CloseHandle(pInit->h); +#if OS_WINCE + sqliteFree(pInit->zDeleteOnClose); +#endif + *pId = 0; + return SQLITE_NOMEM; + }else{ + *pNew = *pInit; + pNew->pMethod = &sqlite3WinIoMethod; + pNew->locktype = NO_LOCK; + pNew->sharedLockByte = 0; + *pId = (OsFile*)pNew; + OpenCounter(+1); + return SQLITE_OK; + } +} + + +#endif /* SQLITE_OMIT_DISKIO */ +/*************************************************************************** +** Everything above deals with file I/O. Everything that follows deals +** with other miscellanous aspects of the operating system interface +****************************************************************************/ + +/* +** 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 sqlite3WinRandomSeed(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); + GetSystemTime((LPSYSTEMTIME)zBuf); + return SQLITE_OK; +} + +/* +** Sleep for a little while. Return the amount of time slept. +*/ +int sqlite3WinSleep(int ms){ + Sleep(ms); + return ms; +} + +/* +** Static variables used for thread synchronization +*/ +static int inMutex = 0; +#ifdef SQLITE_W32_THREADS + static DWORD mutexOwner; + static CRITICAL_SECTION cs; +#endif + +/* +** The following pair of routines 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. +** +** Version 3.3.1 and earlier used a simple mutex. Beginning with +** version 3.3.2, a recursive mutex is required. +*/ +void sqlite3WinEnterMutex(){ +#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); + mutexOwner = GetCurrentThreadId(); +#endif + inMutex++; +} +void sqlite3WinLeaveMutex(){ + assert( inMutex ); + inMutex--; +#ifdef SQLITE_W32_THREADS + assert( mutexOwner==GetCurrentThreadId() ); + LeaveCriticalSection(&cs); +#endif +} + +/* +** Return TRUE if the mutex is currently held. +** +** If the thisThreadOnly parameter is true, return true if and only if the +** calling thread holds the mutex. If the parameter is false, return +** true if any thread holds the mutex. +*/ +int sqlite3WinInMutex(int thisThreadOnly){ +#ifdef SQLITE_W32_THREADS + return inMutex>0 && (thisThreadOnly==0 || mutexOwner==GetCurrentThreadId()); +#else + return inMutex>0; +#endif +} + + +/* +** The following variable, if set to a non-zero value, becomes the result +** returned from sqlite3OsCurrentTime(). This is used for testing. +*/ +#ifdef SQLITE_TEST +int sqlite3_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 sqlite3WinCurrentTime(double *prNow){ + 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; +#if OS_WINCE + SYSTEMTIME time; + GetSystemTime(&time); + SystemTimeToFileTime(&time,&ft); +#else + GetSystemTimeAsFileTime( &ft ); +#endif + now = ((double)ft.dwHighDateTime) * 4294967296.0; + *prNow = (now + ft.dwLowDateTime)/864000000000.0 + 2305813.5; +#ifdef SQLITE_TEST + if( sqlite3_current_time ){ + *prNow = sqlite3_current_time/86400.0 + 2440587.5; + } +#endif + return 0; +} + +/* +** Remember the number of thread-specific-data blocks allocated. +** Use this to verify that we are not leaking thread-specific-data. +** Ticket #1601 +*/ +#ifdef SQLITE_TEST +int sqlite3_tsd_count = 0; +# define TSD_COUNTER_INCR InterlockedIncrement(&sqlite3_tsd_count) +# define TSD_COUNTER_DECR InterlockedDecrement(&sqlite3_tsd_count) +#else +# define TSD_COUNTER_INCR /* no-op */ +# define TSD_COUNTER_DECR /* no-op */ +#endif + + + +/* +** If called with allocateFlag>1, then return a pointer to thread +** specific data for the current thread. Allocate and zero the +** thread-specific data if it does not already exist necessary. +** +** If called with allocateFlag==0, then check the current thread +** specific data. Return it if it exists. If it does not exist, +** then return NULL. +** +** If called with allocateFlag<0, check to see if the thread specific +** data is allocated and is all zero. If it is then deallocate it. +** Return a pointer to the thread specific data or NULL if it is +** unallocated or gets deallocated. +*/ +ThreadData *sqlite3WinThreadSpecificData(int allocateFlag){ + static int key; + static int keyInit = 0; + static const ThreadData zeroData = {0}; + ThreadData *pTsd; + + if( !keyInit ){ + sqlite3OsEnterMutex(); + if( !keyInit ){ + key = TlsAlloc(); + if( key==0xffffffff ){ + sqlite3OsLeaveMutex(); + return 0; + } + keyInit = 1; + } + sqlite3OsLeaveMutex(); + } + pTsd = TlsGetValue(key); + if( allocateFlag>0 ){ + if( !pTsd ){ + pTsd = sqlite3OsMalloc( sizeof(zeroData) ); + if( pTsd ){ + *pTsd = zeroData; + TlsSetValue(key, pTsd); + TSD_COUNTER_INCR; + } + } + }else if( pTsd!=0 && allocateFlag<0 + && memcmp(pTsd, &zeroData, sizeof(ThreadData))==0 ){ + sqlite3OsFree(pTsd); + TlsSetValue(key, 0); + TSD_COUNTER_DECR; + pTsd = 0; + } + return pTsd; +} +#endif /* OS_WIN */ diff --git a/sqlite/pager.c b/sqlite/pager.c index 8ad20ff53..c29bb7c69 100755 --- a/sqlite/pager.c +++ b/sqlite/pager.c @@ -18,10 +18,11 @@ ** file simultaneously, or one process from reading the database while ** another is writing. ** -** @(#) $Id: pager.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** @(#) $Id: pager.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ -#include "os.h" /* Must be first to enable large file support */ +#ifndef SQLITE_OMIT_DISKIO #include "sqliteInt.h" +#include "os.h" #include "pager.h" #include #include @@ -30,63 +31,111 @@ ** 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) +#define TRACE1(X) sqlite3DebugPrintf(X) +#define TRACE2(X,Y) sqlite3DebugPrintf(X,Y) +#define TRACE3(X,Y,Z) sqlite3DebugPrintf(X,Y,Z) +#define TRACE4(X,Y,Z,W) sqlite3DebugPrintf(X,Y,Z,W) +#define TRACE5(X,Y,Z,W,V) sqlite3DebugPrintf(X,Y,Z,W,V) #else -#define SET_PAGER(X) -#define CLR_PAGER(X) #define TRACE1(X) #define TRACE2(X,Y) #define TRACE3(X,Y,Z) +#define TRACE4(X,Y,Z,W) +#define TRACE5(X,Y,Z,W,V) #endif +/* +** The following two macros are used within the TRACEX() macros above +** to print out file-descriptors. +** +** PAGERID() takes a pointer to a Pager struct as it's argument. The +** associated file-descriptor is returned. FILEHANDLEID() takes an OsFile +** struct as it's argument. +*/ +#define PAGERID(p) ((int)(p->fd)) +#define FILEHANDLEID(fd) ((int)fd) /* ** The page cache as a whole is always in one of the following ** states: ** -** SQLITE_UNLOCK The page cache is not currently reading or +** PAGER_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. +** PAGER_SHARED 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. +** PAGER_RESERVED This process has reserved the database for writing +** but has not yet made any changes. Only one process +** at a time can reserve the database. The original +** database file has not been modified so other +** processes may still be reading the on-disk +** database file. +** +** PAGER_EXCLUSIVE 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. +** PAGER_SYNCED The pager moves to this state from PAGER_EXCLUSIVE +** after all dirty pages have been written to the +** database file and the file has been synced to +** disk. All that remains to do is to remove the +** journal file and the transaction will be +** committed. +** +** The page cache comes up in PAGER_UNLOCK. The first time a +** sqlite3pager_get() occurs, the state transitions to PAGER_SHARED. ** 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 +** the state transitions back to PAGER_UNLOCK. The first time +** that sqlite3pager_write() is called, the state transitions to +** PAGER_RESERVED. (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. +** be in PAGER_SHARED before it transitions to PAGER_RESERVED.) +** The transition to PAGER_EXCLUSIVE occurs when before any changes +** are made to the database file. After an sqlite3pager_rollback() +** or sqlite_pager_commit(), the state goes back to PAGER_SHARED. */ -#define SQLITE_UNLOCK 0 -#define SQLITE_READLOCK 1 -#define SQLITE_WRITELOCK 2 +#define PAGER_UNLOCK 0 +#define PAGER_SHARED 1 /* same as SHARED_LOCK */ +#define PAGER_RESERVED 2 /* same as RESERVED_LOCK */ +#define PAGER_EXCLUSIVE 4 /* same as EXCLUSIVE_LOCK */ +#define PAGER_SYNCED 5 +/* +** If the SQLITE_BUSY_RESERVED_LOCK macro is set to true at compile-time, +** then failed attempts to get a reserved lock will invoke the busy callback. +** This is off by default. To see why, consider the following scenario: +** +** Suppose thread A already has a shared lock and wants a reserved lock. +** Thread B already has a reserved lock and wants an exclusive lock. If +** both threads are using their busy callbacks, it might be a long time +** be for one of the threads give up and allows the other to proceed. +** But if the thread trying to get the reserved lock gives up quickly +** (if it never invokes its busy callback) then the contention will be +** resolved quickly. +*/ +#ifndef SQLITE_BUSY_RESERVED_LOCK +# define SQLITE_BUSY_RESERVED_LOCK 0 +#endif + +/* +** This macro rounds values up so that if the value is an address it +** is guaranteed to be an address that is aligned to an 8-byte boundary. +*/ +#define FORCE_ALIGNMENT(X) (((X)+7)&~7) /* ** 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() +** Client code should call sqlite3pager_write() on a page prior to making +** any modifications to that page. The first time sqlite3pager_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 @@ -94,7 +143,7 @@ static Pager *mainPager = 0; ** 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 +** The PgHdr.dirty flag is set when sqlite3pager_write() is called and ** is cleared again when the page content is written back to the original ** database file. */ @@ -103,28 +152,49 @@ 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 */ + PgHdr *pNextAll; /* A list of all pages */ + PgHdr *pNextStmt, *pPrevStmt; /* List of pages in the statement journal */ u8 inJournal; /* TRUE if has been written to journal */ - u8 inCkpt; /* TRUE if written to the checkpoint journal */ + u8 inStmt; /* TRUE if in the statement subjournal */ 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 */ + short int nRef; /* Number of users of this page */ PgHdr *pDirty; /* Dirty pages sorted by PgHdr.pgno */ - /* SQLITE_PAGE_SIZE bytes of page data follow this header */ +#ifdef SQLITE_CHECK_PAGES + u32 pageHash; +#endif + /* pPager->pageSize bytes of page data follow this header */ /* Pager.nExtra bytes of local data follow the page data */ }; +/* +** For an in-memory only database, some extra information is recorded about +** each page so that changes can be rolled back. (Journal files are not +** used for in-memory databases.) The following information is added to +** the end of every EXTRA block for in-memory databases. +** +** This information could have been added directly to the PgHdr structure. +** But then it would take up an extra 8 bytes of storage on every PgHdr +** even for disk-based databases. Splitting it out saves 8 bytes. This +** is only a savings of 0.8% but those percentages add up. +*/ +typedef struct PgHistory PgHistory; +struct PgHistory { + u8 *pOrig; /* Original page text. Restore to this on a full rollback */ + u8 *pStmt; /* Text as it was at the beginning of the current statement */ +}; /* ** 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); } +# define CODEC1(P,D,N,X) if( P->xCodec!=0 ){ P->xCodec(P->pCodecArg,D,N,X); } +# define CODEC2(P,D,N,X) ((char*)(P->xCodec!=0?P->xCodec(P->pCodecArg,D,N,X):D)) #else -# define CODEC(P,D,N,X) +# define CODEC1(P,D,N,X) /* NO-OP */ +# define CODEC2(P,D,N,X) ((char*)D) #endif /* @@ -133,13 +203,22 @@ struct PgHdr { */ #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]) +#define PGHDR_TO_EXTRA(G,P) ((void*)&((char*)(&(G)[1]))[(P)->pageSize]) +#define PGHDR_TO_HIST(P,PGR) \ + ((PgHistory*)&((char*)(&(P)[1]))[(PGR)->pageSize+(PGR)->nExtra]) /* ** How big to make the hash table used for locating in-memory pages -** by page number. +** by page number. This macro looks a little silly, but is evaluated +** at compile-time, not run-time (at least for gcc this is true). */ -#define N_PG_HASH 2048 +#define N_PG_HASH (\ + (MAX_PAGES>1024)?2048: \ + (MAX_PAGES>512)?1024: \ + (MAX_PAGES>256)?512: \ + (MAX_PAGES>128)?256: \ + (MAX_PAGES>64)?128:64 \ +) /* ** Hash a page number @@ -148,96 +227,104 @@ struct PgHdr { /* ** A open page cache is an instance of the following structure. +** +** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, SQLITE_PROTOCOL +** or SQLITE_FULL. Once one of the first three errors occurs, it persists +** and is returned as the result of every major pager API call. The +** SQLITE_FULL return code is slightly different. It persists only until the +** next successful rollback is performed on the pager cache. Also, +** SQLITE_FULL does not affect the sqlite3pager_get() and sqlite3pager_lookup() +** APIs, they may still be used successfully. */ 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 noReadlock; /* Do not bother to obtain readlocks */ + u8 stmtOpen; /* True if the statement subjournal is open */ + u8 stmtInUse; /* True we are in a statement subtransaction */ + u8 stmtAutoopen; /* Open stmt 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 full_fsync; /* Use F_FULLFSYNC when available */ + u8 state; /* PAGER_UNLOCK, _SHARED, _RESERVED, etc. */ + u8 errCode; /* 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 dirtyCache; /* True if cached pages have changed */ u8 alwaysRollback; /* Disable dont_rollback() for all pages */ + u8 memDb; /* True to inhibit all file I/O */ + u8 setMaster; /* True if a m-j name has been written to jrnl */ + int dbSize; /* Number of pages in the file */ + int origDbSize; /* dbSize before the current change */ + int stmtSize; /* Size of database (in pages) at stmt_begin() */ + int nRec; /* Number of pages written to the journal */ + u32 cksumInit; /* Quasi-random value added to every checksum */ + int stmtNRec; /* Number of records in stmt subjournal */ + int nExtra; /* Add this many bytes to each in-memory page */ + int pageSize; /* Number of bytes in a page */ + int nPage; /* Total number of in-memory pages */ + int nMaxPage; /* High water mark of nPage */ + int nRef; /* Number of in-memory pages with PgHdr.nRef>0 */ + int mxPage; /* Maximum number of pages to hold in cache */ u8 *aInJournal; /* One bit for each page in the database file */ - u8 *aInCkpt; /* One bit for each page in the database */ + u8 *aInStmt; /* One bit for each page in the database */ + 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 *stfd; /* File descriptor for the statement subjournal*/ + BusyHandler *pBusyHandler; /* Pointer to sqlite.busyHandler */ 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 */ + PgHdr *pStmt; /* List of pages in the statement subjournal */ + i64 journalOff; /* Current byte offset in the journal file */ + i64 journalHdr; /* Byte offset to previous journal header */ + i64 stmtHdrOff; /* First journal header written this statement */ + i64 stmtCksum; /* cksumInit when statement was started */ + i64 stmtJSize; /* Size of journal at stmt_begin() */ + int sectorSize; /* Assumed sector size during rollback */ +#ifdef SQLITE_TEST + int nHit, nMiss, nOvfl; /* Cache hits, missing, and LRU overflows */ + int nRead,nWrite; /* Database pages read/written */ +#endif + void (*xDestructor)(void*,int); /* Call this routine when freeing pages */ + void (*xReiniter)(void*,int); /* Call this routine when reloading pages */ + void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */ + void *pCodecArg; /* First argument to xCodec() */ + PgHdr *aHash[N_PG_HASH]; /* Hash table to map page number to PgHdr */ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + Pager *pNext; /* Linked list of pagers in this thread */ +#endif }; /* -** These are bits that can be set in Pager.errMask. +** If SQLITE_TEST is defined then increment the variable given in +** the argument */ -#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 */ -}; +#ifdef SQLITE_TEST +# define TEST_INCR(x) x++ +#else +# define TEST_INCR(x) +#endif /* ** 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 +** Since version 2.8.0, the journal format contains additional sanity +** checking information. If the power fails while the journal is begin +** 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 +** The sanity checking information for the new journal format consists ** of a 32-bit checksum on each page of data. The checksum covers both -** the page number and the SQLITE_PAGE_SIZE bytes of data for the page. +** the page number and the pPager->pageSize bytes of data for the page. ** This cksum is initialized to a 32-bit random value that appears in the ** journal file right after the header. The random initializer is important, ** because garbage data that appears at the end of a journal is likely @@ -246,55 +333,66 @@ struct PageRecord { ** 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 aJournalMagic[] = { + 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7, }; -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. +** The size of the header and of each page in the journal is determined +** by the following macros. */ -#ifdef SQLITE_TEST -int journal_format = 3; +#define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8) + +/* +** The journal header size for this pager. In the future, this could be +** set to some value read from the disk controller. The important +** characteristic is that it is the same size as a disk sector. +*/ +#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize) + +/* +** The macro MEMDB is true if we are dealing with an in-memory database. +** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set, +** the value of MEMDB will be a constant and the compiler will optimize +** out code that would never execute. +*/ +#ifdef SQLITE_OMIT_MEMORYDB +# define MEMDB 0 #else -# define journal_format 3 +# define MEMDB pPager->memDb #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. +** The default size of a disk sector */ -#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)) +#define PAGER_SECTOR_SIZE 512 /* -** Enable reference count tracking here: +** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is +** reserved for working around a windows/posix incompatibility). It is +** used in the journal to signify that the remainder of the journal file +** is devoted to storing a master journal name - there are no more pages to +** roll back. See comments for function writeMasterJournal() for details. */ -#ifdef SQLITE_TEST - int pager_refinfo_enable = 0; +/* #define PAGER_MJ_PGNO(x) (PENDING_BYTE/((x)->pageSize)) */ +#define PAGER_MJ_PGNO(x) ((PENDING_BYTE/((x)->pageSize))+1) + +/* +** The maximum legal page number is (2^31 - 1). +*/ +#define PAGER_MAX_PGNO 2147483647 + +/* +** Enable reference count tracking (for debugging) here: +*/ +#ifdef SQLITE_DEBUG + int pager3_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 + if( !pager3_refinfo_enable ) return; + sqlite3DebugPrintf( + "REFCNT: %4d addr=%p nRef=%d\n", + p->pgno, PGHDR_TO_DATA(p), p->nRef ); cnt++; /* Something to set a breakpoint on */ } @@ -308,116 +406,413 @@ int journal_format = 3; ** 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. +** All values are stored on disk as big-endian. */ -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]; +static int read32bits(OsFile *fd, u32 *pRes){ + unsigned char ac[4]; + int rc = sqlite3OsRead(fd, ac, sizeof(ac)); + if( rc==SQLITE_OK ){ + *pRes = (ac[0]<<24) | (ac[1]<<16) | (ac[2]<<8) | ac[3]; } - *pRes = res; return rc; } +/* +** Write a 32-bit integer into a string buffer in big-endian byte order. +*/ +static void put32bits(char *ac, u32 val){ + ac[0] = (val>>24) & 0xff; + ac[1] = (val>>16) & 0xff; + ac[2] = (val>>8) & 0xff; + ac[3] = val & 0xff; +} + /* ** 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); + char ac[4]; + put32bits(ac, val); + return sqlite3OsWrite(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. +** Read a 32-bit integer at offset 'offset' from the page identified by +** page header 'p'. */ -static void store32bits(u32 val, PgHdr *p, int offset){ +static u32 retrieve32bits(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; - } + return (ac[0]<<24) | (ac[1]<<16) | (ac[2]<<8) | ac[3]; } /* -** Convert the bits in the pPager->errMask into an approprate -** return code. +** This function should be called when an error occurs within the pager +** code. The first argument is a pointer to the pager structure, the +** second the error-code about to be returned by a pager API function. +** The value returned is a copy of the second argument to this function. +** +** If the second argument is SQLITE_IOERR, SQLITE_CORRUPT or SQLITE_PROTOCOL, +** the error becomes persistent. All subsequent API calls on this Pager +** will immediately return the same error 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; +static int pager_error(Pager *pPager, int rc){ + assert( pPager->errCode==SQLITE_FULL || pPager->errCode==SQLITE_OK ); + if( + rc==SQLITE_FULL || + rc==SQLITE_IOERR || + rc==SQLITE_CORRUPT || + rc==SQLITE_PROTOCOL + ){ + pPager->errCode = rc; + } + return rc; +} + +#ifdef SQLITE_CHECK_PAGES +/* +** Return a 32-bit hash of the page data for pPage. +*/ +static u32 pager_pagehash(PgHdr *pPage){ + u32 hash = 0; + int i; + unsigned char *pData = (unsigned char *)PGHDR_TO_DATA(pPage); + for(i=0; ipPager->pageSize; i++){ + hash = (hash+i)^pData[i]; + } + return hash; +} + +/* +** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES +** is defined, and NDEBUG is not defined, an assert() statement checks +** that the page is either dirty or still matches the calculated page-hash. +*/ +#define CHECK_PAGE(x) checkPage(x) +static void checkPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + assert( !pPg->pageHash || pPager->errCode || MEMDB || pPg->dirty || + pPg->pageHash==pager_pagehash(pPg) ); +} + +#else +#define CHECK_PAGE(x) +#endif + +/* +** When this is called the journal file for pager pPager must be open. +** The master journal file name is read from the end of the file and +** written into memory obtained from sqliteMalloc(). *pzMaster is +** set to point at the memory and SQLITE_OK returned. The caller must +** sqliteFree() *pzMaster. +** +** If no master journal file name is present *pzMaster is set to 0 and +** SQLITE_OK returned. +*/ +static int readMasterJournal(OsFile *pJrnl, char **pzMaster){ + int rc; + u32 len; + i64 szJ; + u32 cksum; + int i; + unsigned char aMagic[8]; /* A buffer to hold the magic header */ + + *pzMaster = 0; + + rc = sqlite3OsFileSize(pJrnl, &szJ); + if( rc!=SQLITE_OK || szJ<16 ) return rc; + + rc = sqlite3OsSeek(pJrnl, szJ-16); + if( rc!=SQLITE_OK ) return rc; + + rc = read32bits(pJrnl, &len); + if( rc!=SQLITE_OK ) return rc; + + rc = read32bits(pJrnl, &cksum); + if( rc!=SQLITE_OK ) return rc; + + rc = sqlite3OsRead(pJrnl, aMagic, 8); + if( rc!=SQLITE_OK || memcmp(aMagic, aJournalMagic, 8) ) return rc; + + rc = sqlite3OsSeek(pJrnl, szJ-16-len); + if( rc!=SQLITE_OK ) return rc; + + *pzMaster = (char *)sqliteMalloc(len+1); + if( !*pzMaster ){ + return SQLITE_NOMEM; + } + rc = sqlite3OsRead(pJrnl, *pzMaster, len); + if( rc!=SQLITE_OK ){ + sqliteFree(*pzMaster); + *pzMaster = 0; + return rc; + } + + /* See if the checksum matches the master journal name */ + for(i=0; ijournalOff; + if( c ){ + offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager); + } + assert( offset%JOURNAL_HDR_SZ(pPager)==0 ); + assert( offset>=c ); + assert( (offset-c)journalOff = offset; + return sqlite3OsSeek(pPager->jfd, pPager->journalOff); +} + +/* +** The journal file must be open when this routine is called. A journal +** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the +** current location. +** +** The format for the journal header is as follows: +** - 8 bytes: Magic identifying journal format. +** - 4 bytes: Number of records in journal, or -1 no-sync mode is on. +** - 4 bytes: Random number used for page hash. +** - 4 bytes: Initial database page count. +** - 4 bytes: Sector size used by the process that wrote this journal. +** +** Followed by (JOURNAL_HDR_SZ - 24) bytes of unused space. +*/ +static int writeJournalHdr(Pager *pPager){ + char zHeader[sizeof(aJournalMagic)+16]; + + int rc = seekJournalHdr(pPager); + if( rc ) return rc; + + pPager->journalHdr = pPager->journalOff; + if( pPager->stmtHdrOff==0 ){ + pPager->stmtHdrOff = pPager->journalHdr; + } + pPager->journalOff += JOURNAL_HDR_SZ(pPager); + + /* FIX ME: + ** + ** Possibly for a pager not in no-sync mode, the journal magic should not + ** be written until nRec is filled in as part of next syncJournal(). + ** + ** Actually maybe the whole journal header should be delayed until that + ** point. Think about this. + */ + memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic)); + /* The nRec Field. 0xFFFFFFFF for no-sync journals. */ + put32bits(&zHeader[sizeof(aJournalMagic)], pPager->noSync ? 0xffffffff : 0); + /* The random check-hash initialiser */ + sqlite3Randomness(sizeof(pPager->cksumInit), &pPager->cksumInit); + put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit); + /* The initial database size */ + put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbSize); + /* The assumed sector size for this process */ + put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize); + rc = sqlite3OsWrite(pPager->jfd, zHeader, sizeof(zHeader)); + + /* The journal header has been written successfully. Seek the journal + ** file descriptor to the end of the journal header sector. + */ + if( rc==SQLITE_OK ){ + rc = sqlite3OsSeek(pPager->jfd, pPager->journalOff-1); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pPager->jfd, "\000", 1); + } + } + return rc; +} + +/* +** The journal file must be open when this is called. A journal header file +** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal +** file. See comments above function writeJournalHdr() for a description of +** the journal header format. +** +** If the header is read successfully, *nRec is set to the number of +** page records following this header and *dbSize is set to the size of the +** database before the transaction began, in pages. Also, pPager->cksumInit +** is set to the value read from the journal header. SQLITE_OK is returned +** in this case. +** +** If the journal header file appears to be corrupted, SQLITE_DONE is +** returned and *nRec and *dbSize are not set. If JOURNAL_HDR_SZ bytes +** cannot be read from the journal file an error code is returned. +*/ +static int readJournalHdr( + Pager *pPager, + i64 journalSize, + u32 *pNRec, + u32 *pDbSize +){ + int rc; + unsigned char aMagic[8]; /* A buffer to hold the magic header */ + + rc = seekJournalHdr(pPager); + if( rc ) return rc; + + if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){ + return SQLITE_DONE; + } + + rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic)); + if( rc ) return rc; + + if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){ + return SQLITE_DONE; + } + + rc = read32bits(pPager->jfd, pNRec); + if( rc ) return rc; + + rc = read32bits(pPager->jfd, &pPager->cksumInit); + if( rc ) return rc; + + rc = read32bits(pPager->jfd, pDbSize); + if( rc ) return rc; + + /* Update the assumed sector-size to match the value used by + ** the process that created this journal. If this journal was + ** created by a process other than this one, then this routine + ** is being called from within pager_playback(). The local value + ** of Pager.sectorSize is restored at the end of that routine. + */ + rc = read32bits(pPager->jfd, (u32 *)&pPager->sectorSize); + if( rc ) return rc; + + pPager->journalOff += JOURNAL_HDR_SZ(pPager); + rc = sqlite3OsSeek(pPager->jfd, pPager->journalOff); + return rc; +} + + +/* +** Write the supplied master journal name into the journal file for pager +** pPager at the current location. The master journal name must be the last +** thing written to a journal file. If the pager is in full-sync mode, the +** journal file descriptor is advanced to the next sector boundary before +** anything is written. The format is: +** +** + 4 bytes: PAGER_MJ_PGNO. +** + N bytes: length of master journal name. +** + 4 bytes: N +** + 4 bytes: Master journal name checksum. +** + 8 bytes: aJournalMagic[]. +** +** The master journal page checksum is the sum of the bytes in the master +** journal name. +** +** If zMaster is a NULL pointer (occurs for a single database transaction), +** this call is a no-op. +*/ +static int writeMasterJournal(Pager *pPager, const char *zMaster){ + int rc; + int len; + int i; + u32 cksum = 0; + char zBuf[sizeof(aJournalMagic)+2*4]; + + if( !zMaster || pPager->setMaster) return SQLITE_OK; + pPager->setMaster = 1; + + len = strlen(zMaster); + for(i=0; ifullSync ){ + rc = seekJournalHdr(pPager); + if( rc!=SQLITE_OK ) return rc; + } + pPager->journalOff += (len+20); + + rc = write32bits(pPager->jfd, PAGER_MJ_PGNO(pPager)); + if( rc!=SQLITE_OK ) return rc; + + rc = sqlite3OsWrite(pPager->jfd, zMaster, len); + if( rc!=SQLITE_OK ) return rc; + + put32bits(zBuf, len); + put32bits(&zBuf[4], cksum); + memcpy(&zBuf[8], aJournalMagic, sizeof(aJournalMagic)); + rc = sqlite3OsWrite(pPager->jfd, zBuf, 8+sizeof(aJournalMagic)); + pPager->needSync = !pPager->noSync; return rc; } /* ** Add or remove a page from the list of all pages that are in the -** checkpoint journal. +** statement journal. ** ** The Pager keeps a separate list of pages that are currently in -** the checkpoint journal. This helps the sqlitepager_ckpt_commit() +** the statement journal. This helps the sqlite3pager_stmt_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. +** pages in memory but only a few are in the statement journal. */ -static void page_add_to_ckpt_list(PgHdr *pPg){ +static void page_add_to_stmt_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; + if( pPg->inStmt ) return; + assert( pPg->pPrevStmt==0 && pPg->pNextStmt==0 ); + pPg->pPrevStmt = 0; + if( pPager->pStmt ){ + pPager->pStmt->pPrevStmt = pPg; } - pPg->pNextCkpt = pPager->pCkpt; - pPager->pCkpt = pPg; - pPg->inCkpt = 1; + pPg->pNextStmt = pPager->pStmt; + pPager->pStmt = pPg; + pPg->inStmt = 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; +static void page_remove_from_stmt_list(PgHdr *pPg){ + if( !pPg->inStmt ) return; + if( pPg->pPrevStmt ){ + assert( pPg->pPrevStmt->pNextStmt==pPg ); + pPg->pPrevStmt->pNextStmt = pPg->pNextStmt; }else{ - assert( pPg->pPager->pCkpt==pPg ); - pPg->pPager->pCkpt = pPg->pNextCkpt; + assert( pPg->pPager->pStmt==pPg ); + pPg->pPager->pStmt = pPg->pNextStmt; } - if( pPg->pNextCkpt ){ - assert( pPg->pNextCkpt->pPrevCkpt==pPg ); - pPg->pNextCkpt->pPrevCkpt = pPg->pPrevCkpt; + if( pPg->pNextStmt ){ + assert( pPg->pNextStmt->pPrevStmt==pPg ); + pPg->pNextStmt->pPrevStmt = pPg->pPrevStmt; } - pPg->pNextCkpt = 0; - pPg->pPrevCkpt = 0; - pPg->inCkpt = 0; + pPg->pNextStmt = 0; + pPg->pPrevStmt = 0; + pPg->inStmt = 0; } /* @@ -440,6 +835,7 @@ static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){ */ static void pager_reset(Pager *pPager){ PgHdr *pPg, *pNext; + if( pPager->errCode ) return; for(pPg=pPager->pAll; pPg; pPg=pNext){ pNext = pPg->pNextAll; sqliteFree(pPg); @@ -450,11 +846,11 @@ static void pager_reset(Pager *pPager){ pPager->pAll = 0; memset(pPager->aHash, 0, sizeof(pPager->aHash)); pPager->nPage = 0; - if( pPager->state>=SQLITE_WRITELOCK ){ - sqlitepager_rollback(pPager); + if( pPager->state>=PAGER_RESERVED ){ + sqlite3pager_rollback(pPager); } - sqliteOsUnlock(&pPager->fd); - pPager->state = SQLITE_UNLOCK; + sqlite3OsUnlock(pPager->fd, NO_LOCK); + pPager->state = PAGER_UNLOCK; pPager->dbSize = -1; pPager->nRef = 0; assert( pPager->journalOpen==0 ); @@ -462,47 +858,52 @@ static void pager_reset(Pager *pPager){ /* ** 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. +** a RESERVED or EXCLUSIVE lock on the database. This routine releases +** the database lock and acquires a SHARED 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; + int rc; + assert( !MEMDB ); + if( pPager->statestmtOpen ){ + sqlite3OsClose(&pPager->stfd); + pPager->stmtOpen = 0; } if( pPager->journalOpen ){ - sqliteOsClose(&pPager->jfd); + sqlite3OsClose(&pPager->jfd); pPager->journalOpen = 0; - sqliteOsDelete(pPager->zJournal); + sqlite3OsDelete(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; +#ifdef SQLITE_CHECK_PAGES + pPg->pageHash = pager_pagehash(pPg); +#endif } + pPager->dirtyCache = 0; + pPager->nRec = 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; + assert( pPager->aInJournal==0 ); + assert( pPager->dirtyCache==0 || pPager->useJournal==0 ); } + rc = sqlite3OsUnlock(pPager->fd, SHARED_LOCK); + pPager->state = PAGER_SHARED; + pPager->origDbSize = 0; + pPager->setMaster = 0; + pPager->needSync = 0; + pPager->pFirstSynced = pPager->pFirst; return rc; } @@ -510,11 +911,29 @@ static int pager_unwritelock(Pager *pPager){ ** 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. +** random initial value and the page number. We experimented with +** a checksum of the entire data, but that was found to be too slow. +** +** Note that the page number is stored at the beginning of data and +** the checksum is stored at the end. This is important. If journal +** corruption occurs due to a power failure, the most likely scenario +** is that one end or the other of the record will be changed. It is +** much less likely that the two ends of the journal record will be +** correct and the middle be corrupt. Thus, this "checksum" scheme, +** though fast and simple, catches the mostly likely kind of corruption. +** +** FIX ME: Consider adding every 200th (or so) byte of the data to the +** checksum. That way if a single page spans 3 or more disk sectors and +** only the middle sector is corrupt, we will still have a reasonable +** chance of failing the checksum and thus detecting the problem. */ -static u32 pager_cksum(Pager *pPager, Pgno pgno, const char *aData){ - u32 cksum = pPager->cksumInit + pgno; +static u32 pager_cksum(Pager *pPager, const u8 *aData){ + u32 cksum = pPager->cksumInit; + int i = pPager->pageSize-200; + while( i>0 ){ + cksum += aData[i]; + i -= 200; + } return cksum; } @@ -522,86 +941,269 @@ static u32 pager_cksum(Pager *pPager, Pgno pgno, const char *aData){ ** 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. +** If useCksum==0 it means this journal does not use checksums. Checksums +** are not used in statement journals because statement journals do not +** need to survive power failures. */ -static int pager_playback_one_page(Pager *pPager, OsFile *jfd, int format){ +static int pager_playback_one_page(Pager *pPager, OsFile *jfd, int useCksum){ int rc; - PgHdr *pPg; /* An existing page in the cache */ - PageRecord pgRec; - u32 cksum; + PgHdr *pPg; /* An existing page in the cache */ + Pgno pgno; /* The page number of a page in journal */ + u32 cksum; /* Checksum used for sanity checking */ + u8 aData[SQLITE_MAX_PAGE_SIZE]; /* Temp storage for a page */ - rc = read32bits(format, jfd, &pgRec.pgno); + /* useCksum should be true for the main journal and false for + ** statement journals. Verify that this is always the case + */ + assert( jfd == (useCksum ? pPager->jfd : pPager->stfd) ); + + + rc = read32bits(jfd, &pgno); if( rc!=SQLITE_OK ) return rc; - rc = sqliteOsRead(jfd, &pgRec.aData, sizeof(pgRec.aData)); + rc = sqlite3OsRead(jfd, &aData, pPager->pageSize); if( rc!=SQLITE_OK ) return rc; + pPager->journalOff += pPager->pageSize + 4; /* Sanity checking on the page. This is more important that I originally ** thought. If a power failure occurs while the journal is being written, ** it could cause invalid data to be written into the journal. We need to ** detect this invalid data (with high probability) and ignore it. */ - if( pgRec.pgno==0 ){ + if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){ return SQLITE_DONE; } - if( pgRec.pgno>(unsigned)pPager->dbSize ){ + if( pgno>(unsigned)pPager->dbSize ){ return SQLITE_OK; } - if( format>=JOURNAL_FORMAT_3 ){ - rc = read32bits(format, jfd, &cksum); + if( useCksum ){ + rc = read32bits(jfd, &cksum); if( rc ) return rc; - if( pager_cksum(pPager, pgRec.pgno, pgRec.aData)!=cksum ){ + pPager->journalOff += 4; + if( pager_cksum(pPager, aData)!=cksum ){ return SQLITE_DONE; } } - /* Playback the page. Update the in-memory copy of the page - ** at the same time, if there is one. + assert( pPager->state==PAGER_RESERVED || pPager->state>=PAGER_EXCLUSIVE ); + + /* If the pager is in RESERVED state, then there must be a copy of this + ** page in the pager cache. In this case just update the pager cache, + ** not the database file. The page is left marked dirty in this case. + ** + ** If in EXCLUSIVE state, then we update the pager cache if it exists + ** and the main file. The page is then marked not dirty. + ** + ** Ticket #1171: The statement journal might contain page content that is + ** different from the page content at the start of the transaction. + ** This occurs when a page is changed prior to the start of a statement + ** then changed again within the statement. When rolling back such a + ** statement we must not write to the original database unless we know + ** for certain that original page contents are in the main rollback + ** journal. Otherwise, if a full ROLLBACK occurs after the statement + ** rollback the full ROLLBACK will not restore the page to its original + ** content. Two conditions must be met before writing to the database + ** files. (1) the database must be locked. (2) we know that the original + ** page content is in the main journal either because the page is not in + ** cache or else it is marked as needSync==0. */ - 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); + pPg = pager_lookup(pPager, pgno); + assert( pPager->state>=PAGER_EXCLUSIVE || pPg!=0 ); + TRACE3("PLAYBACK %d page %d\n", PAGERID(pPager), pgno); + if( pPager->state>=PAGER_EXCLUSIVE && (pPg==0 || pPg->needSync==0) ){ + rc = sqlite3OsSeek(pPager->fd, (pgno-1)*(i64)pPager->pageSize); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize); + } + if( pPg ) pPg->dirty = 0; + } 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. + /* No page should ever be explicitly rolled back that is in use, except + ** for page 1 which is held in use in order to keep the lock on the + ** database active. However such a page may be rolled back as a result + ** of an internal error resulting in an automatic call to + ** sqlite3pager_rollback(). */ - 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); + void *pData; + /* assert( pPg->nRef==0 || pPg->pgno==1 ); */ + pData = PGHDR_TO_DATA(pPg); + memcpy(pData, aData, pPager->pageSize); + if( pPager->xDestructor ){ /*** FIX ME: Should this be xReinit? ***/ + pPager->xDestructor(pData, pPager->pageSize); + } +#ifdef SQLITE_CHECK_PAGES + pPg->pageHash = pager_pagehash(pPg); +#endif + CODEC1(pPager, pData, pPg->pgno, 3); } return rc; } +/* +** Parameter zMaster is the name of a master journal file. A single journal +** file that referred to the master journal file has just been rolled back. +** This routine checks if it is possible to delete the master journal file, +** and does so if it is. +** +** The master journal file contains the names of all child journals. +** To tell if a master journal can be deleted, check to each of the +** children. If all children are either missing or do not refer to +** a different master journal, then this master journal can be deleted. +*/ +static int pager_delmaster(const char *zMaster){ + int rc; + int master_open = 0; + OsFile *master = 0; + char *zMasterJournal = 0; /* Contents of master journal file */ + i64 nMasterJournal; /* Size of master journal file */ + + /* Open the master journal file exclusively in case some other process + ** is running this routine also. Not that it makes too much difference. + */ + rc = sqlite3OsOpenReadOnly(zMaster, &master); + if( rc!=SQLITE_OK ) goto delmaster_out; + master_open = 1; + rc = sqlite3OsFileSize(master, &nMasterJournal); + if( rc!=SQLITE_OK ) goto delmaster_out; + + if( nMasterJournal>0 ){ + char *zJournal; + char *zMasterPtr = 0; + + /* Load the entire master journal file into space obtained from + ** sqliteMalloc() and pointed to by zMasterJournal. + */ + zMasterJournal = (char *)sqliteMalloc(nMasterJournal); + if( !zMasterJournal ){ + rc = SQLITE_NOMEM; + goto delmaster_out; + } + rc = sqlite3OsRead(master, zMasterJournal, nMasterJournal); + if( rc!=SQLITE_OK ) goto delmaster_out; + + zJournal = zMasterJournal; + while( (zJournal-zMasterJournal)pAll; pPg; pPg=pPg->pNextAll){ + char zBuf[SQLITE_MAX_PAGE_SIZE]; + if( !pPg->dirty ) continue; + if( (int)pPg->pgno <= pPager->origDbSize ){ + rc = sqlite3OsSeek(pPager->fd, pPager->pageSize*(i64)(pPg->pgno-1)); + if( rc==SQLITE_OK ){ + rc = sqlite3OsRead(pPager->fd, zBuf, pPager->pageSize); + } + TRACE3("REFETCH %d page %d\n", PAGERID(pPager), pPg->pgno); + if( rc ) break; + CODEC1(pPager, zBuf, pPg->pgno, 2); + }else{ + memset(zBuf, 0, pPager->pageSize); + } + if( pPg->nRef==0 || memcmp(zBuf, PGHDR_TO_DATA(pPg), pPager->pageSize) ){ + memcpy(PGHDR_TO_DATA(pPg), zBuf, pPager->pageSize); + if( pPager->xReiniter ){ + pPager->xReiniter(PGHDR_TO_DATA(pPg), pPager->pageSize); + }else{ + memset(PGHDR_TO_EXTRA(pPg, pPager), 0, pPager->nExtra); + } + } + pPg->needSync = 0; + pPg->dirty = 0; +#ifdef SQLITE_CHECK_PAGES + pPg->pageHash = pager_pagehash(pPg); +#endif + } + return rc; +} + +/* +** Truncate the main file of the given pager to the number of pages +** indicated. +*/ +static int pager_truncate(Pager *pPager, int nPage){ + assert( pPager->state>=PAGER_EXCLUSIVE ); + return sqlite3OsTruncate(pPager->fd, pPager->pageSize*(i64)nPage); +} + /* ** 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 +** (1) 8 byte prefix. A copy of aJournalMagic[]. +** (2) 4 byte big-endian integer which is the number of valid page records ** in the journal. If this value is 0xffffffff, then compute the -** number of page records from the journal size. 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 +** number of page records from the journal size. +** (3) 4 byte big-endian integer which is the initial value for the +** sanity checksum. +** (4) 4 byte integer which is the number of pages to truncate the ** database to during a rollback. -** * Zero or more pages instances, each as follows: +** (5) 4 byte integer which is the number of bytes in the master journal +** name. The value may be zero (indicate that there is no master +** journal.) +** (6) N bytes of the master journal name. The name will be nul-terminated +** and might be shorter than the value read from (5). If the first byte +** of the name is \000 then there is no master journal. The master +** journal name is stored in UTF-8. +** (7) Zero or more pages instances, each as follows: ** + 4 byte page number. -** + SQLITE_PAGE_SIZE bytes of data. -** + 4 byte checksum (format 3 only) +** + pPager->pageSize bytes of data. +** + 4 byte checksum ** -** 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. +** When we speak of the journal header, we mean the first 6 items above. +** Each entry in the journal is an instance of the 7th item. ** ** Call the value from the second bullet "nRec". nRec is the number of ** valid page entries in the journal. In most cases, you can compute the @@ -618,236 +1220,250 @@ static int pager_playback_one_page(Pager *pPager, OsFile *jfd, int format){ ** 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. +** journal file then all pages up to the first corrupted page are rolled +** back (or no pages if the journal header is corrupted). The journal file +** is then deleted and SQLITE_OK returned, just as if no corruption had +** been encountered. +** +** If an I/O or malloc() error occurs, the journal-file is not deleted +** and an error code is returned. */ -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 */ +static int pager_playback(Pager *pPager){ + i64 szJ; /* Size of the journal file in bytes */ + u32 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; + int rc; /* Result code of a subroutine */ + char *zMaster = 0; /* Name of master journal file if any */ /* 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); + rc = sqlite3OsFileSize(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. + /* Read the master journal name from the journal, if it is present. + ** If a master journal file name is specified, but the file is not + ** present on disk, then the journal is not hot and does not need to be + ** played back. */ - if( szJ < sizeof(aMagic)+sizeof(Pgno) ){ + rc = readMasterJournal(pPager->jfd, &zMaster); + assert( rc!=SQLITE_DONE ); + if( rc!=SQLITE_OK || (zMaster && !sqlite3OsFileExists(zMaster)) ){ + sqliteFree(zMaster); + zMaster = 0; + if( rc==SQLITE_DONE ) rc = SQLITE_OK; goto end_playback; } + sqlite3OsSeek(pPager->jfd, 0); + pPager->journalOff = 0; - /* 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 ){ + /* This loop terminates either when the readJournalHdr() call returns + ** SQLITE_DONE or an IO error occurs. */ + while( 1 ){ + + /* Read the next journal header from the journal file. If there are + ** not enough bytes left in the journal file for a complete header, or + ** it is corrupted, then a process must of failed while writing it. + ** This indicates nothing more needs to be rolled back. + */ + rc = readJournalHdr(pPager, szJ, &nRec, &mxPg); + if( rc!=SQLITE_OK ){ if( rc==SQLITE_DONE ){ rc = SQLITE_OK; } - break; + goto end_playback; } - } - /* 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 nRec is 0xffffffff, then this journal was created by a process + ** working in no-sync mode. This means that the rest of the journal + ** file consists of pages, there are no more journal headers. Compute + ** the value of nRec based on this assumption. + */ + if( nRec==0xffffffff ){ + assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ); + nRec = (szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager); + } + + /* If this is the first header read from the journal, truncate the + ** database file back to it's original size. + */ + if( pPager->state>=PAGER_EXCLUSIVE && + pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){ + assert( pPager->origDbSize==0 || pPager->origDbSize==mxPg ); + rc = pager_truncate(pPager, mxPg); + if( rc!=SQLITE_OK ){ + goto end_playback; } - 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); + pPager->dbSize = mxPg; + } + + /* Copy original pages out of the journal and back into the database file. + */ + for(i=0; ijfd, 1); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + pPager->journalOff = szJ; + break; + }else{ + goto end_playback; + } } - pPg->needSync = 0; - pPg->dirty = 0; } } + /*NOTREACHED*/ + assert( 0 ); end_playback: - if( rc!=SQLITE_OK ){ - pager_unwritelock(pPager); - pPager->errMask |= PAGER_ERR_CORRUPT; - rc = SQLITE_CORRUPT; - }else{ + if( rc==SQLITE_OK ){ rc = pager_unwritelock(pPager); } + if( zMaster ){ + /* If there was a master journal and this routine will return true, + ** see if it is possible to delete the master journal. + */ + if( rc==SQLITE_OK ){ + rc = pager_delmaster(zMaster); + } + sqliteFree(zMaster); + } + + /* The Pager.sectorSize variable may have been updated while rolling + ** back a journal created by a process with a different PAGER_SECTOR_SIZE + ** value. Reset it to the correct value for this process. + */ + pPager->sectorSize = PAGER_SECTOR_SIZE; return rc; } /* -** Playback the checkpoint journal. +** Playback the statement 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 +** the statement is stored in pPager->stmtSize, not in the ** journal file itself. ** -** (2) In addition to playing back the checkpoint journal, also +** (2) In addition to playing back the statement journal, also ** playback all pages of the transaction journal beginning -** at offset pPager->ckptJSize. +** at offset pPager->stmtJSize. */ -static int pager_ckpt_playback(Pager *pPager){ - off_t szJ; /* Size of the full journal */ +static int pager_stmt_playback(Pager *pPager){ + i64 szJ; /* Size of the full journal */ + i64 hdrOff; int nRec; /* Number of Records */ int i; /* Loop counter */ int rc; + szJ = pPager->journalOff; +#ifndef NDEBUG + { + i64 os_szJ; + rc = sqlite3OsFileSize(pPager->jfd, &os_szJ); + if( rc!=SQLITE_OK ) return rc; + assert( szJ==os_szJ ); + } +#endif + + /* Set hdrOff to be the offset to the first journal header written + ** this statement transaction, or the end of the file if no journal + ** header was written. + */ + hdrOff = pPager->stmtHdrOff; + assert( pPager->fullSync || !hdrOff ); + if( !hdrOff ){ + hdrOff = szJ; + } + /* Truncate the database back to its original size. */ - rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)pPager->ckptSize); - pPager->dbSize = pPager->ckptSize; + if( pPager->state>=PAGER_EXCLUSIVE ){ + rc = pager_truncate(pPager, pPager->stmtSize); + } + pPager->dbSize = pPager->stmtSize; - /* Figure out how many records are in the checkpoint journal. + /* Figure out how many records are in the statement journal. */ - assert( pPager->ckptInUse && pPager->journalOpen ); - sqliteOsSeek(&pPager->cpfd, 0); - nRec = pPager->ckptNRec; + assert( pPager->stmtInUse && pPager->journalOpen ); + sqlite3OsSeek(pPager->stfd, 0); + nRec = pPager->stmtNRec; - /* 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. + /* Copy original pages out of the statement journal and back into the + ** database file. Note that the statement journal omits checksums from + ** each record since power-failure recovery is not important to statement + ** journals. */ for(i=nRec-1; i>=0; i--){ - rc = pager_playback_one_page(pPager, &pPager->cpfd, 2); + rc = pager_playback_one_page(pPager, pPager->stfd, 0); assert( rc!=SQLITE_DONE ); - if( rc!=SQLITE_OK ) goto end_ckpt_playback; + if( rc!=SQLITE_OK ) goto end_stmt_playback; } - /* Figure out how many pages need to be copied out of the transaction - ** journal. + /* Now roll some pages back from the transaction journal. Pager.stmtJSize + ** was the size of the journal file when this statement was started, so + ** everything after that needs to be rolled back, either into the + ** database, the memory cache, or both. + ** + ** If it is not zero, then Pager.stmtHdrOff is the offset to the start + ** of the first journal header written during this statement transaction. */ - rc = sqliteOsSeek(&pPager->jfd, pPager->ckptJSize); + rc = sqlite3OsSeek(pPager->jfd, pPager->stmtJSize); if( rc!=SQLITE_OK ){ - goto end_ckpt_playback; + goto end_stmt_playback; } - rc = sqliteOsFileSize(&pPager->jfd, &szJ); - if( rc!=SQLITE_OK ){ - goto end_ckpt_playback; + pPager->journalOff = pPager->stmtJSize; + pPager->cksumInit = pPager->stmtCksum; + assert( JOURNAL_HDR_SZ(pPager)<(pPager->pageSize+8) ); + while( pPager->journalOff <= (hdrOff-(pPager->pageSize+8)) ){ + rc = pager_playback_one_page(pPager, pPager->jfd, 1); + assert( rc!=SQLITE_DONE ); + if( rc!=SQLITE_OK ) goto end_stmt_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); + + while( pPager->journalOff < szJ ){ + u32 nJRec; /* Number of Journal Records */ + u32 dummy; + rc = readJournalHdr(pPager, szJ, &nJRec, &dummy); if( rc!=SQLITE_OK ){ assert( rc!=SQLITE_DONE ); - goto end_ckpt_playback; + goto end_stmt_playback; + } + if( nJRec==0 ){ + nJRec = (szJ - pPager->journalOff) / (pPager->pageSize+8); + } + for(i=nJRec-1; i>=0 && pPager->journalOff < szJ; i--){ + rc = pager_playback_one_page(pPager, pPager->jfd, 1); + assert( rc!=SQLITE_DONE ); + if( rc!=SQLITE_OK ) goto end_stmt_playback; } } + + pPager->journalOff = szJ; -end_ckpt_playback: - if( rc!=SQLITE_OK ){ - pPager->errMask |= PAGER_ERR_CORRUPT; - rc = SQLITE_CORRUPT; +end_stmt_playback: + if( rc==SQLITE_OK) { + pPager->journalOff = szJ; + /* pager_reload_cache(pPager); */ } 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; - } +void sqlite3pager_set_cachesize(Pager *pPager, int mxPage){ if( mxPage>10 ){ pPager->mxPage = mxPage; + }else{ + pPager->mxPage = 10; } } @@ -856,7 +1472,7 @@ void sqlitepager_set_cachesize(Pager *pPager, int mxPage){ ** 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 +** OFF sqlite3OsSync() is never called. This is the default ** for temporary and transient files. ** ** NORMAL The journal is synced once before writes begin on the @@ -877,152 +1493,314 @@ void sqlitepager_set_cachesize(Pager *pPager, int mxPage){ ** Numeric values associated with these states are OFF==1, NORMAL=2, ** and FULL=3. */ -void sqlitepager_set_safety_level(Pager *pPager, int level){ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +void sqlite3pager_set_safety_level(Pager *pPager, int level, int full_fsync){ pPager->noSync = level==1 || pPager->tempFile; pPager->fullSync = level==3 && !pPager->tempFile; - if( pPager->noSync==0 ) pPager->needSync = 0; + pPager->full_fsync = full_fsync; + if( pPager->noSync ) pPager->needSync = 0; } +#endif /* -** Open a temporary file. Write the name of the file into zName -** (zName must be at least SQLITE_TEMPNAME_SIZE bytes long.) Write +** The following global variable is incremented whenever the library +** attempts to open a temporary file. This information is used for +** testing and analysis only. +*/ +int sqlite3_opentemp_count = 0; + +/* +** Open a temporary file. Write the name of the file into zFile +** (zFile 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){ +static int sqlite3pager_opentemp(char *zFile, OsFile **pFd){ int cnt = 8; int rc; + sqlite3_opentemp_count++; /* Used for testing and analysis only */ do{ cnt--; - sqliteOsTempFileName(zFile); - rc = sqliteOsOpenExclusive(zFile, fd, 1); - }while( cnt>0 && rc!=SQLITE_OK ); + sqlite3OsTempFileName(zFile); + rc = sqlite3OsOpenExclusive(zFile, pFd, 1); + }while( cnt>0 && rc!=SQLITE_OK && rc!=SQLITE_NOMEM ); 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(). +** the first call to sqlite3pager_get() and is only held open until the +** last page is released using sqlite3pager_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. +** +** If zFilename is ":memory:" then all information is held in cache. +** It is never written to disk. This can be used to implement an +** in-memory database. */ -int sqlitepager_open( +int sqlite3pager_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 */ + int flags /* flags controlling this file */ ){ - Pager *pPager; - char *zFullPathname; - int nameLen; - OsFile fd; - int rc, i; - int tempFile; + Pager *pPager = 0; + char *zFullPathname = 0; + int nameLen; /* Compiler is wrong. This is always initialized before use */ + OsFile *fd; + int rc = SQLITE_OK; + int i; + int tempFile = 0; + int memDb = 0; int readOnly = 0; + int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; + int noReadlock = (flags & PAGER_NO_READLOCK)!=0; char zTemp[SQLITE_TEMPNAME_SIZE]; +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + /* A malloc() cannot fail in sqlite3ThreadData() as one or more calls to + ** malloc() must have already been made by this thread before it gets + ** to this point. This means the ThreadData must have been allocated already + ** so that ThreadData.nAlloc can be set. It would be nice to assert + ** that ThreadData.nAlloc is non-zero, but alas this breaks test cases + ** written to invoke the pager directly. + */ + ThreadData *pTsd = sqlite3ThreadData(); + assert( pTsd ); +#endif + /* If malloc() has already failed return SQLITE_NOMEM. Before even + ** testing for this, set *ppPager to NULL so the caller knows the pager + ** structure was never allocated. + */ *ppPager = 0; - if( sqlite_malloc_failed ){ + if( sqlite3MallocFailed() ){ return SQLITE_NOMEM; } + memset(&fd, 0, sizeof(fd)); + + /* Open the pager file and set zFullPathname to point at malloc()ed + ** memory containing the complete filename (i.e. including the directory). + */ if( zFilename && zFilename[0] ){ - zFullPathname = sqliteOsFullPathname(zFilename); - rc = sqliteOsOpenReadWrite(zFullPathname, &fd, &readOnly); - tempFile = 0; +#ifndef SQLITE_OMIT_MEMORYDB + if( strcmp(zFilename,":memory:")==0 ){ + memDb = 1; + zFullPathname = sqliteStrDup(""); + }else +#endif + { + zFullPathname = sqlite3OsFullPathname(zFilename); + if( zFullPathname ){ + rc = sqlite3OsOpenReadWrite(zFullPathname, &fd, &readOnly); + } + } }else{ - rc = sqlitepager_opentemp(zTemp, &fd); + rc = sqlite3pager_opentemp(zTemp, &fd); zFilename = zTemp; - zFullPathname = sqliteOsFullPathname(zFilename); - tempFile = 1; + zFullPathname = sqlite3OsFullPathname(zFilename); + if( rc==SQLITE_OK ){ + tempFile = 1; + } } - if( sqlite_malloc_failed ){ - return SQLITE_NOMEM; + + /* Allocate the Pager structure. As part of the same allocation, allocate + ** space for the full paths of the file, directory and journal + ** (Pager.zFilename, Pager.zDirectory and Pager.zJournal). + */ + if( zFullPathname ){ + nameLen = strlen(zFullPathname); + pPager = sqliteMalloc( sizeof(*pPager) + nameLen*3 + 30 ); } - if( rc!=SQLITE_OK ){ + + /* If an error occured in either of the blocks above, free the memory + ** pointed to by zFullPathname, free the Pager structure and close the + ** file. Since the pager is not allocated there is no need to set + ** any Pager.errMask variables. + */ + if( !pPager || !zFullPathname || rc!=SQLITE_OK ){ + sqlite3OsClose(&fd); sqliteFree(zFullPathname); - return SQLITE_CANTOPEN; + sqliteFree(pPager); + return ((rc==SQLITE_OK)?SQLITE_NOMEM:rc); } - nameLen = strlen(zFullPathname); - pPager = sqliteMalloc( sizeof(*pPager) + nameLen*3 + 30 ); - if( pPager==0 ){ - sqliteOsClose(&fd); - sqliteFree(zFullPathname); - return SQLITE_NOMEM; - } - SET_PAGER(pPager); + + TRACE3("OPEN %d %s\n", FILEHANDLEID(fd), zFullPathname); 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->journalOpen = 0; */ + pPager->useJournal = useJournal && !memDb; + pPager->noReadlock = noReadlock && readOnly; + /* pPager->stmtOpen = 0; */ + /* pPager->stmtInUse = 0; */ + /* pPager->nRef = 0; */ + pPager->dbSize = memDb-1; + pPager->pageSize = SQLITE_DEFAULT_PAGE_SIZE; + /* pPager->stmtSize = 0; */ + /* pPager->stmtJSize = 0; */ + /* pPager->nPage = 0; */ + /* pPager->nMaxPage = 0; */ + pPager->mxPage = 100; + assert( PAGER_UNLOCK==0 ); + /* pPager->state = PAGER_UNLOCK; */ + /* pPager->errMask = 0; */ pPager->tempFile = tempFile; + pPager->memDb = memDb; pPager->readOnly = readOnly; - pPager->needSync = 0; + /* 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)); + pPager->fullSync = (pPager->noSync?0:1); + /* pPager->pFirst = 0; */ + /* pPager->pFirstSynced = 0; */ + /* pPager->pLast = 0; */ + pPager->nExtra = FORCE_ALIGNMENT(nExtra); + pPager->sectorSize = PAGER_SECTOR_SIZE; + /* pPager->pBusyHandler = 0; */ + /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */ *ppPager = pPager; +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + pPager->pNext = pTsd->pPager; + pTsd->pPager = pPager; +#endif return SQLITE_OK; } +/* +** Set the busy handler function. +*/ +void sqlite3pager_set_busyhandler(Pager *pPager, BusyHandler *pBusyHandler){ + pPager->pBusyHandler = pBusyHandler; +} + /* ** 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(). +** The destructor is not called as a result sqlite3pager_close(). +** Destructors are only called by sqlite3pager_unref(). */ -void sqlitepager_set_destructor(Pager *pPager, void (*xDesc)(void*)){ +void sqlite3pager_set_destructor(Pager *pPager, void (*xDesc)(void*,int)){ pPager->xDestructor = xDesc; } /* -** Return the total number of pages in the disk file associated with -** pPager. +** Set the reinitializer for this pager. If not NULL, the reinitializer +** is called when the content of a page in cache is restored to its original +** value as a result of a rollback. The callback gives higher-level code +** an opportunity to restore the EXTRA section to agree with the restored +** page data. */ -int sqlitepager_pagecount(Pager *pPager){ - off_t n; +void sqlite3pager_set_reiniter(Pager *pPager, void (*xReinit)(void*,int)){ + pPager->xReiniter = xReinit; +} + +/* +** Set the page size. Return the new size. If the suggest new page +** size is inappropriate, then an alternative page size is selected +** and returned. +*/ +int sqlite3pager_set_pagesize(Pager *pPager, int pageSize){ + assert( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE ); + if( !pPager->memDb ){ + pPager->pageSize = pageSize; + } + return pPager->pageSize; +} + +/* +** The following set of routines are used to disable the simulated +** I/O error mechanism. These routines are used to avoid simulated +** errors in places where we do not care about errors. +** +** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops +** and generate no code. +*/ +#ifdef SQLITE_TEST +extern int sqlite3_io_error_pending; +extern int sqlite3_io_error_hit; +static int saved_cnt; +void clear_simulated_io_error(){ + sqlite3_io_error_hit = 0; +} +void disable_simulated_io_errors(void){ + saved_cnt = sqlite3_io_error_pending; + sqlite3_io_error_pending = -1; +} +void enable_simulated_io_errors(void){ + sqlite3_io_error_pending = saved_cnt; +} +#else +# define clear_simulated_io_error() +# define disable_simulated_io_errors() +# define enable_simulated_io_errors() +#endif + +/* +** Read the first N bytes from the beginning of the file into memory +** that pDest points to. +** +** No error checking is done. The rational for this is that this function +** may be called even if the file does not exist or contain a header. In +** these cases sqlite3OsRead() will return an error, to which the correct +** response is to zero the memory at pDest and continue. A real IO error +** will presumably recur and be picked up later (Todo: Think about this). +*/ +void sqlite3pager_read_fileheader(Pager *pPager, int N, unsigned char *pDest){ + memset(pDest, 0, N); + if( MEMDB==0 ){ + disable_simulated_io_errors(); + sqlite3OsSeek(pPager->fd, 0); + sqlite3OsRead(pPager->fd, pDest, N); + enable_simulated_io_errors(); + } +} + +/* +** Return the total number of pages in the disk file associated with +** pPager. +** +** If the PENDING_BYTE lies on the page directly after the end of the +** file, then consider this page part of the file too. For example, if +** PENDING_BYTE is byte 4096 (the first byte of page 5) and the size of the +** file is 4096 bytes, 5 is returned instead of 4. +*/ +int sqlite3pager_pagecount(Pager *pPager){ + i64 n; assert( pPager!=0 ); if( pPager->dbSize>=0 ){ - return pPager->dbSize; + n = pPager->dbSize; + } else { + if( sqlite3OsFileSize(pPager->fd, &n)!=SQLITE_OK ){ + pager_error(pPager, SQLITE_IOERR); + return 0; + } + if( n>0 && npageSize ){ + n = 1; + }else{ + n /= pPager->pageSize; + } + if( pPager->state!=PAGER_UNLOCK ){ + pPager->dbSize = n; + } } - 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; + if( n==(PENDING_BYTE/pPager->pageSize) ){ + n++; } return n; } @@ -1031,24 +1809,157 @@ int sqlitepager_pagecount(Pager *pPager){ ** Forward declaration */ static int syncJournal(Pager*); +static void clearHistory(PgHistory*); + + +/* +** Unlink pPg from it's hash chain. Also set the page number to 0 to indicate +** that the page is not part of any hash chain. This is required because the +** sqlite3pager_movepage() routine can leave a page in the +** pNextFree/pPrevFree list that is not a part of any hash-chain. +*/ +static void unlinkHashChain(Pager *pPager, PgHdr *pPg){ + if( pPg->pgno==0 ){ + /* If the page number is zero, then this page is not in any hash chain. */ + return; + } + if( pPg->pNextHash ){ + pPg->pNextHash->pPrevHash = pPg->pPrevHash; + } + if( pPg->pPrevHash ){ + assert( pPager->aHash[pager_hash(pPg->pgno)]!=pPg ); + pPg->pPrevHash->pNextHash = pPg->pNextHash; + }else{ + int h = pager_hash(pPg->pgno); + assert( pPager->aHash[h]==pPg ); + pPager->aHash[h] = pPg->pNextHash; + } + if( MEMDB ){ + clearHistory(PGHDR_TO_HIST(pPg, pPager)); + } + pPg->pgno = 0; + pPg->pNextHash = pPg->pPrevHash = 0; +} + +/* +** Unlink a page from the free list (the list of all pages where nRef==0) +** and from its hash collision chain. +*/ +static void unlinkPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + + /* Keep the pFirstSynced pointer pointing at the first synchronized page */ + if( pPg==pPager->pFirstSynced ){ + PgHdr *p = pPg->pNextFree; + while( p && p->needSync ){ p = p->pNextFree; } + pPager->pFirstSynced = p; + } + + /* Unlink from the freelist */ + 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; + + /* Unlink from the pgno hash table */ + unlinkHashChain(pPager, pPg); +} + +#ifndef SQLITE_OMIT_MEMORYDB +/* +** This routine is used to truncate an in-memory database. Delete +** all pages whose pgno is larger than pPager->dbSize and is unreferenced. +** Referenced pages larger than pPager->dbSize are zeroed. +*/ +static void memoryTruncate(Pager *pPager){ + PgHdr *pPg; + PgHdr **ppPg; + int dbSize = pPager->dbSize; + + ppPg = &pPager->pAll; + while( (pPg = *ppPg)!=0 ){ + if( pPg->pgno<=dbSize ){ + ppPg = &pPg->pNextAll; + }else if( pPg->nRef>0 ){ + memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize); + ppPg = &pPg->pNextAll; + }else{ + *ppPg = pPg->pNextAll; + unlinkPage(pPg); + sqliteFree(pPg); + pPager->nPage--; + } + } +} +#else +#define memoryTruncate(p) +#endif + +/* +** Try to obtain a lock on a file. Invoke the busy callback if the lock +** is currently not available. Repeat until the busy callback returns +** false or until the lock succeeds. +** +** Return SQLITE_OK on success and an error code if we cannot obtain +** the lock. +*/ +static int pager_wait_on_lock(Pager *pPager, int locktype){ + int rc; + assert( PAGER_SHARED==SHARED_LOCK ); + assert( PAGER_RESERVED==RESERVED_LOCK ); + assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK ); + if( pPager->state>=locktype ){ + rc = SQLITE_OK; + }else{ + do { + rc = sqlite3OsLock(pPager->fd, locktype); + }while( rc==SQLITE_BUSY && sqlite3InvokeBusyHandler(pPager->pBusyHandler) ); + if( rc==SQLITE_OK ){ + pPager->state = locktype; + } + } + return rc; +} /* ** Truncate the file to the number of pages specified. */ -int sqlitepager_truncate(Pager *pPager, Pgno nPage){ +int sqlite3pager_truncate(Pager *pPager, Pgno nPage){ int rc; - if( pPager->dbSize<0 ){ - sqlitepager_pagecount(pPager); - } - if( pPager->errMask!=0 ){ - rc = pager_errcode(pPager); + sqlite3pager_pagecount(pPager); + if( pPager->errCode ){ + rc = pPager->errCode; return rc; } if( nPage>=(unsigned)pPager->dbSize ){ return SQLITE_OK; } - syncJournal(pPager); - rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)nPage); + if( MEMDB ){ + pPager->dbSize = nPage; + memoryTruncate(pPager); + return SQLITE_OK; + } + rc = syncJournal(pPager); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Get an exclusive lock on the database before truncating. */ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + return rc; + } + + rc = pager_truncate(pPager, nPage); if( rc==SQLITE_OK ){ pPager->dbSize = nPage; } @@ -1063,18 +1974,46 @@ int sqlitepager_truncate(Pager *pPager, Pgno nPage){ ** and their memory is freed. Any attempt to use a page associated ** with this page cache after this function returns will likely ** result in a coredump. +** +** This function always succeeds. If a transaction is active an attempt +** is made to roll it back. If an error occurs during the rollback +** a hot journal may be left in the filesystem but no error is returned +** to the caller. */ -int sqlitepager_close(Pager *pPager){ +int sqlite3pager_close(Pager *pPager){ PgHdr *pPg, *pNext; +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + /* A malloc() cannot fail in sqlite3ThreadData() as one or more calls to + ** malloc() must have already been made by this thread before it gets + ** to this point. This means the ThreadData must have been allocated already + ** so that ThreadData.nAlloc can be set. + */ + ThreadData *pTsd = sqlite3ThreadData(); + assert( pPager ); + assert( pTsd && pTsd->nAlloc ); +#endif + switch( pPager->state ){ - case SQLITE_WRITELOCK: { - sqlitepager_rollback(pPager); - sqliteOsUnlock(&pPager->fd); - assert( pPager->journalOpen==0 ); + case PAGER_RESERVED: + case PAGER_SYNCED: + case PAGER_EXCLUSIVE: { + /* We ignore any IO errors that occur during the rollback + ** operation. So disable IO error simulation so that testing + ** works more easily. + */ + disable_simulated_io_errors(); + sqlite3pager_rollback(pPager); + enable_simulated_io_errors(); + if( !MEMDB ){ + sqlite3OsUnlock(pPager->fd, NO_LOCK); + } + assert( pPager->errCode || pPager->journalOpen==0 ); break; } - case SQLITE_READLOCK: { - sqliteOsUnlock(&pPager->fd); + case PAGER_SHARED: { + if( !MEMDB ){ + sqlite3OsUnlock(pPager->fd, NO_LOCK); + } break; } default: { @@ -1083,23 +2022,46 @@ int sqlitepager_close(Pager *pPager){ } } for(pPg=pPager->pAll; pPg; pPg=pNext){ +#ifndef NDEBUG + if( MEMDB ){ + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + assert( !pPg->alwaysRollback ); + assert( !pHist->pOrig ); + assert( !pHist->pStmt ); + } +#endif pNext = pPg->pNextAll; sqliteFree(pPg); } - sqliteOsClose(&pPager->fd); - assert( pPager->journalOpen==0 ); + TRACE2("CLOSE %d\n", PAGERID(pPager)); + assert( pPager->errCode || (pPager->journalOpen==0 && pPager->stmtOpen==0) ); + if( pPager->journalOpen ){ + sqlite3OsClose(&pPager->jfd); + } + sqliteFree(pPager->aInJournal); + if( pPager->stmtOpen ){ + sqlite3OsClose(&pPager->stfd); + } + sqlite3OsClose(&pPager->fd); /* Temp files are automatically deleted by the OS ** if( pPager->tempFile ){ - ** sqliteOsDelete(pPager->zFilename); + ** sqlite3OsDelete(pPager->zFilename); ** } */ - CLR_PAGER(pPager); - if( pPager->zFilename!=(char*)&pPager[1] ){ - assert( 0 ); /* Cannot happen */ - sqliteFree(pPager->zFilename); - sqliteFree(pPager->zJournal); - sqliteFree(pPager->zDirectory); + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + /* Remove the pager from the linked list of pagers starting at + ** ThreadData.pPager if memory-management is enabled. + */ + if( pPager==pTsd->pPager ){ + pTsd->pPager = pPager->pNext; + }else{ + Pager *pTmp; + for(pTmp = pTsd->pPager; pTmp->pNext!=pPager; pTmp=pTmp->pNext){} + pTmp->pNext = pPager->pNext; } +#endif + sqliteFree(pPager); return SQLITE_OK; } @@ -1107,17 +2069,20 @@ int sqlitepager_close(Pager *pPager){ /* ** Return the page number for the given page data. */ -Pgno sqlitepager_pagenumber(void *pData){ +Pgno sqlite3pager_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 +** The page_ref() function increments 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. +** +** For non-test systems, page_ref() is a macro that calls _page_ref() +** online of the reference count is zero. For test systems, page_ref() +** is a real function so that we can set breakpoints and trace it. */ -#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. */ @@ -1141,12 +2106,24 @@ static void _page_ref(PgHdr *pPg){ pPg->nRef++; REFINFO(pPg); } +#ifdef SQLITE_DEBUG + static void page_ref(PgHdr *pPg){ + if( pPg->nRef==0 ){ + _page_ref(pPg); + }else{ + pPg->nRef++; + REFINFO(pPg); + } + } +#else +# define page_ref(P) ((P)->nRef==0?_page_ref(P):(void)(P)->nRef++) +#endif /* ** Increment the reference count for a page. The input pointer is ** a reference to the page data. */ -int sqlitepager_ref(void *pData){ +int sqlite3pager_ref(void *pData){ PgHdr *pPg = DATA_TO_PGHDR(pData); page_ref(pPg); return SQLITE_OK; @@ -1189,31 +2166,34 @@ static int syncJournal(Pager *pPager){ /* 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); + i64 jSz; + rc = sqlite3OsFileSize(pPager->jfd, &jSz); if( rc!=0 ) return rc; - assert( pPager->nRec*pgSz+hdrSz==jSz ); + assert( pPager->journalOff==jSz ); } #endif - if( journal_format>=3 ){ - /* Write the nRec value into the journal file header */ - off_t szJ; + { + /* Write the nRec value into the journal file header. If in + ** full-synchronous mode, sync the journal first. This ensures that + ** all data has really hit the disk before nRec is updated to mark + ** it as a candidate for rollback. + */ if( pPager->fullSync ){ - TRACE1("SYNC\n"); - rc = sqliteOsSync(&pPager->jfd); + TRACE2("SYNC journal of %d\n", PAGERID(pPager)); + rc = sqlite3OsSync(pPager->jfd, 0); if( rc!=0 ) return rc; } - sqliteOsSeek(&pPager->jfd, sizeof(aJournalMagic1)); - rc = write32bits(&pPager->jfd, pPager->nRec); + rc = sqlite3OsSeek(pPager->jfd, + pPager->journalHdr + sizeof(aJournalMagic)); + if( rc ) return rc; + rc = write32bits(pPager->jfd, pPager->nRec); + if( rc ) return rc; + + rc = sqlite3OsSeek(pPager->jfd, pPager->journalOff); 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); + TRACE2("SYNC journal of %d\n", PAGERID(pPager)); + rc = sqlite3OsSync(pPager->jfd, pPager->full_fsync); if( rc!=0 ) return rc; pPager->journalStarted = 1; } @@ -1254,15 +2234,53 @@ static int pager_write_pagelist(PgHdr *pList){ if( pList==0 ) return SQLITE_OK; pPager = pList->pPager; + + /* At this point there may be either a RESERVED or EXCLUSIVE lock on the + ** database file. If there is already an EXCLUSIVE lock, the following + ** calls to sqlite3OsLock() are no-ops. + ** + ** Moving the lock from RESERVED to EXCLUSIVE actually involves going + ** through an intermediate state PENDING. A PENDING lock prevents new + ** readers from attaching to the database but is unsufficient for us to + ** write. The idea of a PENDING lock is to prevent new readers from + ** coming in while we wait for existing readers to clear. + ** + ** While the pager is in the RESERVED state, the original database file + ** is unchanged and we can rollback without having to playback the + ** journal into the original database file. Once we transition to + ** EXCLUSIVE, it means the database file has been changed and any rollback + ** will require a journal playback. + */ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + return rc; + } + 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); + rc = sqlite3OsSeek(pPager->fd, (pList->pgno-1)*(i64)pPager->pageSize); + if( rc ) return rc; + /* If there are dirty pages in the page cache with page numbers greater + ** than Pager.dbSize, this means sqlite3pager_truncate() was called to + ** make the file smaller (presumably by auto-vacuum code). Do not write + ** any such pages to the file. + */ + if( pList->pgno<=pPager->dbSize ){ + char *pData = CODEC2(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6); + TRACE3("STORE %d page %d\n", PAGERID(pPager), pList->pgno); + rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize); + TEST_INCR(pPager->nWrite); + } +#ifndef NDEBUG + else{ + TRACE3("NOSTORE %d page %d\n", PAGERID(pPager), pList->pgno); + } +#endif if( rc ) return rc; pList->dirty = 0; +#ifdef SQLITE_CHECK_PAGES + pList->pageHash = pager_pagehash(pList); +#endif pList = pList->pDirty; } return SQLITE_OK; @@ -1285,6 +2303,190 @@ static PgHdr *pager_get_all_dirty_pages(Pager *pPager){ return pList; } +/* +** Return TRUE if there is a hot journal on the given pager. +** A hot journal is one that needs to be played back. +** +** If the current size of the database file is 0 but a journal file +** exists, that is probably an old journal left over from a prior +** database with the same name. Just delete the journal. +*/ +static int hasHotJournal(Pager *pPager){ + if( !pPager->useJournal ) return 0; + if( !sqlite3OsFileExists(pPager->zJournal) ) return 0; + if( sqlite3OsCheckReservedLock(pPager->fd) ) return 0; + if( sqlite3pager_pagecount(pPager)==0 ){ + sqlite3OsDelete(pPager->zJournal); + return 0; + }else{ + return 1; + } +} + +/* +** Try to find a page in the cache that can be recycled. +** +** This routine may return SQLITE_IOERR, SQLITE_FULL or SQLITE_OK. It +** does not set the pPager->errCode variable. +*/ +static int pager_recycle(Pager *pPager, int syncOk, PgHdr **ppPg){ + PgHdr *pPg; + *ppPg = 0; + + /* 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 && pPager->pFirst && syncOk && !MEMDB){ + int rc = syncJournal(pPager); + if( rc!=0 ){ + return rc; + } + if( pPager->fullSync ){ + /* If in full-sync mode, write a new journal header into the + ** journal file. This is done to avoid ever modifying a journal + ** header that is involved in the rollback of pages that have + ** already been written to the database (in case the header is + ** trashed when the nRec field is updated). + */ + pPager->nRec = 0; + assert( pPager->journalOff > 0 ); + rc = writeJournalHdr(pPager); + if( rc!=0 ){ + return rc; + } + } + pPg = pPager->pFirst; + } + if( pPg==0 ){ + return SQLITE_OK; + } + + assert( pPg->nRef==0 ); + + /* Write the page to the database file if it is dirty. + */ + if( pPg->dirty ){ + int rc; + assert( pPg->needSync==0 ); + pPg->pDirty = 0; + rc = pager_write_pagelist( pPg ); + if( rc!=SQLITE_OK ){ + return rc; + } + } + 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 + */ + unlinkPage(pPg); + TEST_INCR(pPager->nOvfl); + + *ppPg = pPg; + return SQLITE_OK; +} + +/* +** This function is called to free superfluous dynamically allocated memory +** held by the pager system. Memory in use by any SQLite pager allocated +** by the current thread may be sqliteFree()ed. +** +** nReq is the number of bytes of memory required. Once this much has +** been released, the function returns. A negative value for nReq means +** free as much memory as possible. The return value is the total number +** of bytes of memory released. +*/ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT +int sqlite3pager_release_memory(int nReq){ + const ThreadData *pTsdro = sqlite3ThreadDataReadOnly(); + Pager *p; + int nReleased = 0; + int i; + + /* If the the global mutex is held, this subroutine becomes a + ** o-op; zero bytes of memory are freed. This is because + ** some of the code invoked by this function may also + ** try to obtain the mutex, resulting in a deadlock. + */ + if( sqlite3OsInMutex(0) ){ + return 0; + } + + /* Outermost loop runs for at most two iterations. First iteration we + ** try to find memory that can be released without calling fsync(). Second + ** iteration (which only runs if the first failed to free nReq bytes of + ** memory) is permitted to call fsync(). This is of course much more + ** expensive. + */ + for(i=0; i<=1; i++){ + + /* Loop through all the SQLite pagers opened by the current thread. */ + for(p=pTsdro->pPager; p && (nReq<0 || nReleasedpNext){ + PgHdr *pPg; + int rc; + + /* For each pager, try to free as many pages as possible (without + ** calling fsync() if this is the first iteration of the outermost + ** loop). + */ + while( SQLITE_OK==(rc = pager_recycle(p, i, &pPg)) && pPg) { + /* We've found a page to free. At this point the page has been + ** removed from the page hash-table, free-list and synced-list + ** (pFirstSynced). It is still in the all pages (pAll) list. + ** Remove it from this list before freeing. + ** + ** Todo: Check the Pager.pStmt list to make sure this is Ok. It + ** probably is though. + */ + PgHdr *pTmp; + assert( pPg ); + page_remove_from_stmt_list(pPg); + if( pPg==p->pAll ){ + p->pAll = pPg->pNextAll; + }else{ + for( pTmp=p->pAll; pTmp->pNextAll!=pPg; pTmp=pTmp->pNextAll ){} + pTmp->pNextAll = pPg->pNextAll; + } + nReleased += sqliteAllocSize(pPg); + sqliteFree(pPg); + } + + if( rc!=SQLITE_OK ){ + /* An error occured whilst writing to the database file or + ** journal in pager_recycle(). The error is not returned to the + ** caller of this function. Instead, set the Pager.errCode variable. + ** The error will be returned to the user (or users, in the case + ** of a shared pager cache) of the pager for which the error occured. + */ + assert( rc==SQLITE_IOERR || rc==SQLITE_FULL ); + assert( p->state>=PAGER_RESERVED ); + pager_error(p, rc); + } + } + } + + return nReleased; +} +#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */ + /* ** Acquire a page. ** @@ -1300,7 +2502,7 @@ static PgHdr *pager_get_all_dirty_pages(Pager *pPager){ ** 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 +** See also sqlite3pager_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 @@ -1308,45 +2510,58 @@ static PgHdr *pager_get_all_dirty_pages(Pager *pPager){ ** 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){ +int sqlite3pager_get(Pager *pPager, Pgno pgno, void **ppPage){ PgHdr *pPg; int rc; + /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page + ** number greater than this, or zero, is requested. + */ + if( pgno>PAGER_MAX_PGNO || pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){ + return SQLITE_CORRUPT_BKPT; + } + /* 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( pPager->errCode && pPager->errCode!=SQLITE_FULL ){ + return pPager->errCode; } - /* If this is the first page accessed, then get a read lock + /* If this is the first page accessed, then get a SHARED lock ** on the database file. */ - if( pPager->nRef==0 ){ - rc = sqliteOsReadLock(&pPager->fd); - if( rc!=SQLITE_OK ){ - return rc; + if( pPager->nRef==0 && !MEMDB ){ + if( !pPager->noReadlock ){ + rc = pager_wait_on_lock(pPager, SHARED_LOCK); + if( rc!=SQLITE_OK ){ + return pager_error(pPager, rc); + } } - pPager->state = SQLITE_READLOCK; - /* If a journal file exists, try to play it back. + /* If a journal file exists, and there is no RESERVED lock on the + ** database file, then it either needs to be played back or deleted. */ - if( pPager->useJournal && sqliteOsFileExists(pPager->zJournal) ){ - int rc; - - /* Get a write lock on the database + if( hasHotJournal(pPager) ){ + /* Get an EXCLUSIVE lock on the database file. At this point it is + ** important that a RESERVED lock is not obtained on the way to the + ** EXCLUSIVE lock. If it were, another process might open the + ** database file, detect the RESERVED lock, and conclude that the + ** database is safe to read while this process is still rolling it + ** back. + ** + ** Because the intermediate RESERVED lock is not requested, the + ** second process will get to this point in the code and fail to + ** obtain it's own EXCLUSIVE lock on the database file. */ - rc = sqliteOsWriteLock(&pPager->fd); + rc = sqlite3OsLock(pPager->fd, EXCLUSIVE_LOCK); if( rc!=SQLITE_OK ){ - if( sqliteOsUnlock(&pPager->fd)!=SQLITE_OK ){ - /* This should never happen! */ - rc = SQLITE_INTERNAL; - } - return rc; + sqlite3OsUnlock(pPager->fd, NO_LOCK); + pPager->state = PAGER_UNLOCK; + return pager_error(pPager, rc); } - pPager->state = SQLITE_WRITELOCK; + pPager->state = PAGER_EXCLUSIVE; /* Open the journal for reading only. Return SQLITE_BUSY if ** we are unable to open the journal file. @@ -1356,132 +2571,68 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){ ** 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); + rc = sqlite3OsOpenReadOnly(pPager->zJournal, &pPager->jfd); if( rc!=SQLITE_OK ){ - rc = sqliteOsUnlock(&pPager->fd); - assert( rc==SQLITE_OK ); + sqlite3OsUnlock(pPager->fd, NO_LOCK); + pPager->state = PAGER_UNLOCK; return SQLITE_BUSY; } pPager->journalOpen = 1; pPager->journalStarted = 0; + pPager->journalOff = 0; + pPager->setMaster = 0; + pPager->journalHdr = 0; /* Playback and delete the journal. Drop the database write ** lock and reacquire the read lock. */ - rc = pager_playback(pPager, 0); + rc = pager_playback(pPager); if( rc!=SQLITE_OK ){ - return rc; + return pager_error(pPager, rc); } } pPg = 0; }else{ /* Search for page in cache */ pPg = pager_lookup(pPager, pgno); + if( MEMDB && pPager->state==PAGER_UNLOCK ){ + pPager->state = PAGER_SHARED; + } } if( pPg==0 ){ /* The requested page is not in the page cache. */ int h; - pPager->nMiss++; - if( pPager->nPagemxPage || pPager->pFirst==0 ){ + TEST_INCR(pPager->nMiss); + if( pPager->nPagemxPage || pPager->pFirst==0 || MEMDB ){ /* Create a new page */ - pPg = sqliteMallocRaw( sizeof(*pPg) + SQLITE_PAGE_SIZE - + sizeof(u32) + pPager->nExtra ); + pPg = sqliteMallocRaw( sizeof(*pPg) + pPager->pageSize + + sizeof(u32) + pPager->nExtra + + MEMDB*sizeof(PgHistory) ); if( pPg==0 ){ - pager_unwritelock(pPager); - pPager->errMask |= PAGER_ERR_MEM; return SQLITE_NOMEM; } memset(pPg, 0, sizeof(*pPg)); + if( MEMDB ){ + memset(PGHDR_TO_HIST(pPg, pPager), 0, sizeof(PgHistory)); + } pPg->pPager = pPager; pPg->pNextAll = pPager->pAll; - if( pPager->pAll ){ - pPager->pAll->pPrevAll = pPg; - } - pPg->pPrevAll = 0; pPager->pAll = pPg; pPager->nPage++; + if( pPager->nPage>pPager->nMaxPage ){ + assert( pPager->nMaxPage==(pPager->nPage-1) ); + pPager->nMaxPage++; + } }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; + rc = pager_recycle(pPager, 1, &pPg); + if( rc!=SQLITE_OK ){ + return rc; } - 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++; + assert(pPg) ; } pPg->pgno = pgno; if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){ - sqliteCheckMemory(pPager->aInJournal, pgno/8); + sqlite3CheckMemory(pPager->aInJournal, pgno/8); assert( pPager->journalOpen ); pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0; pPg->needSync = 0; @@ -1489,16 +2640,59 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){ 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); + if( pPager->aInStmt && (int)pgno<=pPager->stmtSize + && (pPager->aInStmt[pgno/8] & (1<<(pgno&7)))!=0 ){ + page_add_to_stmt_list(pPg); }else{ - page_remove_from_ckpt_list(pPg); + page_remove_from_stmt_list(pPg); } pPg->dirty = 0; pPg->nRef = 1; REFINFO(pPg); + pPager->nRef++; + if( pPager->nExtra>0 ){ + memset(PGHDR_TO_EXTRA(pPg, pPager), 0, pPager->nExtra); + } + if( pPager->errCode ){ + sqlite3pager_unref(PGHDR_TO_DATA(pPg)); + rc = pPager->errCode; + return rc; + } + + /* Populate the page with data, either by reading from the database + ** file, or by setting the entire page to zero. + */ + if( sqlite3pager_pagecount(pPager)<(int)pgno || MEMDB ){ + memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize); + }else{ + assert( MEMDB==0 ); + rc = sqlite3OsSeek(pPager->fd, (pgno-1)*(i64)pPager->pageSize); + if( rc==SQLITE_OK ){ + rc = sqlite3OsRead(pPager->fd, PGHDR_TO_DATA(pPg), + pPager->pageSize); + } + TRACE3("FETCH %d page %d\n", PAGERID(pPager), pPg->pgno); + CODEC1(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3); + if( rc!=SQLITE_OK ){ + i64 fileSize; + int rc2 = sqlite3OsFileSize(pPager->fd, &fileSize); + if( rc2!=SQLITE_OK || fileSize>=pgno*pPager->pageSize ){ + /* An IO error occured in one of the the sqlite3OsSeek() or + ** sqlite3OsRead() calls above. */ + pPg->pgno = 0; + sqlite3pager_unref(PGHDR_TO_DATA(pPg)); + return rc; + }else{ + clear_simulated_io_error(); + memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize); + } + }else{ + TEST_INCR(pPager->nRead); + } + } + + /* Link the page into the page hash table */ h = pager_hash(pgno); pPg->pNextHash = pPager->aHash[h]; pPager->aHash[h] = pPg; @@ -1506,37 +2700,13 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){ 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); - } - } - } + +#ifdef SQLITE_CHECK_PAGES + pPg->pageHash = pager_pagehash(pPg); +#endif }else{ /* The requested page is in the page cache. */ - pPager->nHit++; + TEST_INCR(pPager->nHit); page_ref(pPg); } *ppPage = PGHDR_TO_DATA(pPg); @@ -1548,24 +2718,20 @@ int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){ ** 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 +** See also sqlite3pager_get(). The difference between this routine +** and sqlite3pager_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){ +void *sqlite3pager_lookup(Pager *pPager, Pgno pgno){ PgHdr *pPg; assert( pPager!=0 ); assert( pgno!=0 ); - if( pPager->errMask & ~(PAGER_ERR_FULL) ){ + if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){ return 0; } - /* if( pPager->nRef==0 ){ - ** return 0; - ** } - */ pPg = pager_lookup(pPager, pgno); if( pPg==0 ) return 0; page_ref(pPg); @@ -1580,7 +2746,7 @@ void *sqlitepager_lookup(Pager *pPager, Pgno pgno){ ** are released, a rollback occurs and the lock on the database is ** removed. */ -int sqlitepager_unref(void *pData){ +int sqlite3pager_unref(void *pData){ PgHdr *pPg; /* Decrement the reference count for this page @@ -1590,6 +2756,8 @@ int sqlitepager_unref(void *pData){ pPg->nRef--; REFINFO(pPg); + CHECK_PAGE(pPg); + /* When the number of references to a page reach 0, call the ** destructor and add the page to the freelist. */ @@ -1608,7 +2776,7 @@ int sqlitepager_unref(void *pData){ pPager->pFirstSynced = pPg; } if( pPager->xDestructor ){ - pPager->xDestructor(pData); + pPager->xDestructor(pData, pPager->pageSize); } /* When all pages reach the freelist, drop the read lock from @@ -1616,7 +2784,7 @@ int sqlitepager_unref(void *pData){ */ pPager->nRef--; assert( pPager->nRef>=0 ); - if( pPager->nRef==0 ){ + if( pPager->nRef==0 && !MEMDB ){ pager_reset(pPager); } } @@ -1624,110 +2792,131 @@ int sqlitepager_unref(void *pData){ } /* -** Create a journal file for pPager. There should already be a write -** lock on the database file when this routine is called. +** Create a journal file for pPager. There should already be a RESERVED +** or EXCLUSIVE 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( !MEMDB ); + assert( pPager->state>=PAGER_RESERVED ); assert( pPager->journalOpen==0 ); assert( pPager->useJournal ); - sqlitepager_pagecount(pPager); + assert( pPager->aInJournal==0 ); + sqlite3pager_pagecount(pPager); pPager->aInJournal = sqliteMalloc( pPager->dbSize/8 + 1 ); if( pPager->aInJournal==0 ){ - sqliteOsReadLock(&pPager->fd); - pPager->state = SQLITE_READLOCK; - return SQLITE_NOMEM; + rc = SQLITE_NOMEM; + goto failed_to_open_journal; } - rc = sqliteOsOpenExclusive(pPager->zJournal, &pPager->jfd,pPager->tempFile); + rc = sqlite3OsOpenExclusive(pPager->zJournal, &pPager->jfd, + pPager->tempFile); + pPager->journalOff = 0; + pPager->setMaster = 0; + pPager->journalHdr = 0; if( rc!=SQLITE_OK ){ - sqliteFree(pPager->aInJournal); - pPager->aInJournal = 0; - sqliteOsReadLock(&pPager->fd); - pPager->state = SQLITE_READLOCK; - return SQLITE_CANTOPEN; + goto failed_to_open_journal; } - sqliteOsOpenDirectory(pPager->zDirectory, &pPager->jfd); + sqlite3OsSetFullSync(pPager->jfd, pPager->full_fsync); + sqlite3OsSetFullSync(pPager->fd, pPager->full_fsync); + sqlite3OsOpenDirectory(pPager->jfd, pPager->zDirectory); 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; + if( pPager->errCode ){ + rc = pPager->errCode; + goto failed_to_open_journal; } 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)); + + rc = writeJournalHdr(pPager); + + if( pPager->stmtAutoopen && rc==SQLITE_OK ){ + rc = sqlite3pager_stmt_begin(pPager); } - 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 ){ + if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){ rc = pager_unwritelock(pPager); if( rc==SQLITE_OK ){ rc = SQLITE_FULL; } } - return rc; + return rc; + +failed_to_open_journal: + sqliteFree(pPager->aInJournal); + pPager->aInJournal = 0; + if( rc==SQLITE_NOMEM ){ + /* If this was a malloc() failure, then we will not be closing the pager + ** file. So delete any journal file we may have just created. Otherwise, + ** the system will get confused, we have a read-lock on the file and a + ** mysterious journal has appeared in the filesystem. + */ + sqlite3OsDelete(pPager->zJournal); + }else{ + sqlite3OsUnlock(pPager->fd, NO_LOCK); + pPager->state = PAGER_UNLOCK; + } + 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. +** * sqlite3pager_commit() is called. +** * sqlite3pager_rollback() is called. +** * sqlite3pager_close() is called. +** * sqlite3pager_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. +** The first 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. +** The second parameter indicates how much space in bytes to reserve for a +** master journal file-name at the start of the journal when it is created. ** -** If the database is already write-locked, this routine is a no-op. +** 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 reserved for writing, this routine is a no-op. +** +** If exFlag is true, go ahead and get an EXCLUSIVE lock on the file +** immediately instead of waiting until we try to flush the cache. The +** exFlag is ignored if a transaction is already active. */ -int sqlitepager_begin(void *pData){ +int sqlite3pager_begin(void *pData, int exFlag){ 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->state!=PAGER_UNLOCK ); + if( pPager->state==PAGER_SHARED ){ 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); + if( MEMDB ){ + pPager->state = PAGER_EXCLUSIVE; + pPager->origDbSize = pPager->dbSize; + }else{ + rc = sqlite3OsLock(pPager->fd, RESERVED_LOCK); + if( rc==SQLITE_OK ){ + pPager->state = PAGER_RESERVED; + if( exFlag ){ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + } + } + if( rc!=SQLITE_OK ){ + return rc; + } + pPager->dirtyCache = 0; + TRACE2("TRANSACTION %d\n", PAGERID(pPager)); + if( pPager->useJournal && !pPager->tempFile ){ + rc = pager_open_journal(pPager); + } } } return rc; @@ -1739,7 +2928,7 @@ int sqlitepager_begin(void *pData){ ** 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 +** journal and acquires a RESERVED lock on the database. If the RESERVED ** 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. @@ -1747,158 +2936,192 @@ int sqlitepager_begin(void *pData){ ** 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 +** is a call to sqlite3pager_commit() or sqlite3pager_rollback() to ** reset. */ -int sqlitepager_write(void *pData){ +int sqlite3pager_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->errCode ){ + return pPager->errCode; } if( pPager->readOnly ){ return SQLITE_PERM; } + assert( !pPager->setMaster ); + + CHECK_PAGE(pPg); + /* 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( pPg->inJournal && (pPg->inStmt || pPager->stmtInUse==0) ){ + pPager->dirtyCache = 1; + }else{ - /* 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 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!=PAGER_UNLOCK ); + rc = sqlite3pager_begin(pData, 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); + assert( pPager->state>=PAGER_RESERVED ); + if( !pPager->journalOpen && pPager->useJournal ){ + rc = pager_open_journal(pPager); + if( rc!=SQLITE_OK ) return rc; + } + assert( pPager->journalOpen || !pPager->useJournal ); + pPager->dirtyCache = 1; + + /* The transaction journal now exists and we have a RESERVED or an + ** EXCLUSIVE 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 || MEMDB) ){ + if( (int)pPg->pgno <= pPager->origDbSize ){ + int szPg; + if( MEMDB ){ + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + TRACE3("JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno); + assert( pHist->pOrig==0 ); + pHist->pOrig = sqliteMallocRaw( pPager->pageSize ); + if( pHist->pOrig ){ + memcpy(pHist->pOrig, PGHDR_TO_DATA(pPg), pPager->pageSize); + } + }else{ + u32 cksum, saved; + char *pData2, *pEnd; + /* We should never write to the journal file the page that + ** contains the database locks. The following assert verifies + ** that we do not. */ + assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) ); + pData2 = CODEC2(pPager, pData, pPg->pgno, 7); + cksum = pager_cksum(pPager, (u8*)pData2); + pEnd = pData2 + pPager->pageSize; + pData2 -= 4; + saved = *(u32*)pEnd; + put32bits(pEnd, cksum); + szPg = pPager->pageSize+8; + put32bits(pData2, pPg->pgno); + rc = sqlite3OsWrite(pPager->jfd, pData2, szPg); + pPager->journalOff += szPg; + TRACE4("JOURNAL %d page %d needSync=%d\n", + PAGERID(pPager), pPg->pgno, pPg->needSync); + *(u32*)pEnd = saved; + + /* An error has occured writing to the journal file. The + ** transaction will be rolled back by the layer above. + */ + if( rc!=SQLITE_OK ){ + return rc; + } + + pPager->nRec++; + assert( pPager->aInJournal!=0 ); + pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7); + pPg->needSync = !pPager->noSync; + if( pPager->stmtInUse ){ + pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + page_add_to_stmt_list(pPg); + } + } + }else{ + pPg->needSync = !pPager->journalStarted && !pPager->noSync; + TRACE4("APPEND %d page %d needSync=%d\n", + PAGERID(pPager), pPg->pgno, pPg->needSync); + } + if( pPg->needSync ){ + pPager->needSync = 1; + } + pPg->inJournal = 1; + } + + /* If the statement journal is open and the page is not in it, + ** then write the current page to the statement journal. Note that + ** the statement journal format differs from the standard journal format + ** in that it omits the checksums and the header. + */ + if( pPager->stmtInUse && !pPg->inStmt && (int)pPg->pgno<=pPager->stmtSize ){ + assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize ); + if( MEMDB ){ + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + assert( pHist->pStmt==0 ); + pHist->pStmt = sqliteMallocRaw( pPager->pageSize ); + if( pHist->pStmt ){ + memcpy(pHist->pStmt, PGHDR_TO_DATA(pPg), pPager->pageSize); + } + TRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno); + }else{ + char *pData2 = CODEC2(pPager, pData, pPg->pgno, 7)-4; + put32bits(pData2, pPg->pgno); + rc = sqlite3OsWrite(pPager->stfd, pData2, pPager->pageSize+4); + TRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno); + if( rc!=SQLITE_OK ){ + return rc; + } + pPager->stmtNRec++; + assert( pPager->aInStmt!=0 ); + pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + } + page_add_to_stmt_list(pPg); + } } /* Update the database size and return. */ if( pPager->dbSize<(int)pPg->pgno ){ pPager->dbSize = pPg->pgno; + if( !MEMDB && pPager->dbSize==PENDING_BYTE/pPager->pageSize ){ + pPager->dbSize++; + } } 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 sqlite3pager_write(). In other words, return TRUE if it is ok ** to change the content of the page. */ -int sqlitepager_iswriteable(void *pData){ +#ifndef NDEBUG +int sqlite3pager_iswriteable(void *pData){ PgHdr *pPg = DATA_TO_PGHDR(pData); return pPg->dirty; } +#endif +#ifndef SQLITE_OMIT_VACUUM /* ** Replace the content of a single page with the information in the third ** argument. */ -int sqlitepager_overwrite(Pager *pPager, Pgno pgno, void *pData){ +int sqlite3pager_overwrite(Pager *pPager, Pgno pgno, void *pData){ void *pPage; int rc; - rc = sqlitepager_get(pPager, pgno, &pPage); + rc = sqlite3pager_get(pPager, pgno, &pPage); if( rc==SQLITE_OK ){ - rc = sqlitepager_write(pPage); + rc = sqlite3pager_write(pPage); if( rc==SQLITE_OK ){ - memcpy(pPage, pData, SQLITE_PAGE_SIZE); + memcpy(pPage, pData, pPager->pageSize); } - sqlitepager_unref(pPage); + sqlite3pager_unref(pPage); } return rc; } +#endif /* ** A call to this routine tells the pager that it is not necessary to @@ -1910,11 +3133,11 @@ int sqlitepager_overwrite(Pager *pPager, Pgno pgno, void *pData){ ** 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 +** sqlite3pager_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 +** Subsequent calls to sqlite3pager_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 @@ -1924,12 +3147,15 @@ int sqlitepager_overwrite(Pager *pPager, Pgno pgno, void *pData){ ** 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){ +void sqlite3pager_dont_write(Pager *pPager, Pgno pgno){ PgHdr *pPg; + if( MEMDB ) return; + pPg = pager_lookup(pPager, pgno); + assert( pPg!=0 ); /* We never call _dont_write unless the page is in mem */ pPg->alwaysRollback = 1; - if( pPg && pPg->dirty ){ + if( pPg->dirty && !pPager->stmtInUse ){ 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. @@ -1940,8 +3166,11 @@ void sqlitepager_dont_write(Pager *pPager, Pgno pgno){ ** corruption during the next transaction. */ }else{ - TRACE2("DONT_WRITE %d\n", pgno); + TRACE3("DONT_WRITE page %d of %d\n", pgno, PAGERID(pPager)); pPg->dirty = 0; +#ifdef SQLITE_CHECK_PAGES + pPg->pageHash = pager_pagehash(pPg); +#endif } } } @@ -1952,30 +3181,45 @@ void sqlitepager_dont_write(Pager *pPager, Pgno pgno){ ** means that the pager does not have to record the given page in the ** rollback journal. */ -void sqlitepager_dont_rollback(void *pData){ +void sqlite3pager_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( pPager->state!=PAGER_EXCLUSIVE || pPager->journalOpen==0 ) return; + if( pPg->alwaysRollback || pPager->alwaysRollback || MEMDB ) 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); + if( pPager->stmtInUse ){ + pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + page_add_to_stmt_list(pPg); } - TRACE2("DONT_ROLLBACK %d\n", pPg->pgno); + TRACE3("DONT_ROLLBACK page %d of %d\n", pPg->pgno, PAGERID(pPager)); } - if( pPager->ckptInUse && !pPg->inCkpt && (int)pPg->pgno<=pPager->ckptSize ){ + if( pPager->stmtInUse && !pPg->inStmt && (int)pPg->pgno<=pPager->stmtSize ){ 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); + assert( pPager->aInStmt!=0 ); + pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + page_add_to_stmt_list(pPg); } } + +#ifndef SQLITE_OMIT_MEMORYDB +/* +** Clear a PgHistory block +*/ +static void clearHistory(PgHistory *pHist){ + sqliteFree(pHist->pOrig); + sqliteFree(pHist->pStmt); + pHist->pOrig = 0; + pHist->pStmt = 0; +} +#else +#define clearHistory(x) +#endif + /* ** Commit all changes to the database and release the write lock. ** @@ -1983,27 +3227,42 @@ void sqlitepager_dont_rollback(void *pData){ ** and an error code is returned. If the commit worked, SQLITE_OK ** is returned. */ -int sqlitepager_commit(Pager *pPager){ +int sqlite3pager_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->errCode ){ + return pPager->errCode; } - if( pPager->errMask!=0 ){ - rc = pager_errcode(pPager); - return rc; - } - if( pPager->state!=SQLITE_WRITELOCK ){ + if( pPager->statedirtyFile==0 ){ - /* Exit early (without doing the time-consuming sqliteOsSync() calls) + TRACE2("COMMIT %d\n", PAGERID(pPager)); + if( MEMDB ){ + pPg = pager_get_all_dirty_pages(pPager); + while( pPg ){ + clearHistory(PGHDR_TO_HIST(pPg, pPager)); + pPg->dirty = 0; + pPg->inJournal = 0; + pPg->inStmt = 0; + pPg->needSync = 0; + pPg->pPrevStmt = pPg->pNextStmt = 0; + pPg = pPg->pDirty; + } +#ifndef NDEBUG + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + assert( !pPg->alwaysRollback ); + assert( !pHist->pOrig ); + assert( !pHist->pStmt ); + } +#endif + pPager->pStmt = 0; + pPager->state = PAGER_SHARED; + return SQLITE_OK; + } + if( pPager->dirtyCache==0 ){ + /* Exit early (without doing the time-consuming sqlite3OsSync() calls) ** if there have been no changes to the database file. */ assert( pPager->needSync==0 ); rc = pager_unwritelock(pPager); @@ -2011,33 +3270,16 @@ int sqlitepager_commit(Pager *pPager){ 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); + rc = sqlite3pager_sync(pPager, 0, 0); if( rc==SQLITE_OK ){ - rc = SQLITE_FULL; + rc = pager_unwritelock(pPager); + pPager->dbSize = -1; } return rc; } /* -** Rollback all changes. The database falls back to read-only mode. +** Rollback all changes. The database falls back to PAGER_SHARED mode. ** All in-memory cache pages revert to their original data contents. ** The journal is deleted. ** @@ -2048,173 +3290,504 @@ commit_abort: ** codes are returned for all these occasions. Otherwise, ** SQLITE_OK is returned. */ -int sqlitepager_rollback(Pager *pPager){ +int sqlite3pager_rollback(Pager *pPager){ int rc; - TRACE1("ROLLBACK\n"); - if( !pPager->dirtyFile || !pPager->journalOpen ){ + TRACE2("ROLLBACK %d\n", PAGERID(pPager)); + if( MEMDB ){ + PgHdr *p; + for(p=pPager->pAll; p; p=p->pNextAll){ + PgHistory *pHist; + assert( !p->alwaysRollback ); + if( !p->dirty ){ + assert( !((PgHistory *)PGHDR_TO_HIST(p, pPager))->pOrig ); + assert( !((PgHistory *)PGHDR_TO_HIST(p, pPager))->pStmt ); + continue; + } + + pHist = PGHDR_TO_HIST(p, pPager); + if( pHist->pOrig ){ + memcpy(PGHDR_TO_DATA(p), pHist->pOrig, pPager->pageSize); + TRACE3("ROLLBACK-PAGE %d of %d\n", p->pgno, PAGERID(pPager)); + }else{ + TRACE3("PAGE %d is clean on %d\n", p->pgno, PAGERID(pPager)); + } + clearHistory(pHist); + p->dirty = 0; + p->inJournal = 0; + p->inStmt = 0; + p->pPrevStmt = p->pNextStmt = 0; + + if( pPager->xReiniter ){ + pPager->xReiniter(PGHDR_TO_DATA(p), pPager->pageSize); + } + + } + pPager->pStmt = 0; + pPager->dbSize = pPager->origDbSize; + memoryTruncate(pPager); + pPager->stmtInUse = 0; + pPager->state = PAGER_SHARED; + return SQLITE_OK; + } + + if( !pPager->dirtyCache || !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); + if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){ + if( pPager->state>=PAGER_EXCLUSIVE ){ + pager_playback(pPager); } - return pager_errcode(pPager); + return pPager->errCode; } - 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; + if( pPager->state==PAGER_RESERVED ){ + int rc2; + rc = pager_reload_cache(pPager); + rc2 = pager_unwritelock(pPager); + if( rc==SQLITE_OK ){ + rc = rc2; + } + }else{ + rc = pager_playback(pPager); } pPager->dbSize = -1; - return rc; + + /* If an error occurs during a ROLLBACK, we can no longer trust the pager + ** cache. So call pager_error() on the way out to make any error + ** persistent. + */ + return pager_error(pPager, rc); } /* ** Return TRUE if the database file is opened read-only. Return FALSE ** if the database is (in theory) writable. */ -int sqlitepager_isreadonly(Pager *pPager){ +int sqlite3pager_isreadonly(Pager *pPager){ return pPager->readOnly; } /* ** This routine is used for testing and analysis only. */ -int *sqlitepager_stats(Pager *pPager){ - static int a[9]; +int *sqlite3pager_stats(Pager *pPager){ + static int a[11]; 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[5] = pPager->errCode; +#ifdef SQLITE_TEST a[6] = pPager->nHit; a[7] = pPager->nMiss; a[8] = pPager->nOvfl; + a[9] = pPager->nRead; + a[10] = pPager->nWrite; +#endif return a; } /* -** Set the checkpoint. +** Set the statement rollback point. ** ** This routine should be called with the transaction journal already -** open. A new checkpoint journal is created that can be used to rollback +** open. A new statement 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 sqlite3pager_stmt_begin(Pager *pPager){ int rc; char zTemp[SQLITE_TEMPNAME_SIZE]; + assert( !pPager->stmtInUse ); + assert( pPager->dbSize>=0 ); + TRACE2("STMT-BEGIN %d\n", PAGERID(pPager)); + if( MEMDB ){ + pPager->stmtInUse = 1; + pPager->stmtSize = pPager->dbSize; + return SQLITE_OK; + } if( !pPager->journalOpen ){ - pPager->ckptAutoopen = 1; + pPager->stmtAutoopen = 1; return SQLITE_OK; } assert( pPager->journalOpen ); - assert( !pPager->ckptInUse ); - pPager->aInCkpt = sqliteMalloc( pPager->dbSize/8 + 1 ); - if( pPager->aInCkpt==0 ){ - sqliteOsReadLock(&pPager->fd); + pPager->aInStmt = sqliteMalloc( pPager->dbSize/8 + 1 ); + if( pPager->aInStmt==0 ){ + /* sqlite3OsLock(pPager->fd, SHARED_LOCK); */ 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) ); + rc = sqlite3OsFileSize(pPager->jfd, &pPager->stmtJSize); + if( rc ) goto stmt_begin_failed; + assert( pPager->stmtJSize == pPager->journalOff ); #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->stmtJSize = pPager->journalOff; + pPager->stmtSize = pPager->dbSize; + pPager->stmtHdrOff = 0; + pPager->stmtCksum = pPager->cksumInit; + if( !pPager->stmtOpen ){ + rc = sqlite3pager_opentemp(zTemp, &pPager->stfd); + if( rc ) goto stmt_begin_failed; + pPager->stmtOpen = 1; + pPager->stmtNRec = 0; } - pPager->ckptInUse = 1; + pPager->stmtInUse = 1; return SQLITE_OK; -ckpt_begin_failed: - if( pPager->aInCkpt ){ - sqliteFree(pPager->aInCkpt); - pPager->aInCkpt = 0; +stmt_begin_failed: + if( pPager->aInStmt ){ + sqliteFree(pPager->aInStmt); + pPager->aInStmt = 0; } return rc; } /* -** Commit a checkpoint. +** Commit a statement. */ -int sqlitepager_ckpt_commit(Pager *pPager){ - if( pPager->ckptInUse ){ +int sqlite3pager_stmt_commit(Pager *pPager){ + if( pPager->stmtInUse ){ 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; + TRACE2("STMT-COMMIT %d\n", PAGERID(pPager)); + if( !MEMDB ){ + sqlite3OsSeek(pPager->stfd, 0); + /* sqlite3OsTruncate(pPager->stfd, 0); */ + sqliteFree( pPager->aInStmt ); + pPager->aInStmt = 0; } - pPager->pCkpt = 0; + for(pPg=pPager->pStmt; pPg; pPg=pNext){ + pNext = pPg->pNextStmt; + assert( pPg->inStmt ); + pPg->inStmt = 0; + pPg->pPrevStmt = pPg->pNextStmt = 0; + if( MEMDB ){ + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + sqliteFree(pHist->pStmt); + pHist->pStmt = 0; + } + } + pPager->stmtNRec = 0; + pPager->stmtInUse = 0; + pPager->pStmt = 0; } - pPager->ckptAutoopen = 0; + pPager->stmtAutoopen = 0; return SQLITE_OK; } /* -** Rollback a checkpoint. +** Rollback a statement. */ -int sqlitepager_ckpt_rollback(Pager *pPager){ +int sqlite3pager_stmt_rollback(Pager *pPager){ int rc; - if( pPager->ckptInUse ){ - rc = pager_ckpt_playback(pPager); - sqlitepager_ckpt_commit(pPager); + if( pPager->stmtInUse ){ + TRACE2("STMT-ROLLBACK %d\n", PAGERID(pPager)); + if( MEMDB ){ + PgHdr *pPg; + for(pPg=pPager->pStmt; pPg; pPg=pPg->pNextStmt){ + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + if( pHist->pStmt ){ + memcpy(PGHDR_TO_DATA(pPg), pHist->pStmt, pPager->pageSize); + sqliteFree(pHist->pStmt); + pHist->pStmt = 0; + } + } + pPager->dbSize = pPager->stmtSize; + memoryTruncate(pPager); + rc = SQLITE_OK; + }else{ + rc = pager_stmt_playback(pPager); + } + sqlite3pager_stmt_commit(pPager); }else{ rc = SQLITE_OK; } - pPager->ckptAutoopen = 0; + pPager->stmtAutoopen = 0; return rc; } /* ** Return the full pathname of the database file. */ -const char *sqlitepager_filename(Pager *pPager){ +const char *sqlite3pager_filename(Pager *pPager){ return pPager->zFilename; } +/* +** Return the directory of the database file. +*/ +const char *sqlite3pager_dirname(Pager *pPager){ + return pPager->zDirectory; +} + +/* +** Return the full pathname of the journal file. +*/ +const char *sqlite3pager_journalname(Pager *pPager){ + return pPager->zJournal; +} + +/* +** Return true if fsync() calls are disabled for this pager. Return FALSE +** if fsync()s are executed normally. +*/ +int sqlite3pager_nosync(Pager *pPager){ + return pPager->noSync; +} + /* ** Set the codec for this pager */ -void sqlitepager_set_codec( +void sqlite3pager_set_codec( Pager *pPager, - void (*xCodec)(void*,void*,Pgno,int), + void *(*xCodec)(void*,void*,Pgno,int), void *pCodecArg ){ pPager->xCodec = xCodec; pPager->pCodecArg = pCodecArg; } -#ifdef SQLITE_TEST +/* +** This routine is called to increment the database file change-counter, +** stored at byte 24 of the pager file. +*/ +static int pager_incr_changecounter(Pager *pPager){ + void *pPage; + PgHdr *pPgHdr; + u32 change_counter; + int rc; + + /* Open page 1 of the file for writing. */ + rc = sqlite3pager_get(pPager, 1, &pPage); + if( rc!=SQLITE_OK ) return rc; + rc = sqlite3pager_write(pPage); + if( rc!=SQLITE_OK ) return rc; + + /* Read the current value at byte 24. */ + pPgHdr = DATA_TO_PGHDR(pPage); + change_counter = retrieve32bits(pPgHdr, 24); + + /* Increment the value just read and write it back to byte 24. */ + change_counter++; + put32bits(((char*)PGHDR_TO_DATA(pPgHdr))+24, change_counter); + + /* Release the page reference. */ + sqlite3pager_unref(pPage); + return SQLITE_OK; +} + +/* +** Sync the database file for the pager pPager. zMaster points to the name +** of a master journal file that should be written into the individual +** journal file. zMaster may be NULL, which is interpreted as no master +** journal (a single database transaction). +** +** This routine ensures that the journal is synced, all dirty pages written +** to the database file and the database file synced. The only thing that +** remains to commit the transaction is to delete the journal file (or +** master journal file if specified). +** +** Note that if zMaster==NULL, this does not overwrite a previous value +** passed to an sqlite3pager_sync() call. +** +** If parameter nTrunc is non-zero, then the pager file is truncated to +** nTrunc pages (this is used by auto-vacuum databases). +*/ +int sqlite3pager_sync(Pager *pPager, const char *zMaster, Pgno nTrunc){ + int rc = SQLITE_OK; + + TRACE4("DATABASE SYNC: File=%s zMaster=%s nTrunc=%d\n", + pPager->zFilename, zMaster, nTrunc); + + /* If this is an in-memory db, or no pages have been written to, or this + ** function has already been called, it is a no-op. + */ + if( pPager->state!=PAGER_SYNCED && !MEMDB && pPager->dirtyCache ){ + PgHdr *pPg; + assert( pPager->journalOpen ); + + /* If a master journal file name has already been written to the + ** journal file, then no sync is required. This happens when it is + ** written, then the process fails to upgrade from a RESERVED to an + ** EXCLUSIVE lock. The next time the process tries to commit the + ** transaction the m-j name will have already been written. + */ + if( !pPager->setMaster ){ + rc = pager_incr_changecounter(pPager); + if( rc!=SQLITE_OK ) goto sync_exit; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( nTrunc!=0 ){ + /* If this transaction has made the database smaller, then all pages + ** being discarded by the truncation must be written to the journal + ** file. + */ + Pgno i; + void *pPage; + int iSkip = PAGER_MJ_PGNO(pPager); + for( i=nTrunc+1; i<=pPager->origDbSize; i++ ){ + if( !(pPager->aInJournal[i/8] & (1<<(i&7))) && i!=iSkip ){ + rc = sqlite3pager_get(pPager, i, &pPage); + if( rc!=SQLITE_OK ) goto sync_exit; + rc = sqlite3pager_write(pPage); + sqlite3pager_unref(pPage); + if( rc!=SQLITE_OK ) goto sync_exit; + } + } + } +#endif + rc = writeMasterJournal(pPager, zMaster); + if( rc!=SQLITE_OK ) goto sync_exit; + rc = syncJournal(pPager); + if( rc!=SQLITE_OK ) goto sync_exit; + } + +#ifndef SQLITE_OMIT_AUTOVACUUM + if( nTrunc!=0 ){ + rc = sqlite3pager_truncate(pPager, nTrunc); + if( rc!=SQLITE_OK ) goto sync_exit; + } +#endif + + /* Write all dirty pages to the database file */ + pPg = pager_get_all_dirty_pages(pPager); + rc = pager_write_pagelist(pPg); + if( rc!=SQLITE_OK ) goto sync_exit; + + /* Sync the database file. */ + if( !pPager->noSync ){ + rc = sqlite3OsSync(pPager->fd, 0); + } + + pPager->state = PAGER_SYNCED; + }else if( MEMDB && nTrunc!=0 ){ + rc = sqlite3pager_truncate(pPager, nTrunc); + } + +sync_exit: + return rc; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Move the page identified by pData to location pgno in the file. +** +** There must be no references to the current page pgno. If current page +** pgno is not already in the rollback journal, it is not written there by +** by this routine. The same applies to the page pData refers to on entry to +** this routine. +** +** References to the page refered to by pData remain valid. Updating any +** meta-data associated with page pData (i.e. data stored in the nExtra bytes +** allocated along with the page) is the responsibility of the caller. +** +** A transaction must be active when this routine is called. It used to be +** required that a statement transaction was not active, but this restriction +** has been removed (CREATE INDEX needs to move a page when a statement +** transaction is active). +*/ +int sqlite3pager_movepage(Pager *pPager, void *pData, Pgno pgno){ + PgHdr *pPg = DATA_TO_PGHDR(pData); + PgHdr *pPgOld; + int h; + Pgno needSyncPgno = 0; + + assert( pPg->nRef>0 ); + + TRACE5("MOVE %d page %d (needSync=%d) moves to %d\n", + PAGERID(pPager), pPg->pgno, pPg->needSync, pgno); + + if( pPg->needSync ){ + needSyncPgno = pPg->pgno; + assert( pPg->inJournal ); + assert( pPg->dirty ); + assert( pPager->needSync ); + } + + /* Unlink pPg from it's hash-chain */ + unlinkHashChain(pPager, pPg); + + /* If the cache contains a page with page-number pgno, remove it + ** from it's hash chain. Also, if the PgHdr.needSync was set for + ** page pgno before the 'move' operation, it needs to be retained + ** for the page moved there. + */ + pPgOld = pager_lookup(pPager, pgno); + if( pPgOld ){ + assert( pPgOld->nRef==0 ); + unlinkHashChain(pPager, pPgOld); + pPgOld->dirty = 0; + if( pPgOld->needSync ){ + assert( pPgOld->inJournal ); + pPg->inJournal = 1; + pPg->needSync = 1; + assert( pPager->needSync ); + } + } + + /* Change the page number for pPg and insert it into the new hash-chain. */ + pPg->pgno = pgno; + h = pager_hash(pgno); + if( pPager->aHash[h] ){ + assert( pPager->aHash[h]->pPrevHash==0 ); + pPager->aHash[h]->pPrevHash = pPg; + } + pPg->pNextHash = pPager->aHash[h]; + pPager->aHash[h] = pPg; + pPg->pPrevHash = 0; + + pPg->dirty = 1; + pPager->dirtyCache = 1; + + if( needSyncPgno ){ + /* If needSyncPgno is non-zero, then the journal file needs to be + ** sync()ed before any data is written to database file page needSyncPgno. + ** Currently, no such page exists in the page-cache and the + ** Pager.aInJournal bit has been set. This needs to be remedied by loading + ** the page into the pager-cache and setting the PgHdr.needSync flag. + ** + ** The sqlite3pager_get() call may cause the journal to sync. So make + ** sure the Pager.needSync flag is set too. + */ + int rc; + void *pNeedSync; + assert( pPager->needSync ); + rc = sqlite3pager_get(pPager, needSyncPgno, &pNeedSync); + if( rc!=SQLITE_OK ) return rc; + pPager->needSync = 1; + DATA_TO_PGHDR(pNeedSync)->needSync = 1; + DATA_TO_PGHDR(pNeedSync)->inJournal = 1; + DATA_TO_PGHDR(pNeedSync)->dirty = 1; + sqlite3pager_unref(pNeedSync); + } + + return SQLITE_OK; +} +#endif + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) +/* +** Return the current state of the file lock for the given pager. +** The return value is one of NO_LOCK, SHARED_LOCK, RESERVED_LOCK, +** PENDING_LOCK, or EXCLUSIVE_LOCK. +*/ +int sqlite3pager_lockstate(Pager *pPager){ + return sqlite3OsLockState(pPager->fd); +} +#endif + +#ifdef SQLITE_DEBUG /* ** Print a listing of all referenced pages and their ref count. */ -void sqlitepager_refdump(Pager *pPager){ +void sqlite3pager_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); + sqlite3DebugPrintf("PAGE %3d addr=%p nRef=%d\n", + pPg->pgno, PGHDR_TO_DATA(pPg), pPg->nRef); } } #endif + +#endif /* SQLITE_OMIT_DISKIO */ diff --git a/sqlite/pager.h b/sqlite/pager.h index 383c0ef43..706b578b2 100755 --- a/sqlite/pager.h +++ b/sqlite/pager.h @@ -13,45 +13,35 @@ ** subsystem. The page cache subsystem reads and writes a file a page ** at a time and provides a journal for rollback. ** -** @(#) $Id: pager.h,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** @(#) $Id: pager.h,v 1.2 2006-04-13 12:44:29 guy Exp $ */ +#ifndef _PAGER_H_ +#define _PAGER_H_ + /* -** 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. +** The default size of a database page. */ -#ifndef SQLITE_PAGE_SIZE -#define SQLITE_PAGE_SIZE 1024 +#ifndef SQLITE_DEFAULT_PAGE_SIZE +# define SQLITE_DEFAULT_PAGE_SIZE 1024 +#endif + +/* Maximum page size. The upper bound on this value is 32768. This a limit +** imposed by necessity of storing the value in a 2-byte unsigned integer +** and the fact that the page size must be a power of 2. +** +** This value is used to initialize certain arrays on the stack at +** various places in the code. On embedded machines where stack space +** is limited and the flexibility of having large pages is not needed, +** it makes good sense to reduce the maximum page size to something more +** reasonable, like 1024. +*/ +#ifndef SQLITE_MAX_PAGE_SIZE +# define SQLITE_MAX_PAGE_SIZE 32768 #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.) +** Maximum number of pages in one database. */ #define SQLITE_MAX_PAGE 1073741823 @@ -66,42 +56,67 @@ typedef unsigned int Pgno; */ typedef struct Pager Pager; +/* +** Allowed values for the flags parameter to sqlite3pager_open(). +** +** NOTE: This values must match the corresponding BTREE_ values in btree.h. +*/ +#define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */ +#define PAGER_NO_READLOCK 0x0002 /* Omit readlocks on readonly files */ + + /* ** 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*); +int sqlite3pager_open(Pager **ppPager, const char *zFilename, + int nExtra, int flags); +void sqlite3pager_set_busyhandler(Pager*, BusyHandler *pBusyHandler); +void sqlite3pager_set_destructor(Pager*, void(*)(void*,int)); +void sqlite3pager_set_reiniter(Pager*, void(*)(void*,int)); +int sqlite3pager_set_pagesize(Pager*, int); +void sqlite3pager_read_fileheader(Pager*, int, unsigned char*); +void sqlite3pager_set_cachesize(Pager*, int); +int sqlite3pager_close(Pager *pPager); +int sqlite3pager_get(Pager *pPager, Pgno pgno, void **ppPage); +void *sqlite3pager_lookup(Pager *pPager, Pgno pgno); +int sqlite3pager_ref(void*); +int sqlite3pager_unref(void*); +Pgno sqlite3pager_pagenumber(void*); +int sqlite3pager_write(void*); +int sqlite3pager_iswriteable(void*); +int sqlite3pager_overwrite(Pager *pPager, Pgno pgno, void*); +int sqlite3pager_pagecount(Pager*); +int sqlite3pager_truncate(Pager*,Pgno); +int sqlite3pager_begin(void*, int exFlag); +int sqlite3pager_commit(Pager*); +int sqlite3pager_sync(Pager*,const char *zMaster, Pgno); +int sqlite3pager_rollback(Pager*); +int sqlite3pager_isreadonly(Pager*); +int sqlite3pager_stmt_begin(Pager*); +int sqlite3pager_stmt_commit(Pager*); +int sqlite3pager_stmt_rollback(Pager*); +void sqlite3pager_dont_rollback(void*); +void sqlite3pager_dont_write(Pager*, Pgno); +int *sqlite3pager_stats(Pager*); +void sqlite3pager_set_safety_level(Pager*,int,int); +const char *sqlite3pager_filename(Pager*); +const char *sqlite3pager_dirname(Pager*); +const char *sqlite3pager_journalname(Pager*); +int sqlite3pager_nosync(Pager*); +int sqlite3pager_rename(Pager*, const char *zNewName); +void sqlite3pager_set_codec(Pager*,void*(*)(void*,void*,Pgno,int),void*); +int sqlite3pager_movepage(Pager*,void*,Pgno); +int sqlite3pager_reset(Pager*); +int sqlite3pager_release_memory(int); + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) +int sqlite3pager_lockstate(Pager*); +#endif #ifdef SQLITE_TEST -void sqlitepager_refdump(Pager*); -int pager_refinfo_enable; -int journal_format; +void sqlite3pager_refdump(Pager*); +int pager3_refinfo_enable; #endif + +#endif /* _PAGER_H_ */ diff --git a/sqlite/parse.c b/sqlite/parse.c index 463536915..9b07d8cd0 100755 --- a/sqlite/parse.c +++ b/sqlite/parse.c @@ -4,7 +4,7 @@ /* First off, code is include which follows the "include" declaration ** in the input file. */ #include -#line 33 "parse.y" +#line 54 "parse.y" #include "sqliteInt.h" #include "parse.h" @@ -14,8 +14,17 @@ ** 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 */ + Expr *pLimit; /* The LIMIT expression. NULL if there is no limit */ + Expr *pOffset; /* The OFFSET expression. NULL if there is none */ +}; + +/* +** An instance of this structure is used to store the LIKE, +** GLOB, NOT LIKE, and NOT GLOB operators. +*/ +struct LikeOp { + Token eOperator; /* "like" or "glob" or "regexp" */ + int not; /* True if the NOT keyword is present */ }; /* @@ -29,8 +38,12 @@ struct LimitVal { */ struct TrigEvent { int a; IdList * b; }; +/* +** An instance of this structure holds the ATTACH key and the key type. +*/ +struct AttachKey { int type; Token key; }; -#line 34 "parse.c" +#line 48 "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. */ @@ -63,52 +76,52 @@ struct TrigEvent { int a; IdList * b; }; ** 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 +** sqlite3ParserTOKENTYPE is the data type used for minor tokens given ** directly to the parser from the tokenizer. ** YYMINORTYPE is the data type used for all minor tokens. ** This is typically a union of many types, one of -** which is sqliteParserTOKENTYPE. The entry in the union +** which is sqlite3ParserTOKENTYPE. The entry in the union ** for base tokens is called "yy0". ** YYSTACKDEPTH is the maximum depth of the parser's stack. -** 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 +** sqlite3ParserARG_SDECL A static variable declaration for the %extra_argument +** sqlite3ParserARG_PDECL A parameter declaration for the %extra_argument +** sqlite3ParserARG_STORE Code to store %extra_argument into yypParser +** sqlite3ParserARG_FETCH Code to extract %extra_argument from yypParser ** 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 YYNOCODE 240 #define YYACTIONTYPE unsigned short int -#define sqliteParserTOKENTYPE Token +#define sqlite3ParserTOKENTYPE Token typedef union { - sqliteParserTOKENTYPE yy0; - TriggerStep * yy19; - struct LimitVal yy124; - Select* yy179; - Expr * yy182; - Expr* yy242; - struct TrigEvent yy290; - Token yy298; - SrcList* yy307; - IdList* yy320; - ExprList* yy322; - int yy372; - struct {int value; int mask;} yy407; - int yy441; + sqlite3ParserTOKENTYPE yy0; + struct {int value; int mask;} yy13; + struct TrigEvent yy132; + IdList* yy160; + Expr* yy178; + int yy230; + Select* yy239; + TriggerStep* yy247; + struct LimitVal yy270; + SrcList* yy285; + Expr * yy292; + Token yy384; + struct LikeOp yy440; + ExprList* yy462; + int yy479; } YYMINORTYPE; #define YYSTACKDEPTH 100 -#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 YYERRORSYMBOL 131 -#define YYERRSYMDT yy441 +#define sqlite3ParserARG_SDECL Parse *pParse; +#define sqlite3ParserARG_PDECL ,Parse *pParse +#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse +#define sqlite3ParserARG_STORE yypParser->pParse = pParse +#define YYNSTATE 559 +#define YYNRULE 295 +#define YYERRORSYMBOL 137 +#define YYERRSYMDT yy479 #define YYFALLBACK 1 #define YY_NO_ACTION (YYNSTATE+YYNRULE+2) #define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1) @@ -161,446 +174,396 @@ typedef union { ** shifting non-terminals after a reduce. ** yy_default[] Default action for each state. */ -static YYACTIONTYPE yy_action[] = { - /* 0 */ 264, 5, 262, 119, 123, 117, 121, 129, 131, 133, - /* 10 */ 135, 144, 146, 148, 150, 152, 154, 568, 106, 106, - /* 20 */ 143, 857, 1, 562, 3, 142, 129, 131, 133, 135, - /* 30 */ 144, 146, 148, 150, 152, 154, 174, 103, 8, 115, - /* 40 */ 104, 139, 127, 125, 156, 161, 157, 162, 166, 119, - /* 50 */ 123, 117, 121, 129, 131, 133, 135, 144, 146, 148, - /* 60 */ 150, 152, 154, 31, 361, 392, 263, 143, 363, 369, - /* 70 */ 374, 97, 142, 148, 150, 152, 154, 68, 75, 377, - /* 80 */ 167, 64, 218, 46, 20, 289, 115, 104, 139, 127, - /* 90 */ 125, 156, 161, 157, 162, 166, 119, 123, 117, 121, - /* 100 */ 129, 131, 133, 135, 144, 146, 148, 150, 152, 154, - /* 110 */ 193, 41, 336, 563, 44, 54, 60, 62, 308, 331, - /* 120 */ 175, 20, 560, 561, 572, 333, 640, 18, 359, 144, - /* 130 */ 146, 148, 150, 152, 154, 143, 181, 179, 303, 18, - /* 140 */ 142, 84, 86, 20, 177, 66, 67, 111, 21, 22, - /* 150 */ 112, 105, 83, 792, 115, 104, 139, 127, 125, 156, - /* 160 */ 161, 157, 162, 166, 119, 123, 117, 121, 129, 131, - /* 170 */ 133, 135, 144, 146, 148, 150, 152, 154, 790, 560, - /* 180 */ 561, 46, 13, 113, 183, 21, 22, 534, 361, 2, - /* 190 */ 3, 14, 363, 369, 374, 338, 361, 690, 544, 542, - /* 200 */ 363, 369, 374, 377, 836, 143, 15, 21, 22, 16, - /* 210 */ 142, 377, 44, 54, 60, 62, 308, 331, 396, 535, - /* 220 */ 17, 9, 191, 333, 115, 104, 139, 127, 125, 156, - /* 230 */ 161, 157, 162, 166, 119, 123, 117, 121, 129, 131, - /* 240 */ 133, 135, 144, 146, 148, 150, 152, 154, 571, 230, - /* 250 */ 340, 343, 143, 20, 536, 537, 538, 142, 402, 337, - /* 260 */ 398, 339, 357, 68, 346, 347, 32, 64, 266, 391, - /* 270 */ 37, 115, 104, 139, 127, 125, 156, 161, 157, 162, - /* 280 */ 166, 119, 123, 117, 121, 129, 131, 133, 135, 144, - /* 290 */ 146, 148, 150, 152, 154, 839, 193, 651, 291, 298, - /* 300 */ 300, 221, 357, 43, 173, 689, 175, 251, 330, 36, - /* 310 */ 37, 106, 232, 40, 335, 58, 137, 21, 22, 330, - /* 320 */ 411, 143, 181, 179, 47, 59, 142, 358, 390, 174, - /* 330 */ 177, 66, 67, 111, 448, 49, 112, 105, 583, 213, - /* 340 */ 115, 104, 139, 127, 125, 156, 161, 157, 162, 166, - /* 350 */ 119, 123, 117, 121, 129, 131, 133, 135, 144, 146, - /* 360 */ 148, 150, 152, 154, 306, 301, 106, 249, 259, 113, - /* 370 */ 183, 793, 70, 253, 281, 219, 20, 106, 20, 11, - /* 380 */ 106, 482, 454, 444, 299, 143, 169, 10, 171, 172, - /* 390 */ 142, 169, 73, 171, 172, 103, 688, 69, 174, 169, - /* 400 */ 252, 171, 172, 12, 115, 104, 139, 127, 125, 156, - /* 410 */ 161, 157, 162, 166, 119, 123, 117, 121, 129, 131, - /* 420 */ 133, 135, 144, 146, 148, 150, 152, 154, 95, 237, - /* 430 */ 313, 20, 143, 295, 244, 424, 169, 142, 171, 172, - /* 440 */ 21, 22, 21, 22, 219, 386, 316, 323, 325, 837, - /* 450 */ 19, 115, 104, 139, 127, 125, 156, 161, 157, 162, - /* 460 */ 166, 119, 123, 117, 121, 129, 131, 133, 135, 144, - /* 470 */ 146, 148, 150, 152, 154, 106, 661, 20, 264, 143, - /* 480 */ 262, 844, 315, 169, 142, 171, 172, 333, 38, 842, - /* 490 */ 10, 356, 348, 184, 421, 21, 22, 282, 115, 104, - /* 500 */ 139, 127, 125, 156, 161, 157, 162, 166, 119, 123, - /* 510 */ 117, 121, 129, 131, 133, 135, 144, 146, 148, 150, - /* 520 */ 152, 154, 69, 254, 262, 251, 143, 639, 663, 35, - /* 530 */ 65, 142, 726, 313, 283, 259, 185, 417, 419, 418, - /* 540 */ 284, 21, 22, 690, 263, 115, 104, 139, 127, 125, - /* 550 */ 156, 161, 157, 162, 166, 119, 123, 117, 121, 129, - /* 560 */ 131, 133, 135, 144, 146, 148, 150, 152, 154, 256, - /* 570 */ 20, 791, 424, 143, 169, 52, 171, 172, 142, 169, - /* 580 */ 24, 171, 172, 247, 53, 315, 26, 169, 263, 171, - /* 590 */ 172, 253, 115, 164, 139, 127, 125, 156, 161, 157, - /* 600 */ 162, 166, 119, 123, 117, 121, 129, 131, 133, 135, - /* 610 */ 144, 146, 148, 150, 152, 154, 426, 349, 252, 425, - /* 620 */ 143, 262, 575, 297, 591, 142, 169, 296, 171, 172, - /* 630 */ 169, 471, 171, 172, 21, 22, 427, 221, 91, 115, - /* 640 */ 227, 139, 127, 125, 156, 161, 157, 162, 166, 119, - /* 650 */ 123, 117, 121, 129, 131, 133, 135, 144, 146, 148, - /* 660 */ 150, 152, 154, 388, 312, 106, 89, 143, 720, 376, - /* 670 */ 387, 170, 142, 487, 666, 248, 320, 216, 319, 217, - /* 680 */ 28, 459, 30, 305, 189, 263, 209, 104, 139, 127, - /* 690 */ 125, 156, 161, 157, 162, 166, 119, 123, 117, 121, - /* 700 */ 129, 131, 133, 135, 144, 146, 148, 150, 152, 154, - /* 710 */ 106, 106, 809, 494, 143, 489, 106, 816, 33, 142, - /* 720 */ 395, 234, 273, 217, 274, 420, 20, 545, 114, 481, - /* 730 */ 137, 429, 576, 321, 116, 139, 127, 125, 156, 161, - /* 740 */ 157, 162, 166, 119, 123, 117, 121, 129, 131, 133, - /* 750 */ 135, 144, 146, 148, 150, 152, 154, 7, 322, 23, - /* 760 */ 25, 27, 394, 68, 415, 416, 10, 64, 197, 477, - /* 770 */ 577, 533, 266, 548, 578, 831, 276, 201, 520, 4, - /* 780 */ 6, 245, 430, 557, 29, 266, 491, 106, 441, 497, - /* 790 */ 21, 22, 205, 168, 443, 195, 193, 531, 276, 448, - /* 800 */ 276, 808, 267, 272, 529, 174, 175, 318, 440, 341, - /* 810 */ 344, 106, 342, 345, 69, 286, 68, 582, 69, 69, - /* 820 */ 64, 540, 181, 179, 541, 328, 302, 366, 217, 118, - /* 830 */ 177, 66, 67, 111, 34, 143, 112, 105, 445, 510, - /* 840 */ 142, 215, 278, 800, 467, 276, 498, 503, 444, 193, - /* 850 */ 106, 219, 486, 443, 42, 73, 231, 73, 45, 175, - /* 860 */ 449, 39, 225, 229, 278, 451, 278, 68, 174, 113, - /* 870 */ 183, 64, 371, 55, 106, 181, 179, 292, 69, 276, - /* 880 */ 276, 69, 48, 177, 66, 67, 111, 224, 276, 112, - /* 890 */ 105, 106, 481, 393, 106, 106, 63, 106, 106, 106, - /* 900 */ 193, 653, 106, 467, 233, 51, 380, 437, 526, 120, - /* 910 */ 175, 278, 122, 124, 219, 126, 128, 130, 69, 453, - /* 920 */ 132, 106, 113, 183, 451, 106, 181, 179, 159, 106, - /* 930 */ 106, 106, 518, 106, 177, 66, 67, 111, 106, 134, - /* 940 */ 112, 105, 422, 136, 106, 278, 278, 138, 141, 145, - /* 950 */ 720, 147, 106, 329, 275, 274, 149, 106, 852, 158, - /* 960 */ 106, 106, 151, 106, 106, 351, 106, 352, 106, 464, - /* 970 */ 153, 106, 106, 113, 183, 155, 106, 106, 163, 165, - /* 980 */ 106, 176, 178, 106, 180, 106, 182, 106, 401, 190, - /* 990 */ 192, 106, 106, 293, 210, 212, 106, 367, 214, 274, - /* 1000 */ 372, 226, 274, 228, 381, 241, 274, 106, 106, 246, - /* 1010 */ 280, 290, 106, 69, 375, 438, 472, 274, 422, 832, - /* 1020 */ 106, 73, 474, 73, 458, 412, 462, 480, 464, 478, - /* 1030 */ 466, 690, 515, 519, 475, 478, 516, 50, 479, 221, - /* 1040 */ 690, 221, 56, 57, 61, 592, 71, 69, 593, 73, - /* 1050 */ 72, 74, 245, 242, 93, 81, 76, 69, 77, 240, - /* 1060 */ 78, 82, 79, 245, 85, 554, 80, 88, 87, 90, - /* 1070 */ 92, 94, 96, 102, 100, 99, 101, 107, 109, 160, - /* 1080 */ 154, 667, 98, 508, 108, 668, 110, 220, 211, 669, - /* 1090 */ 137, 140, 188, 194, 186, 196, 187, 199, 198, 200, - /* 1100 */ 203, 204, 202, 207, 206, 208, 221, 223, 222, 235, - /* 1110 */ 236, 239, 238, 217, 250, 258, 243, 261, 279, 270, - /* 1120 */ 271, 255, 257, 260, 269, 265, 285, 294, 277, 268, - /* 1130 */ 287, 304, 309, 307, 327, 312, 288, 354, 389, 314, - /* 1140 */ 364, 365, 370, 378, 379, 382, 310, 49, 311, 362, - /* 1150 */ 368, 373, 317, 324, 326, 332, 350, 355, 383, 400, - /* 1160 */ 353, 397, 399, 403, 404, 334, 405, 406, 407, 384, - /* 1170 */ 413, 409, 824, 414, 360, 385, 829, 423, 410, 431, - /* 1180 */ 428, 432, 830, 433, 434, 436, 439, 798, 799, 447, - /* 1190 */ 442, 450, 727, 728, 446, 823, 452, 838, 455, 445, - /* 1200 */ 456, 457, 408, 435, 460, 461, 463, 840, 465, 468, - /* 1210 */ 470, 469, 476, 841, 483, 485, 843, 660, 662, 493, - /* 1220 */ 806, 496, 473, 849, 499, 719, 501, 484, 488, 490, - /* 1230 */ 492, 502, 504, 495, 500, 507, 505, 506, 509, 722, - /* 1240 */ 513, 511, 512, 514, 517, 725, 528, 522, 524, 525, - /* 1250 */ 527, 523, 807, 530, 810, 532, 811, 812, 813, 814, - /* 1260 */ 817, 819, 539, 820, 818, 815, 521, 543, 546, 552, - /* 1270 */ 556, 550, 850, 547, 549, 851, 555, 558, 551, 855, - /* 1280 */ 553, 559, +static const YYACTIONTYPE yy_action[] = { + /* 0 */ 279, 67, 283, 69, 147, 165, 545, 418, 61, 61, + /* 10 */ 61, 61, 201, 63, 63, 63, 63, 64, 64, 65, + /* 20 */ 65, 65, 66, 66, 547, 548, 431, 68, 63, 63, + /* 30 */ 63, 63, 64, 64, 65, 65, 65, 66, 67, 453, + /* 40 */ 69, 147, 498, 60, 58, 287, 439, 440, 436, 436, + /* 50 */ 62, 62, 61, 61, 61, 61, 500, 63, 63, 63, + /* 60 */ 63, 64, 64, 65, 65, 65, 66, 279, 370, 283, + /* 70 */ 418, 2, 376, 79, 157, 114, 219, 304, 224, 305, + /* 80 */ 169, 244, 855, 118, 558, 503, 203, 2, 245, 388, + /* 90 */ 495, 218, 21, 431, 513, 20, 418, 57, 492, 511, + /* 100 */ 63, 63, 63, 63, 64, 64, 65, 65, 65, 66, + /* 110 */ 60, 58, 287, 439, 440, 436, 436, 62, 62, 61, + /* 120 */ 61, 61, 61, 530, 63, 63, 63, 63, 64, 64, + /* 130 */ 65, 65, 65, 66, 279, 377, 378, 174, 371, 368, + /* 140 */ 330, 333, 334, 219, 304, 224, 305, 169, 244, 510, + /* 150 */ 479, 19, 335, 138, 376, 245, 509, 301, 372, 418, + /* 160 */ 431, 529, 91, 199, 65, 65, 65, 66, 504, 167, + /* 170 */ 191, 64, 64, 65, 65, 65, 66, 60, 58, 287, + /* 180 */ 439, 440, 436, 436, 62, 62, 61, 61, 61, 61, + /* 190 */ 254, 63, 63, 63, 63, 64, 64, 65, 65, 65, + /* 200 */ 66, 279, 250, 410, 410, 430, 109, 395, 426, 204, + /* 210 */ 357, 260, 259, 308, 145, 168, 153, 377, 378, 396, + /* 220 */ 327, 201, 67, 189, 69, 147, 225, 431, 546, 361, + /* 230 */ 465, 365, 397, 499, 318, 409, 40, 413, 428, 312, + /* 240 */ 161, 180, 550, 178, 60, 58, 287, 439, 440, 436, + /* 250 */ 436, 62, 62, 61, 61, 61, 61, 410, 63, 63, + /* 260 */ 63, 63, 64, 64, 65, 65, 65, 66, 279, 471, + /* 270 */ 415, 415, 415, 282, 308, 322, 235, 426, 204, 308, + /* 280 */ 174, 367, 308, 330, 333, 334, 67, 308, 69, 147, + /* 290 */ 148, 559, 371, 368, 431, 335, 409, 34, 165, 465, + /* 300 */ 418, 409, 34, 275, 409, 34, 428, 502, 161, 409, + /* 310 */ 35, 60, 58, 287, 439, 440, 436, 436, 62, 62, + /* 320 */ 61, 61, 61, 61, 410, 63, 63, 63, 63, 64, + /* 330 */ 64, 65, 65, 65, 66, 308, 503, 395, 237, 290, + /* 340 */ 279, 391, 392, 146, 324, 387, 20, 288, 347, 396, + /* 350 */ 174, 450, 350, 330, 333, 334, 450, 409, 27, 450, + /* 360 */ 474, 231, 397, 418, 393, 335, 431, 501, 354, 144, + /* 370 */ 512, 503, 524, 232, 394, 465, 496, 410, 527, 392, + /* 380 */ 555, 20, 75, 60, 58, 287, 439, 440, 436, 436, + /* 390 */ 62, 62, 61, 61, 61, 61, 220, 63, 63, 63, + /* 400 */ 63, 64, 64, 65, 65, 65, 66, 308, 221, 185, + /* 410 */ 338, 254, 279, 308, 239, 443, 475, 308, 319, 308, + /* 420 */ 389, 444, 286, 421, 422, 379, 380, 381, 492, 409, + /* 430 */ 34, 311, 421, 422, 212, 409, 48, 170, 431, 409, + /* 440 */ 40, 409, 48, 410, 122, 314, 526, 442, 442, 1, + /* 450 */ 376, 469, 255, 376, 78, 60, 58, 287, 439, 440, + /* 460 */ 436, 436, 62, 62, 61, 61, 61, 61, 355, 63, + /* 470 */ 63, 63, 63, 64, 64, 65, 65, 65, 66, 279, + /* 480 */ 233, 152, 298, 478, 449, 203, 792, 192, 299, 351, + /* 490 */ 376, 281, 376, 9, 203, 376, 245, 376, 201, 432, + /* 500 */ 314, 376, 442, 442, 490, 431, 314, 325, 442, 442, + /* 510 */ 418, 356, 289, 377, 378, 354, 377, 378, 403, 434, + /* 520 */ 435, 410, 60, 58, 287, 439, 440, 436, 436, 62, + /* 530 */ 62, 61, 61, 61, 61, 263, 63, 63, 63, 63, + /* 540 */ 64, 64, 65, 65, 65, 66, 279, 433, 328, 236, + /* 550 */ 497, 473, 490, 377, 378, 377, 378, 484, 377, 378, + /* 560 */ 377, 378, 308, 522, 377, 378, 314, 521, 442, 442, + /* 570 */ 409, 3, 431, 418, 130, 254, 264, 485, 309, 346, + /* 580 */ 461, 213, 462, 242, 409, 28, 469, 292, 214, 60, + /* 590 */ 58, 287, 439, 440, 436, 436, 62, 62, 61, 61, + /* 600 */ 61, 61, 308, 63, 63, 63, 63, 64, 64, 65, + /* 610 */ 65, 65, 66, 279, 308, 458, 536, 248, 5, 308, + /* 620 */ 201, 308, 469, 308, 409, 23, 308, 202, 291, 308, + /* 630 */ 375, 243, 308, 362, 54, 115, 409, 32, 74, 431, + /* 640 */ 76, 409, 53, 409, 24, 409, 51, 345, 409, 96, + /* 650 */ 149, 409, 93, 265, 409, 98, 60, 58, 287, 439, + /* 660 */ 440, 436, 436, 62, 62, 61, 61, 61, 61, 308, + /* 670 */ 63, 63, 63, 63, 64, 64, 65, 65, 65, 66, + /* 680 */ 279, 308, 404, 297, 410, 90, 308, 176, 308, 405, + /* 690 */ 308, 409, 99, 308, 419, 308, 22, 308, 520, 344, + /* 700 */ 520, 164, 153, 409, 110, 141, 431, 313, 409, 111, + /* 710 */ 409, 16, 409, 97, 254, 409, 33, 409, 94, 409, + /* 720 */ 52, 410, 187, 60, 58, 287, 439, 440, 436, 436, + /* 730 */ 62, 62, 61, 61, 61, 61, 308, 63, 63, 63, + /* 740 */ 63, 64, 64, 65, 65, 65, 66, 279, 308, 490, + /* 750 */ 490, 414, 308, 320, 308, 538, 308, 460, 409, 112, + /* 760 */ 308, 171, 172, 173, 308, 408, 308, 424, 424, 407, + /* 770 */ 409, 113, 427, 431, 409, 25, 409, 36, 409, 37, + /* 780 */ 170, 437, 409, 26, 211, 293, 409, 38, 409, 39, + /* 790 */ 60, 58, 287, 439, 440, 436, 436, 62, 62, 61, + /* 800 */ 61, 61, 61, 308, 63, 63, 63, 63, 64, 64, + /* 810 */ 65, 65, 65, 66, 279, 308, 490, 490, 451, 308, + /* 820 */ 81, 308, 151, 308, 459, 409, 41, 308, 243, 243, + /* 830 */ 400, 401, 308, 448, 281, 12, 464, 409, 42, 468, + /* 840 */ 431, 409, 43, 409, 29, 409, 30, 241, 460, 409, + /* 850 */ 44, 294, 296, 480, 409, 45, 329, 60, 70, 287, + /* 860 */ 439, 440, 436, 436, 62, 62, 61, 61, 61, 61, + /* 870 */ 308, 63, 63, 63, 63, 64, 64, 65, 65, 65, + /* 880 */ 66, 279, 308, 408, 483, 482, 308, 407, 308, 467, + /* 890 */ 308, 166, 409, 46, 308, 243, 243, 476, 488, 12, + /* 900 */ 122, 518, 519, 179, 409, 47, 481, 431, 409, 31, + /* 910 */ 409, 10, 409, 49, 505, 486, 409, 50, 254, 249, + /* 920 */ 254, 254, 254, 158, 279, 58, 287, 439, 440, 436, + /* 930 */ 436, 62, 62, 61, 61, 61, 61, 410, 63, 63, + /* 940 */ 63, 63, 64, 64, 65, 65, 65, 66, 487, 247, + /* 950 */ 431, 122, 254, 337, 525, 122, 122, 251, 533, 539, + /* 960 */ 166, 540, 266, 360, 534, 543, 88, 88, 252, 287, + /* 970 */ 439, 440, 436, 436, 62, 62, 61, 61, 61, 61, + /* 980 */ 195, 63, 63, 63, 63, 64, 64, 65, 65, 65, + /* 990 */ 66, 71, 315, 268, 4, 253, 182, 258, 285, 349, + /* 1000 */ 342, 352, 353, 261, 262, 544, 310, 71, 315, 269, + /* 1010 */ 4, 222, 363, 272, 285, 593, 273, 554, 140, 226, + /* 1020 */ 385, 423, 310, 317, 425, 316, 532, 542, 18, 156, + /* 1030 */ 479, 454, 457, 430, 332, 489, 374, 382, 383, 317, + /* 1040 */ 384, 8, 302, 303, 491, 390, 398, 284, 403, 430, + /* 1050 */ 223, 406, 73, 72, 402, 81, 411, 399, 323, 56, + /* 1060 */ 71, 306, 307, 205, 321, 413, 80, 227, 73, 72, + /* 1070 */ 472, 77, 452, 163, 234, 455, 71, 306, 307, 71, + /* 1080 */ 315, 413, 4, 229, 201, 456, 285, 412, 228, 82, + /* 1090 */ 119, 326, 230, 206, 310, 207, 101, 276, 415, 415, + /* 1100 */ 415, 416, 417, 11, 238, 494, 466, 470, 240, 209, + /* 1110 */ 210, 317, 493, 506, 415, 415, 415, 416, 417, 11, + /* 1120 */ 507, 430, 155, 339, 508, 514, 177, 215, 216, 217, + /* 1130 */ 105, 277, 341, 181, 516, 83, 343, 85, 256, 455, + /* 1140 */ 73, 72, 517, 197, 183, 270, 348, 117, 71, 306, + /* 1150 */ 307, 528, 271, 413, 186, 126, 535, 358, 127, 128, + /* 1160 */ 541, 135, 300, 132, 194, 136, 529, 551, 552, 553, + /* 1170 */ 129, 193, 89, 196, 430, 556, 208, 100, 95, 373, + /* 1180 */ 386, 116, 200, 55, 17, 594, 415, 415, 415, 416, + /* 1190 */ 417, 11, 92, 142, 143, 595, 159, 108, 160, 59, + /* 1200 */ 438, 420, 499, 429, 137, 441, 413, 445, 150, 162, + /* 1210 */ 446, 447, 6, 7, 13, 359, 267, 259, 463, 12, + /* 1220 */ 120, 280, 121, 154, 477, 102, 201, 246, 331, 103, + /* 1230 */ 84, 104, 336, 175, 221, 340, 139, 515, 123, 415, + /* 1240 */ 415, 415, 184, 124, 295, 166, 257, 106, 523, 278, + /* 1250 */ 364, 531, 125, 86, 188, 14, 190, 537, 131, 133, + /* 1260 */ 87, 134, 15, 107, 198, 549, 366, 369, 536, 557, + /* 1270 */ 274, }; -static YYCODETYPE yy_lookahead[] = { - /* 0 */ 21, 9, 23, 70, 71, 72, 73, 74, 75, 76, - /* 10 */ 77, 78, 79, 80, 81, 82, 83, 9, 140, 140, - /* 20 */ 41, 132, 133, 134, 135, 46, 74, 75, 76, 77, - /* 30 */ 78, 79, 80, 81, 82, 83, 158, 158, 138, 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, 19, 90, 21, 87, 41, 94, 95, - /* 70 */ 96, 192, 46, 80, 81, 82, 83, 19, 174, 105, - /* 80 */ 19, 23, 204, 62, 23, 181, 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 */ 52, 90, 91, 0, 93, 94, 95, 96, 97, 98, - /* 120 */ 62, 23, 9, 10, 9, 104, 20, 12, 22, 78, - /* 130 */ 79, 80, 81, 82, 83, 41, 78, 79, 80, 12, - /* 140 */ 46, 78, 79, 23, 86, 87, 88, 89, 87, 88, - /* 150 */ 92, 93, 89, 127, 60, 61, 62, 63, 64, 65, - /* 160 */ 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - /* 170 */ 76, 77, 78, 79, 80, 81, 82, 83, 14, 9, - /* 180 */ 10, 62, 15, 125, 126, 87, 88, 140, 90, 134, - /* 190 */ 135, 24, 94, 95, 96, 23, 90, 9, 78, 79, - /* 200 */ 94, 95, 96, 105, 11, 41, 39, 87, 88, 42, - /* 210 */ 46, 105, 93, 94, 95, 96, 97, 98, 17, 99, - /* 220 */ 53, 139, 128, 104, 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, 9, 19, - /* 250 */ 78, 79, 41, 23, 207, 208, 209, 46, 57, 87, - /* 260 */ 59, 89, 140, 19, 92, 93, 144, 23, 152, 147, - /* 270 */ 148, 60, 61, 62, 63, 64, 65, 66, 67, 68, - /* 280 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - /* 290 */ 79, 80, 81, 82, 83, 14, 52, 9, 182, 20, - /* 300 */ 20, 113, 140, 156, 20, 20, 62, 22, 161, 147, - /* 310 */ 148, 140, 20, 155, 156, 26, 200, 87, 88, 161, - /* 320 */ 127, 41, 78, 79, 93, 36, 46, 165, 166, 158, - /* 330 */ 86, 87, 88, 89, 53, 104, 92, 93, 9, 128, - /* 340 */ 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - /* 350 */ 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - /* 360 */ 80, 81, 82, 83, 20, 194, 140, 183, 184, 125, - /* 370 */ 126, 127, 146, 88, 19, 204, 23, 140, 23, 31, - /* 380 */ 140, 100, 101, 102, 158, 41, 107, 99, 109, 110, - /* 390 */ 46, 107, 111, 109, 110, 158, 20, 171, 158, 107, - /* 400 */ 115, 109, 110, 170, 60, 61, 62, 63, 64, 65, - /* 410 */ 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - /* 420 */ 76, 77, 78, 79, 80, 81, 82, 83, 191, 192, - /* 430 */ 47, 23, 41, 80, 194, 140, 107, 46, 109, 110, - /* 440 */ 87, 88, 87, 88, 204, 62, 100, 101, 102, 11, - /* 450 */ 140, 60, 61, 62, 63, 64, 65, 66, 67, 68, - /* 460 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - /* 470 */ 79, 80, 81, 82, 83, 140, 9, 23, 21, 41, - /* 480 */ 23, 9, 99, 107, 46, 109, 110, 104, 149, 9, - /* 490 */ 99, 152, 153, 158, 199, 87, 88, 146, 60, 61, - /* 500 */ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - /* 510 */ 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - /* 520 */ 82, 83, 171, 115, 23, 22, 41, 20, 9, 22, - /* 530 */ 19, 46, 9, 47, 183, 184, 201, 100, 101, 102, - /* 540 */ 189, 87, 88, 19, 87, 60, 61, 62, 63, 64, - /* 550 */ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - /* 560 */ 75, 76, 77, 78, 79, 80, 81, 82, 83, 115, - /* 570 */ 23, 14, 140, 41, 107, 34, 109, 110, 46, 107, - /* 580 */ 138, 109, 110, 22, 43, 99, 138, 107, 87, 109, - /* 590 */ 110, 88, 60, 61, 62, 63, 64, 65, 66, 67, - /* 600 */ 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - /* 610 */ 78, 79, 80, 81, 82, 83, 25, 19, 115, 28, - /* 620 */ 41, 23, 9, 108, 113, 46, 107, 112, 109, 110, - /* 630 */ 107, 199, 109, 110, 87, 88, 45, 113, 22, 60, - /* 640 */ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - /* 650 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - /* 660 */ 81, 82, 83, 161, 162, 140, 50, 41, 9, 139, - /* 670 */ 168, 108, 46, 17, 111, 114, 91, 20, 93, 22, - /* 680 */ 138, 22, 142, 158, 127, 87, 129, 61, 62, 63, - /* 690 */ 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - /* 700 */ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - /* 710 */ 140, 140, 9, 57, 41, 59, 140, 9, 145, 46, - /* 720 */ 143, 20, 20, 22, 22, 49, 23, 19, 158, 158, - /* 730 */ 200, 18, 9, 29, 158, 62, 63, 64, 65, 66, - /* 740 */ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - /* 750 */ 77, 78, 79, 80, 81, 82, 83, 11, 54, 13, - /* 760 */ 14, 15, 16, 19, 55, 56, 99, 23, 15, 198, - /* 770 */ 9, 63, 152, 27, 9, 99, 140, 24, 32, 136, - /* 780 */ 137, 122, 205, 37, 141, 152, 130, 140, 211, 146, - /* 790 */ 87, 88, 39, 146, 146, 42, 52, 51, 140, 53, - /* 800 */ 140, 9, 182, 167, 58, 158, 62, 103, 95, 89, - /* 810 */ 89, 140, 92, 92, 171, 182, 19, 9, 171, 171, - /* 820 */ 23, 89, 78, 79, 92, 167, 20, 167, 22, 158, - /* 830 */ 86, 87, 88, 89, 20, 41, 92, 93, 60, 196, - /* 840 */ 46, 194, 206, 130, 196, 140, 100, 101, 102, 52, - /* 850 */ 140, 204, 106, 146, 140, 111, 146, 111, 139, 62, - /* 860 */ 212, 150, 68, 69, 206, 217, 206, 19, 158, 125, - /* 870 */ 126, 23, 167, 48, 140, 78, 79, 80, 171, 140, - /* 880 */ 140, 171, 139, 86, 87, 88, 89, 93, 140, 92, - /* 890 */ 93, 140, 158, 146, 140, 140, 19, 140, 140, 140, - /* 900 */ 52, 123, 140, 196, 194, 44, 167, 167, 116, 158, - /* 910 */ 62, 206, 158, 158, 204, 158, 158, 158, 171, 212, - /* 920 */ 158, 140, 125, 126, 217, 140, 78, 79, 62, 140, - /* 930 */ 140, 140, 198, 140, 86, 87, 88, 89, 140, 158, - /* 940 */ 92, 93, 22, 158, 140, 206, 206, 158, 158, 158, - /* 950 */ 9, 158, 140, 20, 206, 22, 158, 140, 9, 93, - /* 960 */ 140, 140, 158, 140, 140, 20, 140, 22, 140, 140, - /* 970 */ 158, 140, 140, 125, 126, 158, 140, 140, 158, 158, - /* 980 */ 140, 158, 158, 140, 158, 140, 158, 140, 146, 158, - /* 990 */ 158, 140, 140, 140, 158, 158, 140, 20, 158, 22, - /* 1000 */ 20, 158, 22, 158, 20, 158, 22, 140, 140, 158, - /* 1010 */ 158, 158, 140, 171, 158, 20, 20, 22, 22, 99, - /* 1020 */ 140, 111, 146, 111, 195, 158, 158, 20, 140, 22, - /* 1030 */ 158, 103, 146, 20, 124, 22, 124, 164, 158, 113, - /* 1040 */ 114, 113, 157, 139, 139, 113, 172, 171, 113, 111, - /* 1050 */ 171, 173, 122, 119, 117, 180, 175, 171, 176, 120, - /* 1060 */ 177, 121, 178, 122, 89, 116, 179, 154, 89, 154, - /* 1070 */ 154, 118, 22, 151, 98, 157, 23, 113, 113, 93, - /* 1080 */ 83, 111, 193, 195, 140, 111, 140, 140, 127, 111, - /* 1090 */ 200, 200, 14, 19, 202, 20, 203, 140, 22, 20, - /* 1100 */ 140, 20, 22, 140, 22, 20, 113, 186, 140, 140, - /* 1110 */ 186, 157, 193, 22, 185, 115, 118, 186, 99, 116, - /* 1120 */ 19, 140, 140, 140, 188, 140, 20, 113, 157, 187, - /* 1130 */ 187, 20, 140, 139, 19, 162, 188, 20, 166, 140, - /* 1140 */ 48, 19, 19, 48, 19, 97, 159, 104, 160, 140, - /* 1150 */ 139, 139, 163, 163, 163, 151, 154, 152, 140, 21, - /* 1160 */ 154, 140, 140, 140, 213, 164, 214, 99, 140, 159, - /* 1170 */ 40, 215, 11, 38, 166, 160, 99, 140, 216, 130, - /* 1180 */ 49, 140, 99, 99, 140, 19, 139, 9, 130, 169, - /* 1190 */ 11, 14, 123, 123, 170, 9, 9, 14, 169, 60, - /* 1200 */ 140, 103, 186, 186, 140, 63, 176, 9, 63, 123, - /* 1210 */ 19, 140, 19, 9, 114, 176, 9, 9, 9, 186, - /* 1220 */ 9, 186, 197, 9, 114, 9, 186, 140, 140, 140, - /* 1230 */ 140, 176, 169, 140, 140, 103, 140, 186, 176, 9, - /* 1240 */ 186, 123, 140, 197, 19, 9, 87, 140, 114, 140, - /* 1250 */ 35, 186, 9, 140, 9, 152, 9, 9, 9, 9, - /* 1260 */ 9, 9, 210, 9, 9, 9, 169, 210, 140, 140, - /* 1270 */ 33, 152, 9, 20, 218, 9, 152, 218, 21, 9, - /* 1280 */ 219, 140, +static const YYCODETYPE yy_lookahead[] = { + /* 0 */ 16, 216, 16, 218, 219, 21, 146, 23, 68, 69, + /* 10 */ 70, 71, 109, 73, 74, 75, 76, 77, 78, 79, + /* 20 */ 80, 81, 82, 82, 164, 165, 42, 72, 73, 74, + /* 30 */ 75, 76, 77, 78, 79, 80, 81, 82, 216, 217, + /* 40 */ 218, 219, 168, 59, 60, 61, 62, 63, 64, 65, + /* 50 */ 66, 67, 68, 69, 70, 71, 168, 73, 74, 75, + /* 60 */ 76, 77, 78, 79, 80, 81, 82, 16, 140, 16, + /* 70 */ 86, 143, 23, 22, 88, 89, 90, 91, 92, 93, + /* 80 */ 94, 95, 138, 139, 140, 146, 226, 143, 102, 166, + /* 90 */ 167, 152, 19, 42, 155, 156, 23, 46, 175, 180, + /* 100 */ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + /* 110 */ 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + /* 120 */ 69, 70, 71, 11, 73, 74, 75, 76, 77, 78, + /* 130 */ 79, 80, 81, 82, 16, 86, 87, 88, 1, 2, + /* 140 */ 91, 92, 93, 90, 91, 92, 93, 94, 95, 175, + /* 150 */ 176, 19, 103, 21, 23, 102, 182, 141, 142, 86, + /* 160 */ 42, 49, 44, 147, 79, 80, 81, 82, 180, 154, + /* 170 */ 154, 77, 78, 79, 80, 81, 82, 59, 60, 61, + /* 180 */ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + /* 190 */ 146, 73, 74, 75, 76, 77, 78, 79, 80, 81, + /* 200 */ 82, 16, 14, 188, 188, 58, 21, 12, 77, 78, + /* 210 */ 98, 99, 100, 146, 22, 200, 201, 86, 87, 24, + /* 220 */ 205, 109, 216, 154, 218, 219, 189, 42, 97, 213, + /* 230 */ 160, 187, 37, 86, 39, 168, 169, 90, 160, 161, + /* 240 */ 162, 53, 236, 55, 59, 60, 61, 62, 63, 64, + /* 250 */ 65, 66, 67, 68, 69, 70, 71, 188, 73, 74, + /* 260 */ 75, 76, 77, 78, 79, 80, 81, 82, 16, 199, + /* 270 */ 123, 124, 125, 149, 146, 208, 209, 77, 78, 146, + /* 280 */ 88, 237, 146, 91, 92, 93, 216, 146, 218, 219, + /* 290 */ 154, 0, 1, 2, 42, 103, 168, 169, 21, 160, + /* 300 */ 23, 168, 169, 157, 168, 169, 160, 161, 162, 168, + /* 310 */ 169, 59, 60, 61, 62, 63, 64, 65, 66, 67, + /* 320 */ 68, 69, 70, 71, 188, 73, 74, 75, 76, 77, + /* 330 */ 78, 79, 80, 81, 82, 146, 146, 12, 199, 211, + /* 340 */ 16, 184, 185, 154, 211, 155, 156, 211, 224, 24, + /* 350 */ 88, 223, 228, 91, 92, 93, 223, 168, 169, 223, + /* 360 */ 20, 220, 37, 86, 39, 103, 42, 159, 146, 179, + /* 370 */ 180, 146, 18, 146, 49, 160, 168, 188, 184, 185, + /* 380 */ 155, 156, 130, 59, 60, 61, 62, 63, 64, 65, + /* 390 */ 66, 67, 68, 69, 70, 71, 90, 73, 74, 75, + /* 400 */ 76, 77, 78, 79, 80, 81, 82, 146, 102, 154, + /* 410 */ 16, 146, 16, 146, 199, 20, 20, 146, 185, 146, + /* 420 */ 167, 20, 163, 164, 165, 7, 8, 9, 175, 168, + /* 430 */ 169, 163, 164, 165, 212, 168, 169, 43, 42, 168, + /* 440 */ 169, 168, 169, 188, 22, 105, 92, 107, 108, 19, + /* 450 */ 23, 146, 187, 23, 130, 59, 60, 61, 62, 63, + /* 460 */ 64, 65, 66, 67, 68, 69, 70, 71, 213, 73, + /* 470 */ 74, 75, 76, 77, 78, 79, 80, 81, 82, 16, + /* 480 */ 209, 146, 215, 20, 223, 226, 132, 154, 215, 234, + /* 490 */ 23, 97, 23, 19, 226, 23, 102, 23, 109, 42, + /* 500 */ 105, 23, 107, 108, 146, 42, 105, 146, 107, 108, + /* 510 */ 23, 122, 207, 86, 87, 146, 86, 87, 96, 62, + /* 520 */ 63, 188, 59, 60, 61, 62, 63, 64, 65, 66, + /* 530 */ 67, 68, 69, 70, 71, 14, 73, 74, 75, 76, + /* 540 */ 77, 78, 79, 80, 81, 82, 16, 90, 146, 146, + /* 550 */ 20, 79, 146, 86, 87, 86, 87, 30, 86, 87, + /* 560 */ 86, 87, 146, 25, 86, 87, 105, 29, 107, 108, + /* 570 */ 168, 169, 42, 86, 53, 146, 55, 50, 146, 41, + /* 580 */ 113, 212, 113, 225, 168, 169, 146, 181, 144, 59, + /* 590 */ 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + /* 600 */ 70, 71, 146, 73, 74, 75, 76, 77, 78, 79, + /* 610 */ 80, 81, 82, 16, 146, 22, 187, 20, 190, 146, + /* 620 */ 109, 146, 146, 146, 168, 169, 146, 191, 101, 146, + /* 630 */ 146, 225, 146, 122, 198, 146, 168, 169, 129, 42, + /* 640 */ 131, 168, 169, 168, 169, 168, 169, 207, 168, 169, + /* 650 */ 154, 168, 169, 132, 168, 169, 59, 60, 61, 62, + /* 660 */ 63, 64, 65, 66, 67, 68, 69, 70, 71, 146, + /* 670 */ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + /* 680 */ 16, 146, 27, 207, 188, 21, 146, 154, 146, 34, + /* 690 */ 146, 168, 169, 146, 20, 146, 22, 146, 98, 99, + /* 700 */ 100, 200, 201, 168, 169, 112, 42, 16, 168, 169, + /* 710 */ 168, 169, 168, 169, 146, 168, 169, 168, 169, 168, + /* 720 */ 169, 188, 22, 59, 60, 61, 62, 63, 64, 65, + /* 730 */ 66, 67, 68, 69, 70, 71, 146, 73, 74, 75, + /* 740 */ 76, 77, 78, 79, 80, 81, 82, 16, 146, 146, + /* 750 */ 146, 146, 146, 146, 146, 187, 146, 22, 168, 169, + /* 760 */ 146, 98, 99, 100, 146, 106, 146, 123, 124, 110, + /* 770 */ 168, 169, 160, 42, 168, 169, 168, 169, 168, 169, + /* 780 */ 43, 90, 168, 169, 181, 181, 168, 169, 168, 169, + /* 790 */ 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + /* 800 */ 69, 70, 71, 146, 73, 74, 75, 76, 77, 78, + /* 810 */ 79, 80, 81, 82, 16, 146, 146, 146, 146, 146, + /* 820 */ 120, 146, 87, 146, 202, 168, 169, 146, 225, 225, + /* 830 */ 7, 8, 146, 20, 97, 22, 146, 168, 169, 146, + /* 840 */ 42, 168, 169, 168, 169, 168, 169, 146, 113, 168, + /* 850 */ 169, 181, 181, 146, 168, 169, 79, 59, 60, 61, + /* 860 */ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + /* 870 */ 146, 73, 74, 75, 76, 77, 78, 79, 80, 81, + /* 880 */ 82, 16, 146, 106, 89, 90, 146, 110, 146, 20, + /* 890 */ 146, 22, 168, 169, 146, 225, 225, 20, 20, 22, + /* 900 */ 22, 51, 52, 154, 168, 169, 177, 42, 168, 169, + /* 910 */ 168, 169, 168, 169, 146, 177, 168, 169, 146, 146, + /* 920 */ 146, 146, 146, 19, 16, 60, 61, 62, 63, 64, + /* 930 */ 65, 66, 67, 68, 69, 70, 71, 188, 73, 74, + /* 940 */ 75, 76, 77, 78, 79, 80, 81, 82, 177, 20, + /* 950 */ 42, 22, 146, 20, 20, 22, 22, 146, 20, 187, + /* 960 */ 22, 187, 187, 187, 20, 20, 22, 22, 146, 61, + /* 970 */ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + /* 980 */ 19, 73, 74, 75, 76, 77, 78, 79, 80, 81, + /* 990 */ 82, 16, 17, 187, 19, 146, 230, 146, 23, 146, + /* 1000 */ 231, 146, 146, 146, 146, 146, 31, 16, 17, 146, + /* 1010 */ 19, 171, 146, 146, 23, 111, 146, 146, 190, 192, + /* 1020 */ 148, 227, 31, 48, 227, 222, 193, 193, 67, 6, + /* 1030 */ 176, 171, 171, 58, 172, 171, 145, 145, 145, 48, + /* 1040 */ 145, 22, 153, 97, 171, 170, 170, 40, 96, 58, + /* 1050 */ 170, 170, 77, 78, 172, 120, 188, 178, 117, 119, + /* 1060 */ 85, 86, 87, 221, 115, 90, 118, 193, 77, 78, + /* 1070 */ 79, 129, 151, 111, 95, 23, 85, 86, 87, 16, + /* 1080 */ 17, 90, 19, 195, 109, 159, 23, 197, 194, 97, + /* 1090 */ 151, 114, 196, 210, 31, 210, 19, 173, 123, 124, + /* 1100 */ 125, 126, 127, 128, 203, 178, 204, 204, 203, 210, + /* 1110 */ 210, 48, 159, 170, 123, 124, 125, 126, 127, 128, + /* 1120 */ 170, 58, 5, 15, 170, 151, 150, 10, 11, 12, + /* 1130 */ 13, 173, 151, 151, 151, 19, 38, 129, 232, 23, + /* 1140 */ 77, 78, 233, 26, 150, 28, 151, 59, 85, 86, + /* 1150 */ 87, 183, 35, 90, 183, 19, 193, 15, 186, 186, + /* 1160 */ 193, 214, 151, 183, 47, 214, 49, 33, 151, 151, + /* 1170 */ 186, 54, 235, 56, 58, 136, 174, 174, 158, 1, + /* 1180 */ 20, 32, 44, 19, 229, 111, 123, 124, 125, 126, + /* 1190 */ 127, 128, 235, 77, 78, 111, 111, 238, 111, 19, + /* 1200 */ 90, 20, 86, 20, 19, 106, 90, 11, 19, 22, + /* 1210 */ 20, 20, 116, 116, 22, 98, 99, 100, 113, 22, + /* 1220 */ 19, 104, 20, 111, 20, 19, 109, 20, 44, 19, + /* 1230 */ 19, 19, 44, 94, 102, 16, 21, 17, 97, 123, + /* 1240 */ 124, 125, 97, 45, 36, 22, 132, 19, 45, 5, + /* 1250 */ 133, 1, 101, 67, 121, 19, 112, 17, 112, 101, + /* 1260 */ 67, 121, 19, 14, 134, 20, 57, 3, 239, 4, + /* 1270 */ 135, }; -#define YY_SHIFT_USE_DFLT (-68) -static short yy_shift_ofst[] = { - /* 0 */ 170, 113, -68, 746, -8, -68, 8, 127, 288, 239, - /* 10 */ 348, 167, -68, -68, -68, -68, -68, -68, 547, -68, - /* 20 */ -68, -68, -68, 115, 613, 115, 723, 115, 761, 44, - /* 30 */ 765, 547, 507, 814, 808, 98, -68, 501, -68, 21, - /* 40 */ -68, 547, 119, -68, 667, -68, 231, 667, -68, 861, - /* 50 */ -68, 541, -68, -68, 825, 289, 667, -68, -68, -68, - /* 60 */ 667, -68, 877, 848, 511, 58, 932, 935, 744, -68, - /* 70 */ 279, 938, -68, 515, -68, 561, 930, 934, 939, 937, - /* 80 */ 940, -68, 63, -68, 975, -68, 979, -68, 616, 63, - /* 90 */ -68, 63, -68, 953, 848, 1050, 848, 976, 289, -68, - /* 100 */ 1053, -68, -68, 485, 848, -68, 964, 547, 965, 547, - /* 110 */ -68, -68, -68, -68, 673, 848, 626, 848, -48, 848, - /* 120 */ -48, 848, -48, 848, -48, 848, -67, 848, -67, 848, - /* 130 */ 51, 848, 51, 848, 51, 848, 51, 848, -67, 794, - /* 140 */ 848, -67, -68, -68, 848, -7, 848, -7, 848, 997, - /* 150 */ 848, 997, 848, 997, 848, -68, -68, 866, -68, 986, - /* 160 */ -68, -68, 848, 532, 848, -67, 61, 744, 284, 563, - /* 170 */ 970, 974, 978, -68, 485, 848, 673, 848, -68, 848, - /* 180 */ -68, 848, -68, 244, 26, 961, 557, 1078, -68, 848, - /* 190 */ 94, 848, 485, 1074, 753, 1075, -68, 1076, 547, 1079, - /* 200 */ -68, 1080, 547, 1081, -68, 1082, 547, 1085, -68, 848, - /* 210 */ 164, 848, 211, 848, 485, 657, -68, 848, -68, -68, - /* 220 */ 993, 547, -68, -68, -68, 848, 579, 848, 673, 230, - /* 230 */ 744, 292, -68, 701, -68, 993, -68, 976, 289, -68, - /* 240 */ 848, 485, 998, 848, 1091, 848, 485, -68, -68, 503, - /* 250 */ -68, -68, -68, 408, -68, 454, -68, 1000, -68, 355, - /* 260 */ 993, 457, -68, -68, 547, -68, -68, 1019, 1003, -68, - /* 270 */ 1101, 547, 702, -68, 547, -68, 289, -68, -68, 848, - /* 280 */ 485, 938, 376, 285, 1106, 457, 1019, 1003, -68, 797, - /* 290 */ -21, -68, -68, 1014, 353, -68, -68, -68, -68, 280, - /* 300 */ -68, 806, -68, 1111, -68, 344, 667, -68, 547, 1115, - /* 310 */ -68, 486, -68, 547, -68, 346, 704, -68, 585, -68, - /* 320 */ -68, -68, -68, 704, -68, 704, -68, 547, 933, -68, - /* 330 */ -68, 1053, -68, 861, -68, -68, 172, -68, -68, -68, - /* 340 */ 720, -68, -68, 721, -68, -68, -68, -68, 598, 63, - /* 350 */ 945, -68, 63, 1117, -68, -68, -68, -68, 106, -26, - /* 360 */ -68, 547, -68, 1092, 1122, 547, 977, 667, -68, 1123, - /* 370 */ 547, 980, 667, -68, 848, 391, -68, 1095, 1125, 547, - /* 380 */ 984, 1048, 547, 1115, -68, 383, 1043, -68, -68, -68, - /* 390 */ -68, -68, 938, 329, 713, 201, 547, -68, 547, 1138, - /* 400 */ 938, 467, 547, 591, 437, 1068, 547, 993, 1130, 193, - /* 410 */ 1161, 848, 438, 1135, 709, -68, -68, 1077, 1083, 676, - /* 420 */ 547, 920, 547, -68, -68, -68, -68, 1131, -68, -68, - /* 430 */ 1049, 547, 1084, 547, 524, 1166, 547, 995, 288, 1178, - /* 440 */ 1058, 1179, 281, 472, 778, 167, -68, 1069, 1070, 1177, - /* 450 */ 1186, 1187, 281, 1183, 1139, 547, 1098, 547, 659, 547, - /* 460 */ 1142, 848, 485, 1198, 1145, 848, 485, 1086, 547, 1191, - /* 470 */ 547, 996, -68, 910, 480, 1193, 848, 1007, 848, 485, - /* 480 */ 1204, 485, 1100, 547, 941, 1207, 656, 547, 1208, 547, - /* 490 */ 1209, 547, 188, 1211, 547, 188, 1214, 519, 1110, 547, - /* 500 */ 993, 941, 1216, 1139, 547, 928, 1132, 547, 659, 1230, - /* 510 */ 1118, 547, 993, 1191, 912, 523, 1225, 848, 1013, 1236, - /* 520 */ 1139, 547, 926, 1134, 547, 792, 1215, 1159, 1243, 703, - /* 530 */ 1245, 501, 708, 120, 1247, 1248, 1249, 1250, 732, 1251, - /* 540 */ 1252, 1254, 732, 1255, -68, 547, 1253, 1256, 1237, 501, - /* 550 */ 1257, 547, 949, 1263, 501, 1266, -68, 1237, 547, 1270, - /* 560 */ -68, -68, -68, +#define YY_SHIFT_USE_DFLT (-98) +#define YY_SHIFT_MAX 369 +static const short yy_shift_ofst[] = { + /* 0 */ 137, 975, 1117, -16, 975, 1063, 1063, 1063, 49, -97, + /* 10 */ 118, 1063, 1063, 1063, 1063, 1063, -45, 112, 131, 478, + /* 20 */ 487, 200, 200, 51, 185, 252, 324, 396, 463, 530, + /* 30 */ 597, 664, 731, 798, 731, 731, 731, 731, 731, 731, + /* 40 */ 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, + /* 50 */ 731, 865, 908, 908, 991, 1063, 1063, 1063, 1063, 1063, + /* 60 */ 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, + /* 70 */ 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, + /* 80 */ 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, + /* 90 */ 1063, 1063, 1063, -60, -60, -14, 27, 27, 94, 85, + /* 100 */ 394, 478, 478, 478, 478, 354, 478, 478, 478, 487, + /* 110 */ -59, -98, -98, -98, 1116, 53, 325, 325, 291, 277, + /* 120 */ 478, 277, 478, 478, 478, 478, 478, 478, 478, 478, + /* 130 */ 478, 478, 478, 478, 478, 389, 511, -97, -97, -97, + /* 140 */ -98, -98, 147, 147, 192, 262, 340, 430, 395, 401, + /* 150 */ 195, 467, 469, 474, 472, 418, 427, 427, 777, 427, + /* 160 */ 427, 73, 427, 427, 735, 427, 427, 461, 735, 427, + /* 170 */ 427, 527, 527, 527, 427, 427, 461, 427, 427, 461, + /* 180 */ 427, 538, 600, 427, 427, 461, 427, 427, 427, 461, + /* 190 */ 427, 461, 461, 427, 427, 427, 427, 427, 427, 132, + /* 200 */ 655, 659, 593, 644, 644, 509, 655, 655, 737, 655, + /* 210 */ 655, 422, 700, 700, 1023, 1023, 1023, 1023, 1019, 946, + /* 220 */ 946, 1007, 946, 952, 946, -97, 935, 941, 948, 949, + /* 230 */ 940, 942, 962, 979, 1052, 979, 962, 992, 977, 992, + /* 240 */ 977, 1077, 979, 979, 1052, 1007, 946, 946, 946, 1077, + /* 250 */ 1108, 962, 962, 962, 962, 1098, 1008, 1108, 962, 1088, + /* 260 */ 1088, 1136, 935, 1142, 1142, 1142, 935, 1088, 1136, 962, + /* 270 */ 1134, 1134, 962, 962, 1039, -98, -98, -98, -98, 457, + /* 280 */ 521, 663, 188, 306, 823, 904, 674, 691, 813, 869, + /* 290 */ 877, 795, 878, 929, 933, 850, 934, 938, 944, 945, + /* 300 */ 961, 1178, 1160, 1149, 1138, 1164, 1074, 1084, 1085, 1087, + /* 310 */ 1180, 1181, 1183, 1110, 1099, 1185, 1196, 1189, 1190, 1187, + /* 320 */ 1191, 1096, 1192, 1097, 1197, 1105, 1201, 1202, 1112, 1204, + /* 330 */ 1184, 1206, 1207, 1210, 1211, 1188, 1212, 1139, 1132, 1219, + /* 340 */ 1220, 1215, 1141, 1208, 1198, 1223, 1203, 1114, 1145, 1228, + /* 350 */ 1244, 1250, 1151, 1186, 1193, 1133, 1236, 1144, 1240, 1146, + /* 360 */ 1158, 1140, 1243, 1245, 1249, 1209, 1130, 1135, 1264, 1265, }; -#define YY_REDUCE_USE_DFLT (-123) -static short yy_reduce_ofst[] = { - /* 0 */ -111, 55, -123, 643, -123, -123, -123, -100, 82, -123, - /* 10 */ -123, 233, -123, -123, -123, -123, -123, -123, 310, -123, - /* 20 */ -123, -123, -123, 442, -123, 448, -123, 542, -123, 540, - /* 30 */ -123, 122, 573, -123, -123, 162, -123, 339, 711, 158, - /* 40 */ -123, 714, 147, -123, 719, -123, -123, 743, -123, 873, - /* 50 */ -123, -123, -123, -123, -123, 885, 904, -123, -123, -123, - /* 60 */ 905, -123, -123, 525, -123, 171, -123, -123, 226, -123, - /* 70 */ 874, 879, -123, 878, -96, 881, 882, 883, 884, 887, - /* 80 */ 875, -123, 913, -123, -123, -123, -123, -123, -123, 915, - /* 90 */ -123, 916, -123, -123, 237, -123, -121, 889, 918, -123, - /* 100 */ 922, -123, -123, 890, 570, -123, -123, 944, -123, 946, - /* 110 */ -123, -123, -123, -123, 890, 576, 890, 671, 890, 751, - /* 120 */ 890, 754, 890, 755, 890, 757, 890, 758, 890, 759, - /* 130 */ 890, 762, 890, 781, 890, 785, 890, 789, 890, 891, - /* 140 */ 790, 890, -123, -123, 791, 890, 793, 890, 798, 890, - /* 150 */ 804, 890, 812, 890, 817, 890, -123, -123, -123, -123, - /* 160 */ -123, -123, 820, 890, 821, 890, 947, 647, 874, -123, - /* 170 */ -123, -123, -123, -123, 890, 823, 890, 824, 890, 826, - /* 180 */ 890, 828, 890, 335, 890, 892, 893, -123, -123, 831, - /* 190 */ 890, 832, 890, -123, -123, -123, -123, -123, 957, -123, - /* 200 */ -123, -123, 960, -123, -123, -123, 963, -123, -123, 836, - /* 210 */ 890, 837, 890, 840, 890, -123, -123, -122, -123, -123, - /* 220 */ 921, 968, -123, -123, -123, 843, 890, 845, 890, 969, - /* 230 */ 710, 874, -123, -123, -123, 924, -123, 919, 954, -123, - /* 240 */ 847, 890, -123, 240, -123, 851, 890, -123, 184, 929, - /* 250 */ -123, -123, -123, 981, -123, 982, -123, -123, -123, 983, - /* 260 */ 931, 620, -123, -123, 985, -123, -123, 942, 936, -123, - /* 270 */ -123, 636, -123, -123, 748, -123, 971, -123, -123, 852, - /* 280 */ 890, 351, 874, 929, -123, 633, 943, 948, -123, 853, - /* 290 */ 116, -123, -123, -123, 944, -123, -123, -123, -123, 890, - /* 300 */ -123, -123, -123, -123, -123, 890, 994, -123, 992, 987, - /* 310 */ 988, 973, -123, 999, -123, -123, 989, -123, -123, -123, - /* 320 */ -123, -123, -123, 990, -123, 991, -123, 658, -123, -123, - /* 330 */ -123, 1004, -123, 1001, -123, -123, -123, -123, -123, -123, - /* 340 */ -123, -123, -123, -123, -123, -123, -123, -123, 1005, 1002, - /* 350 */ -123, -123, 1006, -123, -123, -123, -123, -123, 972, 1008, - /* 360 */ -123, 1009, -123, -123, -123, 660, -123, 1011, -123, -123, - /* 370 */ 705, -123, 1012, -123, 856, 530, -123, -123, -123, 739, - /* 380 */ -123, -123, 1018, 1010, 1015, 502, -123, -123, -123, -123, - /* 390 */ -123, -123, 747, 874, 577, -123, 1021, -123, 1022, -123, - /* 400 */ 842, 874, 1023, 951, 952, -123, 1028, 1016, 956, 962, - /* 410 */ -123, 867, 890, -123, -123, -123, -123, -123, -123, -123, - /* 420 */ 295, -123, 1037, -123, -123, -123, -123, -123, -123, -123, - /* 430 */ -123, 1041, -123, 1044, 1017, -123, 740, -123, 1047, -123, - /* 440 */ -123, -123, 648, 874, 1020, 1024, -123, -123, -123, -123, - /* 450 */ -123, -123, 707, -123, 1029, 1060, -123, 829, 1030, 1064, - /* 460 */ -123, 868, 890, -123, -123, 872, 890, -123, 1071, 1025, - /* 470 */ 432, -123, -123, 876, 874, -123, 571, -123, 880, 890, - /* 480 */ -123, 890, -123, 1087, 1039, -123, -123, 1088, -123, 1089, - /* 490 */ -123, 1090, 1033, -123, 1093, 1035, -123, 874, -123, 1094, - /* 500 */ 1040, 1055, -123, 1063, 1096, 1051, -123, 888, 1062, -123, - /* 510 */ -123, 1102, 1054, 1046, 886, 874, -123, 734, -123, -123, - /* 520 */ 1097, 1107, 1065, -123, 1109, -123, -123, -123, -123, 1113, - /* 530 */ -123, 1103, -123, 47, -123, -123, -123, -123, 1052, -123, - /* 540 */ -123, -123, 1057, -123, -123, 1128, -123, -123, 1056, 1119, - /* 550 */ -123, 1129, 1061, -123, 1124, -123, -123, 1059, 1141, -123, - /* 560 */ -123, -123, -123, +#define YY_REDUCE_USE_DFLT (-216) +#define YY_REDUCE_MAX 278 +static const short yy_reduce_ofst[] = { + /* 0 */ -56, 136, 16, 70, 189, 128, 67, 133, 190, 15, + /* 10 */ 6, 141, 261, 271, 267, 273, -178, 255, -140, -61, + /* 20 */ 146, 259, 268, -215, -215, -215, -215, -215, -215, -215, + /* 30 */ -215, -215, -215, -215, -215, -215, -215, -215, -215, -215, + /* 40 */ -215, -215, -215, -215, -215, -215, -215, -215, -215, -215, + /* 50 */ -215, -215, -215, -215, 402, 416, 456, 468, 473, 475, + /* 60 */ 477, 480, 483, 486, 523, 535, 540, 542, 544, 547, + /* 70 */ 549, 551, 590, 602, 606, 608, 610, 614, 618, 620, + /* 80 */ 657, 669, 673, 675, 677, 681, 686, 724, 736, 740, + /* 90 */ 742, 744, 748, -215, -215, -77, -215, -215, -215, -215, + /* 100 */ -26, 406, 603, 604, 670, 124, 671, 44, 225, 78, + /* 110 */ -215, -215, -215, -215, 208, 253, 157, 194, -72, 139, + /* 120 */ 305, 215, 358, 265, 440, 222, 476, 429, 568, 772, + /* 130 */ 774, 775, 776, 369, 806, 69, 333, 496, 533, 749, + /* 140 */ 436, 501, -126, -112, -81, -12, 37, 227, 37, 37, + /* 150 */ 233, 335, 361, 403, 432, 444, 484, 489, 428, 432, + /* 160 */ 605, 612, 607, 672, 622, 690, 693, 37, 622, 701, + /* 170 */ 707, 729, 738, 771, 768, 773, 37, 811, 822, 37, + /* 180 */ 849, 766, 769, 851, 853, 37, 855, 856, 857, 37, + /* 190 */ 858, 37, 37, 859, 863, 866, 867, 870, 871, 872, + /* 200 */ 840, 828, 827, 794, 797, 803, 860, 861, 854, 864, + /* 210 */ 873, 862, 833, 834, 891, 892, 893, 895, 889, 875, + /* 220 */ 876, 879, 880, 882, 881, 868, 874, 894, 888, 896, + /* 230 */ 890, 842, 921, 883, 926, 885, 939, 901, 902, 905, + /* 240 */ 903, 924, 899, 900, 953, 927, 943, 950, 954, 958, + /* 250 */ 976, 974, 981, 982, 983, 906, 909, 994, 995, 968, + /* 260 */ 971, 947, 963, 972, 973, 984, 967, 980, 951, 1011, + /* 270 */ 937, 957, 1017, 1018, 959, 1020, 1002, 1003, 955, }; -static YYACTIONTYPE yy_default[] = { - /* 0 */ 570, 570, 564, 856, 856, 566, 856, 572, 856, 856, - /* 10 */ 856, 856, 652, 655, 656, 657, 658, 659, 573, 574, - /* 20 */ 591, 592, 593, 856, 856, 856, 856, 856, 856, 856, - /* 30 */ 856, 856, 856, 856, 856, 856, 584, 594, 604, 586, - /* 40 */ 603, 856, 856, 605, 651, 616, 856, 651, 617, 636, - /* 50 */ 634, 856, 637, 638, 856, 708, 651, 618, 706, 707, - /* 60 */ 651, 619, 856, 856, 737, 797, 743, 738, 856, 664, - /* 70 */ 856, 856, 665, 673, 675, 682, 720, 711, 713, 701, - /* 80 */ 715, 670, 856, 600, 856, 601, 856, 602, 716, 856, - /* 90 */ 717, 856, 718, 856, 856, 702, 856, 709, 708, 703, - /* 100 */ 856, 588, 710, 705, 856, 736, 856, 856, 739, 856, - /* 110 */ 740, 741, 742, 744, 747, 856, 748, 856, 749, 856, - /* 120 */ 750, 856, 751, 856, 752, 856, 753, 856, 754, 856, - /* 130 */ 755, 856, 756, 856, 757, 856, 758, 856, 759, 856, - /* 140 */ 856, 760, 761, 762, 856, 763, 856, 764, 856, 765, - /* 150 */ 856, 766, 856, 767, 856, 768, 769, 856, 770, 856, - /* 160 */ 773, 771, 856, 856, 856, 779, 856, 797, 856, 856, - /* 170 */ 856, 856, 856, 782, 796, 856, 774, 856, 775, 856, - /* 180 */ 776, 856, 777, 856, 856, 856, 856, 856, 787, 856, - /* 190 */ 856, 856, 788, 856, 856, 856, 845, 856, 856, 856, - /* 200 */ 846, 856, 856, 856, 847, 856, 856, 856, 848, 856, - /* 210 */ 856, 856, 856, 856, 789, 856, 781, 797, 794, 795, - /* 220 */ 690, 856, 691, 785, 772, 856, 856, 856, 780, 856, - /* 230 */ 797, 856, 784, 856, 783, 690, 786, 709, 708, 704, - /* 240 */ 856, 714, 856, 797, 712, 856, 721, 674, 685, 683, - /* 250 */ 684, 692, 693, 856, 694, 856, 695, 856, 696, 856, - /* 260 */ 690, 681, 589, 590, 856, 679, 680, 698, 700, 686, - /* 270 */ 856, 856, 856, 699, 856, 803, 708, 805, 804, 856, - /* 280 */ 697, 685, 856, 856, 856, 681, 698, 700, 687, 856, - /* 290 */ 681, 676, 677, 856, 856, 678, 671, 672, 778, 856, - /* 300 */ 735, 856, 745, 856, 746, 856, 651, 620, 856, 801, - /* 310 */ 624, 621, 625, 856, 626, 856, 856, 627, 856, 630, - /* 320 */ 631, 632, 633, 856, 628, 856, 629, 856, 856, 802, - /* 330 */ 622, 856, 623, 636, 635, 606, 856, 607, 608, 609, - /* 340 */ 856, 610, 613, 856, 611, 614, 612, 615, 595, 856, - /* 350 */ 856, 596, 856, 856, 597, 599, 598, 587, 856, 856, - /* 360 */ 641, 856, 644, 856, 856, 856, 856, 651, 645, 856, - /* 370 */ 856, 856, 651, 646, 856, 651, 647, 856, 856, 856, - /* 380 */ 856, 856, 856, 801, 624, 649, 856, 648, 650, 642, - /* 390 */ 643, 585, 856, 856, 581, 856, 856, 579, 856, 856, - /* 400 */ 856, 856, 856, 828, 856, 856, 856, 690, 833, 856, - /* 410 */ 856, 856, 856, 856, 856, 834, 835, 856, 856, 856, - /* 420 */ 856, 856, 856, 733, 734, 825, 826, 856, 827, 580, - /* 430 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856, - /* 440 */ 856, 856, 856, 856, 856, 856, 654, 856, 856, 856, - /* 450 */ 856, 856, 856, 856, 653, 856, 856, 856, 856, 856, - /* 460 */ 856, 856, 723, 856, 856, 856, 724, 856, 856, 731, - /* 470 */ 856, 856, 732, 856, 856, 856, 856, 856, 856, 729, - /* 480 */ 856, 730, 856, 856, 856, 856, 856, 856, 856, 856, - /* 490 */ 856, 856, 856, 856, 856, 856, 856, 856, 856, 856, - /* 500 */ 690, 856, 856, 653, 856, 856, 856, 856, 856, 856, - /* 510 */ 856, 856, 690, 731, 856, 856, 856, 856, 856, 856, - /* 520 */ 653, 856, 856, 856, 856, 856, 856, 856, 856, 856, - /* 530 */ 856, 856, 856, 822, 856, 856, 856, 856, 856, 856, - /* 540 */ 856, 856, 856, 856, 821, 856, 856, 856, 854, 856, - /* 550 */ 856, 856, 856, 856, 856, 856, 853, 854, 856, 856, - /* 560 */ 567, 569, 565, +static const YYACTIONTYPE yy_default[] = { + /* 0 */ 565, 789, 854, 680, 854, 789, 854, 789, 854, 684, + /* 10 */ 840, 785, 789, 854, 854, 854, 760, 854, 811, 854, + /* 20 */ 596, 811, 811, 715, 854, 854, 854, 854, 854, 854, + /* 30 */ 854, 854, 716, 854, 788, 784, 780, 782, 781, 717, + /* 40 */ 704, 713, 720, 696, 825, 722, 723, 728, 729, 841, + /* 50 */ 844, 750, 766, 749, 854, 854, 854, 854, 854, 854, + /* 60 */ 854, 854, 854, 854, 854, 854, 854, 854, 854, 854, + /* 70 */ 854, 854, 854, 854, 854, 854, 854, 854, 854, 854, + /* 80 */ 854, 854, 854, 854, 854, 854, 854, 854, 854, 854, + /* 90 */ 854, 854, 854, 752, 771, 589, 751, 759, 753, 754, + /* 100 */ 649, 854, 854, 854, 854, 584, 854, 854, 854, 854, + /* 110 */ 755, 756, 767, 768, 854, 854, 854, 854, 565, 680, + /* 120 */ 854, 680, 854, 854, 854, 854, 854, 854, 854, 854, + /* 130 */ 854, 854, 854, 854, 854, 854, 854, 854, 854, 854, + /* 140 */ 674, 684, 854, 854, 640, 854, 854, 854, 854, 854, + /* 150 */ 854, 854, 854, 854, 854, 572, 570, 854, 672, 854, + /* 160 */ 854, 598, 854, 854, 682, 854, 854, 687, 688, 854, + /* 170 */ 854, 854, 854, 854, 854, 854, 586, 854, 854, 661, + /* 180 */ 854, 817, 854, 854, 854, 832, 854, 854, 854, 830, + /* 190 */ 854, 663, 725, 799, 854, 854, 845, 847, 854, 854, + /* 200 */ 707, 672, 681, 854, 854, 783, 707, 707, 619, 707, + /* 210 */ 707, 622, 719, 719, 569, 569, 569, 569, 639, 651, + /* 220 */ 651, 636, 651, 622, 651, 854, 719, 710, 712, 700, + /* 230 */ 714, 854, 689, 708, 854, 708, 689, 697, 699, 697, + /* 240 */ 699, 793, 708, 708, 854, 636, 651, 651, 651, 793, + /* 250 */ 581, 689, 689, 689, 689, 821, 824, 581, 689, 653, + /* 260 */ 653, 730, 719, 660, 660, 660, 719, 653, 730, 689, + /* 270 */ 843, 843, 689, 689, 852, 606, 624, 624, 827, 854, + /* 280 */ 854, 854, 854, 854, 854, 737, 854, 854, 854, 854, + /* 290 */ 854, 854, 854, 854, 854, 854, 854, 854, 854, 854, + /* 300 */ 806, 854, 854, 854, 854, 854, 742, 738, 854, 739, + /* 310 */ 854, 854, 854, 854, 666, 854, 854, 854, 854, 854, + /* 320 */ 854, 854, 701, 854, 711, 854, 854, 854, 854, 854, + /* 330 */ 854, 854, 854, 854, 854, 854, 854, 854, 854, 854, + /* 340 */ 854, 854, 854, 854, 819, 820, 854, 854, 854, 854, + /* 350 */ 854, 854, 854, 854, 854, 854, 854, 854, 854, 854, + /* 360 */ 854, 854, 854, 854, 854, 851, 854, 854, 566, 854, + /* 370 */ 560, 563, 562, 564, 568, 571, 593, 594, 595, 573, + /* 380 */ 574, 575, 576, 577, 578, 579, 585, 587, 605, 607, + /* 390 */ 614, 652, 655, 656, 657, 835, 836, 837, 615, 634, + /* 400 */ 637, 638, 616, 623, 705, 706, 617, 670, 671, 734, + /* 410 */ 664, 665, 669, 736, 740, 741, 743, 744, 592, 599, + /* 420 */ 600, 603, 604, 807, 809, 808, 810, 602, 601, 745, + /* 430 */ 748, 757, 758, 764, 770, 773, 762, 763, 765, 769, + /* 440 */ 772, 667, 668, 776, 778, 779, 833, 834, 774, 786, + /* 450 */ 787, 690, 777, 761, 702, 591, 709, 703, 673, 683, + /* 460 */ 692, 693, 694, 695, 678, 679, 685, 698, 732, 733, + /* 470 */ 686, 675, 676, 677, 775, 735, 746, 747, 618, 625, + /* 480 */ 626, 627, 630, 631, 632, 633, 628, 629, 794, 795, + /* 490 */ 797, 796, 620, 621, 635, 608, 609, 610, 611, 742, + /* 500 */ 612, 613, 597, 590, 641, 644, 645, 646, 647, 648, + /* 510 */ 650, 642, 643, 588, 580, 582, 691, 813, 822, 823, + /* 520 */ 818, 814, 815, 816, 583, 790, 791, 654, 726, 727, + /* 530 */ 812, 826, 828, 731, 829, 831, 658, 659, 662, 798, + /* 540 */ 838, 718, 721, 724, 800, 801, 802, 803, 804, 805, + /* 550 */ 839, 842, 846, 848, 849, 850, 853, 567, 561, }; #define YY_SZ_ACTTAB (sizeof(yy_action)/sizeof(yy_action[0])) @@ -617,23 +580,23 @@ static YYACTIONTYPE yy_default[] = { #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, /* QUERY => ID */ + 23, /* PLAN => ID */ 23, /* BEGIN => ID */ 0, /* TRANSACTION => nothing */ + 23, /* DEFERRED => ID */ + 23, /* IMMEDIATE => ID */ + 23, /* EXCLUSIVE => ID */ 0, /* COMMIT => nothing */ 23, /* END => ID */ 0, /* ROLLBACK => nothing */ 0, /* CREATE => nothing */ 0, /* TABLE => nothing */ + 23, /* IF => ID */ + 0, /* NOT => nothing */ + 0, /* EXISTS => nothing */ 23, /* TEMP => ID */ 0, /* LP => nothing */ 0, /* RP => nothing */ @@ -642,27 +605,23 @@ static const YYCODETYPE yyFallback[] = { 0, /* ID => nothing */ 23, /* ABORT => ID */ 23, /* AFTER => ID */ + 23, /* ANALYZE => ID */ 23, /* ASC => ID */ 23, /* ATTACH => ID */ 23, /* BEFORE => ID */ 23, /* CASCADE => ID */ - 23, /* CLUSTER => ID */ + 23, /* CAST => 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, /* LIKE_KW => ID */ 23, /* MATCH => ID */ 23, /* KEY => ID */ 23, /* OF => ID */ @@ -676,20 +635,23 @@ static const YYCODETYPE yyFallback[] = { 23, /* TRIGGER => ID */ 23, /* VACUUM => ID */ 23, /* VIEW => ID */ + 23, /* REINDEX => ID */ + 23, /* RENAME => ID */ + 23, /* CTIME_KW => ID */ 0, /* OR => nothing */ 0, /* AND => nothing */ - 0, /* NOT => nothing */ - 0, /* EQ => nothing */ - 0, /* NE => nothing */ - 0, /* ISNULL => nothing */ - 0, /* NOTNULL => nothing */ 0, /* IS => nothing */ 0, /* BETWEEN => nothing */ 0, /* IN => nothing */ + 0, /* ISNULL => nothing */ + 0, /* NOTNULL => nothing */ + 0, /* NE => nothing */ + 0, /* EQ => nothing */ 0, /* GT => nothing */ - 0, /* GE => nothing */ - 0, /* LT => nothing */ 0, /* LE => nothing */ + 0, /* LT => nothing */ + 0, /* GE => nothing */ + 0, /* ESCAPE => nothing */ 0, /* BITAND => nothing */ 0, /* BITOR => nothing */ 0, /* LSHIFT => nothing */ @@ -705,16 +667,15 @@ static const YYCODETYPE yyFallback[] = { 0, /* BITNOT => nothing */ 0, /* STRING => nothing */ 0, /* JOIN_KW => nothing */ - 0, /* INTEGER => nothing */ 0, /* CONSTRAINT => nothing */ 0, /* DEFAULT => nothing */ - 0, /* FLOAT => nothing */ 0, /* NULL => nothing */ 0, /* PRIMARY => nothing */ 0, /* UNIQUE => nothing */ 0, /* CHECK => nothing */ 0, /* REFERENCES => nothing */ 0, /* COLLATE => nothing */ + 0, /* AUTOINCR => nothing */ 0, /* ON => nothing */ 0, /* DELETE => nothing */ 0, /* UPDATE => nothing */ @@ -725,8 +686,8 @@ static const YYCODETYPE yyFallback[] = { 0, /* DROP => nothing */ 0, /* UNION => nothing */ 0, /* ALL => nothing */ - 0, /* INTERSECT => nothing */ 0, /* EXCEPT => nothing */ + 0, /* INTERSECT => nothing */ 0, /* SELECT => nothing */ 0, /* DISTINCT => nothing */ 0, /* DOT => nothing */ @@ -741,12 +702,20 @@ static const YYCODETYPE yyFallback[] = { 0, /* WHERE => nothing */ 0, /* INTO => nothing */ 0, /* VALUES => nothing */ + 0, /* INTEGER => nothing */ + 0, /* FLOAT => nothing */ + 0, /* BLOB => nothing */ + 0, /* REGISTER => nothing */ 0, /* VARIABLE => nothing */ 0, /* CASE => nothing */ 0, /* WHEN => nothing */ 0, /* THEN => nothing */ 0, /* ELSE => nothing */ 0, /* INDEX => nothing */ + 0, /* ALTER => nothing */ + 0, /* TO => nothing */ + 0, /* ADD => nothing */ + 0, /* COLUMNKW => nothing */ }; #endif /* YYFALLBACK */ @@ -776,7 +745,7 @@ typedef struct yyStackEntry yyStackEntry; struct yyParser { int yyidx; /* Index of top element in stack */ int yyerrcnt; /* Shifts left before out of the error */ - sqliteParserARG_SDECL /* A place to hold %extra_argument */ + sqlite3ParserARG_SDECL /* A place to hold %extra_argument */ yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ }; typedef struct yyParser yyParser; @@ -805,7 +774,7 @@ static char *yyTracePrompt = 0; ** Outputs: ** None. */ -void sqliteParserTrace(FILE *TraceFILE, char *zTracePrompt){ +void sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){ yyTraceFILE = TraceFILE; yyTracePrompt = zTracePrompt; if( yyTraceFILE==0 ) yyTracePrompt = 0; @@ -816,362 +785,369 @@ void sqliteParserTrace(FILE *TraceFILE, char *zTracePrompt){ #ifndef NDEBUG /* For tracing shifts, the names of all terminals and nonterminals ** are required. The following table supplies these names */ -static const char *yyTokenName[] = { - "$", "END_OF_FILE", "ILLEGAL", "SPACE", - "UNCLOSED_STRING", "COMMENT", "FUNCTION", "COLUMN", - "AGG_FUNCTION", "SEMI", "EXPLAIN", "BEGIN", - "TRANSACTION", "COMMIT", "END", "ROLLBACK", - "CREATE", "TABLE", "TEMP", "LP", +static const char *const yyTokenName[] = { + "$", "SEMI", "EXPLAIN", "QUERY", + "PLAN", "BEGIN", "TRANSACTION", "DEFERRED", + "IMMEDIATE", "EXCLUSIVE", "COMMIT", "END", + "ROLLBACK", "CREATE", "TABLE", "IF", + "NOT", "EXISTS", "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", + "ABORT", "AFTER", "ANALYZE", "ASC", + "ATTACH", "BEFORE", "CASCADE", "CAST", + "CONFLICT", "DATABASE", "DESC", "DETACH", + "EACH", "FAIL", "FOR", "IGNORE", + "INITIALLY", "INSTEAD", "LIKE_KW", "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", + "REINDEX", "RENAME", "CTIME_KW", "OR", + "AND", "IS", "BETWEEN", "IN", + "ISNULL", "NOTNULL", "NE", "EQ", + "GT", "LE", "LT", "GE", + "ESCAPE", "BITAND", "BITOR", "LSHIFT", + "RSHIFT", "PLUS", "MINUS", "STAR", + "SLASH", "REM", "CONCAT", "UMINUS", + "UPLUS", "BITNOT", "STRING", "JOIN_KW", + "CONSTRAINT", "DEFAULT", "NULL", "PRIMARY", + "UNIQUE", "CHECK", "REFERENCES", "COLLATE", + "AUTOINCR", "ON", "DELETE", "UPDATE", + "INSERT", "SET", "DEFERRABLE", "FOREIGN", + "DROP", "UNION", "ALL", "EXCEPT", + "INTERSECT", "SELECT", "DISTINCT", "DOT", + "FROM", "JOIN", "USING", "ORDER", + "BY", "GROUP", "HAVING", "LIMIT", + "WHERE", "INTO", "VALUES", "INTEGER", + "FLOAT", "BLOB", "REGISTER", "VARIABLE", + "CASE", "WHEN", "THEN", "ELSE", + "INDEX", "ALTER", "TO", "ADD", + "COLUMNKW", "error", "input", "cmdlist", + "ecmd", "cmdx", "cmd", "explain", + "transtype", "trans_opt", "nm", "create_table", + "create_table_args", "temp", "ifnotexists", "dbnm", "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", + "ids", "typetoken", "typename", "signed", + "plus_num", "minus_num", "carg", "ccons", + "term", "expr", "onconf", "sortorder", + "autoinc", "idxlist_opt", "refargs", "defer_subclause", + "refarg", "refact", "init_deferred_pred_opt", "conslist", + "tcons", "idxlist", "defer_subclause_opt", "orconf", + "resolvetype", "raisetype", "ifexists", "fullname", + "oneselect", "multiselect_op", "distinct", "selcollist", + "from", "where_opt", "groupby_opt", "having_opt", + "orderby_opt", "limit_opt", "sclp", "as", + "seltablist", "stl_prefix", "joinop", "on_opt", + "using_opt", "seltablist_paren", "joinop2", "inscollist", + "sortlist", "sortitem", "collate", "exprlist", + "setlist", "insert_cmd", "inscollist_opt", "itemlist", + "likeop", "escape", "between_op", "in_op", + "case_operand", "case_exprlist", "case_else", "expritem", + "uniqueflag", "idxitem", "plus_opt", "number", + "trigger_decl", "trigger_cmd_list", "trigger_time", "trigger_event", + "foreach_clause", "when_clause", "trigger_cmd", "database_kw_opt", + "key_opt", "add_column_fullname", "kwcolumn_opt", }; #endif /* NDEBUG */ #ifndef NDEBUG /* For tracing reduce actions, the names of all rules are required. */ -static const char *yyRuleName[] = { +static const char *const yyRuleName[] = { /* 0 */ "input ::= cmdlist", /* 1 */ "cmdlist ::= cmdlist ecmd", /* 2 */ "cmdlist ::= ecmd", - /* 3 */ "ecmd ::= explain cmdx SEMI", + /* 3 */ "cmdx ::= cmd", /* 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", + /* 5 */ "ecmd ::= explain cmdx SEMI", + /* 6 */ "explain ::=", + /* 7 */ "explain ::= EXPLAIN", + /* 8 */ "explain ::= EXPLAIN QUERY PLAN", + /* 9 */ "cmd ::= BEGIN transtype trans_opt", + /* 10 */ "trans_opt ::=", + /* 11 */ "trans_opt ::= TRANSACTION", + /* 12 */ "trans_opt ::= TRANSACTION nm", + /* 13 */ "transtype ::=", + /* 14 */ "transtype ::= DEFERRED", + /* 15 */ "transtype ::= IMMEDIATE", + /* 16 */ "transtype ::= EXCLUSIVE", + /* 17 */ "cmd ::= COMMIT trans_opt", + /* 18 */ "cmd ::= END trans_opt", + /* 19 */ "cmd ::= ROLLBACK trans_opt", + /* 20 */ "cmd ::= create_table create_table_args", + /* 21 */ "create_table ::= CREATE temp TABLE ifnotexists nm dbnm", + /* 22 */ "ifnotexists ::=", + /* 23 */ "ifnotexists ::= IF NOT EXISTS", + /* 24 */ "temp ::= TEMP", + /* 25 */ "temp ::=", + /* 26 */ "create_table_args ::= LP columnlist conslist_opt RP", + /* 27 */ "create_table_args ::= AS select", + /* 28 */ "columnlist ::= columnlist COMMA column", + /* 29 */ "columnlist ::= column", + /* 30 */ "column ::= columnid type carglist", + /* 31 */ "columnid ::= nm", + /* 32 */ "id ::= ID", + /* 33 */ "ids ::= ID|STRING", + /* 34 */ "nm ::= ID", + /* 35 */ "nm ::= STRING", + /* 36 */ "nm ::= JOIN_KW", + /* 37 */ "type ::=", + /* 38 */ "type ::= typetoken", + /* 39 */ "typetoken ::= typename", + /* 40 */ "typetoken ::= typename LP signed RP", + /* 41 */ "typetoken ::= typename LP signed COMMA signed RP", + /* 42 */ "typename ::= ids", + /* 43 */ "typename ::= typename ids", + /* 44 */ "signed ::= plus_num", + /* 45 */ "signed ::= minus_num", + /* 46 */ "carglist ::= carglist carg", + /* 47 */ "carglist ::=", + /* 48 */ "carg ::= CONSTRAINT nm ccons", + /* 49 */ "carg ::= ccons", + /* 50 */ "carg ::= DEFAULT term", + /* 51 */ "carg ::= DEFAULT LP expr RP", + /* 52 */ "carg ::= DEFAULT PLUS term", + /* 53 */ "carg ::= DEFAULT MINUS term", + /* 54 */ "carg ::= DEFAULT id", + /* 55 */ "ccons ::= NULL onconf", + /* 56 */ "ccons ::= NOT NULL onconf", + /* 57 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc", + /* 58 */ "ccons ::= UNIQUE onconf", + /* 59 */ "ccons ::= CHECK LP expr RP", + /* 60 */ "ccons ::= REFERENCES nm idxlist_opt refargs", + /* 61 */ "ccons ::= defer_subclause", + /* 62 */ "ccons ::= COLLATE id", + /* 63 */ "autoinc ::=", + /* 64 */ "autoinc ::= AUTOINCR", + /* 65 */ "refargs ::=", + /* 66 */ "refargs ::= refargs refarg", + /* 67 */ "refarg ::= MATCH nm", + /* 68 */ "refarg ::= ON DELETE refact", + /* 69 */ "refarg ::= ON UPDATE refact", + /* 70 */ "refarg ::= ON INSERT refact", + /* 71 */ "refact ::= SET NULL", + /* 72 */ "refact ::= SET DEFAULT", + /* 73 */ "refact ::= CASCADE", + /* 74 */ "refact ::= RESTRICT", + /* 75 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt", + /* 76 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt", + /* 77 */ "init_deferred_pred_opt ::=", + /* 78 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED", + /* 79 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE", + /* 80 */ "conslist_opt ::=", + /* 81 */ "conslist_opt ::= COMMA conslist", + /* 82 */ "conslist ::= conslist COMMA tcons", + /* 83 */ "conslist ::= conslist tcons", + /* 84 */ "conslist ::= tcons", + /* 85 */ "tcons ::= CONSTRAINT nm", + /* 86 */ "tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf", + /* 87 */ "tcons ::= UNIQUE LP idxlist RP onconf", + /* 88 */ "tcons ::= CHECK LP expr RP onconf", + /* 89 */ "tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt", + /* 90 */ "defer_subclause_opt ::=", + /* 91 */ "defer_subclause_opt ::= defer_subclause", + /* 92 */ "onconf ::=", + /* 93 */ "onconf ::= ON CONFLICT resolvetype", + /* 94 */ "orconf ::=", + /* 95 */ "orconf ::= OR resolvetype", + /* 96 */ "resolvetype ::= raisetype", + /* 97 */ "resolvetype ::= IGNORE", + /* 98 */ "resolvetype ::= REPLACE", + /* 99 */ "cmd ::= DROP TABLE ifexists fullname", + /* 100 */ "ifexists ::= IF EXISTS", + /* 101 */ "ifexists ::=", + /* 102 */ "cmd ::= CREATE temp VIEW nm dbnm AS select", + /* 103 */ "cmd ::= DROP VIEW ifexists fullname", + /* 104 */ "cmd ::= select", + /* 105 */ "select ::= oneselect", + /* 106 */ "select ::= select multiselect_op oneselect", + /* 107 */ "multiselect_op ::= UNION", + /* 108 */ "multiselect_op ::= UNION ALL", + /* 109 */ "multiselect_op ::= EXCEPT|INTERSECT", + /* 110 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt", + /* 111 */ "distinct ::= DISTINCT", + /* 112 */ "distinct ::= ALL", + /* 113 */ "distinct ::=", + /* 114 */ "sclp ::= selcollist COMMA", + /* 115 */ "sclp ::=", + /* 116 */ "selcollist ::= sclp expr as", + /* 117 */ "selcollist ::= sclp STAR", + /* 118 */ "selcollist ::= sclp nm DOT STAR", + /* 119 */ "as ::= AS nm", + /* 120 */ "as ::= ids", + /* 121 */ "as ::=", + /* 122 */ "from ::=", + /* 123 */ "from ::= FROM seltablist", + /* 124 */ "stl_prefix ::= seltablist joinop", + /* 125 */ "stl_prefix ::=", + /* 126 */ "seltablist ::= stl_prefix nm dbnm as on_opt using_opt", + /* 127 */ "seltablist ::= stl_prefix LP seltablist_paren RP as on_opt using_opt", + /* 128 */ "seltablist_paren ::= select", + /* 129 */ "seltablist_paren ::= seltablist", + /* 130 */ "dbnm ::=", + /* 131 */ "dbnm ::= DOT nm", + /* 132 */ "fullname ::= nm dbnm", + /* 133 */ "joinop ::= COMMA|JOIN", + /* 134 */ "joinop ::= JOIN_KW JOIN", + /* 135 */ "joinop ::= JOIN_KW nm JOIN", + /* 136 */ "joinop ::= JOIN_KW nm nm JOIN", + /* 137 */ "on_opt ::= ON expr", + /* 138 */ "on_opt ::=", + /* 139 */ "using_opt ::= USING LP inscollist RP", + /* 140 */ "using_opt ::=", + /* 141 */ "orderby_opt ::=", + /* 142 */ "orderby_opt ::= ORDER BY sortlist", + /* 143 */ "sortlist ::= sortlist COMMA sortitem collate sortorder", + /* 144 */ "sortlist ::= sortitem collate sortorder", + /* 145 */ "sortitem ::= expr", + /* 146 */ "sortorder ::= ASC", + /* 147 */ "sortorder ::= DESC", + /* 148 */ "sortorder ::=", + /* 149 */ "collate ::=", + /* 150 */ "collate ::= COLLATE id", + /* 151 */ "groupby_opt ::=", + /* 152 */ "groupby_opt ::= GROUP BY exprlist", + /* 153 */ "having_opt ::=", + /* 154 */ "having_opt ::= HAVING expr", + /* 155 */ "limit_opt ::=", + /* 156 */ "limit_opt ::= LIMIT expr", + /* 157 */ "limit_opt ::= LIMIT expr OFFSET expr", + /* 158 */ "limit_opt ::= LIMIT expr COMMA expr", + /* 159 */ "cmd ::= DELETE FROM fullname where_opt", + /* 160 */ "where_opt ::=", + /* 161 */ "where_opt ::= WHERE expr", + /* 162 */ "cmd ::= UPDATE orconf fullname SET setlist where_opt", + /* 163 */ "setlist ::= setlist COMMA nm EQ expr", + /* 164 */ "setlist ::= nm EQ expr", + /* 165 */ "cmd ::= insert_cmd INTO fullname inscollist_opt VALUES LP itemlist RP", + /* 166 */ "cmd ::= insert_cmd INTO fullname inscollist_opt select", + /* 167 */ "insert_cmd ::= INSERT orconf", + /* 168 */ "insert_cmd ::= REPLACE", + /* 169 */ "itemlist ::= itemlist COMMA expr", + /* 170 */ "itemlist ::= expr", + /* 171 */ "inscollist_opt ::=", + /* 172 */ "inscollist_opt ::= LP inscollist RP", + /* 173 */ "inscollist ::= inscollist COMMA nm", + /* 174 */ "inscollist ::= nm", + /* 175 */ "expr ::= term", + /* 176 */ "expr ::= LP expr RP", + /* 177 */ "term ::= NULL", + /* 178 */ "expr ::= ID", + /* 179 */ "expr ::= JOIN_KW", + /* 180 */ "expr ::= nm DOT nm", + /* 181 */ "expr ::= nm DOT nm DOT nm", + /* 182 */ "term ::= INTEGER|FLOAT|BLOB", + /* 183 */ "term ::= STRING", + /* 184 */ "expr ::= REGISTER", + /* 185 */ "expr ::= VARIABLE", + /* 186 */ "expr ::= CAST LP expr AS typetoken RP", + /* 187 */ "expr ::= ID LP distinct exprlist RP", + /* 188 */ "expr ::= ID LP STAR RP", + /* 189 */ "term ::= CTIME_KW", + /* 190 */ "expr ::= expr AND expr", + /* 191 */ "expr ::= expr OR expr", + /* 192 */ "expr ::= expr LT|GT|GE|LE expr", + /* 193 */ "expr ::= expr EQ|NE expr", + /* 194 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr", + /* 195 */ "expr ::= expr PLUS|MINUS expr", + /* 196 */ "expr ::= expr STAR|SLASH|REM expr", + /* 197 */ "expr ::= expr CONCAT expr", + /* 198 */ "likeop ::= LIKE_KW", + /* 199 */ "likeop ::= NOT LIKE_KW", + /* 200 */ "escape ::= ESCAPE expr", + /* 201 */ "escape ::=", + /* 202 */ "expr ::= expr likeop expr escape", + /* 203 */ "expr ::= expr ISNULL|NOTNULL", + /* 204 */ "expr ::= expr IS NULL", + /* 205 */ "expr ::= expr NOT NULL", + /* 206 */ "expr ::= expr IS NOT NULL", + /* 207 */ "expr ::= NOT|BITNOT expr", + /* 208 */ "expr ::= MINUS expr", + /* 209 */ "expr ::= PLUS expr", + /* 210 */ "between_op ::= BETWEEN", + /* 211 */ "between_op ::= NOT BETWEEN", + /* 212 */ "expr ::= expr between_op expr AND expr", + /* 213 */ "in_op ::= IN", + /* 214 */ "in_op ::= NOT IN", + /* 215 */ "expr ::= expr in_op LP exprlist RP", + /* 216 */ "expr ::= LP select RP", + /* 217 */ "expr ::= expr in_op LP select RP", + /* 218 */ "expr ::= expr in_op nm dbnm", + /* 219 */ "expr ::= EXISTS LP select RP", + /* 220 */ "expr ::= CASE case_operand case_exprlist case_else END", + /* 221 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", + /* 222 */ "case_exprlist ::= WHEN expr THEN expr", + /* 223 */ "case_else ::= ELSE expr", + /* 224 */ "case_else ::=", + /* 225 */ "case_operand ::= expr", + /* 226 */ "case_operand ::=", + /* 227 */ "exprlist ::= exprlist COMMA expritem", + /* 228 */ "exprlist ::= expritem", + /* 229 */ "expritem ::= expr", + /* 230 */ "expritem ::=", + /* 231 */ "cmd ::= CREATE uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP", + /* 232 */ "uniqueflag ::= UNIQUE", + /* 233 */ "uniqueflag ::=", + /* 234 */ "idxlist_opt ::=", + /* 235 */ "idxlist_opt ::= LP idxlist RP", + /* 236 */ "idxlist ::= idxlist COMMA idxitem collate sortorder", + /* 237 */ "idxlist ::= idxitem collate sortorder", + /* 238 */ "idxitem ::= nm", + /* 239 */ "cmd ::= DROP INDEX ifexists fullname", + /* 240 */ "cmd ::= VACUUM", + /* 241 */ "cmd ::= VACUUM nm", + /* 242 */ "cmd ::= PRAGMA nm dbnm EQ nm", + /* 243 */ "cmd ::= PRAGMA nm dbnm EQ ON", + /* 244 */ "cmd ::= PRAGMA nm dbnm EQ plus_num", + /* 245 */ "cmd ::= PRAGMA nm dbnm EQ minus_num", + /* 246 */ "cmd ::= PRAGMA nm dbnm LP nm RP", + /* 247 */ "cmd ::= PRAGMA nm dbnm", + /* 248 */ "plus_num ::= plus_opt number", + /* 249 */ "minus_num ::= MINUS number", + /* 250 */ "number ::= INTEGER|FLOAT", + /* 251 */ "plus_opt ::= PLUS", + /* 252 */ "plus_opt ::=", + /* 253 */ "cmd ::= CREATE trigger_decl BEGIN trigger_cmd_list END", + /* 254 */ "trigger_decl ::= temp TRIGGER nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause", + /* 255 */ "trigger_time ::= BEFORE", + /* 256 */ "trigger_time ::= AFTER", + /* 257 */ "trigger_time ::= INSTEAD OF", + /* 258 */ "trigger_time ::=", + /* 259 */ "trigger_event ::= DELETE|INSERT", + /* 260 */ "trigger_event ::= UPDATE", + /* 261 */ "trigger_event ::= UPDATE OF inscollist", + /* 262 */ "foreach_clause ::=", + /* 263 */ "foreach_clause ::= FOR EACH ROW", + /* 264 */ "foreach_clause ::= FOR EACH STATEMENT", + /* 265 */ "when_clause ::=", + /* 266 */ "when_clause ::= WHEN expr", + /* 267 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", + /* 268 */ "trigger_cmd_list ::=", + /* 269 */ "trigger_cmd ::= UPDATE orconf nm SET setlist where_opt", + /* 270 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt VALUES LP itemlist RP", + /* 271 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt select", + /* 272 */ "trigger_cmd ::= DELETE FROM nm where_opt", + /* 273 */ "trigger_cmd ::= select", + /* 274 */ "expr ::= RAISE LP IGNORE RP", + /* 275 */ "expr ::= RAISE LP raisetype COMMA nm RP", + /* 276 */ "raisetype ::= ROLLBACK", + /* 277 */ "raisetype ::= ABORT", + /* 278 */ "raisetype ::= FAIL", + /* 279 */ "cmd ::= DROP TRIGGER fullname", + /* 280 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", + /* 281 */ "key_opt ::=", + /* 282 */ "key_opt ::= KEY expr", + /* 283 */ "database_kw_opt ::= DATABASE", + /* 284 */ "database_kw_opt ::=", + /* 285 */ "cmd ::= DETACH database_kw_opt expr", + /* 286 */ "cmd ::= REINDEX", + /* 287 */ "cmd ::= REINDEX nm dbnm", + /* 288 */ "cmd ::= ANALYZE", + /* 289 */ "cmd ::= ANALYZE nm dbnm", + /* 290 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", + /* 291 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column", + /* 292 */ "add_column_fullname ::= fullname", + /* 293 */ "kwcolumn_opt ::=", + /* 294 */ "kwcolumn_opt ::= COLUMNKW", }; #endif /* NDEBUG */ @@ -1179,7 +1155,7 @@ static const char *yyRuleName[] = { ** This function returns the symbolic name associated with a token ** value. */ -const char *sqliteParserTokenName(int tokenType){ +const char *sqlite3ParserTokenName(int tokenType){ #ifndef NDEBUG if( tokenType>0 && tokenType<(sizeof(yyTokenName)/sizeof(yyTokenName[0])) ){ return yyTokenName[tokenType]; @@ -1201,9 +1177,9 @@ const char *sqliteParserTokenName(int tokenType){ ** ** Outputs: ** A pointer to a parser. This pointer is used in subsequent calls -** to sqliteParser and sqliteParserFree. +** to sqlite3Parser and sqlite3ParserFree. */ -void *sqliteParserAlloc(void *(*mallocProc)(size_t)){ +void *sqlite3ParserAlloc(void *(*mallocProc)(size_t)){ yyParser *pParser; pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) ); if( pParser ){ @@ -1229,150 +1205,81 @@ static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ ** which appear on the RHS of the rule, but which are not used ** inside the C code. */ - case 146: -#line 286 "parse.y" -{sqliteSelectDelete((yypminor->yy179));} -#line 1235 "parse.c" + case 154: + case 188: + case 205: +#line 371 "parse.y" +{sqlite3SelectDelete((yypminor->yy239));} +#line 1215 "parse.c" break; - case 158: -#line 533 "parse.y" -{sqliteExprDelete((yypminor->yy242));} -#line 1240 "parse.c" + case 168: + case 169: + case 193: + case 195: + case 203: + case 209: + case 217: + case 220: + case 222: + case 223: + case 233: +#line 628 "parse.y" +{sqlite3ExprDelete((yypminor->yy178));} +#line 1230 "parse.c" break; - case 159: -#line 746 "parse.y" -{sqliteIdListDelete((yypminor->yy320));} + case 173: + case 181: + case 191: + case 194: + case 196: + case 198: + case 208: + case 211: + case 212: + case 215: + case 221: +#line 859 "parse.y" +{sqlite3ExprListDelete((yypminor->yy462));} #line 1245 "parse.c" break; - case 167: -#line 744 "parse.y" -{sqliteIdListDelete((yypminor->yy320));} -#line 1250 "parse.c" - break; - case 171: -#line 288 "parse.y" -{sqliteSelectDelete((yypminor->yy179));} -#line 1255 "parse.c" - break; - case 174: -#line 322 "parse.y" -{sqliteExprListDelete((yypminor->yy322));} -#line 1260 "parse.c" - break; - case 175: -#line 353 "parse.y" -{sqliteSrcListDelete((yypminor->yy307));} -#line 1265 "parse.c" - break; - case 176: -#line 483 "parse.y" -{sqliteExprDelete((yypminor->yy242));} -#line 1270 "parse.c" - break; - case 177: -#line 459 "parse.y" -{sqliteExprListDelete((yypminor->yy322));} -#line 1275 "parse.c" - break; - case 178: -#line 464 "parse.y" -{sqliteExprDelete((yypminor->yy242));} -#line 1280 "parse.c" - break; - case 179: -#line 431 "parse.y" -{sqliteExprListDelete((yypminor->yy322));} -#line 1285 "parse.c" - break; - case 181: -#line 324 "parse.y" -{sqliteExprListDelete((yypminor->yy322));} -#line 1290 "parse.c" - break; - case 183: -#line 349 "parse.y" -{sqliteSrcListDelete((yypminor->yy307));} -#line 1295 "parse.c" - break; - case 184: -#line 351 "parse.y" -{sqliteSrcListDelete((yypminor->yy307));} -#line 1300 "parse.c" - break; case 187: -#line 420 "parse.y" -{sqliteExprDelete((yypminor->yy242));} -#line 1305 "parse.c" - break; - case 188: -#line 425 "parse.y" -{sqliteIdListDelete((yypminor->yy320));} -#line 1310 "parse.c" - break; - case 189: -#line 400 "parse.y" -{sqliteSelectDelete((yypminor->yy179));} -#line 1315 "parse.c" - break; - case 191: -#line 433 "parse.y" -{sqliteExprListDelete((yypminor->yy322));} -#line 1320 "parse.c" - break; case 192: -#line 435 "parse.y" -{sqliteExprDelete((yypminor->yy242));} -#line 1325 "parse.c" - break; - case 194: -#line 719 "parse.y" -{sqliteExprListDelete((yypminor->yy322));} -#line 1330 "parse.c" - break; - case 195: -#line 489 "parse.y" -{sqliteExprListDelete((yypminor->yy322));} -#line 1335 "parse.c" + case 200: + case 201: +#line 499 "parse.y" +{sqlite3SrcListDelete((yypminor->yy285));} +#line 1253 "parse.c" break; case 197: -#line 520 "parse.y" -{sqliteIdListDelete((yypminor->yy320));} -#line 1340 "parse.c" - break; - case 198: -#line 514 "parse.y" -{sqliteExprListDelete((yypminor->yy322));} -#line 1345 "parse.c" - break; - case 199: -#line 522 "parse.y" -{sqliteIdListDelete((yypminor->yy320));} -#line 1350 "parse.c" - break; - case 202: -#line 702 "parse.y" -{sqliteExprListDelete((yypminor->yy322));} -#line 1355 "parse.c" +#line 560 "parse.y" +{ + sqlite3ExprDelete((yypminor->yy270).pLimit); + sqlite3ExprDelete((yypminor->yy270).pOffset); +} +#line 1261 "parse.c" break; case 204: -#line 721 "parse.y" -{sqliteExprDelete((yypminor->yy242));} -#line 1360 "parse.c" - break; - case 212: -#line 828 "parse.y" -{sqliteDeleteTriggerStep((yypminor->yy19));} -#line 1365 "parse.c" - break; + case 207: case 214: -#line 812 "parse.y" -{sqliteIdListDelete((yypminor->yy290).b);} -#line 1370 "parse.c" +#line 516 "parse.y" +{sqlite3IdListDelete((yypminor->yy160));} +#line 1268 "parse.c" break; - case 217: -#line 836 "parse.y" -{sqliteDeleteTriggerStep((yypminor->yy19));} -#line 1375 "parse.c" + case 229: + case 234: +#line 953 "parse.y" +{sqlite3DeleteTriggerStep((yypminor->yy247));} +#line 1274 "parse.c" + break; + case 231: +#line 937 "parse.y" +{sqlite3IdListDelete((yypminor->yy132).b);} +#line 1279 "parse.c" + break; + case 236: +#line 1021 "parse.y" +{sqlite3ExprDelete((yypminor->yy292));} +#line 1284 "parse.c" break; default: break; /* If no destructor action specified: do nothing */ } @@ -1411,12 +1318,12 @@ static int yy_pop_parser_stack(yyParser *pParser){ ** Inputs: **
    **
  • A pointer to the parser. This should be a pointer -** obtained from sqliteParserAlloc. +** obtained from sqlite3ParserAlloc. **
  • A pointer to a function used to reclaim memory obtained ** from malloc. **
*/ -void sqliteParserFree( +void sqlite3ParserFree( void *p, /* The parser to be deleted */ void (*freeProc)(void*) /* Function used to reclaim memory */ ){ @@ -1441,9 +1348,7 @@ static int yy_find_shift_action( int i; int stateno = pParser->yystack[pParser->yyidx].stateno; - /* if( pParser->yyidx<0 ) return YY_NO_ACTION; */ - i = yy_shift_ofst[stateno]; - if( i==YY_SHIFT_USE_DFLT ){ + if( stateno>YY_SHIFT_MAX || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){ return yy_default[stateno]; } if( iLookAhead==YYNOCODE ){ @@ -1479,14 +1384,14 @@ static int yy_find_shift_action( ** return YY_NO_ACTION. */ static int yy_find_reduce_action( - yyParser *pParser, /* The parser */ + int stateno, /* Current state number */ int iLookAhead /* The look-ahead token */ ){ int i; - int stateno = pParser->yystack[pParser->yyidx].stateno; + /* int stateno = pParser->yystack[pParser->yyidx].stateno; */ - i = yy_reduce_ofst[stateno]; - if( i==YY_REDUCE_USE_DFLT ){ + if( stateno>YY_REDUCE_MAX || + (i = yy_reduce_ofst[stateno])==YY_REDUCE_USE_DFLT ){ return yy_default[stateno]; } if( iLookAhead==YYNOCODE ){ @@ -1512,7 +1417,7 @@ static void yy_shift( yyStackEntry *yytos; yypParser->yyidx++; if( yypParser->yyidx>=YYSTACKDEPTH ){ - sqliteParserARG_FETCH; + sqlite3ParserARG_FETCH; yypParser->yyidx--; #ifndef NDEBUG if( yyTraceFILE ){ @@ -1522,7 +1427,11 @@ static void yy_shift( 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 */ +#line 43 "parse.y" + + sqlite3ErrorMsg(pParse, "parser stack overflow"); +#line 1436 "parse.c" + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument var */ return; } yytos = &yypParser->yystack[yypParser->yyidx]; @@ -1544,303 +1453,305 @@ static void yy_shift( /* The following table contains information about every rule that ** is used during the reduce. */ -static struct { +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 }, + { 139, 2 }, + { 139, 1 }, + { 141, 1 }, + { 140, 1 }, + { 140, 3 }, { 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 }, + { 143, 1 }, + { 143, 3 }, + { 142, 3 }, { 145, 0 }, + { 145, 1 }, { 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 }, + { 144, 0 }, + { 144, 1 }, + { 144, 1 }, + { 144, 1 }, + { 142, 2 }, + { 142, 2 }, + { 142, 2 }, + { 142, 2 }, + { 147, 6 }, + { 150, 0 }, + { 150, 3 }, + { 149, 1 }, + { 149, 0 }, + { 148, 4 }, + { 148, 2 }, + { 152, 3 }, + { 152, 1 }, + { 155, 3 }, + { 156, 1 }, + { 159, 1 }, + { 160, 1 }, + { 146, 1 }, + { 146, 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 }, + { 157, 1 }, + { 161, 1 }, + { 161, 4 }, + { 161, 6 }, + { 162, 1 }, + { 162, 2 }, + { 163, 1 }, + { 163, 1 }, + { 158, 2 }, + { 158, 0 }, + { 166, 3 }, + { 166, 1 }, + { 166, 2 }, + { 166, 4 }, + { 166, 3 }, + { 166, 3 }, + { 166, 2 }, + { 167, 2 }, + { 167, 3 }, + { 167, 5 }, + { 167, 2 }, + { 167, 4 }, + { 167, 4 }, + { 167, 1 }, + { 167, 2 }, + { 172, 0 }, + { 172, 1 }, + { 174, 0 }, + { 174, 2 }, + { 176, 2 }, + { 176, 3 }, + { 176, 3 }, + { 176, 3 }, + { 177, 2 }, + { 177, 2 }, + { 177, 1 }, + { 177, 1 }, + { 175, 3 }, + { 175, 2 }, { 178, 0 }, { 178, 2 }, - { 180, 0 }, + { 178, 2 }, + { 153, 0 }, + { 153, 2 }, + { 179, 3 }, + { 179, 2 }, + { 179, 1 }, { 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 }, + { 180, 7 }, + { 180, 5 }, + { 180, 5 }, + { 180, 10 }, + { 182, 0 }, + { 182, 1 }, + { 170, 0 }, + { 170, 3 }, + { 183, 0 }, + { 183, 2 }, + { 184, 1 }, + { 184, 1 }, + { 184, 1 }, + { 142, 4 }, + { 186, 2 }, + { 186, 0 }, + { 142, 7 }, + { 142, 4 }, + { 142, 1 }, + { 154, 1 }, + { 154, 3 }, + { 189, 1 }, + { 189, 2 }, + { 189, 1 }, + { 188, 9 }, + { 190, 1 }, + { 190, 1 }, + { 190, 0 }, + { 198, 2 }, + { 198, 0 }, + { 191, 3 }, + { 191, 2 }, + { 191, 4 }, + { 199, 2 }, { 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 }, + { 199, 0 }, + { 192, 0 }, + { 192, 2 }, + { 201, 2 }, + { 201, 0 }, + { 200, 6 }, + { 200, 7 }, + { 205, 1 }, + { 205, 1 }, + { 151, 0 }, + { 151, 2 }, + { 187, 2 }, + { 202, 1 }, + { 202, 2 }, + { 202, 3 }, { 202, 4 }, { 203, 2 }, { 203, 0 }, - { 201, 1 }, - { 201, 0 }, - { 194, 3 }, - { 194, 1 }, - { 204, 1 }, + { 204, 4 }, { 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 }, + { 196, 0 }, + { 196, 3 }, + { 208, 5 }, + { 208, 3 }, { 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 }, + { 171, 1 }, + { 171, 1 }, + { 171, 0 }, + { 210, 0 }, + { 210, 2 }, + { 194, 0 }, + { 194, 3 }, + { 195, 0 }, + { 195, 2 }, + { 197, 0 }, + { 197, 2 }, + { 197, 4 }, + { 197, 4 }, + { 142, 4 }, + { 193, 0 }, + { 193, 2 }, + { 142, 6 }, + { 212, 5 }, { 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 }, + { 142, 8 }, + { 142, 5 }, + { 213, 2 }, + { 213, 1 }, + { 215, 3 }, + { 215, 1 }, + { 214, 0 }, + { 214, 3 }, + { 207, 3 }, + { 207, 1 }, + { 169, 1 }, + { 169, 3 }, + { 168, 1 }, + { 169, 1 }, + { 169, 1 }, + { 169, 3 }, + { 169, 5 }, + { 168, 1 }, + { 168, 1 }, + { 169, 1 }, + { 169, 1 }, + { 169, 6 }, + { 169, 5 }, + { 169, 4 }, + { 168, 1 }, + { 169, 3 }, + { 169, 3 }, + { 169, 3 }, + { 169, 3 }, + { 169, 3 }, + { 169, 3 }, + { 169, 3 }, + { 169, 3 }, + { 216, 1 }, + { 216, 2 }, + { 217, 2 }, + { 217, 0 }, + { 169, 4 }, + { 169, 2 }, + { 169, 3 }, + { 169, 3 }, + { 169, 4 }, + { 169, 2 }, + { 169, 2 }, + { 169, 2 }, { 218, 1 }, - { 218, 0 }, - { 137, 3 }, + { 218, 2 }, + { 169, 5 }, + { 219, 1 }, + { 219, 2 }, + { 169, 5 }, + { 169, 3 }, + { 169, 5 }, + { 169, 4 }, + { 169, 4 }, + { 169, 5 }, + { 221, 5 }, + { 221, 4 }, + { 222, 2 }, + { 222, 0 }, + { 220, 1 }, + { 220, 0 }, + { 211, 3 }, + { 211, 1 }, + { 223, 1 }, + { 223, 0 }, + { 142, 11 }, + { 224, 1 }, + { 224, 0 }, + { 173, 0 }, + { 173, 3 }, + { 181, 5 }, + { 181, 3 }, + { 225, 1 }, + { 142, 4 }, + { 142, 1 }, + { 142, 2 }, + { 142, 5 }, + { 142, 5 }, + { 142, 5 }, + { 142, 5 }, + { 142, 6 }, + { 142, 3 }, + { 164, 2 }, + { 165, 2 }, + { 227, 1 }, + { 226, 1 }, + { 226, 0 }, + { 142, 5 }, + { 228, 10 }, + { 230, 1 }, + { 230, 1 }, + { 230, 2 }, + { 230, 0 }, + { 231, 1 }, + { 231, 1 }, + { 231, 3 }, + { 232, 0 }, + { 232, 3 }, + { 232, 3 }, + { 233, 0 }, + { 233, 2 }, + { 229, 3 }, + { 229, 0 }, + { 234, 6 }, + { 234, 8 }, + { 234, 5 }, + { 234, 4 }, + { 234, 1 }, + { 169, 4 }, + { 169, 6 }, + { 185, 1 }, + { 185, 1 }, + { 185, 1 }, + { 142, 3 }, + { 142, 6 }, + { 236, 0 }, + { 236, 2 }, + { 235, 1 }, + { 235, 0 }, + { 142, 3 }, + { 142, 1 }, + { 142, 3 }, + { 142, 1 }, + { 142, 3 }, + { 142, 6 }, + { 142, 6 }, + { 237, 1 }, + { 238, 0 }, + { 238, 1 }, }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -1858,7 +1769,7 @@ static void yy_reduce( 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; + sqlite3ParserARG_FETCH; yymsp = &yypParser->yystack[yypParser->yyidx]; #ifndef NDEBUG if( yyTraceFILE && yyruleno>=0 @@ -1868,6 +1779,18 @@ static void yy_reduce( } #endif /* NDEBUG */ +#ifndef 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. + */ + memset(&yygotominor, 0, sizeof(yygotominor)); +#endif + switch( yyruleno ){ /* Beginning here are the reduction cases. A typical example ** follows: @@ -1877,1948 +1800,1307 @@ static void yy_reduce( ** #line ** break; */ - case 0: - /* No destructor defined for cmdlist */ - break; - case 1: - /* No destructor defined for cmdlist */ - /* No destructor defined for ecmd */ - break; - case 2: - /* No destructor defined for ecmd */ - break; case 3: - /* No destructor defined for explain */ - /* No destructor defined for cmdx */ - /* No destructor defined for SEMI */ - break; - case 4: - /* No destructor defined for SEMI */ - break; - case 5: -#line 72 "parse.y" -{ sqliteExec(pParse); } -#line 1901 "parse.c" - /* No destructor defined for cmd */ +#line 98 "parse.y" +{ sqlite3FinishCoding(pParse); } +#line 1809 "parse.c" break; case 6: -#line 73 "parse.y" -{ sqliteBeginParse(pParse, 1); } -#line 1907 "parse.c" - /* No destructor defined for EXPLAIN */ +#line 101 "parse.y" +{ sqlite3BeginParse(pParse, 0); } +#line 1814 "parse.c" break; case 7: -#line 74 "parse.y" -{ sqliteBeginParse(pParse, 0); } -#line 1913 "parse.c" +#line 103 "parse.y" +{ sqlite3BeginParse(pParse, 1); } +#line 1819 "parse.c" break; case 8: -#line 79 "parse.y" -{sqliteBeginTransaction(pParse,yymsp[0].minor.yy372);} -#line 1918 "parse.c" - /* No destructor defined for BEGIN */ - /* No destructor defined for trans_opt */ +#line 104 "parse.y" +{ sqlite3BeginParse(pParse, 2); } +#line 1824 "parse.c" break; case 9: - break; - case 10: - /* No destructor defined for TRANSACTION */ - break; - case 11: - /* No destructor defined for TRANSACTION */ - /* No destructor defined for nm */ - break; - case 12: -#line 83 "parse.y" -{sqliteCommitTransaction(pParse);} -#line 1934 "parse.c" - /* No destructor defined for COMMIT */ - /* No destructor defined for trans_opt */ +#line 110 "parse.y" +{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy230);} +#line 1829 "parse.c" break; case 13: -#line 84 "parse.y" -{sqliteCommitTransaction(pParse);} -#line 1941 "parse.c" - /* No destructor defined for END */ - /* No destructor defined for trans_opt */ +#line 115 "parse.y" +{yygotominor.yy230 = TK_DEFERRED;} +#line 1834 "parse.c" break; case 14: -#line 85 "parse.y" -{sqliteRollbackTransaction(pParse);} -#line 1948 "parse.c" - /* No destructor defined for ROLLBACK */ - /* No destructor defined for trans_opt */ - break; case 15: - /* No destructor defined for create_table */ - /* No destructor defined for create_table_args */ - break; case 16: -#line 90 "parse.y" -{ - sqliteStartTable(pParse,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy298,yymsp[-2].minor.yy372,0); -} -#line 1961 "parse.c" - /* No destructor defined for TABLE */ + case 107: + case 109: +#line 116 "parse.y" +{yygotominor.yy230 = yymsp[0].major;} +#line 1843 "parse.c" break; case 17: -#line 94 "parse.y" -{yygotominor.yy372 = 1;} -#line 1967 "parse.c" - /* No destructor defined for TEMP */ - break; case 18: -#line 95 "parse.y" -{yygotominor.yy372 = 0;} -#line 1973 "parse.c" +#line 119 "parse.y" +{sqlite3CommitTransaction(pParse);} +#line 1849 "parse.c" break; case 19: -#line 96 "parse.y" -{ - sqliteEndTable(pParse,&yymsp[0].minor.yy0,0); -} -#line 1980 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for columnlist */ - /* No destructor defined for conslist_opt */ - break; - case 20: -#line 99 "parse.y" -{ - sqliteEndTable(pParse,0,yymsp[0].minor.yy179); - sqliteSelectDelete(yymsp[0].minor.yy179); -} -#line 1991 "parse.c" - /* No destructor defined for AS */ +#line 121 "parse.y" +{sqlite3RollbackTransaction(pParse);} +#line 1854 "parse.c" break; case 21: - /* No destructor defined for columnlist */ - /* No destructor defined for COMMA */ - /* No destructor defined for column */ +#line 126 "parse.y" +{ + sqlite3StartTable(pParse,&yymsp[-1].minor.yy384,&yymsp[0].minor.yy384,yymsp[-4].minor.yy230,0,yymsp[-2].minor.yy230); +} +#line 1861 "parse.c" break; case 22: - /* No destructor defined for column */ + case 25: + case 63: + case 77: + case 79: + case 90: + case 101: + case 112: + case 113: + case 210: + case 213: +#line 130 "parse.y" +{yygotominor.yy230 = 0;} +#line 1876 "parse.c" break; case 23: - /* No destructor defined for columnid */ - /* No destructor defined for type */ - /* No destructor defined for carglist */ - break; case 24: -#line 111 "parse.y" -{sqliteAddColumn(pParse,&yymsp[0].minor.yy298);} -#line 2010 "parse.c" - break; - case 25: -#line 117 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy0;} -#line 2015 "parse.c" + case 64: + case 78: + case 100: + case 111: + case 211: + case 214: +#line 131 "parse.y" +{yygotominor.yy230 = 1;} +#line 1888 "parse.c" break; case 26: -#line 149 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy0;} -#line 2020 "parse.c" +#line 137 "parse.y" +{ + sqlite3EndTable(pParse,&yymsp[-1].minor.yy384,&yymsp[0].minor.yy0,0); +} +#line 1895 "parse.c" break; case 27: -#line 150 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy0;} -#line 2025 "parse.c" - break; - case 28: -#line 155 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy0;} -#line 2030 "parse.c" - break; - case 29: -#line 156 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy0;} -#line 2035 "parse.c" +#line 140 "parse.y" +{ + sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy239); + sqlite3SelectDelete(yymsp[0].minor.yy239); +} +#line 1903 "parse.c" break; case 30: -#line 157 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy0;} -#line 2040 "parse.c" +#line 152 "parse.y" +{ + yygotominor.yy384.z = yymsp[-2].minor.yy384.z; + yygotominor.yy384.n = (pParse->sLastToken.z-yymsp[-2].minor.yy384.z) + pParse->sLastToken.n; +} +#line 1911 "parse.c" break; case 31: +#line 156 "parse.y" +{ + sqlite3AddColumn(pParse,&yymsp[0].minor.yy384); + yygotominor.yy384 = yymsp[0].minor.yy384; +} +#line 1919 "parse.c" break; case 32: -#line 160 "parse.y" -{sqliteAddColumnType(pParse,&yymsp[0].minor.yy298,&yymsp[0].minor.yy298);} -#line 2047 "parse.c" - break; case 33: -#line 161 "parse.y" -{sqliteAddColumnType(pParse,&yymsp[-3].minor.yy298,&yymsp[0].minor.yy0);} -#line 2052 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for signed */ - break; case 34: -#line 163 "parse.y" -{sqliteAddColumnType(pParse,&yymsp[-5].minor.yy298,&yymsp[0].minor.yy0);} -#line 2059 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for signed */ - /* No destructor defined for COMMA */ - /* No destructor defined for signed */ - break; case 35: -#line 165 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy298;} -#line 2068 "parse.c" - break; case 36: + case 250: #line 166 "parse.y" -{yygotominor.yy298 = yymsp[-1].minor.yy298;} -#line 2073 "parse.c" - /* No destructor defined for ids */ - break; - case 37: -#line 168 "parse.y" -{ yygotominor.yy372 = atoi(yymsp[0].minor.yy0.z); } -#line 2079 "parse.c" +{yygotominor.yy384 = yymsp[0].minor.yy0;} +#line 1929 "parse.c" break; case 38: -#line 169 "parse.y" -{ yygotominor.yy372 = atoi(yymsp[0].minor.yy0.z); } -#line 2084 "parse.c" - /* No destructor defined for PLUS */ +#line 225 "parse.y" +{sqlite3AddColumnType(pParse,&yymsp[0].minor.yy384);} +#line 1934 "parse.c" break; case 39: -#line 170 "parse.y" -{ yygotominor.yy372 = -atoi(yymsp[0].minor.yy0.z); } -#line 2090 "parse.c" - /* No destructor defined for MINUS */ + case 42: + case 119: + case 120: + case 131: + case 150: + case 238: + case 248: + case 249: +#line 226 "parse.y" +{yygotominor.yy384 = yymsp[0].minor.yy384;} +#line 1947 "parse.c" break; case 40: - /* No destructor defined for carglist */ - /* No destructor defined for carg */ +#line 227 "parse.y" +{ + yygotominor.yy384.z = yymsp[-3].minor.yy384.z; + yygotominor.yy384.n = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy384.z; +} +#line 1955 "parse.c" break; case 41: - break; - case 42: - /* No destructor defined for CONSTRAINT */ - /* No destructor defined for nm */ - /* No destructor defined for ccons */ +#line 231 "parse.y" +{ + yygotominor.yy384.z = yymsp[-5].minor.yy384.z; + yygotominor.yy384.n = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy384.z; +} +#line 1963 "parse.c" break; case 43: - /* No destructor defined for ccons */ +#line 237 "parse.y" +{yygotominor.yy384.z=yymsp[-1].minor.yy384.z; yygotominor.yy384.n=yymsp[0].minor.yy384.n+(yymsp[0].minor.yy384.z-yymsp[-1].minor.yy384.z);} +#line 1968 "parse.c" break; case 44: -#line 175 "parse.y" -{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,0);} -#line 2110 "parse.c" - /* No destructor defined for DEFAULT */ +#line 239 "parse.y" +{ yygotominor.yy230 = atoi((char*)yymsp[0].minor.yy384.z); } +#line 1973 "parse.c" break; case 45: -#line 176 "parse.y" -{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,0);} -#line 2116 "parse.c" - /* No destructor defined for DEFAULT */ - break; - case 46: -#line 177 "parse.y" -{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,0);} -#line 2122 "parse.c" - /* No destructor defined for DEFAULT */ - break; - case 47: -#line 178 "parse.y" -{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,0);} -#line 2128 "parse.c" - /* No destructor defined for DEFAULT */ - /* No destructor defined for PLUS */ - break; - case 48: -#line 179 "parse.y" -{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,1);} -#line 2135 "parse.c" - /* No destructor defined for DEFAULT */ - /* No destructor defined for MINUS */ - break; - case 49: -#line 180 "parse.y" -{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,0);} -#line 2142 "parse.c" - /* No destructor defined for DEFAULT */ +#line 240 "parse.y" +{ yygotominor.yy230 = -atoi((char*)yymsp[0].minor.yy384.z); } +#line 1978 "parse.c" break; case 50: -#line 181 "parse.y" -{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,0);} -#line 2148 "parse.c" - /* No destructor defined for DEFAULT */ - /* No destructor defined for PLUS */ + case 52: +#line 249 "parse.y" +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy178);} +#line 1984 "parse.c" break; case 51: -#line 182 "parse.y" -{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,1);} -#line 2155 "parse.c" - /* No destructor defined for DEFAULT */ - /* No destructor defined for MINUS */ - break; - case 52: - /* No destructor defined for DEFAULT */ - /* No destructor defined for NULL */ +#line 250 "parse.y" +{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy178);} +#line 1989 "parse.c" break; case 53: - /* No destructor defined for NULL */ - /* No destructor defined for onconf */ +#line 252 "parse.y" +{ + Expr *p = sqlite3Expr(TK_UMINUS, yymsp[0].minor.yy178, 0, 0); + sqlite3AddDefaultValue(pParse,p); +} +#line 1997 "parse.c" break; case 54: -#line 189 "parse.y" -{sqliteAddNotNull(pParse, yymsp[0].minor.yy372);} -#line 2170 "parse.c" - /* No destructor defined for NOT */ - /* No destructor defined for NULL */ - break; - case 55: -#line 190 "parse.y" -{sqliteAddPrimaryKey(pParse,0,yymsp[0].minor.yy372);} -#line 2177 "parse.c" - /* No destructor defined for PRIMARY */ - /* No destructor defined for KEY */ - /* No destructor defined for sortorder */ +#line 256 "parse.y" +{ + Expr *p = sqlite3Expr(TK_STRING, 0, 0, &yymsp[0].minor.yy384); + sqlite3AddDefaultValue(pParse,p); +} +#line 2005 "parse.c" break; case 56: -#line 191 "parse.y" -{sqliteCreateIndex(pParse,0,0,0,yymsp[0].minor.yy372,0,0);} -#line 2185 "parse.c" - /* No destructor defined for UNIQUE */ +#line 265 "parse.y" +{sqlite3AddNotNull(pParse, yymsp[0].minor.yy230);} +#line 2010 "parse.c" break; case 57: - /* No destructor defined for CHECK */ - /* No destructor defined for LP */ - yy_destructor(158,&yymsp[-2].minor); - /* No destructor defined for RP */ - /* No destructor defined for onconf */ +#line 267 "parse.y" +{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy230,yymsp[0].minor.yy230,yymsp[-2].minor.yy230);} +#line 2015 "parse.c" break; case 58: -#line 194 "parse.y" -{sqliteCreateForeignKey(pParse,0,&yymsp[-2].minor.yy298,yymsp[-1].minor.yy320,yymsp[0].minor.yy372);} -#line 2198 "parse.c" - /* No destructor defined for REFERENCES */ +#line 268 "parse.y" +{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy230,0,0,0,0);} +#line 2020 "parse.c" break; case 59: -#line 195 "parse.y" -{sqliteDeferForeignKey(pParse,yymsp[0].minor.yy372);} -#line 2204 "parse.c" +#line 269 "parse.y" +{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy178);} +#line 2025 "parse.c" break; case 60: -#line 196 "parse.y" -{ - sqliteAddCollateType(pParse, sqliteCollateType(yymsp[0].minor.yy298.z, yymsp[0].minor.yy298.n)); -} -#line 2211 "parse.c" - /* No destructor defined for COLLATE */ +#line 271 "parse.y" +{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy384,yymsp[-1].minor.yy462,yymsp[0].minor.yy230);} +#line 2030 "parse.c" break; case 61: -#line 206 "parse.y" -{ yygotominor.yy372 = OE_Restrict * 0x010101; } -#line 2217 "parse.c" +#line 272 "parse.y" +{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy230);} +#line 2035 "parse.c" break; case 62: -#line 207 "parse.y" -{ yygotominor.yy372 = (yymsp[-1].minor.yy372 & yymsp[0].minor.yy407.mask) | yymsp[0].minor.yy407.value; } -#line 2222 "parse.c" - break; - case 63: -#line 209 "parse.y" -{ yygotominor.yy407.value = 0; yygotominor.yy407.mask = 0x000000; } -#line 2227 "parse.c" - /* No destructor defined for MATCH */ - /* No destructor defined for nm */ - break; - case 64: -#line 210 "parse.y" -{ yygotominor.yy407.value = yymsp[0].minor.yy372; yygotominor.yy407.mask = 0x0000ff; } -#line 2234 "parse.c" - /* No destructor defined for ON */ - /* No destructor defined for DELETE */ +#line 273 "parse.y" +{sqlite3AddCollateType(pParse, (char*)yymsp[0].minor.yy384.z, yymsp[0].minor.yy384.n);} +#line 2040 "parse.c" break; case 65: -#line 211 "parse.y" -{ yygotominor.yy407.value = yymsp[0].minor.yy372<<8; yygotominor.yy407.mask = 0x00ff00; } -#line 2241 "parse.c" - /* No destructor defined for ON */ - /* No destructor defined for UPDATE */ +#line 286 "parse.y" +{ yygotominor.yy230 = OE_Restrict * 0x010101; } +#line 2045 "parse.c" break; case 66: -#line 212 "parse.y" -{ yygotominor.yy407.value = yymsp[0].minor.yy372<<16; yygotominor.yy407.mask = 0xff0000; } -#line 2248 "parse.c" - /* No destructor defined for ON */ - /* No destructor defined for INSERT */ +#line 287 "parse.y" +{ yygotominor.yy230 = (yymsp[-1].minor.yy230 & yymsp[0].minor.yy13.mask) | yymsp[0].minor.yy13.value; } +#line 2050 "parse.c" break; case 67: -#line 214 "parse.y" -{ yygotominor.yy372 = OE_SetNull; } -#line 2255 "parse.c" - /* No destructor defined for SET */ - /* No destructor defined for NULL */ +#line 289 "parse.y" +{ yygotominor.yy13.value = 0; yygotominor.yy13.mask = 0x000000; } +#line 2055 "parse.c" break; case 68: -#line 215 "parse.y" -{ yygotominor.yy372 = OE_SetDflt; } -#line 2262 "parse.c" - /* No destructor defined for SET */ - /* No destructor defined for DEFAULT */ +#line 290 "parse.y" +{ yygotominor.yy13.value = yymsp[0].minor.yy230; yygotominor.yy13.mask = 0x0000ff; } +#line 2060 "parse.c" break; case 69: -#line 216 "parse.y" -{ yygotominor.yy372 = OE_Cascade; } -#line 2269 "parse.c" - /* No destructor defined for CASCADE */ +#line 291 "parse.y" +{ yygotominor.yy13.value = yymsp[0].minor.yy230<<8; yygotominor.yy13.mask = 0x00ff00; } +#line 2065 "parse.c" break; case 70: -#line 217 "parse.y" -{ yygotominor.yy372 = OE_Restrict; } -#line 2275 "parse.c" - /* No destructor defined for RESTRICT */ +#line 292 "parse.y" +{ yygotominor.yy13.value = yymsp[0].minor.yy230<<16; yygotominor.yy13.mask = 0xff0000; } +#line 2070 "parse.c" break; case 71: -#line 219 "parse.y" -{yygotominor.yy372 = yymsp[0].minor.yy372;} -#line 2281 "parse.c" - /* No destructor defined for NOT */ - /* No destructor defined for DEFERRABLE */ +#line 294 "parse.y" +{ yygotominor.yy230 = OE_SetNull; } +#line 2075 "parse.c" break; case 72: -#line 220 "parse.y" -{yygotominor.yy372 = yymsp[0].minor.yy372;} -#line 2288 "parse.c" - /* No destructor defined for DEFERRABLE */ +#line 295 "parse.y" +{ yygotominor.yy230 = OE_SetDflt; } +#line 2080 "parse.c" break; case 73: -#line 222 "parse.y" -{yygotominor.yy372 = 0;} -#line 2294 "parse.c" +#line 296 "parse.y" +{ yygotominor.yy230 = OE_Cascade; } +#line 2085 "parse.c" break; case 74: -#line 223 "parse.y" -{yygotominor.yy372 = 1;} -#line 2299 "parse.c" - /* No destructor defined for INITIALLY */ - /* No destructor defined for DEFERRED */ +#line 297 "parse.y" +{ yygotominor.yy230 = OE_Restrict; } +#line 2090 "parse.c" break; case 75: -#line 224 "parse.y" -{yygotominor.yy372 = 0;} -#line 2306 "parse.c" - /* No destructor defined for INITIALLY */ - /* No destructor defined for IMMEDIATE */ - break; case 76: - break; - case 77: - /* No destructor defined for COMMA */ - /* No destructor defined for conslist */ - break; - case 78: - /* No destructor defined for conslist */ - /* No destructor defined for COMMA */ - /* No destructor defined for tcons */ - break; - case 79: - /* No destructor defined for conslist */ - /* No destructor defined for tcons */ + case 91: + case 93: + case 95: + case 96: + case 167: +#line 299 "parse.y" +{yygotominor.yy230 = yymsp[0].minor.yy230;} +#line 2101 "parse.c" break; case 80: - /* No destructor defined for tcons */ +#line 309 "parse.y" +{yygotominor.yy384.n = 0; yygotominor.yy384.z = 0;} +#line 2106 "parse.c" break; case 81: - /* No destructor defined for CONSTRAINT */ - /* No destructor defined for nm */ - break; - case 82: -#line 236 "parse.y" -{sqliteAddPrimaryKey(pParse,yymsp[-2].minor.yy320,yymsp[0].minor.yy372);} -#line 2335 "parse.c" - /* No destructor defined for PRIMARY */ - /* No destructor defined for KEY */ - /* No destructor defined for LP */ - /* No destructor defined for RP */ - break; - case 83: -#line 238 "parse.y" -{sqliteCreateIndex(pParse,0,0,yymsp[-2].minor.yy320,yymsp[0].minor.yy372,0,0);} -#line 2344 "parse.c" - /* No destructor defined for UNIQUE */ - /* No destructor defined for LP */ - /* No destructor defined for RP */ - break; - case 84: - /* No destructor defined for CHECK */ - yy_destructor(158,&yymsp[-1].minor); - /* No destructor defined for onconf */ - break; - case 85: -#line 241 "parse.y" -{ - sqliteCreateForeignKey(pParse, yymsp[-6].minor.yy320, &yymsp[-3].minor.yy298, yymsp[-2].minor.yy320, yymsp[-1].minor.yy372); - sqliteDeferForeignKey(pParse, yymsp[0].minor.yy372); -} -#line 2360 "parse.c" - /* No destructor defined for FOREIGN */ - /* No destructor defined for KEY */ - /* No destructor defined for LP */ - /* No destructor defined for RP */ - /* No destructor defined for REFERENCES */ +#line 310 "parse.y" +{yygotominor.yy384 = yymsp[-1].minor.yy0;} +#line 2111 "parse.c" break; case 86: -#line 246 "parse.y" -{yygotominor.yy372 = 0;} -#line 2370 "parse.c" +#line 316 "parse.y" +{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy462,yymsp[0].minor.yy230,yymsp[-2].minor.yy230,0);} +#line 2116 "parse.c" break; case 87: -#line 247 "parse.y" -{yygotominor.yy372 = yymsp[0].minor.yy372;} -#line 2375 "parse.c" +#line 318 "parse.y" +{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy462,yymsp[0].minor.yy230,0,0,0,0);} +#line 2121 "parse.c" break; case 88: -#line 255 "parse.y" -{ yygotominor.yy372 = OE_Default; } -#line 2380 "parse.c" +#line 319 "parse.y" +{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy178);} +#line 2126 "parse.c" break; case 89: -#line 256 "parse.y" -{ yygotominor.yy372 = yymsp[0].minor.yy372; } -#line 2385 "parse.c" - /* No destructor defined for ON */ - /* No destructor defined for CONFLICT */ - break; - case 90: -#line 257 "parse.y" -{ yygotominor.yy372 = OE_Default; } -#line 2392 "parse.c" - break; - case 91: -#line 258 "parse.y" -{ yygotominor.yy372 = yymsp[0].minor.yy372; } -#line 2397 "parse.c" - /* No destructor defined for OR */ +#line 321 "parse.y" +{ + sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy462, &yymsp[-3].minor.yy384, yymsp[-2].minor.yy462, yymsp[-1].minor.yy230); + sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy230); +} +#line 2134 "parse.c" break; case 92: -#line 259 "parse.y" -{ yygotominor.yy372 = OE_Rollback; } -#line 2403 "parse.c" - /* No destructor defined for ROLLBACK */ - break; - case 93: -#line 260 "parse.y" -{ yygotominor.yy372 = OE_Abort; } -#line 2409 "parse.c" - /* No destructor defined for ABORT */ - break; case 94: -#line 261 "parse.y" -{ yygotominor.yy372 = OE_Fail; } -#line 2415 "parse.c" - /* No destructor defined for FAIL */ - break; - case 95: -#line 262 "parse.y" -{ yygotominor.yy372 = OE_Ignore; } -#line 2421 "parse.c" - /* No destructor defined for IGNORE */ - break; - case 96: -#line 263 "parse.y" -{ yygotominor.yy372 = OE_Replace; } -#line 2427 "parse.c" - /* No destructor defined for REPLACE */ +#line 335 "parse.y" +{yygotominor.yy230 = OE_Default;} +#line 2140 "parse.c" break; case 97: -#line 267 "parse.y" -{sqliteDropTable(pParse,&yymsp[0].minor.yy298,0);} -#line 2433 "parse.c" - /* No destructor defined for DROP */ - /* No destructor defined for TABLE */ +#line 340 "parse.y" +{yygotominor.yy230 = OE_Ignore;} +#line 2145 "parse.c" break; case 98: -#line 271 "parse.y" -{ - sqliteCreateView(pParse, &yymsp[-5].minor.yy0, &yymsp[-2].minor.yy298, yymsp[0].minor.yy179, yymsp[-4].minor.yy372); -} -#line 2442 "parse.c" - /* No destructor defined for VIEW */ - /* No destructor defined for AS */ + case 168: +#line 341 "parse.y" +{yygotominor.yy230 = OE_Replace;} +#line 2151 "parse.c" break; case 99: -#line 274 "parse.y" +#line 345 "parse.y" { - sqliteDropTable(pParse, &yymsp[0].minor.yy298, 1); + sqlite3DropTable(pParse, yymsp[0].minor.yy285, 0, yymsp[-1].minor.yy230); } -#line 2451 "parse.c" - /* No destructor defined for DROP */ - /* No destructor defined for VIEW */ - break; - case 100: -#line 280 "parse.y" -{ - sqliteSelect(pParse, yymsp[0].minor.yy179, SRT_Callback, 0, 0, 0, 0); - sqliteSelectDelete(yymsp[0].minor.yy179); -} -#line 2461 "parse.c" - break; - case 101: -#line 290 "parse.y" -{yygotominor.yy179 = yymsp[0].minor.yy179;} -#line 2466 "parse.c" +#line 2158 "parse.c" break; case 102: -#line 291 "parse.y" +#line 355 "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; + sqlite3CreateView(pParse, &yymsp[-6].minor.yy0, &yymsp[-3].minor.yy384, &yymsp[-2].minor.yy384, yymsp[0].minor.yy239, yymsp[-5].minor.yy230); } -#line 2477 "parse.c" +#line 2165 "parse.c" break; case 103: -#line 299 "parse.y" -{yygotominor.yy372 = TK_UNION;} -#line 2482 "parse.c" - /* No destructor defined for UNION */ +#line 358 "parse.y" +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy285, 1, yymsp[-1].minor.yy230); +} +#line 2172 "parse.c" break; case 104: -#line 300 "parse.y" -{yygotominor.yy372 = TK_ALL;} -#line 2488 "parse.c" - /* No destructor defined for UNION */ - /* No destructor defined for ALL */ +#line 365 "parse.y" +{ + sqlite3Select(pParse, yymsp[0].minor.yy239, SRT_Callback, 0, 0, 0, 0, 0); + sqlite3SelectDelete(yymsp[0].minor.yy239); +} +#line 2180 "parse.c" break; case 105: -#line 301 "parse.y" -{yygotominor.yy372 = TK_INTERSECT;} -#line 2495 "parse.c" - /* No destructor defined for INTERSECT */ + case 128: +#line 375 "parse.y" +{yygotominor.yy239 = yymsp[0].minor.yy239;} +#line 2186 "parse.c" break; case 106: -#line 302 "parse.y" -{yygotominor.yy372 = TK_EXCEPT;} -#line 2501 "parse.c" - /* No destructor defined for EXCEPT */ - break; - case 107: -#line 304 "parse.y" +#line 377 "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); + if( yymsp[0].minor.yy239 ){ + yymsp[0].minor.yy239->op = yymsp[-1].minor.yy230; + yymsp[0].minor.yy239->pPrior = yymsp[-2].minor.yy239; + } + yygotominor.yy239 = yymsp[0].minor.yy239; } -#line 2509 "parse.c" - /* No destructor defined for SELECT */ +#line 2197 "parse.c" break; case 108: -#line 312 "parse.y" -{yygotominor.yy372 = 1;} -#line 2515 "parse.c" - /* No destructor defined for DISTINCT */ - break; - case 109: -#line 313 "parse.y" -{yygotominor.yy372 = 0;} -#line 2521 "parse.c" - /* No destructor defined for ALL */ +#line 386 "parse.y" +{yygotominor.yy230 = TK_ALL;} +#line 2202 "parse.c" break; case 110: -#line 314 "parse.y" -{yygotominor.yy372 = 0;} -#line 2527 "parse.c" - break; - case 111: -#line 325 "parse.y" -{yygotominor.yy322 = yymsp[-1].minor.yy322;} -#line 2532 "parse.c" - /* No destructor defined for COMMA */ - break; - case 112: -#line 326 "parse.y" -{yygotominor.yy322 = 0;} -#line 2538 "parse.c" - break; - case 113: -#line 327 "parse.y" +#line 390 "parse.y" { - yygotominor.yy322 = sqliteExprListAppend(yymsp[-2].minor.yy322,yymsp[-1].minor.yy242,yymsp[0].minor.yy298.n?&yymsp[0].minor.yy298:0); + yygotominor.yy239 = sqlite3SelectNew(yymsp[-6].minor.yy462,yymsp[-5].minor.yy285,yymsp[-4].minor.yy178,yymsp[-3].minor.yy462,yymsp[-2].minor.yy178,yymsp[-1].minor.yy462,yymsp[-7].minor.yy230,yymsp[0].minor.yy270.pLimit,yymsp[0].minor.yy270.pOffset); } -#line 2545 "parse.c" +#line 2209 "parse.c" break; case 114: -#line 330 "parse.y" -{ - yygotominor.yy322 = sqliteExprListAppend(yymsp[-1].minor.yy322, sqliteExpr(TK_ALL, 0, 0, 0), 0); -} -#line 2552 "parse.c" - /* No destructor defined for STAR */ + case 235: +#line 411 "parse.y" +{yygotominor.yy462 = yymsp[-1].minor.yy462;} +#line 2215 "parse.c" break; case 115: -#line 333 "parse.y" -{ - Expr *pRight = sqliteExpr(TK_ALL, 0, 0, 0); - Expr *pLeft = sqliteExpr(TK_ID, 0, 0, &yymsp[-2].minor.yy298); - yygotominor.yy322 = sqliteExprListAppend(yymsp[-3].minor.yy322, sqliteExpr(TK_DOT, pLeft, pRight, 0), 0); -} -#line 2562 "parse.c" - /* No destructor defined for DOT */ - /* No destructor defined for STAR */ + case 141: + case 151: + case 234: +#line 412 "parse.y" +{yygotominor.yy462 = 0;} +#line 2223 "parse.c" break; case 116: -#line 343 "parse.y" -{ yygotominor.yy298 = yymsp[0].minor.yy298; } -#line 2569 "parse.c" - /* No destructor defined for AS */ +#line 413 "parse.y" +{ + yygotominor.yy462 = sqlite3ExprListAppend(yymsp[-2].minor.yy462,yymsp[-1].minor.yy178,yymsp[0].minor.yy384.n?&yymsp[0].minor.yy384:0); +} +#line 2230 "parse.c" break; case 117: -#line 344 "parse.y" -{ yygotominor.yy298 = yymsp[0].minor.yy298; } -#line 2575 "parse.c" +#line 416 "parse.y" +{ + yygotominor.yy462 = sqlite3ExprListAppend(yymsp[-1].minor.yy462, sqlite3Expr(TK_ALL, 0, 0, 0), 0); +} +#line 2237 "parse.c" break; case 118: -#line 345 "parse.y" -{ yygotominor.yy298.n = 0; } -#line 2580 "parse.c" - break; - case 119: -#line 357 "parse.y" -{yygotominor.yy307 = sqliteMalloc(sizeof(*yygotominor.yy307));} -#line 2585 "parse.c" - break; - case 120: -#line 358 "parse.y" -{yygotominor.yy307 = yymsp[0].minor.yy307;} -#line 2590 "parse.c" - /* No destructor defined for FROM */ +#line 419 "parse.y" +{ + Expr *pRight = sqlite3Expr(TK_ALL, 0, 0, 0); + Expr *pLeft = sqlite3Expr(TK_ID, 0, 0, &yymsp[-2].minor.yy384); + yygotominor.yy462 = sqlite3ExprListAppend(yymsp[-3].minor.yy462, sqlite3Expr(TK_DOT, pLeft, pRight, 0), 0); +} +#line 2246 "parse.c" break; case 121: -#line 363 "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 2599 "parse.c" +#line 431 "parse.y" +{yygotominor.yy384.n = 0;} +#line 2251 "parse.c" break; case 122: -#line 367 "parse.y" -{yygotominor.yy307 = 0;} -#line 2604 "parse.c" +#line 443 "parse.y" +{yygotominor.yy285 = sqliteMalloc(sizeof(*yygotominor.yy285));} +#line 2256 "parse.c" break; case 123: -#line 368 "parse.y" -{ - yygotominor.yy307 = sqliteSrcListAppend(yymsp[-5].minor.yy307,&yymsp[-4].minor.yy298,&yymsp[-3].minor.yy298); - if( yymsp[-2].minor.yy298.n ) sqliteSrcListAddAlias(yygotominor.yy307,&yymsp[-2].minor.yy298); - 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 2620 "parse.c" +#line 444 "parse.y" +{yygotominor.yy285 = yymsp[0].minor.yy285;} +#line 2261 "parse.c" break; case 124: -#line 381 "parse.y" +#line 449 "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.yy298.n ) sqliteSrcListAddAlias(yygotominor.yy307,&yymsp[-2].minor.yy298); - 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); } - } + yygotominor.yy285 = yymsp[-1].minor.yy285; + if( yygotominor.yy285 && yygotominor.yy285->nSrc>0 ) yygotominor.yy285->a[yygotominor.yy285->nSrc-1].jointype = yymsp[0].minor.yy230; } -#line 2637 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for RP */ +#line 2269 "parse.c" break; case 125: -#line 401 "parse.y" -{yygotominor.yy179 = yymsp[0].minor.yy179;} -#line 2644 "parse.c" +#line 453 "parse.y" +{yygotominor.yy285 = 0;} +#line 2274 "parse.c" break; case 126: -#line 402 "parse.y" +#line 454 "parse.y" { - yygotominor.yy179 = sqliteSelectNew(0,yymsp[0].minor.yy307,0,0,0,0,0,-1,0); + yygotominor.yy285 = sqlite3SrcListAppend(yymsp[-5].minor.yy285,&yymsp[-4].minor.yy384,&yymsp[-3].minor.yy384); + if( yymsp[-2].minor.yy384.n ) sqlite3SrcListAddAlias(yygotominor.yy285,&yymsp[-2].minor.yy384); + if( yymsp[-1].minor.yy178 ){ + if( yygotominor.yy285 && yygotominor.yy285->nSrc>1 ){ yygotominor.yy285->a[yygotominor.yy285->nSrc-2].pOn = yymsp[-1].minor.yy178; } + else { sqlite3ExprDelete(yymsp[-1].minor.yy178); } + } + if( yymsp[0].minor.yy160 ){ + if( yygotominor.yy285 && yygotominor.yy285->nSrc>1 ){ yygotominor.yy285->a[yygotominor.yy285->nSrc-2].pUsing = yymsp[0].minor.yy160; } + else { sqlite3IdListDelete(yymsp[0].minor.yy160); } + } } -#line 2651 "parse.c" +#line 2290 "parse.c" break; case 127: -#line 407 "parse.y" -{yygotominor.yy298.z=0; yygotominor.yy298.n=0;} -#line 2656 "parse.c" - break; - case 128: -#line 408 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy298;} -#line 2661 "parse.c" - /* No destructor defined for DOT */ +#line 468 "parse.y" +{ + yygotominor.yy285 = sqlite3SrcListAppend(yymsp[-6].minor.yy285,0,0); + yygotominor.yy285->a[yygotominor.yy285->nSrc-1].pSelect = yymsp[-4].minor.yy239; + if( yymsp[-2].minor.yy384.n ) sqlite3SrcListAddAlias(yygotominor.yy285,&yymsp[-2].minor.yy384); + if( yymsp[-1].minor.yy178 ){ + if( yygotominor.yy285 && yygotominor.yy285->nSrc>1 ){ yygotominor.yy285->a[yygotominor.yy285->nSrc-2].pOn = yymsp[-1].minor.yy178; } + else { sqlite3ExprDelete(yymsp[-1].minor.yy178); } + } + if( yymsp[0].minor.yy160 ){ + if( yygotominor.yy285 && yygotominor.yy285->nSrc>1 ){ yygotominor.yy285->a[yygotominor.yy285->nSrc-2].pUsing = yymsp[0].minor.yy160; } + else { sqlite3IdListDelete(yymsp[0].minor.yy160); } + } + } +#line 2307 "parse.c" break; case 129: -#line 412 "parse.y" -{ yygotominor.yy372 = JT_INNER; } -#line 2667 "parse.c" - /* No destructor defined for COMMA */ +#line 489 "parse.y" +{ + yygotominor.yy239 = sqlite3SelectNew(0,yymsp[0].minor.yy285,0,0,0,0,0,0,0); + } +#line 2314 "parse.c" break; case 130: -#line 413 "parse.y" -{ yygotominor.yy372 = JT_INNER; } -#line 2673 "parse.c" - /* No destructor defined for JOIN */ - break; - case 131: -#line 414 "parse.y" -{ yygotominor.yy372 = sqliteJoinType(pParse,&yymsp[-1].minor.yy0,0,0); } -#line 2679 "parse.c" - /* No destructor defined for JOIN */ +#line 495 "parse.y" +{yygotominor.yy384.z=0; yygotominor.yy384.n=0;} +#line 2319 "parse.c" break; case 132: -#line 415 "parse.y" -{ yygotominor.yy372 = sqliteJoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy298,0); } -#line 2685 "parse.c" - /* No destructor defined for JOIN */ +#line 500 "parse.y" +{yygotominor.yy285 = sqlite3SrcListAppend(0,&yymsp[-1].minor.yy384,&yymsp[0].minor.yy384);} +#line 2324 "parse.c" break; case 133: -#line 417 "parse.y" -{ yygotominor.yy372 = sqliteJoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy298,&yymsp[-1].minor.yy298); } -#line 2691 "parse.c" - /* No destructor defined for JOIN */ +#line 504 "parse.y" +{ yygotominor.yy230 = JT_INNER; } +#line 2329 "parse.c" break; case 134: -#line 421 "parse.y" -{yygotominor.yy242 = yymsp[0].minor.yy242;} -#line 2697 "parse.c" - /* No destructor defined for ON */ +#line 505 "parse.y" +{ yygotominor.yy230 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); } +#line 2334 "parse.c" break; case 135: -#line 422 "parse.y" -{yygotominor.yy242 = 0;} -#line 2703 "parse.c" +#line 506 "parse.y" +{ yygotominor.yy230 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy384,0); } +#line 2339 "parse.c" break; case 136: -#line 426 "parse.y" -{yygotominor.yy320 = yymsp[-1].minor.yy320;} -#line 2708 "parse.c" - /* No destructor defined for USING */ - /* No destructor defined for LP */ - /* No destructor defined for RP */ +#line 508 "parse.y" +{ yygotominor.yy230 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy384,&yymsp[-1].minor.yy384); } +#line 2344 "parse.c" break; case 137: -#line 427 "parse.y" -{yygotominor.yy320 = 0;} -#line 2716 "parse.c" + case 145: + case 154: + case 161: + case 175: + case 200: + case 223: + case 225: + case 229: +#line 512 "parse.y" +{yygotominor.yy178 = yymsp[0].minor.yy178;} +#line 2357 "parse.c" break; case 138: -#line 437 "parse.y" -{yygotominor.yy322 = 0;} -#line 2721 "parse.c" + case 153: + case 160: + case 201: + case 224: + case 226: + case 230: +#line 513 "parse.y" +{yygotominor.yy178 = 0;} +#line 2368 "parse.c" break; case 139: -#line 438 "parse.y" -{yygotominor.yy322 = yymsp[0].minor.yy322;} -#line 2726 "parse.c" - /* No destructor defined for ORDER */ - /* No destructor defined for BY */ + case 172: +#line 517 "parse.y" +{yygotominor.yy160 = yymsp[-1].minor.yy160;} +#line 2374 "parse.c" break; case 140: -#line 439 "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 2736 "parse.c" - /* No destructor defined for COMMA */ - break; - case 141: -#line 443 "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 2745 "parse.c" + case 171: +#line 518 "parse.y" +{yygotominor.yy160 = 0;} +#line 2380 "parse.c" break; case 142: -#line 447 "parse.y" -{yygotominor.yy242 = yymsp[0].minor.yy242;} -#line 2750 "parse.c" + case 152: +#line 529 "parse.y" +{yygotominor.yy462 = yymsp[0].minor.yy462;} +#line 2386 "parse.c" break; case 143: -#line 452 "parse.y" -{yygotominor.yy372 = SQLITE_SO_ASC;} -#line 2755 "parse.c" - /* No destructor defined for ASC */ +#line 530 "parse.y" +{ + yygotominor.yy462 = sqlite3ExprListAppend(yymsp[-4].minor.yy462,yymsp[-2].minor.yy178,yymsp[-1].minor.yy384.n>0?&yymsp[-1].minor.yy384:0); + if( yygotominor.yy462 ) yygotominor.yy462->a[yygotominor.yy462->nExpr-1].sortOrder = yymsp[0].minor.yy230; +} +#line 2394 "parse.c" break; case 144: -#line 453 "parse.y" -{yygotominor.yy372 = SQLITE_SO_DESC;} -#line 2761 "parse.c" - /* No destructor defined for DESC */ - break; - case 145: -#line 454 "parse.y" -{yygotominor.yy372 = SQLITE_SO_ASC;} -#line 2767 "parse.c" +#line 534 "parse.y" +{ + yygotominor.yy462 = sqlite3ExprListAppend(0,yymsp[-2].minor.yy178,yymsp[-1].minor.yy384.n>0?&yymsp[-1].minor.yy384:0); + if( yygotominor.yy462 && yygotominor.yy462->a ) yygotominor.yy462->a[0].sortOrder = yymsp[0].minor.yy230; +} +#line 2402 "parse.c" break; case 146: -#line 455 "parse.y" -{yygotominor.yy372 = SQLITE_SO_UNK;} -#line 2772 "parse.c" + case 148: +#line 543 "parse.y" +{yygotominor.yy230 = SQLITE_SO_ASC;} +#line 2408 "parse.c" break; case 147: -#line 456 "parse.y" -{yygotominor.yy372 = sqliteCollateType(yymsp[0].minor.yy298.z, yymsp[0].minor.yy298.n);} -#line 2777 "parse.c" - /* No destructor defined for COLLATE */ - break; - case 148: -#line 460 "parse.y" -{yygotominor.yy322 = 0;} -#line 2783 "parse.c" +#line 544 "parse.y" +{yygotominor.yy230 = SQLITE_SO_DESC;} +#line 2413 "parse.c" break; case 149: -#line 461 "parse.y" -{yygotominor.yy322 = yymsp[0].minor.yy322;} -#line 2788 "parse.c" - /* No destructor defined for GROUP */ - /* No destructor defined for BY */ - break; - case 150: -#line 465 "parse.y" -{yygotominor.yy242 = 0;} -#line 2795 "parse.c" - break; - case 151: -#line 466 "parse.y" -{yygotominor.yy242 = yymsp[0].minor.yy242;} -#line 2800 "parse.c" - /* No destructor defined for HAVING */ - break; - case 152: -#line 469 "parse.y" -{yygotominor.yy124.limit = -1; yygotominor.yy124.offset = 0;} -#line 2806 "parse.c" - break; - case 153: -#line 470 "parse.y" -{yygotominor.yy124.limit = yymsp[0].minor.yy372; yygotominor.yy124.offset = 0;} -#line 2811 "parse.c" - /* No destructor defined for LIMIT */ - break; - case 154: -#line 472 "parse.y" -{yygotominor.yy124.limit = yymsp[-2].minor.yy372; yygotominor.yy124.offset = yymsp[0].minor.yy372;} -#line 2817 "parse.c" - /* No destructor defined for LIMIT */ - /* No destructor defined for OFFSET */ +#line 546 "parse.y" +{yygotominor.yy384.z = 0; yygotominor.yy384.n = 0;} +#line 2418 "parse.c" break; case 155: -#line 474 "parse.y" -{yygotominor.yy124.limit = yymsp[0].minor.yy372; yygotominor.yy124.offset = yymsp[-2].minor.yy372;} -#line 2824 "parse.c" - /* No destructor defined for LIMIT */ - /* No destructor defined for COMMA */ +#line 564 "parse.y" +{yygotominor.yy270.pLimit = 0; yygotominor.yy270.pOffset = 0;} +#line 2423 "parse.c" break; case 156: -#line 478 "parse.y" -{ - sqliteDeleteFrom(pParse, sqliteSrcListAppend(0,&yymsp[-2].minor.yy298,&yymsp[-1].minor.yy298), yymsp[0].minor.yy242); -} -#line 2833 "parse.c" - /* No destructor defined for DELETE */ - /* No destructor defined for FROM */ +#line 565 "parse.y" +{yygotominor.yy270.pLimit = yymsp[0].minor.yy178; yygotominor.yy270.pOffset = 0;} +#line 2428 "parse.c" break; case 157: -#line 485 "parse.y" -{yygotominor.yy242 = 0;} -#line 2840 "parse.c" +#line 567 "parse.y" +{yygotominor.yy270.pLimit = yymsp[-2].minor.yy178; yygotominor.yy270.pOffset = yymsp[0].minor.yy178;} +#line 2433 "parse.c" break; case 158: -#line 486 "parse.y" -{yygotominor.yy242 = yymsp[0].minor.yy242;} -#line 2845 "parse.c" - /* No destructor defined for WHERE */ +#line 569 "parse.y" +{yygotominor.yy270.pOffset = yymsp[-2].minor.yy178; yygotominor.yy270.pLimit = yymsp[0].minor.yy178;} +#line 2438 "parse.c" break; case 159: -#line 494 "parse.y" -{sqliteUpdate(pParse,sqliteSrcListAppend(0,&yymsp[-4].minor.yy298,&yymsp[-3].minor.yy298),yymsp[-1].minor.yy322,yymsp[0].minor.yy242,yymsp[-5].minor.yy372);} -#line 2851 "parse.c" - /* No destructor defined for UPDATE */ - /* No destructor defined for SET */ - break; - case 160: -#line 497 "parse.y" -{yygotominor.yy322 = sqliteExprListAppend(yymsp[-4].minor.yy322,yymsp[0].minor.yy242,&yymsp[-2].minor.yy298);} -#line 2858 "parse.c" - /* No destructor defined for COMMA */ - /* No destructor defined for EQ */ - break; - case 161: -#line 498 "parse.y" -{yygotominor.yy322 = sqliteExprListAppend(0,yymsp[0].minor.yy242,&yymsp[-2].minor.yy298);} -#line 2865 "parse.c" - /* No destructor defined for EQ */ +#line 573 "parse.y" +{sqlite3DeleteFrom(pParse,yymsp[-1].minor.yy285,yymsp[0].minor.yy178);} +#line 2443 "parse.c" break; case 162: -#line 504 "parse.y" -{sqliteInsert(pParse, sqliteSrcListAppend(0,&yymsp[-6].minor.yy298,&yymsp[-5].minor.yy298), yymsp[-1].minor.yy322, 0, yymsp[-4].minor.yy320, yymsp[-8].minor.yy372);} -#line 2871 "parse.c" - /* No destructor defined for INTO */ - /* No destructor defined for VALUES */ - /* No destructor defined for LP */ - /* No destructor defined for RP */ +#line 584 "parse.y" +{sqlite3Update(pParse,yymsp[-3].minor.yy285,yymsp[-1].minor.yy462,yymsp[0].minor.yy178,yymsp[-4].minor.yy230);} +#line 2448 "parse.c" break; case 163: -#line 506 "parse.y" -{sqliteInsert(pParse, sqliteSrcListAppend(0,&yymsp[-3].minor.yy298,&yymsp[-2].minor.yy298), 0, yymsp[0].minor.yy179, yymsp[-1].minor.yy320, yymsp[-5].minor.yy372);} -#line 2880 "parse.c" - /* No destructor defined for INTO */ +#line 590 "parse.y" +{yygotominor.yy462 = sqlite3ExprListAppend(yymsp[-4].minor.yy462,yymsp[0].minor.yy178,&yymsp[-2].minor.yy384);} +#line 2453 "parse.c" break; case 164: -#line 509 "parse.y" -{yygotominor.yy372 = yymsp[0].minor.yy372;} -#line 2886 "parse.c" - /* No destructor defined for INSERT */ +#line 591 "parse.y" +{yygotominor.yy462 = sqlite3ExprListAppend(0,yymsp[0].minor.yy178,&yymsp[-2].minor.yy384);} +#line 2458 "parse.c" break; case 165: -#line 510 "parse.y" -{yygotominor.yy372 = OE_Replace;} -#line 2892 "parse.c" - /* No destructor defined for REPLACE */ +#line 597 "parse.y" +{sqlite3Insert(pParse, yymsp[-5].minor.yy285, yymsp[-1].minor.yy462, 0, yymsp[-4].minor.yy160, yymsp[-7].minor.yy230);} +#line 2463 "parse.c" break; case 166: -#line 516 "parse.y" -{yygotominor.yy322 = sqliteExprListAppend(yymsp[-2].minor.yy322,yymsp[0].minor.yy242,0);} -#line 2898 "parse.c" - /* No destructor defined for COMMA */ - break; - case 167: -#line 517 "parse.y" -{yygotominor.yy322 = sqliteExprListAppend(0,yymsp[0].minor.yy242,0);} -#line 2904 "parse.c" - break; - case 168: -#line 524 "parse.y" -{yygotominor.yy320 = 0;} -#line 2909 "parse.c" +#line 599 "parse.y" +{sqlite3Insert(pParse, yymsp[-2].minor.yy285, 0, yymsp[0].minor.yy239, yymsp[-1].minor.yy160, yymsp[-4].minor.yy230);} +#line 2468 "parse.c" break; case 169: -#line 525 "parse.y" -{yygotominor.yy320 = yymsp[-1].minor.yy320;} -#line 2914 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for RP */ + case 227: +#line 609 "parse.y" +{yygotominor.yy462 = sqlite3ExprListAppend(yymsp[-2].minor.yy462,yymsp[0].minor.yy178,0);} +#line 2474 "parse.c" break; case 170: -#line 526 "parse.y" -{yygotominor.yy320 = sqliteIdListAppend(yymsp[-2].minor.yy320,&yymsp[0].minor.yy298);} -#line 2921 "parse.c" - /* No destructor defined for COMMA */ - break; - case 171: -#line 527 "parse.y" -{yygotominor.yy320 = sqliteIdListAppend(0,&yymsp[0].minor.yy298);} -#line 2927 "parse.c" - break; - case 172: -#line 535 "parse.y" -{yygotominor.yy242 = yymsp[-1].minor.yy242; sqliteExprSpan(yygotominor.yy242,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); } -#line 2932 "parse.c" + case 228: +#line 610 "parse.y" +{yygotominor.yy462 = sqlite3ExprListAppend(0,yymsp[0].minor.yy178,0);} +#line 2480 "parse.c" break; case 173: -#line 536 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_NULL, 0, 0, &yymsp[0].minor.yy0);} -#line 2937 "parse.c" +#line 619 "parse.y" +{yygotominor.yy160 = sqlite3IdListAppend(yymsp[-2].minor.yy160,&yymsp[0].minor.yy384);} +#line 2485 "parse.c" break; case 174: -#line 537 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_ID, 0, 0, &yymsp[0].minor.yy0);} -#line 2942 "parse.c" - break; - case 175: -#line 538 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_ID, 0, 0, &yymsp[0].minor.yy0);} -#line 2947 "parse.c" +#line 620 "parse.y" +{yygotominor.yy160 = sqlite3IdListAppend(0,&yymsp[0].minor.yy384);} +#line 2490 "parse.c" break; case 176: -#line 539 "parse.y" -{ - Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &yymsp[-2].minor.yy298); - Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &yymsp[0].minor.yy298); - yygotominor.yy242 = sqliteExpr(TK_DOT, temp1, temp2, 0); -} -#line 2956 "parse.c" - /* No destructor defined for DOT */ +#line 631 "parse.y" +{yygotominor.yy178 = yymsp[-1].minor.yy178; sqlite3ExprSpan(yygotominor.yy178,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); } +#line 2495 "parse.c" break; case 177: -#line 544 "parse.y" -{ - Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &yymsp[-4].minor.yy298); - Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &yymsp[-2].minor.yy298); - Expr *temp3 = sqliteExpr(TK_ID, 0, 0, &yymsp[0].minor.yy298); - Expr *temp4 = sqliteExpr(TK_DOT, temp2, temp3, 0); - yygotominor.yy242 = sqliteExpr(TK_DOT, temp1, temp4, 0); -} -#line 2968 "parse.c" - /* No destructor defined for DOT */ - /* No destructor defined for DOT */ + case 182: + case 183: +#line 632 "parse.y" +{yygotominor.yy178 = sqlite3Expr(yymsp[0].major, 0, 0, &yymsp[0].minor.yy0);} +#line 2502 "parse.c" break; case 178: -#line 551 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_INTEGER, 0, 0, &yymsp[0].minor.yy0);} -#line 2975 "parse.c" - break; case 179: -#line 552 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_FLOAT, 0, 0, &yymsp[0].minor.yy0);} -#line 2980 "parse.c" +#line 633 "parse.y" +{yygotominor.yy178 = sqlite3Expr(TK_ID, 0, 0, &yymsp[0].minor.yy0);} +#line 2508 "parse.c" break; case 180: -#line 553 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_STRING, 0, 0, &yymsp[0].minor.yy0);} -#line 2985 "parse.c" +#line 635 "parse.y" +{ + Expr *temp1 = sqlite3Expr(TK_ID, 0, 0, &yymsp[-2].minor.yy384); + Expr *temp2 = sqlite3Expr(TK_ID, 0, 0, &yymsp[0].minor.yy384); + yygotominor.yy178 = sqlite3Expr(TK_DOT, temp1, temp2, 0); +} +#line 2517 "parse.c" break; case 181: -#line 554 "parse.y" +#line 640 "parse.y" { - yygotominor.yy242 = sqliteExpr(TK_VARIABLE, 0, 0, &yymsp[0].minor.yy0); - if( yygotominor.yy242 ) yygotominor.yy242->iTable = ++pParse->nVar; + Expr *temp1 = sqlite3Expr(TK_ID, 0, 0, &yymsp[-4].minor.yy384); + Expr *temp2 = sqlite3Expr(TK_ID, 0, 0, &yymsp[-2].minor.yy384); + Expr *temp3 = sqlite3Expr(TK_ID, 0, 0, &yymsp[0].minor.yy384); + Expr *temp4 = sqlite3Expr(TK_DOT, temp2, temp3, 0); + yygotominor.yy178 = sqlite3Expr(TK_DOT, temp1, temp4, 0); } -#line 2993 "parse.c" - break; - case 182: -#line 558 "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 3001 "parse.c" - /* No destructor defined for LP */ - break; - case 183: -#line 562 "parse.y" -{ - yygotominor.yy242 = sqliteExprFunction(0, &yymsp[-3].minor.yy0); - sqliteExprSpan(yygotominor.yy242,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); -} -#line 3010 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for STAR */ +#line 2528 "parse.c" break; case 184: -#line 566 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_AND, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3017 "parse.c" - /* No destructor defined for AND */ +#line 649 "parse.y" +{yygotominor.yy178 = sqlite3RegisterExpr(pParse, &yymsp[0].minor.yy0);} +#line 2533 "parse.c" break; case 185: -#line 567 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_OR, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3023 "parse.c" - /* No destructor defined for OR */ - break; - case 186: -#line 568 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_LT, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3029 "parse.c" - /* No destructor defined for LT */ - break; - case 187: -#line 569 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_GT, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3035 "parse.c" - /* No destructor defined for GT */ - break; - case 188: -#line 570 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_LE, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3041 "parse.c" - /* No destructor defined for LE */ - break; - case 189: -#line 571 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_GE, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3047 "parse.c" - /* No destructor defined for GE */ - break; - case 190: -#line 572 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_NE, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3053 "parse.c" - /* No destructor defined for NE */ - break; - case 191: -#line 573 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_EQ, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3059 "parse.c" - /* No destructor defined for EQ */ - break; - case 192: -#line 574 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_BITAND, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3065 "parse.c" - /* No destructor defined for BITAND */ - break; - case 193: -#line 575 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_BITOR, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3071 "parse.c" - /* No destructor defined for BITOR */ - break; - case 194: -#line 576 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_LSHIFT, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3077 "parse.c" - /* No destructor defined for LSHIFT */ - break; - case 195: -#line 577 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_RSHIFT, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3083 "parse.c" - /* No destructor defined for RSHIFT */ - break; - case 196: -#line 578 "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 3095 "parse.c" - break; - case 197: -#line 585 "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 3107 "parse.c" - /* No destructor defined for NOT */ - break; - case 198: -#line 594 "parse.y" -{yygotominor.yy372 = TK_LIKE;} -#line 3113 "parse.c" - /* No destructor defined for LIKE */ - break; - case 199: -#line 595 "parse.y" -{yygotominor.yy372 = TK_GLOB;} -#line 3119 "parse.c" - /* No destructor defined for GLOB */ - break; - case 200: -#line 596 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_PLUS, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3125 "parse.c" - /* No destructor defined for PLUS */ - break; - case 201: -#line 597 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_MINUS, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3131 "parse.c" - /* No destructor defined for MINUS */ - break; - case 202: -#line 598 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_STAR, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3137 "parse.c" - /* No destructor defined for STAR */ - break; - case 203: -#line 599 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_SLASH, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3143 "parse.c" - /* No destructor defined for SLASH */ - break; - case 204: -#line 600 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_REM, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3149 "parse.c" - /* No destructor defined for REM */ - break; - case 205: -#line 601 "parse.y" -{yygotominor.yy242 = sqliteExpr(TK_CONCAT, yymsp[-2].minor.yy242, yymsp[0].minor.yy242, 0);} -#line 3155 "parse.c" - /* No destructor defined for CONCAT */ - break; - case 206: -#line 602 "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 3164 "parse.c" - break; - case 207: -#line 606 "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 3172 "parse.c" - /* No destructor defined for IS */ - break; - case 208: -#line 610 "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 3181 "parse.c" - break; - case 209: -#line 614 "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 3189 "parse.c" - /* No destructor defined for NOT */ - break; - case 210: -#line 618 "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 3198 "parse.c" - /* No destructor defined for IS */ - /* No destructor defined for NOT */ - break; - case 211: -#line 622 "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 3208 "parse.c" - break; - case 212: -#line 626 "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 3216 "parse.c" - break; - case 213: -#line 630 "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 3224 "parse.c" - break; - case 214: -#line 634 "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 3232 "parse.c" - break; - case 215: -#line 638 "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 3241 "parse.c" - break; - case 216: -#line 643 "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 3252 "parse.c" - /* No destructor defined for BETWEEN */ - /* No destructor defined for AND */ - break; - case 217: #line 650 "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); + Token *pToken = &yymsp[0].minor.yy0; + Expr *pExpr = yygotominor.yy178 = sqlite3Expr(TK_VARIABLE, 0, 0, pToken); + sqlite3ExprAssignVarNumber(pParse, pExpr); } -#line 3266 "parse.c" - /* No destructor defined for NOT */ - /* No destructor defined for BETWEEN */ - /* No destructor defined for AND */ +#line 2542 "parse.c" break; - case 218: -#line 658 "parse.y" + case 186: +#line 656 "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); + yygotominor.yy178 = sqlite3Expr(TK_CAST, yymsp[-3].minor.yy178, 0, &yymsp[-1].minor.yy384); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0); } -#line 3278 "parse.c" - /* No destructor defined for IN */ - /* No destructor defined for LP */ +#line 2550 "parse.c" break; - case 219: -#line 663 "parse.y" + case 187: +#line 661 "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); + yygotominor.yy178 = sqlite3ExprFunction(yymsp[-1].minor.yy462, &yymsp[-4].minor.yy0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0); + if( yymsp[-2].minor.yy230 && yygotominor.yy178 ){ + yygotominor.yy178->flags |= EP_Distinct; + } } -#line 3289 "parse.c" - /* No destructor defined for IN */ - /* No destructor defined for LP */ +#line 2561 "parse.c" break; - case 220: + case 188: #line 668 "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); + yygotominor.yy178 = sqlite3ExprFunction(0, &yymsp[-3].minor.yy0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); } -#line 3301 "parse.c" - /* No destructor defined for NOT */ - /* No destructor defined for IN */ - /* No destructor defined for LP */ +#line 2569 "parse.c" + break; + case 189: +#line 672 "parse.y" +{ + /* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are + ** treated as functions that return constants */ + yygotominor.yy178 = sqlite3ExprFunction(0,&yymsp[0].minor.yy0); + if( yygotominor.yy178 ) yygotominor.yy178->op = TK_CONST_FUNC; +} +#line 2579 "parse.c" + break; + case 190: + case 191: + case 192: + case 193: + case 194: + case 195: + case 196: + case 197: +#line 678 "parse.y" +{yygotominor.yy178 = sqlite3Expr(yymsp[-1].major, yymsp[-2].minor.yy178, yymsp[0].minor.yy178, 0);} +#line 2591 "parse.c" + break; + case 198: +#line 688 "parse.y" +{yygotominor.yy440.eOperator = yymsp[0].minor.yy0; yygotominor.yy440.not = 0;} +#line 2596 "parse.c" + break; + case 199: +#line 689 "parse.y" +{yygotominor.yy440.eOperator = yymsp[0].minor.yy0; yygotominor.yy440.not = 1;} +#line 2601 "parse.c" + break; + case 202: +#line 694 "parse.y" +{ + ExprList *pList; + pList = sqlite3ExprListAppend(0, yymsp[-1].minor.yy178, 0); + pList = sqlite3ExprListAppend(pList, yymsp[-3].minor.yy178, 0); + if( yymsp[0].minor.yy178 ){ + pList = sqlite3ExprListAppend(pList, yymsp[0].minor.yy178, 0); + } + yygotominor.yy178 = sqlite3ExprFunction(pList, &yymsp[-2].minor.yy440.eOperator); + if( yymsp[-2].minor.yy440.not ) yygotominor.yy178 = sqlite3Expr(TK_NOT, yygotominor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178, &yymsp[-3].minor.yy178->span, &yymsp[-1].minor.yy178->span); +} +#line 2616 "parse.c" + break; + case 203: +#line 706 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(yymsp[0].major, yymsp[-1].minor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-1].minor.yy178->span,&yymsp[0].minor.yy0); +} +#line 2624 "parse.c" + break; + case 204: +#line 710 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(TK_ISNULL, yymsp[-2].minor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-2].minor.yy178->span,&yymsp[0].minor.yy0); +} +#line 2632 "parse.c" + break; + case 205: +#line 714 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(TK_NOTNULL, yymsp[-2].minor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-2].minor.yy178->span,&yymsp[0].minor.yy0); +} +#line 2640 "parse.c" + break; + case 206: +#line 718 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(TK_NOTNULL, yymsp[-3].minor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-3].minor.yy178->span,&yymsp[0].minor.yy0); +} +#line 2648 "parse.c" + break; + case 207: +#line 722 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(yymsp[-1].major, yymsp[0].minor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy178->span); +} +#line 2656 "parse.c" + break; + case 208: +#line 726 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(TK_UMINUS, yymsp[0].minor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy178->span); +} +#line 2664 "parse.c" + break; + case 209: +#line 730 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(TK_UPLUS, yymsp[0].minor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy178->span); +} +#line 2672 "parse.c" + break; + case 212: +#line 737 "parse.y" +{ + ExprList *pList = sqlite3ExprListAppend(0, yymsp[-2].minor.yy178, 0); + pList = sqlite3ExprListAppend(pList, yymsp[0].minor.yy178, 0); + yygotominor.yy178 = sqlite3Expr(TK_BETWEEN, yymsp[-4].minor.yy178, 0, 0); + if( yygotominor.yy178 ){ + yygotominor.yy178->pList = pList; + }else{ + sqlite3ExprListDelete(pList); + } + if( yymsp[-3].minor.yy230 ) yygotominor.yy178 = sqlite3Expr(TK_NOT, yygotominor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-4].minor.yy178->span,&yymsp[0].minor.yy178->span); +} +#line 2688 "parse.c" + break; + case 215: +#line 753 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(TK_IN, yymsp[-4].minor.yy178, 0, 0); + if( yygotominor.yy178 ){ + yygotominor.yy178->pList = yymsp[-1].minor.yy462; + }else{ + sqlite3ExprListDelete(yymsp[-1].minor.yy462); + } + if( yymsp[-3].minor.yy230 ) yygotominor.yy178 = sqlite3Expr(TK_NOT, yygotominor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-4].minor.yy178->span,&yymsp[0].minor.yy0); + } +#line 2702 "parse.c" + break; + case 216: +#line 763 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(TK_SELECT, 0, 0, 0); + if( yygotominor.yy178 ){ + yygotominor.yy178->pSelect = yymsp[-1].minor.yy239; + }else{ + sqlite3SelectDelete(yymsp[-1].minor.yy239); + } + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); + } +#line 2715 "parse.c" + break; + case 217: +#line 772 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(TK_IN, yymsp[-4].minor.yy178, 0, 0); + if( yygotominor.yy178 ){ + yygotominor.yy178->pSelect = yymsp[-1].minor.yy239; + }else{ + sqlite3SelectDelete(yymsp[-1].minor.yy239); + } + if( yymsp[-3].minor.yy230 ) yygotominor.yy178 = sqlite3Expr(TK_NOT, yygotominor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-4].minor.yy178->span,&yymsp[0].minor.yy0); + } +#line 2729 "parse.c" + break; + case 218: +#line 782 "parse.y" +{ + SrcList *pSrc = sqlite3SrcListAppend(0,&yymsp[-1].minor.yy384,&yymsp[0].minor.yy384); + yygotominor.yy178 = sqlite3Expr(TK_IN, yymsp[-3].minor.yy178, 0, 0); + if( yygotominor.yy178 ){ + yygotominor.yy178->pSelect = sqlite3SelectNew(0,pSrc,0,0,0,0,0,0,0); + }else{ + sqlite3SrcListDelete(pSrc); + } + if( yymsp[-2].minor.yy230 ) yygotominor.yy178 = sqlite3Expr(TK_NOT, yygotominor.yy178, 0, 0); + sqlite3ExprSpan(yygotominor.yy178,&yymsp[-3].minor.yy178->span,yymsp[0].minor.yy384.z?&yymsp[0].minor.yy384:&yymsp[-1].minor.yy384); + } +#line 2744 "parse.c" + break; + case 219: +#line 793 "parse.y" +{ + Expr *p = yygotominor.yy178 = sqlite3Expr(TK_EXISTS, 0, 0, 0); + if( p ){ + p->pSelect = yymsp[-1].minor.yy239; + sqlite3ExprSpan(p,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); + }else{ + sqlite3SelectDelete(yymsp[-1].minor.yy239); + } + } +#line 2757 "parse.c" + break; + case 220: +#line 805 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(TK_CASE, yymsp[-3].minor.yy178, yymsp[-1].minor.yy178, 0); + if( yygotominor.yy178 ){ + yygotominor.yy178->pList = yymsp[-2].minor.yy462; + }else{ + sqlite3ExprListDelete(yymsp[-2].minor.yy462); + } + sqlite3ExprSpan(yygotominor.yy178, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0); +} +#line 2770 "parse.c" break; case 221: -#line 674 "parse.y" +#line 816 "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); + yygotominor.yy462 = sqlite3ExprListAppend(yymsp[-4].minor.yy462, yymsp[-2].minor.yy178, 0); + yygotominor.yy462 = sqlite3ExprListAppend(yygotominor.yy462, yymsp[0].minor.yy178, 0); } -#line 3314 "parse.c" - /* No destructor defined for NOT */ - /* No destructor defined for IN */ - /* No destructor defined for LP */ +#line 2778 "parse.c" break; case 222: -#line 680 "parse.y" +#line 820 "parse.y" { - SrcList *pSrc = sqliteSrcListAppend(0, &yymsp[-1].minor.yy298, &yymsp[0].minor.yy298); - 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.yy298.z?&yymsp[0].minor.yy298:&yymsp[-1].minor.yy298); + yygotominor.yy462 = sqlite3ExprListAppend(0, yymsp[-2].minor.yy178, 0); + yygotominor.yy462 = sqlite3ExprListAppend(yygotominor.yy462, yymsp[0].minor.yy178, 0); } -#line 3327 "parse.c" - /* No destructor defined for IN */ - break; - case 223: -#line 686 "parse.y" -{ - SrcList *pSrc = sqliteSrcListAppend(0, &yymsp[-1].minor.yy298, &yymsp[0].minor.yy298); - 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.yy298.z?&yymsp[0].minor.yy298:&yymsp[-1].minor.yy298); -} -#line 3339 "parse.c" - /* No destructor defined for NOT */ - /* No destructor defined for IN */ - break; - case 224: -#line 696 "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 3350 "parse.c" - break; - case 225: -#line 703 "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 3358 "parse.c" - /* No destructor defined for WHEN */ - /* No destructor defined for THEN */ - break; - case 226: -#line 707 "parse.y" -{ - yygotominor.yy322 = sqliteExprListAppend(0, yymsp[-2].minor.yy242, 0); - yygotominor.yy322 = sqliteExprListAppend(yygotominor.yy322, yymsp[0].minor.yy242, 0); -} -#line 3368 "parse.c" - /* No destructor defined for WHEN */ - /* No destructor defined for THEN */ - break; - case 227: -#line 712 "parse.y" -{yygotominor.yy242 = yymsp[0].minor.yy242;} -#line 3375 "parse.c" - /* No destructor defined for ELSE */ - break; - case 228: -#line 713 "parse.y" -{yygotominor.yy242 = 0;} -#line 3381 "parse.c" - break; - case 229: -#line 715 "parse.y" -{yygotominor.yy242 = yymsp[0].minor.yy242;} -#line 3386 "parse.c" - break; - case 230: -#line 716 "parse.y" -{yygotominor.yy242 = 0;} -#line 3391 "parse.c" +#line 2786 "parse.c" break; case 231: -#line 724 "parse.y" -{yygotominor.yy322 = sqliteExprListAppend(yymsp[-2].minor.yy322,yymsp[0].minor.yy242,0);} -#line 3396 "parse.c" - /* No destructor defined for COMMA */ +#line 847 "parse.y" +{ + sqlite3CreateIndex(pParse, &yymsp[-6].minor.yy384, &yymsp[-5].minor.yy384, sqlite3SrcListAppend(0,&yymsp[-3].minor.yy384,0), yymsp[-1].minor.yy462, yymsp[-9].minor.yy230, + &yymsp[-10].minor.yy0, &yymsp[0].minor.yy0, SQLITE_SO_ASC, yymsp[-7].minor.yy230); +} +#line 2794 "parse.c" break; case 232: -#line 725 "parse.y" -{yygotominor.yy322 = sqliteExprListAppend(0,yymsp[0].minor.yy242,0);} -#line 3402 "parse.c" + case 277: +#line 853 "parse.y" +{yygotominor.yy230 = OE_Abort;} +#line 2800 "parse.c" break; case 233: -#line 726 "parse.y" -{yygotominor.yy242 = yymsp[0].minor.yy242;} -#line 3407 "parse.c" - break; - case 234: -#line 727 "parse.y" -{yygotominor.yy242 = 0;} -#line 3412 "parse.c" - break; - case 235: -#line 732 "parse.y" -{ - SrcList *pSrc = sqliteSrcListAppend(0, &yymsp[-5].minor.yy298, &yymsp[-4].minor.yy298); - 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.yy298, pSrc, yymsp[-2].minor.yy320, yymsp[-9].minor.yy372, &yymsp[-10].minor.yy0, &yymsp[-1].minor.yy0); -} -#line 3422 "parse.c" - /* No destructor defined for INDEX */ - /* No destructor defined for ON */ - /* No destructor defined for LP */ +#line 854 "parse.y" +{yygotominor.yy230 = OE_None;} +#line 2805 "parse.c" break; case 236: -#line 740 "parse.y" -{ yygotominor.yy372 = OE_Abort; } -#line 3430 "parse.c" - /* No destructor defined for UNIQUE */ +#line 864 "parse.y" +{ + Expr *p = 0; + if( yymsp[-1].minor.yy384.n>0 ){ + p = sqlite3Expr(TK_COLUMN, 0, 0, 0); + if( p ) p->pColl = sqlite3LocateCollSeq(pParse, (char*)yymsp[-1].minor.yy384.z, yymsp[-1].minor.yy384.n); + } + yygotominor.yy462 = sqlite3ExprListAppend(yymsp[-4].minor.yy462, p, &yymsp[-2].minor.yy384); + if( yygotominor.yy462 ) yygotominor.yy462->a[yygotominor.yy462->nExpr-1].sortOrder = yymsp[0].minor.yy230; +} +#line 2818 "parse.c" break; case 237: -#line 741 "parse.y" -{ yygotominor.yy372 = OE_None; } -#line 3436 "parse.c" - break; - case 238: -#line 749 "parse.y" -{yygotominor.yy320 = 0;} -#line 3441 "parse.c" +#line 873 "parse.y" +{ + Expr *p = 0; + if( yymsp[-1].minor.yy384.n>0 ){ + p = sqlite3Expr(TK_COLUMN, 0, 0, 0); + if( p ) p->pColl = sqlite3LocateCollSeq(pParse, (char*)yymsp[-1].minor.yy384.z, yymsp[-1].minor.yy384.n); + } + yygotominor.yy462 = sqlite3ExprListAppend(0, p, &yymsp[-2].minor.yy384); + if( yygotominor.yy462 ) yygotominor.yy462->a[yygotominor.yy462->nExpr-1].sortOrder = yymsp[0].minor.yy230; +} +#line 2831 "parse.c" break; case 239: -#line 750 "parse.y" -{yygotominor.yy320 = yymsp[-1].minor.yy320;} -#line 3446 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for RP */ +#line 887 "parse.y" +{sqlite3DropIndex(pParse, yymsp[0].minor.yy285, yymsp[-1].minor.yy230);} +#line 2836 "parse.c" break; case 240: -#line 751 "parse.y" -{yygotominor.yy320 = sqliteIdListAppend(yymsp[-2].minor.yy320,&yymsp[0].minor.yy298);} -#line 3453 "parse.c" - /* No destructor defined for COMMA */ - break; case 241: -#line 752 "parse.y" -{yygotominor.yy320 = sqliteIdListAppend(0,&yymsp[0].minor.yy298);} -#line 3459 "parse.c" +#line 891 "parse.y" +{sqlite3Vacuum(pParse);} +#line 2842 "parse.c" break; case 242: -#line 753 "parse.y" -{yygotominor.yy298 = yymsp[-1].minor.yy298;} -#line 3464 "parse.c" - /* No destructor defined for sortorder */ + case 244: +#line 897 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy384,&yymsp[-2].minor.yy384,&yymsp[0].minor.yy384,0);} +#line 2848 "parse.c" break; case 243: -#line 758 "parse.y" -{ - sqliteDropIndex(pParse, sqliteSrcListAppend(0,&yymsp[-1].minor.yy298,&yymsp[0].minor.yy298)); -} -#line 3472 "parse.c" - /* No destructor defined for DROP */ - /* No destructor defined for INDEX */ - break; - case 244: -#line 766 "parse.y" -{sqliteCopy(pParse,sqliteSrcListAppend(0,&yymsp[-6].minor.yy298,&yymsp[-5].minor.yy298),&yymsp[-3].minor.yy298,&yymsp[0].minor.yy0,yymsp[-7].minor.yy372);} -#line 3479 "parse.c" - /* No destructor defined for COPY */ - /* No destructor defined for FROM */ - /* No destructor defined for USING */ - /* No destructor defined for DELIMITERS */ +#line 898 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy384,&yymsp[-2].minor.yy384,&yymsp[0].minor.yy0,0);} +#line 2853 "parse.c" break; case 245: -#line 768 "parse.y" -{sqliteCopy(pParse,sqliteSrcListAppend(0,&yymsp[-3].minor.yy298,&yymsp[-2].minor.yy298),&yymsp[0].minor.yy298,0,yymsp[-4].minor.yy372);} -#line 3488 "parse.c" - /* No destructor defined for COPY */ - /* No destructor defined for FROM */ +#line 900 "parse.y" +{ + sqlite3Pragma(pParse,&yymsp[-3].minor.yy384,&yymsp[-2].minor.yy384,&yymsp[0].minor.yy384,1); +} +#line 2860 "parse.c" break; case 246: -#line 772 "parse.y" -{sqliteVacuum(pParse,0);} -#line 3495 "parse.c" - /* No destructor defined for VACUUM */ +#line 903 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-4].minor.yy384,&yymsp[-3].minor.yy384,&yymsp[-1].minor.yy384,0);} +#line 2865 "parse.c" break; case 247: -#line 773 "parse.y" -{sqliteVacuum(pParse,&yymsp[0].minor.yy298);} -#line 3501 "parse.c" - /* No destructor defined for VACUUM */ - break; - case 248: -#line 777 "parse.y" -{sqlitePragma(pParse,&yymsp[-2].minor.yy298,&yymsp[0].minor.yy298,0);} -#line 3507 "parse.c" - /* No destructor defined for PRAGMA */ - /* No destructor defined for EQ */ - break; - case 249: -#line 778 "parse.y" -{sqlitePragma(pParse,&yymsp[-2].minor.yy298,&yymsp[0].minor.yy0,0);} -#line 3514 "parse.c" - /* No destructor defined for PRAGMA */ - /* No destructor defined for EQ */ - break; - case 250: -#line 779 "parse.y" -{sqlitePragma(pParse,&yymsp[-2].minor.yy298,&yymsp[0].minor.yy298,0);} -#line 3521 "parse.c" - /* No destructor defined for PRAGMA */ - /* No destructor defined for EQ */ - break; - case 251: -#line 780 "parse.y" -{sqlitePragma(pParse,&yymsp[-2].minor.yy298,&yymsp[0].minor.yy298,1);} -#line 3528 "parse.c" - /* No destructor defined for PRAGMA */ - /* No destructor defined for EQ */ - break; - case 252: -#line 781 "parse.y" -{sqlitePragma(pParse,&yymsp[-3].minor.yy298,&yymsp[-1].minor.yy298,0);} -#line 3535 "parse.c" - /* No destructor defined for PRAGMA */ - /* No destructor defined for LP */ - /* No destructor defined for RP */ +#line 904 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-1].minor.yy384,&yymsp[0].minor.yy384,0,0);} +#line 2870 "parse.c" break; case 253: -#line 782 "parse.y" -{sqlitePragma(pParse,&yymsp[0].minor.yy298,&yymsp[0].minor.yy298,0);} -#line 3543 "parse.c" - /* No destructor defined for PRAGMA */ - break; - case 254: -#line 783 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy298;} -#line 3549 "parse.c" - /* No destructor defined for plus_opt */ - break; - case 255: -#line 784 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy298;} -#line 3555 "parse.c" - /* No destructor defined for MINUS */ - break; - case 256: -#line 785 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy0;} -#line 3561 "parse.c" - break; - case 257: -#line 786 "parse.y" -{yygotominor.yy298 = yymsp[0].minor.yy0;} -#line 3566 "parse.c" - break; - case 258: - /* No destructor defined for PLUS */ - break; - case 259: - break; - case 260: -#line 792 "parse.y" +#line 916 "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); + all.z = yymsp[-3].minor.yy384.z; + all.n = (yymsp[0].minor.yy0.z - yymsp[-3].minor.yy384.z) + yymsp[0].minor.yy0.n; + sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy247, &all); } -#line 3581 "parse.c" - /* No destructor defined for trigger_decl */ - /* No destructor defined for BEGIN */ +#line 2880 "parse.c" + break; + case 254: +#line 925 "parse.y" +{ + sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy384, &yymsp[-6].minor.yy384, yymsp[-5].minor.yy230, yymsp[-4].minor.yy132.a, yymsp[-4].minor.yy132.b, yymsp[-2].minor.yy285, yymsp[-1].minor.yy230, yymsp[0].minor.yy178, yymsp[-9].minor.yy230); + yygotominor.yy384 = (yymsp[-6].minor.yy384.n==0?yymsp[-7].minor.yy384:yymsp[-6].minor.yy384); +} +#line 2888 "parse.c" + break; + case 255: + case 258: +#line 931 "parse.y" +{ yygotominor.yy230 = TK_BEFORE; } +#line 2894 "parse.c" + break; + case 256: +#line 932 "parse.y" +{ yygotominor.yy230 = TK_AFTER; } +#line 2899 "parse.c" + break; + case 257: +#line 933 "parse.y" +{ yygotominor.yy230 = TK_INSTEAD;} +#line 2904 "parse.c" + break; + case 259: + case 260: +#line 938 "parse.y" +{yygotominor.yy132.a = yymsp[0].major; yygotominor.yy132.b = 0;} +#line 2910 "parse.c" break; case 261: -#line 800 "parse.y" -{ - SrcList *pTab = sqliteSrcListAppend(0, &yymsp[-3].minor.yy298, &yymsp[-2].minor.yy298); - sqliteBeginTrigger(pParse, &yymsp[-7].minor.yy298, 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 3591 "parse.c" - /* No destructor defined for TRIGGER */ - /* No destructor defined for ON */ +#line 940 "parse.y" +{yygotominor.yy132.a = TK_UPDATE; yygotominor.yy132.b = yymsp[0].minor.yy160;} +#line 2915 "parse.c" break; case 262: -#line 806 "parse.y" -{ yygotominor.yy372 = TK_BEFORE; } -#line 3598 "parse.c" - /* No destructor defined for BEFORE */ - break; case 263: -#line 807 "parse.y" -{ yygotominor.yy372 = TK_AFTER; } -#line 3604 "parse.c" - /* No destructor defined for AFTER */ +#line 943 "parse.y" +{ yygotominor.yy230 = TK_ROW; } +#line 2921 "parse.c" break; case 264: -#line 808 "parse.y" -{ yygotominor.yy372 = TK_INSTEAD;} -#line 3610 "parse.c" - /* No destructor defined for INSTEAD */ - /* No destructor defined for OF */ +#line 945 "parse.y" +{ yygotominor.yy230 = TK_STATEMENT; } +#line 2926 "parse.c" break; case 265: -#line 809 "parse.y" -{ yygotominor.yy372 = TK_BEFORE; } -#line 3617 "parse.c" +#line 949 "parse.y" +{ yygotominor.yy178 = 0; } +#line 2931 "parse.c" break; case 266: -#line 813 "parse.y" -{ yygotominor.yy290.a = TK_DELETE; yygotominor.yy290.b = 0; } -#line 3622 "parse.c" - /* No destructor defined for DELETE */ +#line 950 "parse.y" +{ yygotominor.yy178 = yymsp[0].minor.yy178; } +#line 2936 "parse.c" break; case 267: -#line 814 "parse.y" -{ yygotominor.yy290.a = TK_INSERT; yygotominor.yy290.b = 0; } -#line 3628 "parse.c" - /* No destructor defined for INSERT */ +#line 954 "parse.y" +{ + if( yymsp[-2].minor.yy247 ){ + yymsp[-2].minor.yy247->pLast->pNext = yymsp[-1].minor.yy247; + }else{ + yymsp[-2].minor.yy247 = yymsp[-1].minor.yy247; + } + yymsp[-2].minor.yy247->pLast = yymsp[-1].minor.yy247; + yygotominor.yy247 = yymsp[-2].minor.yy247; +} +#line 2949 "parse.c" break; case 268: -#line 815 "parse.y" -{ yygotominor.yy290.a = TK_UPDATE; yygotominor.yy290.b = 0;} -#line 3634 "parse.c" - /* No destructor defined for UPDATE */ +#line 963 "parse.y" +{ yygotominor.yy247 = 0; } +#line 2954 "parse.c" break; case 269: -#line 816 "parse.y" -{yygotominor.yy290.a = TK_UPDATE; yygotominor.yy290.b = yymsp[0].minor.yy320; } -#line 3640 "parse.c" - /* No destructor defined for UPDATE */ - /* No destructor defined for OF */ +#line 969 "parse.y" +{ yygotominor.yy247 = sqlite3TriggerUpdateStep(&yymsp[-3].minor.yy384, yymsp[-1].minor.yy462, yymsp[0].minor.yy178, yymsp[-4].minor.yy230); } +#line 2959 "parse.c" break; case 270: -#line 819 "parse.y" -{ yygotominor.yy372 = TK_ROW; } -#line 3647 "parse.c" +#line 974 "parse.y" +{yygotominor.yy247 = sqlite3TriggerInsertStep(&yymsp[-5].minor.yy384, yymsp[-4].minor.yy160, yymsp[-1].minor.yy462, 0, yymsp[-7].minor.yy230);} +#line 2964 "parse.c" break; case 271: -#line 820 "parse.y" -{ yygotominor.yy372 = TK_ROW; } -#line 3652 "parse.c" - /* No destructor defined for FOR */ - /* No destructor defined for EACH */ - /* No destructor defined for ROW */ +#line 977 "parse.y" +{yygotominor.yy247 = sqlite3TriggerInsertStep(&yymsp[-2].minor.yy384, yymsp[-1].minor.yy160, 0, yymsp[0].minor.yy239, yymsp[-4].minor.yy230);} +#line 2969 "parse.c" break; case 272: -#line 821 "parse.y" -{ yygotominor.yy372 = TK_STATEMENT; } -#line 3660 "parse.c" - /* No destructor defined for FOR */ - /* No destructor defined for EACH */ - /* No destructor defined for STATEMENT */ +#line 981 "parse.y" +{yygotominor.yy247 = sqlite3TriggerDeleteStep(&yymsp[-1].minor.yy384, yymsp[0].minor.yy178);} +#line 2974 "parse.c" break; case 273: -#line 824 "parse.y" -{ yygotominor.yy182 = 0; } -#line 3668 "parse.c" +#line 984 "parse.y" +{yygotominor.yy247 = sqlite3TriggerSelectStep(yymsp[0].minor.yy239); } +#line 2979 "parse.c" break; case 274: -#line 825 "parse.y" -{ yygotominor.yy182 = yymsp[0].minor.yy242; } -#line 3673 "parse.c" - /* No destructor defined for WHEN */ +#line 987 "parse.y" +{ + yygotominor.yy178 = sqlite3Expr(TK_RAISE, 0, 0, 0); + if( yygotominor.yy178 ){ + yygotominor.yy178->iColumn = OE_Ignore; + sqlite3ExprSpan(yygotominor.yy178, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0); + } +} +#line 2990 "parse.c" break; case 275: -#line 829 "parse.y" +#line 994 "parse.y" { - yymsp[-2].minor.yy19->pNext = yymsp[0].minor.yy19; - yygotominor.yy19 = yymsp[-2].minor.yy19; + yygotominor.yy178 = sqlite3Expr(TK_RAISE, 0, 0, &yymsp[-1].minor.yy384); + if( yygotominor.yy178 ) { + yygotominor.yy178->iColumn = yymsp[-3].minor.yy230; + sqlite3ExprSpan(yygotominor.yy178, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0); + } } -#line 3682 "parse.c" - /* No destructor defined for SEMI */ +#line 3001 "parse.c" break; case 276: -#line 833 "parse.y" -{ yygotominor.yy19 = 0; } -#line 3688 "parse.c" - break; - case 277: -#line 839 "parse.y" -{ yygotominor.yy19 = sqliteTriggerUpdateStep(&yymsp[-3].minor.yy298, yymsp[-1].minor.yy322, yymsp[0].minor.yy242, yymsp[-4].minor.yy372); } -#line 3693 "parse.c" - /* No destructor defined for UPDATE */ - /* No destructor defined for SET */ +#line 1004 "parse.y" +{yygotominor.yy230 = OE_Rollback;} +#line 3006 "parse.c" break; case 278: -#line 844 "parse.y" -{yygotominor.yy19 = sqliteTriggerInsertStep(&yymsp[-5].minor.yy298, yymsp[-4].minor.yy320, yymsp[-1].minor.yy322, 0, yymsp[-7].minor.yy372);} -#line 3700 "parse.c" - /* No destructor defined for INTO */ - /* No destructor defined for VALUES */ - /* No destructor defined for LP */ - /* No destructor defined for RP */ +#line 1006 "parse.y" +{yygotominor.yy230 = OE_Fail;} +#line 3011 "parse.c" break; case 279: -#line 847 "parse.y" -{yygotominor.yy19 = sqliteTriggerInsertStep(&yymsp[-2].minor.yy298, yymsp[-1].minor.yy320, 0, yymsp[0].minor.yy179, yymsp[-4].minor.yy372);} -#line 3709 "parse.c" - /* No destructor defined for INTO */ +#line 1011 "parse.y" +{ + sqlite3DropTrigger(pParse,yymsp[0].minor.yy285); +} +#line 3018 "parse.c" break; case 280: -#line 851 "parse.y" -{yygotominor.yy19 = sqliteTriggerDeleteStep(&yymsp[-1].minor.yy298, yymsp[0].minor.yy242);} -#line 3715 "parse.c" - /* No destructor defined for DELETE */ - /* No destructor defined for FROM */ +#line 1017 "parse.y" +{ + sqlite3Attach(pParse, yymsp[-3].minor.yy178, yymsp[-1].minor.yy178, yymsp[0].minor.yy292); +} +#line 3025 "parse.c" break; case 281: -#line 854 "parse.y" -{yygotominor.yy19 = sqliteTriggerSelectStep(yymsp[0].minor.yy179); } -#line 3722 "parse.c" +#line 1022 "parse.y" +{ yygotominor.yy292 = 0; } +#line 3030 "parse.c" break; case 282: -#line 857 "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 3731 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for IGNORE */ - break; - case 283: -#line 862 "parse.y" -{ - yygotominor.yy242 = sqliteExpr(TK_RAISE, 0, 0, &yymsp[-1].minor.yy298); - yygotominor.yy242->iColumn = OE_Rollback; - sqliteExprSpan(yygotominor.yy242, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0); -} -#line 3742 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for ROLLBACK */ - /* No destructor defined for COMMA */ - break; - case 284: -#line 867 "parse.y" -{ - yygotominor.yy242 = sqliteExpr(TK_RAISE, 0, 0, &yymsp[-1].minor.yy298); - yygotominor.yy242->iColumn = OE_Abort; - sqliteExprSpan(yygotominor.yy242, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0); -} -#line 3754 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for ABORT */ - /* No destructor defined for COMMA */ +#line 1023 "parse.y" +{ yygotominor.yy292 = yymsp[0].minor.yy178; } +#line 3035 "parse.c" break; case 285: -#line 872 "parse.y" +#line 1029 "parse.y" { - yygotominor.yy242 = sqliteExpr(TK_RAISE, 0, 0, &yymsp[-1].minor.yy298); - yygotominor.yy242->iColumn = OE_Fail; - sqliteExprSpan(yygotominor.yy242, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0); + sqlite3Detach(pParse, yymsp[0].minor.yy178); } -#line 3766 "parse.c" - /* No destructor defined for LP */ - /* No destructor defined for FAIL */ - /* No destructor defined for COMMA */ +#line 3042 "parse.c" break; case 286: -#line 879 "parse.y" -{ - sqliteDropTrigger(pParse,sqliteSrcListAppend(0,&yymsp[-1].minor.yy298,&yymsp[0].minor.yy298)); -} -#line 3776 "parse.c" - /* No destructor defined for DROP */ - /* No destructor defined for TRIGGER */ +#line 1035 "parse.y" +{sqlite3Reindex(pParse, 0, 0);} +#line 3047 "parse.c" break; case 287: -#line 884 "parse.y" -{ - sqliteAttach(pParse, &yymsp[-3].minor.yy298, &yymsp[-1].minor.yy298, &yymsp[0].minor.yy298); -} -#line 3785 "parse.c" - /* No destructor defined for ATTACH */ - /* No destructor defined for database_kw_opt */ - /* No destructor defined for AS */ +#line 1036 "parse.y" +{sqlite3Reindex(pParse, &yymsp[-1].minor.yy384, &yymsp[0].minor.yy384);} +#line 3052 "parse.c" break; case 288: -#line 888 "parse.y" -{ yygotominor.yy298 = yymsp[0].minor.yy298; } -#line 3793 "parse.c" - /* No destructor defined for USING */ +#line 1041 "parse.y" +{sqlite3Analyze(pParse, 0, 0);} +#line 3057 "parse.c" break; case 289: -#line 889 "parse.y" -{ yygotominor.yy298.z = 0; yygotominor.yy298.n = 0; } -#line 3799 "parse.c" +#line 1042 "parse.y" +{sqlite3Analyze(pParse, &yymsp[-1].minor.yy384, &yymsp[0].minor.yy384);} +#line 3062 "parse.c" break; case 290: - /* No destructor defined for DATABASE */ +#line 1047 "parse.y" +{ + sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy285,&yymsp[0].minor.yy384); +} +#line 3069 "parse.c" break; case 291: +#line 1050 "parse.y" +{ + sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy384); +} +#line 3076 "parse.c" break; case 292: -#line 895 "parse.y" +#line 1053 "parse.y" { - sqliteDetach(pParse, &yymsp[0].minor.yy298); + sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy285); } -#line 3811 "parse.c" - /* No destructor defined for DETACH */ - /* No destructor defined for database_kw_opt */ +#line 3083 "parse.c" break; }; yygoto = yyRuleInfo[yyruleno].lhs; yysize = yyRuleInfo[yyruleno].nrhs; yypParser->yyidx -= yysize; - yyact = yy_find_reduce_action(yypParser,yygoto); + yyact = yy_find_reduce_action(yymsp[-yysize].stateno,yygoto); if( yyact < YYNSTATE ){ - yy_shift(yypParser,yyact,yygoto,&yygotominor); +#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 = yyact; + yymsp->major = yygoto; + yymsp->minor = yygotominor; + }else +#endif + { + yy_shift(yypParser,yyact,yygoto,&yygotominor); + } }else if( yyact == YYNSTATE + YYNRULE + 1 ){ yy_accept(yypParser); } @@ -3830,7 +3112,7 @@ static void yy_reduce( static void yy_parse_failed( yyParser *yypParser /* The parser */ ){ - sqliteParserARG_FETCH; + sqlite3ParserARG_FETCH; #ifndef NDEBUG if( yyTraceFILE ){ fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); @@ -3839,7 +3121,7 @@ static void yy_parse_failed( 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 */ + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ } /* @@ -3850,20 +3132,19 @@ static void yy_syntax_error( int yymajor, /* The major type of the error token */ YYMINORTYPE yyminor /* The minor type of the error token */ ){ - sqliteParserARG_FETCH; + sqlite3ParserARG_FETCH; #define TOKEN (yyminor.yy0) -#line 23 "parse.y" +#line 34 "parse.y" if( pParse->zErrMsg==0 ){ if( TOKEN.z[0] ){ - sqliteErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); }else{ - sqliteErrorMsg(pParse, "incomplete SQL statement"); + sqlite3ErrorMsg(pParse, "incomplete SQL statement"); } } - -#line 3865 "parse.c" - sqliteParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +#line 3150 "parse.c" + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ } /* @@ -3872,7 +3153,7 @@ static void yy_syntax_error( static void yy_accept( yyParser *yypParser /* The parser */ ){ - sqliteParserARG_FETCH; + sqlite3ParserARG_FETCH; #ifndef NDEBUG if( yyTraceFILE ){ fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); @@ -3881,12 +3162,12 @@ static void yy_accept( 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 */ + sqlite3ParserARG_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. +** "sqlite3ParserAlloc" which describes the current state of the parser. ** The second argument is the major token number. The third is ** the minor token. The fourth optional argument is whatever the ** user wants (and specified in the grammar) and is available for @@ -3903,11 +3184,11 @@ static void yy_accept( ** Outputs: ** None. */ -void sqliteParser( +void sqlite3Parser( void *yyp, /* The parser */ int yymajor, /* The major token code number */ - sqliteParserTOKENTYPE yyminor /* The value for the token */ - sqliteParserARG_PDECL /* Optional %extra_argument parameter */ + sqlite3ParserTOKENTYPE yyminor /* The value for the token */ + sqlite3ParserARG_PDECL /* Optional %extra_argument parameter */ ){ YYMINORTYPE yyminorunion; int yyact; /* The parser action. */ @@ -3918,7 +3199,7 @@ void sqliteParser( /* (re)initialize the parser, if necessary */ yypParser = (yyParser*)yyp; if( yypParser->yyidx<0 ){ - if( yymajor==0 ) return; + /* if( yymajor==0 ) return; // not sure why this was here... */ yypParser->yyidx = 0; yypParser->yyerrcnt = -1; yypParser->yystack[0].stateno = 0; @@ -3926,7 +3207,7 @@ void sqliteParser( } yyminorunion.yy0 = yyminor; yyendofinput = (yymajor==0); - sqliteParserARG_STORE; + sqlite3ParserARG_STORE; #ifndef NDEBUG if( yyTraceFILE ){ diff --git a/sqlite/parse.h b/sqlite/parse.h index 188a336c8..116e7f5bf 100755 --- a/sqlite/parse.h +++ b/sqlite/parse.h @@ -1,20 +1,20 @@ -#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_SEMI 1 +#define TK_EXPLAIN 2 +#define TK_QUERY 3 +#define TK_PLAN 4 +#define TK_BEGIN 5 +#define TK_TRANSACTION 6 +#define TK_DEFERRED 7 +#define TK_IMMEDIATE 8 +#define TK_EXCLUSIVE 9 +#define TK_COMMIT 10 +#define TK_END 11 +#define TK_ROLLBACK 12 +#define TK_CREATE 13 +#define TK_TABLE 14 +#define TK_IF 15 +#define TK_NOT 16 +#define TK_EXISTS 17 #define TK_TEMP 18 #define TK_LP 19 #define TK_RP 20 @@ -23,108 +23,129 @@ #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_ANALYZE 26 +#define TK_ASC 27 +#define TK_ATTACH 28 +#define TK_BEFORE 29 +#define TK_CASCADE 30 +#define TK_CAST 31 +#define TK_CONFLICT 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_DESC 34 +#define TK_DETACH 35 +#define TK_EACH 36 +#define TK_FAIL 37 +#define TK_FOR 38 +#define TK_IGNORE 39 +#define TK_INITIALLY 40 +#define TK_INSTEAD 41 +#define TK_LIKE_KW 42 +#define TK_MATCH 43 +#define TK_KEY 44 +#define TK_OF 45 +#define TK_OFFSET 46 +#define TK_PRAGMA 47 +#define TK_RAISE 48 +#define TK_REPLACE 49 +#define TK_RESTRICT 50 +#define TK_ROW 51 +#define TK_STATEMENT 52 +#define TK_TRIGGER 53 +#define TK_VACUUM 54 +#define TK_VIEW 55 +#define TK_REINDEX 56 +#define TK_RENAME 57 +#define TK_CTIME_KW 58 +#define TK_OR 59 +#define TK_AND 60 +#define TK_IS 61 +#define TK_BETWEEN 62 +#define TK_IN 63 +#define TK_ISNULL 64 +#define TK_NOTNULL 65 +#define TK_NE 66 +#define TK_EQ 67 +#define TK_GT 68 +#define TK_LE 69 +#define TK_LT 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 +#define TK_ESCAPE 72 +#define TK_BITAND 73 +#define TK_BITOR 74 +#define TK_LSHIFT 75 +#define TK_RSHIFT 76 +#define TK_PLUS 77 +#define TK_MINUS 78 +#define TK_STAR 79 +#define TK_SLASH 80 +#define TK_REM 81 +#define TK_CONCAT 82 +#define TK_UMINUS 83 +#define TK_UPLUS 84 +#define TK_BITNOT 85 +#define TK_STRING 86 +#define TK_JOIN_KW 87 +#define TK_CONSTRAINT 88 +#define TK_DEFAULT 89 +#define TK_NULL 90 +#define TK_PRIMARY 91 +#define TK_UNIQUE 92 +#define TK_CHECK 93 +#define TK_REFERENCES 94 +#define TK_COLLATE 95 +#define TK_AUTOINCR 96 +#define TK_ON 97 +#define TK_DELETE 98 +#define TK_UPDATE 99 +#define TK_INSERT 100 +#define TK_SET 101 +#define TK_DEFERRABLE 102 +#define TK_FOREIGN 103 +#define TK_DROP 104 +#define TK_UNION 105 +#define TK_ALL 106 +#define TK_EXCEPT 107 +#define TK_INTERSECT 108 +#define TK_SELECT 109 +#define TK_DISTINCT 110 +#define TK_DOT 111 +#define TK_FROM 112 +#define TK_JOIN 113 +#define TK_USING 114 +#define TK_ORDER 115 +#define TK_BY 116 +#define TK_GROUP 117 +#define TK_HAVING 118 +#define TK_LIMIT 119 +#define TK_WHERE 120 +#define TK_INTO 121 +#define TK_VALUES 122 +#define TK_INTEGER 123 +#define TK_FLOAT 124 +#define TK_BLOB 125 +#define TK_REGISTER 126 +#define TK_VARIABLE 127 +#define TK_CASE 128 +#define TK_WHEN 129 +#define TK_THEN 130 +#define TK_ELSE 131 +#define TK_INDEX 132 +#define TK_ALTER 133 +#define TK_TO 134 +#define TK_ADD 135 +#define TK_COLUMNKW 136 +#define TK_TO_TEXT 137 +#define TK_TO_BLOB 138 +#define TK_TO_NUMERIC 139 +#define TK_TO_INT 140 +#define TK_TO_REAL 141 +#define TK_END_OF_FILE 142 +#define TK_ILLEGAL 143 +#define TK_SPACE 144 +#define TK_UNCLOSED_STRING 145 +#define TK_COMMENT 146 +#define TK_FUNCTION 147 +#define TK_COLUMN 148 +#define TK_AGG_FUNCTION 149 +#define TK_AGG_COLUMN 150 +#define TK_CONST_FUNC 151 diff --git a/sqlite/pragma.c b/sqlite/pragma.c index ae8e20da6..8f84a7745 100755 --- a/sqlite/pragma.c +++ b/sqlite/pragma.c @@ -11,26 +11,20 @@ ************************************************************************* ** This file contains code used to implement the PRAGMA command. ** -** $Id: pragma.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** $Id: pragma.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #include "sqliteInt.h" +#include "os.h" #include -/* -** Interpret the given string as a boolean value. +/* Ignore this whole file if pragmas are disabled */ -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' ){ +static int getTempStore(const char *z){ + if( z[0]>='0' && z[0]<='2' ){ return z[0] - '0'; - }else if( sqliteStrICmp(z, "file")==0 ){ + }else if( sqlite3StrICmp(z, "file")==0 ){ return 1; - }else if( sqliteStrICmp(z, "memory")==0 ){ + }else if( sqlite3StrICmp(z, "memory")==0 ){ return 2; }else{ return 0; } } +#endif /* SQLITE_PAGER_PRAGMAS */ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** Invalidate temp storage, either when the temp storage is changed +** from default, or when 'file' and the temp_store_directory has changed +*/ +static int invalidateTempStorage(Parse *pParse){ + sqlite3 *db = pParse->db; + if( db->aDb[1].pBt!=0 ){ + if( db->flags & SQLITE_InTrans ){ + sqlite3ErrorMsg(pParse, "temporary storage cannot be changed " + "from within a transaction"); + return SQLITE_ERROR; + } + sqlite3BtreeClose(db->aDb[1].pBt); + db->aDb[1].pBt = 0; + sqlite3ResetInternalSchema(db, 0); + } + return SQLITE_OK; +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** If the TEMP database is open, close it and mark the database schema +** as needing reloading. This must be done when using the TEMP_STORE +** or DEFAULT_TEMP_STORE pragmas. +*/ +static int changeTempStorage(Parse *pParse, const char *zStorageType){ + int ts = getTempStore(zStorageType); + sqlite3 *db = pParse->db; + if( db->temp_store==ts ) return SQLITE_OK; + if( invalidateTempStorage( pParse ) != SQLITE_OK ){ + return SQLITE_ERROR; + } + db->temp_store = ts; + return SQLITE_OK; +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +/* +** Generate code to return a single integer value. +*/ +static void returnSingleInt(Parse *pParse, const char *zLabel, int value){ + Vdbe *v = sqlite3GetVdbe(pParse); + sqlite3VdbeAddOp(v, OP_Integer, value, 0); + if( pParse->explain==0 ){ + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, P3_STATIC); + } + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); +} + +#ifndef SQLITE_OMIT_FLAG_PRAGMAS /* ** 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 { + static const struct sPragmaType { const char *zName; /* Name of the pragma */ int mask; /* Mask for the db->flags value */ } aPragma[] = { { "vdbe_trace", SQLITE_VdbeTrace }, + { "sql_trace", SQLITE_SqlTrace }, + { "vdbe_listing", SQLITE_VdbeListing }, { "full_column_names", SQLITE_FullColNames }, { "short_column_names", SQLITE_ShortColNames }, - { "show_datatypes", SQLITE_ReportTypes }, { "count_changes", SQLITE_CountRows }, { "empty_result_callbacks", SQLITE_NullCallback }, + { "legacy_file_format", SQLITE_LegacyFileFmt }, + { "fullfsync", SQLITE_FullFSync }, +#ifndef SQLITE_OMIT_CHECK + { "ignore_check_constraints", SQLITE_IgnoreChecks }, +#endif + /* The following is VERY experimental */ + { "writable_schema", SQLITE_WriteSchema }, + { "omit_readlock", SQLITE_NoReadlock }, + + /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted + ** flag if there are any active statements. */ + { "read_uncommitted", SQLITE_ReadUncommitted }, }; int i; - for(i=0; idb; + const struct sPragmaType *p; + for(i=0, p=aPragma; izName)==0 ){ + sqlite3 *db = pParse->db; 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; + v = sqlite3GetVdbe(pParse); + if( v ){ + if( zRight==0 ){ + returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 ); + }else{ + if( getBoolean(zRight) ){ + db->flags |= p->mask; + }else{ + db->flags &= ~p->mask; + } + } } return 1; } } return 0; } +#endif /* SQLITE_OMIT_FLAG_PRAGMAS */ /* ** Process a pragma statement. ** ** Pragmas are of this form: ** -** PRAGMA id = value +** PRAGMA [database.]id [= value] ** ** The identifier might also be a string. The value is a string, and ** identifier, or a number. If minusFlag is true, then the value is ** a number that was preceded by a minus sign. +** +** If the left side is "database.id" then pId1 is the database name +** and pId2 is the id. If the left side is just "id" then pId1 is the +** id and pId2 is any empty string. */ -void sqlitePragma(Parse *pParse, Token *pLeft, Token *pRight, int minusFlag){ - char *zLeft = 0; - char *zRight = 0; - sqlite *db = pParse->db; - Vdbe *v = sqliteGetVdbe(pParse); +void sqlite3Pragma( + Parse *pParse, + Token *pId1, /* First part of [database.]id field */ + Token *pId2, /* Second part of [database.]id field, or NULL */ + Token *pValue, /* Token for , or NULL */ + int minusFlag /* True if a '-' sign preceded */ +){ + char *zLeft = 0; /* Nul-terminated UTF-8 string */ + char *zRight = 0; /* Nul-terminated UTF-8 string , or NULL */ + const char *zDb = 0; /* The database name */ + Token *pId; /* Pointer to token */ + int iDb; /* Database index for */ + sqlite3 *db = pParse->db; + Db *pDb; + Vdbe *v = sqlite3GetVdbe(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); + /* Interpret the [database.] part of the pragma statement. iDb is the + ** index of the database this pragma is being applied to in db.aDb[]. */ + iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId); + if( iDb<0 ) return; + pDb = &db->aDb[iDb]; + + /* If the temp database has been explicitly named as part of the + ** pragma, make sure it is open. + */ + if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){ return; } + + zLeft = sqlite3NameFromToken(pId); + if( !zLeft ) return; + if( minusFlag ){ + zRight = sqlite3MPrintf("-%T", pValue); + }else{ + zRight = sqlite3NameFromToken(pValue); + } + + zDb = ((iDb>0)?pDb->zName:0); + if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){ + goto pragma_out; + } +#ifndef SQLITE_OMIT_PAGER_PRAGMAS /* - ** PRAGMA default_cache_size - ** PRAGMA default_cache_size=N + ** PRAGMA [database.]default_cache_size + ** PRAGMA [database.]default_cache_size=N ** ** The first form reports the current persistent setting for the ** page cache size. The value returned is the maximum number of @@ -171,40 +264,82 @@ void sqlitePragma(Parse *pParse, Token *pLeft, Token *pRight, int minusFlag){ ** 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}, + if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){ + static const VdbeOpList getCacheSize[] = { + { OP_ReadCookie, 0, 2, 0}, /* 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); + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + if( !zRight ){ + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", P3_STATIC); + addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize); + sqlite3VdbeChangeP1(v, addr, iDb); + sqlite3VdbeChangeP1(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); + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3VdbeAddOp(v, OP_Integer, size, 0); + sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 2); + addr = sqlite3VdbeAddOp(v, OP_Integer, 0, 0); + sqlite3VdbeAddOp(v, OP_Ge, 0, addr+3); + sqlite3VdbeAddOp(v, OP_Negative, 0, 0); + sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 2); + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); } }else /* - ** PRAGMA cache_size - ** PRAGMA cache_size=N + ** PRAGMA [database.]page_size + ** PRAGMA [database.]page_size=N + ** + ** The first form reports the current setting for the + ** database page size in bytes. The second form sets the + ** database page size value. The value can only be set if + ** the database has not yet been created. + */ + if( sqlite3StrICmp(zLeft,"page_size")==0 ){ + Btree *pBt = pDb->pBt; + if( !zRight ){ + int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0; + returnSingleInt(pParse, "page_size", size); + }else{ + sqlite3BtreeSetPageSize(pBt, atoi(zRight), -1); + } + }else +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + + /* + ** PRAGMA [database.]auto_vacuum + ** PRAGMA [database.]auto_vacuum=N + ** + ** Get or set the (boolean) value of the database 'auto-vacuum' parameter. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){ + Btree *pBt = pDb->pBt; + if( !zRight ){ + int auto_vacuum = + pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM; + returnSingleInt(pParse, "auto_vacuum", auto_vacuum); + }else{ + sqlite3BtreeSetAutoVacuum(pBt, getBoolean(zRight)); + } + }else +#endif + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + /* + ** PRAGMA [database.]cache_size + ** PRAGMA [database.]cache_size=N ** ** The first form reports the current local setting for the ** page cache size. The local setting can be different from @@ -216,268 +351,18 @@ void sqlitePragma(Parse *pParse, Token *pLeft, Token *pRight, int minusFlag){ ** 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); + if( sqlite3StrICmp(zLeft,"cache_size")==0 ){ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + if( !zRight ){ + returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size); }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); + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->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" @@ -489,211 +374,597 @@ void sqlitePragma(Parse *pParse, Token *pLeft, Token *pRight, int minusFlag){ ** 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); + if( sqlite3StrICmp(zLeft, "temp_store")==0 ){ + if( !zRight ){ + returnSingleInt(pParse, "temp_store", db->temp_store); }else{ - if (&db->aDb[1].pBt != 0) { - sqliteErrorMsg(pParse, "The temporary database already exists - " - "its location cannot now be changed"); - } else { - db->temp_store = getTempStore(zRight); + changeTempStorage(pParse, zRight); + } + }else + + /* + ** PRAGMA temp_store_directory + ** PRAGMA temp_store_directory = ""|"directory_name" + ** + ** Return or set the local value of the temp_store_directory flag. Changing + ** the value sets a specific directory to be used for temporary files. + ** Setting to a null string reverts to the default temporary directory search. + ** If temporary directory is changed, then invalidateTempStorage. + ** + */ + if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){ + if( !zRight ){ + if( sqlite3_temp_directory ){ + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, + "temp_store_directory", P3_STATIC); + sqlite3VdbeOp3(v, OP_String8, 0, 0, sqlite3_temp_directory, 0); + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + } + }else{ + if( zRight[0] && !sqlite3OsIsDirWritable(zRight) ){ + sqlite3ErrorMsg(pParse, "not a writable directory"); + goto pragma_out; + } + if( TEMP_STORE==0 + || (TEMP_STORE==1 && db->temp_store<=1) + || (TEMP_STORE==2 && db->temp_store==1) + ){ + invalidateTempStorage(pParse); + } + sqliteFree(sqlite3_temp_directory); + if( zRight[0] ){ + sqlite3_temp_directory = zRight; + zRight = 0; + }else{ + sqlite3_temp_directory = 0; } } }else /* - ** PRAGMA default_temp_store - ** PRAGMA default_temp_store = "default"|"memory"|"file" + ** PRAGMA [database.]synchronous + ** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL ** - ** Return or set the value of the persistent temp_store flag (as - ** well as the value currently in force). - ** - ** Note that it is possible for the library compile-time options to - ** override this setting + ** 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, "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); + if( sqlite3StrICmp(zLeft,"synchronous")==0 ){ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + if( !zRight ){ + returnSingleInt(pParse, "synchronous", pDb->safety_level-1); }else{ - if (&db->aDb[1].pBt != 0) { - sqliteErrorMsg(pParse, "The temporary database already exists - " - "its location cannot now be changed"); - } else { - sqliteBeginWriteOperation(pParse, 0, 0); - db->temp_store = getTempStore(zRight); - sqliteVdbeAddOp(v, OP_Integer, db->temp_store, 0); - sqliteVdbeAddOp(v, OP_SetCookie, 0, 5); - sqliteEndWriteOperation(pParse); + if( !db->autoCommit ){ + sqlite3ErrorMsg(pParse, + "Safety level may not be changed inside a transaction"); + }else{ + pDb->safety_level = getSafetyLevel(zRight)+1; + } + } + }else +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_FLAG_PRAGMAS + if( flagPragma(pParse, zLeft, zRight) ){ + /* The flagPragma() subroutine also generates any necessary code + ** there is nothing more to do here */ + }else +#endif /* SQLITE_OMIT_FLAG_PRAGMAS */ + +#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS + /* + ** PRAGMA table_info() + ** + ** Return a single row for each column of the named table. The columns of + ** the returned data set are: + ** + ** cid: Column id (numbered from left to right, starting at 0) + ** name: Column name + ** type: Column declaration type. + ** notnull: True if 'NOT NULL' is part of column declaration + ** dflt_value: The default value for the column, if any. + */ + if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){ + Table *pTab; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + int i; + Column *pCol; + sqlite3VdbeSetNumCols(v, 6); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", P3_STATIC); + sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", P3_STATIC); + sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", P3_STATIC); + sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", P3_STATIC); + sqlite3ViewGetColumnNames(pParse, pTab); + for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pCol->zName, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, + pCol->zType ? pCol->zType : "", 0); + sqlite3VdbeAddOp(v, OP_Integer, pCol->notNull, 0); + sqlite3ExprCode(pParse, pCol->pDflt); + sqlite3VdbeAddOp(v, OP_Integer, pCol->isPrimKey, 0); + sqlite3VdbeAddOp(v, OP_Callback, 6, 0); } } }else + if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){ + Index *pIdx; + Table *pTab; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + pIdx = sqlite3FindIndex(db, zRight, zDb); + if( pIdx ){ + int i; + pTab = pIdx->pTable; + sqlite3VdbeSetNumCols(v, 3); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", P3_STATIC); + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", P3_STATIC); + for(i=0; inColumn; i++){ + int cnum = pIdx->aiColumn[i]; + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + sqlite3VdbeAddOp(v, OP_Integer, cnum, 0); + assert( pTab->nCol>cnum ); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->aCol[cnum].zName, 0); + sqlite3VdbeAddOp(v, OP_Callback, 3, 0); + } + } + }else + + if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){ + Index *pIdx; + Table *pTab; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + v = sqlite3GetVdbe(pParse); + pIdx = pTab->pIndex; + if( pIdx ){ + int i = 0; + sqlite3VdbeSetNumCols(v, 3); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", P3_STATIC); + while(pIdx){ + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pIdx->zName, 0); + sqlite3VdbeAddOp(v, OP_Integer, pIdx->onError!=OE_None, 0); + sqlite3VdbeAddOp(v, OP_Callback, 3, 0); + ++i; + pIdx = pIdx->pNext; + } + } + } + }else + + if( sqlite3StrICmp(zLeft, "database_list")==0 ){ + int i; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + sqlite3VdbeSetNumCols(v, 3); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", P3_STATIC); + for(i=0; inDb; i++){ + if( db->aDb[i].pBt==0 ) continue; + assert( db->aDb[i].zName!=0 ); + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, + sqlite3BtreeGetFilename(db->aDb[i].pBt), 0); + sqlite3VdbeAddOp(v, OP_Callback, 3, 0); + } + }else + + if( sqlite3StrICmp(zLeft, "collation_list")==0 ){ + int i = 0; + HashElem *p; + sqlite3VdbeSetNumCols(v, 2); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); + for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){ + CollSeq *pColl = (CollSeq *)sqliteHashData(p); + sqlite3VdbeAddOp(v, OP_Integer, i++, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pColl->zName, 0); + sqlite3VdbeAddOp(v, OP_Callback, 2, 0); + } + }else +#endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY + if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){ + FKey *pFK; + Table *pTab; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + v = sqlite3GetVdbe(pParse); + pFK = pTab->pFKey; + if( pFK ){ + int i = 0; + sqlite3VdbeSetNumCols(v, 5); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", P3_STATIC); + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", P3_STATIC); + sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", P3_STATIC); + sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", P3_STATIC); + while(pFK){ + int j; + for(j=0; jnCol; j++){ + char *zCol = pFK->aCol[j].zCol; + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + sqlite3VdbeAddOp(v, OP_Integer, j, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pFK->zTo, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, + pTab->aCol[pFK->aCol[j].iFrom].zName, 0); + sqlite3VdbeOp3(v, zCol ? OP_String8 : OP_Null, 0, 0, zCol, 0); + sqlite3VdbeAddOp(v, OP_Callback, 5, 0); + } + ++i; + pFK = pFK->pNextFrom; + } + } + } + }else +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + #ifndef NDEBUG - if( sqliteStrICmp(zLeft, "parser_trace")==0 ){ - extern void sqliteParserTrace(FILE*, char *); - if( getBoolean(zRight) ){ - sqliteParserTrace(stdout, "parser: "); - }else{ - sqliteParserTrace(0, 0); + if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){ + extern void sqlite3ParserTrace(FILE*, char *); + if( zRight ){ + if( getBoolean(zRight) ){ + sqlite3ParserTrace(stderr, "parser: "); + }else{ + sqlite3ParserTrace(0, 0); + } } }else #endif - if( sqliteStrICmp(zLeft, "integrity_check")==0 ){ + /* Reinstall the LIKE and GLOB functions. The variant of LIKE + ** used will be case sensitive or not depending on the RHS. + */ + if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){ + if( zRight ){ + sqlite3RegisterLikeFunctions(db, getBoolean(zRight)); + } + }else + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK + if( sqlite3StrICmp(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[] = { + static const VdbeOpList endCode[] = { { OP_MemLoad, 0, 0, 0}, { OP_Integer, 0, 0, 0}, { OP_Ne, 0, 0, 0}, /* 2 */ - { OP_String, 0, 0, "ok"}, + { OP_String8, 0, 0, "ok"}, { OP_Callback, 1, 0, 0}, }; /* Initialize the VDBE program */ - sqliteVdbeAddOpList(v, ArraySize(initCode), initCode); + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", P3_STATIC); + sqlite3VdbeAddOp(v, OP_MemInt, 0, 0); /* Initialize error count to 0 */ /* Do an integrity check on each database file */ for(i=0; inDb; i++){ HashElem *x; + Hash *pTbls; + int cnt = 0; + + if( OMIT_TEMPDB && i==1 ) continue; + + sqlite3CodeVerifySchema(pParse, i); /* 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); + pTbls = &db->aDb[i].pSchema->tblHash; + for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ + Table *pTab = sqliteHashData(x); + Index *pIdx; + sqlite3VdbeAddOp(v, OP_Integer, pTab->tnum, 0); + cnt++; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + sqlite3VdbeAddOp(v, OP_Integer, pIdx->tnum, 0); + cnt++; + } + } + assert( cnt>0 ); + sqlite3VdbeAddOp(v, OP_IntegrityCk, cnt, i); + sqlite3VdbeAddOp(v, OP_Dup, 0, 1); + addr = sqlite3VdbeOp3(v, OP_String8, 0, 0, "ok", P3_STATIC); + sqlite3VdbeAddOp(v, OP_Eq, 0, addr+7); + sqlite3VdbeOp3(v, OP_String8, 0, 0, + sqlite3MPrintf("*** in database %s ***\n", db->aDb[i].zName), + P3_DYNAMIC); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + sqlite3VdbeAddOp(v, OP_Concat, 0, 1); + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + sqlite3VdbeAddOp(v, OP_MemIncr, 1, 0); /* Make sure all the indices are constructed correctly. */ - sqliteCodeVerifySchema(pParse, i); - for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){ + sqlite3CodeVerifySchema(pParse, i); + for(x=sqliteHashFirst(pTbls); 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); + sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead); + sqlite3VdbeAddOp(v, OP_MemInt, 0, 1); + loopTop = sqlite3VdbeAddOp(v, OP_Rewind, 1, 0); + sqlite3VdbeAddOp(v, OP_MemIncr, 1, 1); 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}, + int jmp2; + static const VdbeOpList idxErr[] = { + { OP_MemIncr, 1, 0, 0}, + { OP_String8, 0, 0, "rowid "}, + { OP_Rowid, 1, 0, 0}, + { OP_String8, 0, 0, " missing from index "}, + { OP_String8, 0, 0, 0}, /* 4 */ + { OP_Concat, 2, 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)); + sqlite3GenerateIndexKey(v, pIdx, 1); + jmp2 = sqlite3VdbeAddOp(v, OP_Found, j+2, 0); + addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr); + sqlite3VdbeChangeP3(v, addr+4, pIdx->zName, P3_STATIC); + sqlite3VdbeJumpHere(v, jmp2); } - sqliteVdbeAddOp(v, OP_Next, 1, loopTop+1); - sqliteVdbeChangeP2(v, loopTop, sqliteVdbeCurrentAddr(v)); + sqlite3VdbeAddOp(v, OP_Next, 1, loopTop+1); + sqlite3VdbeJumpHere(v, loopTop); 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 */ + static const VdbeOpList cntIdx[] = { + { OP_MemInt, 0, 2, 0}, + { OP_Rewind, 0, 0, 0}, /* 1 */ + { OP_MemIncr, 1, 2, 0}, + { OP_Next, 0, 0, 0}, /* 3 */ { 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_Eq, 0, 0, 0}, /* 6 */ + { OP_MemIncr, 1, 0, 0}, + { OP_String8, 0, 0, "wrong # of entries in index "}, + { OP_String8, 0, 0, 0}, /* 9 */ + { OP_Concat, 0, 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 = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx); + sqlite3VdbeChangeP1(v, addr+1, j+2); + sqlite3VdbeChangeP2(v, addr+1, addr+4); + sqlite3VdbeChangeP1(v, addr+3, j+2); + sqlite3VdbeChangeP2(v, addr+3, addr+2); + sqlite3VdbeJumpHere(v, addr+6); + sqlite3VdbeChangeP3(v, addr+9, pIdx->zName, P3_STATIC); } } } - addr = sqliteVdbeAddOpList(v, ArraySize(endCode), endCode); - sqliteVdbeChangeP2(v, addr+2, addr+ArraySize(endCode)); + addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode); + sqlite3VdbeJumpHere(v, addr+2); }else +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_UTF16 + /* + ** PRAGMA encoding + ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be" + ** + ** In it's first form, this pragma returns the encoding of the main + ** database. If the database is not initialized, it is initialized now. + ** + ** The second form of this pragma is a no-op if the main database file + ** has not already been initialized. In this case it sets the default + ** encoding that will be used for the main database file if a new file + ** is created. If an existing main database file is opened, then the + ** default text encoding for the existing database is used. + ** + ** In all cases new databases created using the ATTACH command are + ** created to use the same default text encoding as the main database. If + ** the main database has not been initialized and/or created when ATTACH + ** is executed, this is done before the ATTACH operation. + ** + ** In the second form this pragma sets the text encoding to be used in + ** new database files created using this database handle. It is only + ** useful if invoked immediately after the main database i + */ + if( sqlite3StrICmp(zLeft, "encoding")==0 ){ + static struct EncName { + char *zName; + u8 enc; + } encnames[] = { + { "UTF-8", SQLITE_UTF8 }, + { "UTF8", SQLITE_UTF8 }, + { "UTF-16le", SQLITE_UTF16LE }, + { "UTF16le", SQLITE_UTF16LE }, + { "UTF-16be", SQLITE_UTF16BE }, + { "UTF16be", SQLITE_UTF16BE }, + { "UTF-16", 0 /* Filled in at run-time */ }, + { "UTF16", 0 /* Filled in at run-time */ }, + { 0, 0 } + }; + struct EncName *pEnc; + encnames[6].enc = encnames[7].enc = SQLITE_UTF16NATIVE; + if( !zRight ){ /* "PRAGMA encoding" */ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", P3_STATIC); + sqlite3VdbeAddOp(v, OP_String8, 0, 0); + for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ + if( pEnc->enc==ENC(pParse->db) ){ + sqlite3VdbeChangeP3(v, -1, pEnc->zName, P3_STATIC); + break; + } + } + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + }else{ /* "PRAGMA encoding = XXX" */ + /* Only change the value of sqlite.enc if the database handle is not + ** initialized. If the main database exists, the new sqlite.enc value + ** will be overwritten when the schema is next loaded. If it does not + ** already exists, it will be created to use the new encoding value. + */ + if( + !(DbHasProperty(db, 0, DB_SchemaLoaded)) || + DbHasProperty(db, 0, DB_Empty) + ){ + for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ + if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){ + ENC(pParse->db) = pEnc->enc; + break; + } + } + if( !pEnc->zName ){ + sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight); + } + } + } + }else +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS + /* + ** PRAGMA [database.]schema_version + ** PRAGMA [database.]schema_version = + ** + ** PRAGMA [database.]user_version + ** PRAGMA [database.]user_version = + ** + ** The pragma's schema_version and user_version are used to set or get + ** the value of the schema-version and user-version, respectively. Both + ** the schema-version and the user-version are 32-bit signed integers + ** stored in the database header. + ** + ** The schema-cookie is usually only manipulated internally by SQLite. It + ** is incremented by SQLite whenever the database schema is modified (by + ** creating or dropping a table or index). The schema version is used by + ** SQLite each time a query is executed to ensure that the internal cache + ** of the schema used when compiling the SQL query matches the schema of + ** the database against which the compiled query is actually executed. + ** Subverting this mechanism by using "PRAGMA schema_version" to modify + ** the schema-version is potentially dangerous and may lead to program + ** crashes or database corruption. Use with caution! + ** + ** The user-version is not used internally by SQLite. It may be used by + ** applications for any purpose. + */ + if( sqlite3StrICmp(zLeft, "schema_version")==0 || + sqlite3StrICmp(zLeft, "user_version")==0 ){ + + int iCookie; /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */ + if( zLeft[0]=='s' || zLeft[0]=='S' ){ + iCookie = 0; + }else{ + iCookie = 5; + } + + if( zRight ){ + /* Write the specified cookie value */ + static const VdbeOpList setCookie[] = { + { OP_Transaction, 0, 1, 0}, /* 0 */ + { OP_Integer, 0, 0, 0}, /* 1 */ + { OP_SetCookie, 0, 0, 0}, /* 2 */ + }; + int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie); + sqlite3VdbeChangeP1(v, addr, iDb); + sqlite3VdbeChangeP1(v, addr+1, atoi(zRight)); + sqlite3VdbeChangeP1(v, addr+2, iDb); + sqlite3VdbeChangeP2(v, addr+2, iCookie); + }else{ + /* Read the specified cookie value */ + static const VdbeOpList readCookie[] = { + { OP_ReadCookie, 0, 0, 0}, /* 0 */ + { OP_Callback, 1, 0, 0} + }; + int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie); + sqlite3VdbeChangeP1(v, addr, iDb); + sqlite3VdbeChangeP2(v, addr, iCookie); + sqlite3VdbeSetNumCols(v, 1); + } + } +#endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */ + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* + ** Report the current state of file logs for all databases + */ + if( sqlite3StrICmp(zLeft, "lock_status")==0 ){ + static const char *const azLockName[] = { + "unlocked", "shared", "reserved", "pending", "exclusive" + }; + int i; + Vdbe *v = sqlite3GetVdbe(pParse); + sqlite3VdbeSetNumCols(v, 2); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", P3_STATIC); + for(i=0; inDb; i++){ + Btree *pBt; + Pager *pPager; + if( db->aDb[i].zName==0 ) continue; + sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, P3_STATIC); + pBt = db->aDb[i].pBt; + if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){ + sqlite3VdbeOp3(v, OP_String8, 0, 0, "closed", P3_STATIC); + }else{ + int j = sqlite3pager_lockstate(pPager); + sqlite3VdbeOp3(v, OP_String8, 0, 0, + (j>=0 && j<=4) ? azLockName[j] : "unknown", P3_STATIC); + } + sqlite3VdbeAddOp(v, OP_Callback, 2, 0); + } + }else +#endif + +#ifdef SQLITE_SSE + /* + ** Check to see if the sqlite_statements table exists. Create it + ** if it does not. + */ + if( sqlite3StrICmp(zLeft, "create_sqlite_statement_table")==0 ){ + extern int sqlite3CreateStatementsTable(Parse*); + sqlite3CreateStatementsTable(pParse); + }else +#endif + +#if SQLITE_HAS_CODEC + if( sqlite3StrICmp(zLeft, "key")==0 ){ + sqlite3_key(db, zRight, strlen(zRight)); + }else +#endif {} + + if( v ){ + /* Code an OP_Expire at the end of each PRAGMA program to cause + ** the VDBE implementing the pragma to expire. Most (all?) pragmas + ** are only valid for a single execution. + */ + sqlite3VdbeAddOp(v, OP_Expire, 1, 0); + + /* + ** Reset the safety level, in case the fullfsync flag or synchronous + ** setting changed. + */ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + if( db->autoCommit ){ + sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level, + (db->flags&SQLITE_FullFSync)!=0); + } +#endif + } +pragma_out: sqliteFree(zLeft); sqliteFree(zRight); } + +#endif /* SQLITE_OMIT_PRAGMA || SQLITE_OMIT_PARSER */ diff --git a/sqlite/prepare.c b/sqlite/prepare.c new file mode 100755 index 000000000..2c099c7b5 --- /dev/null +++ b/sqlite/prepare.c @@ -0,0 +1,583 @@ +/* +** 2005 May 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the implementation of the sqlite3_prepare() +** interface, and routines that contribute to loading the database schema +** from disk. +** +** $Id: prepare.c,v 1.1 2006-04-13 12:44:29 guy Exp $ +*/ +#include "sqliteInt.h" +#include "os.h" +#include + +/* +** Fill the InitData structure with an error message that indicates +** that the database is corrupt. +*/ +static void corruptSchema(InitData *pData, const char *zExtra){ + if( !sqlite3MallocFailed() ){ + sqlite3SetString(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 sqlite3Init() below for additional information. +** This routine is also called from the OP_ParseSchema opcode of the VDBE. +** +** Each callback contains the following information: +** +** argv[0] = name of thing being created +** argv[1] = root page number for table or index. NULL for trigger or view. +** argv[2] = SQL text for the CREATE statement. +** argv[3] = "1" for temporary files, "0" for main database, "2" or more +** for auxiliary database files. +** +*/ +int sqlite3InitCallback(void *pInit, int argc, char **argv, char **azColName){ + InitData *pData = (InitData*)pInit; + sqlite3 *db = pData->db; + int iDb; + + if( sqlite3MallocFailed() ){ + return SQLITE_NOMEM; + } + + assert( argc==4 ); + if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ + if( argv[1]==0 || argv[3]==0 ){ + corruptSchema(pData, 0); + return 1; + } + iDb = atoi(argv[3]); + assert( iDb>=0 && iDbnDb ); + if( argv[2] && argv[2][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; + int rc; + assert( db->init.busy ); + db->init.iDb = iDb; + db->init.newTnum = atoi(argv[1]); + rc = sqlite3_exec(db, argv[2], 0, 0, &zErr); + db->init.iDb = 0; + assert( rc!=SQLITE_OK || zErr==0 ); + if( SQLITE_OK!=rc ){ + if( rc==SQLITE_NOMEM ){ + sqlite3FailedMalloc(); + }else{ + corruptSchema(pData, zErr); + } + sqlite3_free(zErr); + return rc; + } + }else{ + /* If the SQL column is blank it means this is an index that + ** was created to be the PRIMARY KEY or to fulfill a UNIQUE + ** constraint for a CREATE TABLE. The index should have already + ** been created when we processed the CREATE TABLE. All we have + ** to do here is record the root page number for that index. + */ + Index *pIndex; + pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName); + if( pIndex==0 || 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[1]); + } + } + return 0; +} + +/* +** Attempt to read the database schema and initialize internal +** data structures for a single database file. The index of the +** database file is given by iDb. iDb==0 is used for the main +** database. iDb==1 should never be used. iDb>=2 is used for +** auxiliary databases. Return one of the SQLITE_ error codes to +** indicate success or failure. +*/ +static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){ + int rc; + BtCursor *curMain; + int size; + Table *pTab; + Db *pDb; + char const *azArg[5]; + char zDbNum[30]; + int meta[10]; + InitData initData; + char const *zMasterSchema; + char const *zMasterName = SCHEMA_TABLE(iDb); + + /* + ** The master database table has a structure like this + */ + static const char master_schema[] = + "CREATE TABLE sqlite_master(\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")" + ; +#ifndef SQLITE_OMIT_TEMPDB + static const char temp_master_schema[] = + "CREATE TEMP TABLE sqlite_temp_master(\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")" + ; +#else + #define temp_master_schema 0 +#endif + + assert( iDb>=0 && iDbnDb ); + assert( db->aDb[iDb].pSchema ); + + /* 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( !OMIT_TEMPDB && iDb==1 ){ + zMasterSchema = temp_master_schema; + }else{ + zMasterSchema = master_schema; + } + zMasterName = SCHEMA_TABLE(iDb); + + /* Construct the schema tables. */ + sqlite3SafetyOff(db); + azArg[0] = zMasterName; + azArg[1] = "1"; + azArg[2] = zMasterSchema; + sprintf(zDbNum, "%d", iDb); + azArg[3] = zDbNum; + azArg[4] = 0; + initData.db = db; + initData.pzErrMsg = pzErrMsg; + rc = sqlite3InitCallback(&initData, 4, (char **)azArg, 0); + if( rc!=SQLITE_OK ){ + sqlite3SafetyOn(db); + return rc; + } + pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName); + if( pTab ){ + pTab->readOnly = 1; + } + sqlite3SafetyOn(db); + + /* Create a cursor to hold the database open + */ + pDb = &db->aDb[iDb]; + if( pDb->pBt==0 ){ + if( !OMIT_TEMPDB && iDb==1 ){ + DbSetProperty(db, 1, DB_SchemaLoaded); + } + return SQLITE_OK; + } + rc = sqlite3BtreeCursor(pDb->pBt, MASTER_ROOT, 0, 0, 0, &curMain); + if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){ + sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0); + return rc; + } + + /* Get the database meta information. + ** + ** Meta values are as follows: + ** meta[0] Schema cookie. Changes with each schema change. + ** meta[1] File format of schema layer. + ** meta[2] Size of the page cache. + ** meta[3] Use freelist if 0. Autovacuum if greater than zero. + ** meta[4] Db text encoding. 1:UTF-8 3:UTF-16 LE 4:UTF-16 BE + ** meta[5] The user cookie. Used by the application. + ** meta[6] + ** meta[7] + ** meta[8] + ** meta[9] + ** + ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to + ** the possible values of meta[4]. + */ + if( rc==SQLITE_OK ){ + int i; + for(i=0; rc==SQLITE_OK && ipBt, i+1, (u32 *)&meta[i]); + } + if( rc ){ + sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0); + sqlite3BtreeCloseCursor(curMain); + return rc; + } + }else{ + memset(meta, 0, sizeof(meta)); + } + pDb->pSchema->schema_cookie = meta[0]; + + /* If opening a non-empty database, check the text encoding. For the + ** main database, set sqlite3.enc to the encoding of the main database. + ** For an attached db, it is an error if the encoding is not the same + ** as sqlite3.enc. + */ + if( meta[4] ){ /* text encoding */ + if( iDb==0 ){ + /* If opening the main database, set ENC(db). */ + ENC(db) = (u8)meta[4]; + db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0); + }else{ + /* If opening an attached database, the encoding much match ENC(db) */ + if( meta[4]!=ENC(db) ){ + sqlite3BtreeCloseCursor(curMain); + sqlite3SetString(pzErrMsg, "attached databases must use the same" + " text encoding as main database", (char*)0); + return SQLITE_ERROR; + } + } + }else{ + DbSetProperty(db, iDb, DB_Empty); + } + pDb->pSchema->enc = ENC(db); + + size = meta[2]; + if( size==0 ){ size = MAX_PAGES; } + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + + /* + ** file_format==1 Version 3.0.0. + ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN + ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults + ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants + */ + pDb->pSchema->file_format = meta[1]; + if( pDb->pSchema->file_format==0 ){ + pDb->pSchema->file_format = 1; + } + if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){ + sqlite3BtreeCloseCursor(curMain); + sqlite3SetString(pzErrMsg, "unsupported file format", (char*)0); + return SQLITE_ERROR; + } + + + /* Read the schema information out of the schema tables + */ + assert( db->init.busy ); + if( rc==SQLITE_EMPTY ){ + /* For an empty database, there is nothing to read */ + rc = SQLITE_OK; + }else{ + char *zSql; + zSql = sqlite3MPrintf( + "SELECT name, rootpage, sql, '%s' FROM '%q'.%s", + zDbNum, db->aDb[iDb].zName, zMasterName); + sqlite3SafetyOff(db); + rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); + sqlite3SafetyOn(db); + sqliteFree(zSql); +#ifndef SQLITE_OMIT_ANALYZE + if( rc==SQLITE_OK ){ + sqlite3AnalysisLoad(db, iDb); + } +#endif + sqlite3BtreeCloseCursor(curMain); + } + if( sqlite3MallocFailed() ){ + /* sqlite3SetString(pzErrMsg, "out of memory", (char*)0); */ + rc = SQLITE_NOMEM; + sqlite3ResetInternalSchema(db, 0); + } + if( rc==SQLITE_OK ){ + DbSetProperty(db, iDb, DB_SchemaLoaded); + }else{ + sqlite3ResetInternalSchema(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 a database is initialized, the DB_SchemaLoaded bit is set +** bit is set in the flags field of the Db structure. If the database +** file was of zero-length, then the DB_Empty flag is also set. +*/ +int sqlite3Init(sqlite3 *db, char **pzErrMsg){ + int i, rc; + int called_initone = 0; + + if( db->init.busy ) return SQLITE_OK; + 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 = sqlite3InitOne(db, i, pzErrMsg); + if( rc ){ + sqlite3ResetInternalSchema(db, i); + } + called_initone = 1; + } + + /* 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. + */ +#ifndef SQLITE_OMIT_TEMPDB + if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){ + rc = sqlite3InitOne(db, 1, pzErrMsg); + if( rc ){ + sqlite3ResetInternalSchema(db, 1); + } + called_initone = 1; + } +#endif + + db->init.busy = 0; + if( rc==SQLITE_OK && called_initone ){ + sqlite3CommitInternalChanges(db); + } + + return rc; +} + +/* +** This routine is a no-op if the database schema is already initialised. +** Otherwise, the schema is loaded. An error code is returned. +*/ +int sqlite3ReadSchema(Parse *pParse){ + int rc = SQLITE_OK; + sqlite3 *db = pParse->db; + if( !db->init.busy ){ + rc = sqlite3Init(db, &pParse->zErrMsg); + } + if( rc!=SQLITE_OK ){ + pParse->rc = rc; + pParse->nErr++; + } + return rc; +} + + +/* +** Check schema cookies in all databases. If any cookie is out +** of date, return 0. If all schema cookies are current, return 1. +*/ +static int schemaIsValid(sqlite3 *db){ + int iDb; + int rc; + BtCursor *curTemp; + int cookie; + int allOk = 1; + + for(iDb=0; allOk && iDbnDb; iDb++){ + Btree *pBt; + pBt = db->aDb[iDb].pBt; + if( pBt==0 ) continue; + rc = sqlite3BtreeCursor(pBt, MASTER_ROOT, 0, 0, 0, &curTemp); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&cookie); + if( rc==SQLITE_OK && cookie!=db->aDb[iDb].pSchema->schema_cookie ){ + allOk = 0; + } + sqlite3BtreeCloseCursor(curTemp); + } + } + return allOk; +} + +/* +** Convert a schema pointer into the iDb index that indicates +** which database file in db->aDb[] the schema refers to. +** +** If the same database is attached more than once, the first +** attached database is returned. +*/ +int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){ + int i = -1000000; + + /* If pSchema is NULL, then return -1000000. This happens when code in + ** expr.c is trying to resolve a reference to a transient table (i.e. one + ** created by a sub-select). In this case the return value of this + ** function should never be used. + ** + ** We return -1000000 instead of the more usual -1 simply because using + ** -1000000 as incorrectly using -1000000 index into db->aDb[] is much + ** more likely to cause a segfault than -1 (of course there are assert() + ** statements too, but it never hurts to play the odds). + */ + if( pSchema ){ + for(i=0; inDb; i++){ + if( db->aDb[i].pSchema==pSchema ){ + break; + } + } + assert( i>=0 &&i>=0 && inDb ); + } + return i; +} + +/* +** Compile the UTF-8 encoded SQL statement zSql into a statement handle. +*/ +int sqlite3_prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char** pzTail /* OUT: End of parsed string */ +){ + Parse sParse; + char *zErrMsg = 0; + int rc = SQLITE_OK; + int i; + + /* Assert that malloc() has not failed */ + assert( !sqlite3MallocFailed() ); + + assert( ppStmt ); + *ppStmt = 0; + if( sqlite3SafetyOn(db) ){ + return SQLITE_MISUSE; + } + + /* If any attached database schemas are locked, do not proceed with + ** compilation. Instead return SQLITE_LOCKED immediately. + */ + for(i=0; inDb; i++) { + Btree *pBt = db->aDb[i].pBt; + if( pBt && sqlite3BtreeSchemaLocked(pBt) ){ + const char *zDb = db->aDb[i].zName; + sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb); + sqlite3SafetyOff(db); + return SQLITE_LOCKED; + } + } + + memset(&sParse, 0, sizeof(sParse)); + sParse.db = db; + if( nBytes>=0 && zSql[nBytes]!=0 ){ + char *zSqlCopy = sqlite3StrNDup(zSql, nBytes); + sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg); + sParse.zTail += zSql - zSqlCopy; + sqliteFree(zSqlCopy); + }else{ + sqlite3RunParser(&sParse, zSql, &zErrMsg); + } + + if( sqlite3MallocFailed() ){ + sParse.rc = SQLITE_NOMEM; + } + if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK; + if( sParse.checkSchema && !schemaIsValid(db) ){ + sParse.rc = SQLITE_SCHEMA; + } + if( sParse.rc==SQLITE_SCHEMA ){ + sqlite3ResetInternalSchema(db, 0); + } + if( pzTail ) *pzTail = sParse.zTail; + rc = sParse.rc; + +#ifndef SQLITE_OMIT_EXPLAIN + if( rc==SQLITE_OK && sParse.pVdbe && sParse.explain ){ + if( sParse.explain==2 ){ + sqlite3VdbeSetNumCols(sParse.pVdbe, 3); + sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "order", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "from", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "detail", P3_STATIC); + }else{ + sqlite3VdbeSetNumCols(sParse.pVdbe, 5); + sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "addr", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "opcode", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "p1", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 3, COLNAME_NAME, "p2", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 4, COLNAME_NAME, "p3", P3_STATIC); + } + } +#endif + + if( sqlite3SafetyOff(db) ){ + rc = SQLITE_MISUSE; + } + if( rc==SQLITE_OK ){ + *ppStmt = (sqlite3_stmt*)sParse.pVdbe; + }else if( sParse.pVdbe ){ + sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe); + } + + if( zErrMsg ){ + sqlite3Error(db, rc, "%s", zErrMsg); + sqliteFree(zErrMsg); + }else{ + sqlite3Error(db, rc, 0); + } + + rc = sqlite3ApiExit(db, rc); + sqlite3ReleaseThreadData(); + return rc; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Compile the UTF-16 encoded SQL statement zSql into a statement handle. +*/ +int sqlite3_prepare16( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + /* This function currently works by first transforming the UTF-16 + ** encoded string to UTF-8, then invoking sqlite3_prepare(). The + ** tricky bit is figuring out the pointer to return in *pzTail. + */ + char *zSql8; + const char *zTail8 = 0; + int rc = SQLITE_OK; + + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + zSql8 = sqlite3utf16to8(zSql, nBytes); + if( zSql8 ){ + rc = sqlite3_prepare(db, zSql8, -1, ppStmt, &zTail8); + } + + if( zTail8 && pzTail ){ + /* If sqlite3_prepare returns a tail pointer, we calculate the + ** equivalent pointer into the UTF-16 string by counting the unicode + ** characters between zSql8 and zTail8, and then returning a pointer + ** the same number of characters into the UTF-16 string. + */ + int chars_parsed = sqlite3utf8CharLen(zSql8, zTail8-zSql8); + *pzTail = (u8 *)zSql + sqlite3utf16ByteLen(zSql, chars_parsed); + } + sqliteFree(zSql8); + return sqlite3ApiExit(db, rc); +} +#endif /* SQLITE_OMIT_UTF16 */ diff --git a/sqlite/printf.c b/sqlite/printf.c index 620578d76..4e1de1af7 100755 --- a/sqlite/printf.c +++ b/sqlite/printf.c @@ -65,14 +65,14 @@ #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 '', +#define etCHARLIT 10 /* Literal characters. %' */ +#define etSQLESCAPE 11 /* Strings with '\'' doubled. %q */ +#define etSQLESCAPE2 12 /* 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 */ +#define etTOKEN 13 /* a pointer to a Token structure */ +#define etSRCLIST 14 /* a pointer to a SrcList */ +#define etPOINTER 15 /* The %p conversion */ /* @@ -89,8 +89,8 @@ typedef struct et_info { /* Information about each format field */ 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 */ + etByte charset; /* Offset into aDigits[] of the digits string */ + etByte prefix; /* Offset into aPrefix[] of the prefix string */ } et_info; /* @@ -98,42 +98,47 @@ typedef struct et_info { /* Information about each format field */ */ #define FLAG_SIGNED 1 /* True if the value to convert is signed */ #define FLAG_INTERN 2 /* True if for internal use only */ +#define FLAG_STRING 4 /* Allow infinity precision */ /* ** The following table is searched linearly, so it is good to put the ** most frequently used conversion types first. */ -static 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 }, +static const char aDigits[] = "0123456789ABCDEF0123456789abcdef"; +static const char aPrefix[] = "-x0\000X0"; +static const et_info fmtinfo[] = { + { 'd', 10, 1, etRADIX, 0, 0 }, + { 's', 0, 4, etSTRING, 0, 0 }, + { 'g', 0, 1, etGENERIC, 30, 0 }, + { 'z', 0, 6, etDYNSTRING, 0, 0 }, + { 'q', 0, 4, etSQLESCAPE, 0, 0 }, + { 'Q', 0, 4, etSQLESCAPE2, 0, 0 }, + { 'c', 0, 0, etCHARX, 0, 0 }, + { 'o', 8, 0, etRADIX, 0, 2 }, + { 'u', 10, 0, etRADIX, 0, 0 }, + { 'x', 16, 0, etRADIX, 16, 1 }, + { 'X', 16, 0, etRADIX, 0, 4 }, +#ifndef SQLITE_OMIT_FLOATING_POINT + { 'f', 0, 1, etFLOAT, 0, 0 }, + { 'e', 0, 1, etEXP, 30, 0 }, + { 'E', 0, 1, etEXP, 14, 0 }, + { 'G', 0, 1, etGENERIC, 14, 0 }, +#endif + { 'i', 10, 1, etRADIX, 0, 0 }, + { 'n', 0, 0, etSIZE, 0, 0 }, + { '%', 0, 0, etPERCENT, 0, 0 }, + { 'p', 16, 0, etPOINTER, 0, 1 }, + { '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 +** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point ** conversions will work. */ -#ifndef etNOFLOATINGPOINT +#ifndef SQLITE_OMIT_FLOATING_POINT /* ** "*val" is a double such that 0.1 <= *val < 10.0 ** Return the ascii code for the leading digit of *val, then @@ -157,9 +162,17 @@ static int et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){ *val = (*val - d)*10.0; return digit; } -#endif +#endif /* SQLITE_OMIT_FLOATING_POINT */ -#define etBUFSIZE 1000 /* Size of the output buffer */ +/* +** On machines with a small stack size, you can redefine the +** SQLITE_PRINT_BUF_SIZE to be less than 350. But beware - for +** smaller values some %f conversions may go into an infinite loop. +*/ +#ifndef SQLITE_PRINT_BUF_SIZE +# define SQLITE_PRINT_BUF_SIZE 350 +#endif +#define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */ /* ** The root program. All variations call this core. @@ -206,20 +219,24 @@ static int vxprintf( etByte flag_plussign; /* True if "+" flag is present */ etByte flag_blanksign; /* True if " " flag is present */ etByte flag_alternateform; /* True if "#" flag is present */ + etByte flag_altform2; /* True if "!" flag is present */ etByte flag_zeropad; /* True if field width constant starts with zero */ etByte flag_long; /* True if "l" flag is present */ - unsigned long longvalue; /* Value for integer types */ + etByte flag_longlong; /* True if the "ll" flag is present */ + etByte done; /* Loop termination flag */ + sqlite_uint64 longvalue; /* Value for integer types */ LONGDOUBLE_TYPE realvalue; /* Value for real types */ - et_info *infop; /* Pointer to the appropriate info structure */ + const 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[] = " "; + static const char spaces[] = + " "; #define etSPACESIZE (sizeof(spaces)-1) -#ifndef etNOFLOATINGPOINT - int exp; /* exponent of real numbers */ +#ifndef SQLITE_OMIT_FLOATING_POINT + int exp, e2; /* 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 */ @@ -227,6 +244,7 @@ static int vxprintf( int nsd; /* Number of significant digits returned */ #endif + func(arg,"",0); count = length = 0; bufpt = 0; for(; (c=(*fmt))!=0; ++fmt){ @@ -247,17 +265,19 @@ static int vxprintf( } /* Find out what flags are present */ flag_leftjustify = flag_plussign = flag_blanksign = - flag_alternateform = flag_zeropad = 0; + flag_alternateform = flag_altform2 = flag_zeropad = 0; + done = 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; + case '-': flag_leftjustify = 1; break; + case '+': flag_plussign = 1; break; + case ' ': flag_blanksign = 1; break; + case '#': flag_alternateform = 1; break; + case '!': flag_altform2 = 1; break; + case '0': flag_zeropad = 1; break; + default: done = 1; break; } - }while( c==0 && (c=(*++fmt))!=0 ); + }while( !done && (c=(*++fmt))!=0 ); /* Get the field width */ width = 0; if( c=='*' ){ @@ -290,8 +310,6 @@ static int vxprintf( c = *++fmt; } } - /* Limit the precision to prevent overflowing buf[] during conversion */ - if( precision>etBUFSIZE-40 ) precision = etBUFSIZE-40; }else{ precision = -1; } @@ -299,12 +317,17 @@ static int vxprintf( if( c=='l' ){ flag_long = 1; c = *++fmt; + if( c=='l' ){ + flag_longlong = 1; + c = *++fmt; + }else{ + flag_longlong = 0; + } }else{ - flag_long = 0; + flag_long = flag_longlong = 0; } /* Fetch the info entry for the field */ infop = 0; - xtype = etERROR; for(idx=0; idxetBUFSIZE-40 && (infop->flags & FLAG_STRING)==0 ){ + precision = etBUFSIZE-40; + } /* ** At this point, variables are initialized as follows: ** ** flag_alternateform TRUE if a '#' is present. + ** flag_altform2 TRUE if a '!' is present. ** flag_plussign TRUE if a '+' is present. ** flag_leftjustify TRUE if a '-' is present or if the ** field width was negative. ** flag_zeropad TRUE if the width began with 0. ** flag_long TRUE if the letter 'l' (ell) prefixed ** the conversion character. + ** flag_longlong TRUE if the letter 'll' (ell ell) prefixed + ** the conversion character. ** flag_blanksign TRUE if a ' ' is present. ** width The specified field width. This is ** always non-negative. Zero is the default. @@ -335,34 +370,40 @@ static int vxprintf( ** infop Pointer to the appropriate info struct. */ switch( xtype ){ + case etPOINTER: + flag_longlong = sizeof(char*)==sizeof(i64); + flag_long = sizeof(char*)==sizeof(long int); + /* Fall through into the next case */ case 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; + i64 v; + if( flag_longlong ) v = va_arg(ap,i64); + else if( flag_long ) v = va_arg(ap,long int); + else v = va_arg(ap,int); + if( v<0 ){ + longvalue = -v; prefix = '-'; - }else if( flag_plussign ) prefix = '+'; - else if( flag_blanksign ) prefix = ' '; - else prefix = 0; - }else prefix = 0; + }else{ + longvalue = v; + if( flag_plussign ) prefix = '+'; + else if( flag_blanksign ) prefix = ' '; + else prefix = 0; + } + }else{ + if( flag_longlong ) longvalue = va_arg(ap,u64); + else if( flag_long ) longvalue = va_arg(ap,unsigned long int); + else longvalue = va_arg(ap,unsigned int); + prefix = 0; + } + if( longvalue==0 ) flag_alternateform = 0; if( flag_zeropad && precisioncharset; + cset = &aDigits[infop->charset]; base = infop->base; do{ /* Convert to ascii */ *(--bufpt) = cset[longvalue%base]; @@ -375,10 +416,11 @@ static int vxprintf( } if( prefix ) *(--bufpt) = prefix; /* Add sign */ if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */ - char *pre, x; - pre = infop->prefix; + const char *pre; + char x; + pre = &aPrefix[infop->prefix]; if( *bufpt!=pre[0] ){ - for(pre=infop->prefix; (x=(*pre))!=0; pre++) *(--bufpt) = x; + for(; (x=(*pre))!=0; pre++) *(--bufpt) = x; } } length = &buf[etBUFSIZE-1]-bufpt; @@ -387,9 +429,9 @@ static int vxprintf( case etEXP: case etGENERIC: realvalue = va_arg(ap,double); -#ifndef etNOFLOATINGPOINT +#ifndef SQLITE_OMIT_FLOATING_POINT if( precision<0 ) precision = 6; /* Set default precision */ - if( precision>etBUFSIZE-10 ) precision = etBUFSIZE-10; + if( precision>etBUFSIZE/2-10 ) precision = etBUFSIZE/2-10; if( realvalue<0.0 ){ realvalue = -realvalue; prefix = '-'; @@ -398,19 +440,19 @@ static int vxprintf( else if( flag_blanksign ) prefix = ' '; else prefix = 0; } - if( infop->type==etGENERIC && precision>0 ) precision--; - rounder = 0.0; + if( xtype==etGENERIC && precision>0 ) precision--; #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); + for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){} #endif - if( infop->type==etFLOAT ) realvalue += rounder; + if( xtype==etFLOAT ) realvalue += rounder; /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */ exp = 0; if( realvalue>0.0 ){ + while( realvalue>=1e32 && exp<=350 ){ realvalue *= 1e-32; exp+=32; } 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; } @@ -442,51 +484,67 @@ static int vxprintf( }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[]. - */ + if( xtype==etEXP ){ + e2 = 0; + }else{ + e2 = exp; + } 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 */ + flag_dp = (precision>0) | flag_alternateform | flag_altform2; + /* The sign in front of the number */ + if( prefix ){ + *(bufpt++) = prefix; + } + /* Digits prior to the decimal point */ + if( e2<0 ){ + *(bufpt++) = '0'; + }else{ + for(; e2>=0; e2--){ + *(bufpt++) = et_getdigit(&realvalue,&nsd); } } + /* The decimal point */ + if( flag_dp ){ + *(bufpt++) = '.'; + } + /* "0" digits after the decimal point but before the first + ** significant digit of the number */ + for(e2++; e2<0 && precision>0; precision--, e2++){ + *(bufpt++) = '0'; + } + /* Significant digits after the decimal point */ + while( (precision--)>0 ){ + *(bufpt++) = et_getdigit(&realvalue,&nsd); + } + /* Remove trailing zeros and the "." if no digits follow the "." */ + if( flag_rtz && flag_dp ){ + while( bufpt[-1]=='0' ) *(--bufpt) = 0; + assert( bufpt>buf ); + if( bufpt[-1]=='.' ){ + if( flag_altform2 ){ + *(bufpt++) = '0'; + }else{ + *(--bufpt) = 0; + } + } + } + /* Add the "eNNN" suffix */ + if( flag_exp || (xtype==etEXP && exp) ){ + *(bufpt++) = aDigits[infop->charset]; + if( exp<0 ){ + *(bufpt++) = '-'; exp = -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 */ + } + *bufpt = 0; + /* The converted number is in buf[] and zero terminated. Output it. ** Note that the number is in the usual order, not reversed as with ** integer conversions. */ @@ -539,37 +597,41 @@ static int vxprintf( if( precision>=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 && precisionetBUFSIZE ){ + bufpt = zExtra = sqliteMalloc( n ); + if( bufpt==0 ) return -1; + }else{ + bufpt = buf; + } + j = 0; + if( needQuote ) bufpt[j++] = '\''; + for(i=0; (ch=escarg[i])!=0; i++){ + bufpt[j++] = ch; + if( ch=='\'' ) bufpt[j++] = ch; + } + if( needQuote ) bufpt[j++] = '\''; + bufpt[j] = 0; + length = j; + /* The precision is ignored on %q and %Q */ + /* if( precision>=0 && precisionz, pToken->n); + if( pToken && pToken->z ){ + (*func)(arg, (char*)pToken->z, pToken->n); + } length = width = 0; break; } @@ -586,15 +648,6 @@ static int vxprintf( 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 @@ -669,13 +722,19 @@ static void mout(void *arg, const char *zNewText, int nNewChar){ memcpy(pM->zText, pM->zBase, pM->nChar); } }else{ - pM->zText = pM->xRealloc(pM->zText, pM->nAlloc); + char *zNew; + zNew = pM->xRealloc(pM->zText, pM->nAlloc); + if( zNew ){ + pM->zText = zNew; + } } } } - if( pM->zText && nNewChar>0 ){ - memcpy(&pM->zText[pM->nChar], zNewText, nNewChar); - pM->nChar += nNewChar; + if( pM->zText ){ + if( nNewChar>0 ){ + memcpy(&pM->zText[pM->nChar], zNewText, nNewChar); + pM->nChar += nNewChar; + } pM->zText[pM->nChar] = 0; } } @@ -701,9 +760,14 @@ static char *base_vprintf( if( xRealloc ){ if( sM.zText==sM.zBase ){ sM.zText = xRealloc(0, sM.nChar+1); - memcpy(sM.zText, sM.zBase, sM.nChar+1); + if( sM.zText ){ + memcpy(sM.zText, sM.zBase, sM.nChar+1); + } }else if( sM.nAlloc>sM.nChar+10 ){ - sM.zText = xRealloc(sM.zText, sM.nChar+1); + char *zNew = xRealloc(sM.zText, sM.nChar+1); + if( zNew ){ + sM.zText = zNew; + } } } return sM.zText; @@ -720,8 +784,8 @@ static void *printf_realloc(void *old, int size){ ** Print into memory obtained from sqliteMalloc(). Use the internal ** %-conversion extensions. */ -char *sqliteVMPrintf(const char *zFormat, va_list ap){ - char zBase[1000]; +char *sqlite3VMPrintf(const char *zFormat, va_list ap){ + char zBase[SQLITE_PRINT_BUF_SIZE]; return base_vprintf(printf_realloc, 1, zBase, sizeof(zBase), zFormat, ap); } @@ -729,10 +793,10 @@ char *sqliteVMPrintf(const char *zFormat, va_list ap){ ** Print into memory obtained from sqliteMalloc(). Use the internal ** %-conversion extensions. */ -char *sqliteMPrintf(const char *zFormat, ...){ +char *sqlite3MPrintf(const char *zFormat, ...){ va_list ap; char *z; - char zBase[1000]; + char zBase[SQLITE_PRINT_BUF_SIZE]; va_start(ap, zFormat); z = base_vprintf(printf_realloc, 1, zBase, sizeof(zBase), zFormat, ap); va_end(ap); @@ -743,7 +807,7 @@ char *sqliteMPrintf(const char *zFormat, ...){ ** 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, ...){ +char *sqlite3_mprintf(const char *zFormat, ...){ va_list ap; char *z; char zBuf[200]; @@ -755,21 +819,21 @@ char *sqlite_mprintf(const char *zFormat, ...){ return z; } -/* This is the varargs version of sqlite_mprintf. +/* This is the varargs version of sqlite3_mprintf. */ -char *sqlite_vmprintf(const char *zFormat, va_list ap){ +char *sqlite3_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 +** sqlite3_snprintf() works like snprintf() except that it ignores the ** current locale settings. This is important for SQLite because we ** are not able to use a "," as the decimal point in place of "." as ** specified by some locales. */ -char *sqlite_snprintf(int n, char *zBuf, const char *zFormat, ...){ +char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){ char *z; va_list ap; @@ -779,77 +843,20 @@ char *sqlite_snprintf(int n, char *zBuf, const char *zFormat, ...){ return z; } +#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) /* -** 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. +** A version of printf() that understands %lld. Used for debugging. +** The printf() built into some versions of windows does not understand %lld +** and segfaults if you give it a long long int. */ -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. */ -){ +void sqlite3DebugPrintf(const char *zFormat, ...){ + extern int getpid(void); va_list ap; - int rc; - - va_start(ap, errmsg); - rc = sqlite_exec_vprintf(db, sqlFormat, xCallback, pArg, errmsg, ap); + char zBuf[500]; + va_start(ap, zFormat); + base_vprintf(0, 0, zBuf, sizeof(zBuf), zFormat, 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; + fprintf(stdout,"%d: %s", getpid(), zBuf); + fflush(stdout); } +#endif diff --git a/sqlite/random.c b/sqlite/random.c index 872005d04..3820c4edf 100755 --- a/sqlite/random.c +++ b/sqlite/random.c @@ -15,7 +15,7 @@ ** Random numbers are used by some of the database backends in order ** to generate random integer keys for tables or random filenames. ** -** $Id: random.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** $Id: random.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #include "sqliteInt.h" #include "os.h" @@ -26,13 +26,16 @@ ** 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 +** Because the OP_NewRowid 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. +** +** (Later): Actually, OP_NewRowid does not depend on a good source of +** randomness any more. But we will leave this code in all the same. */ static int randomByte(){ unsigned char t; @@ -60,7 +63,7 @@ static int randomByte(){ char k[256]; prng.j = 0; prng.i = 0; - sqliteOsRandomSeed(k); + sqlite3OsRandomSeed(k); for(i=0; i<256; i++){ prng.s[i] = i; } @@ -87,11 +90,11 @@ static int randomByte(){ /* ** Return N random bytes. */ -void sqliteRandomness(int N, void *pBuf){ +void sqlite3Randomness(int N, void *pBuf){ unsigned char *zBuf = pBuf; - sqliteOsEnterMutex(); + sqlite3OsEnterMutex(); while( N-- ){ *(zBuf++) = randomByte(); } - sqliteOsLeaveMutex(); + sqlite3OsLeaveMutex(); } diff --git a/sqlite/select.c b/sqlite/select.c index 43eeed84d..b9cd7b209 100755 --- a/sqlite/select.c +++ b/sqlite/select.c @@ -12,16 +12,33 @@ ** This file contains C code routines that are called by the parser ** to handle SELECT statements in SQLite. ** -** $Id: select.c,v 1.1.1.1 2004-03-11 22:22:23 alex Exp $ +** $Id: select.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #include "sqliteInt.h" +/* +** Delete all the content of a Select structure but do not deallocate +** the select structure itself. +*/ +static void clearSelect(Select *p){ + sqlite3ExprListDelete(p->pEList); + sqlite3SrcListDelete(p->pSrc); + sqlite3ExprDelete(p->pWhere); + sqlite3ExprListDelete(p->pGroupBy); + sqlite3ExprDelete(p->pHaving); + sqlite3ExprListDelete(p->pOrderBy); + sqlite3SelectDelete(p->pPrior); + sqlite3ExprDelete(p->pLimit); + sqlite3ExprDelete(p->pOffset); +} + + /* ** Allocate a new Select structure and return a pointer to that ** structure. */ -Select *sqliteSelectNew( +Select *sqlite3SelectNew( ExprList *pEList, /* which columns to include in the result */ SrcList *pSrc, /* the FROM clause -- which tables to scan */ Expr *pWhere, /* the WHERE clause */ @@ -29,44 +46,59 @@ Select *sqliteSelectNew( 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 */ + Expr *pLimit, /* LIMIT value. NULL means not used */ + Expr *pOffset /* OFFSET value. NULL means no offset */ ){ Select *pNew; + Select standin; pNew = sqliteMalloc( sizeof(*pNew) ); + assert( !pOffset || pLimit ); /* Can't have OFFSET without LIMIT. */ 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; + pNew = &standin; + memset(pNew, 0, sizeof(*pNew)); + } + if( pEList==0 ){ + pEList = sqlite3ExprListAppend(0, sqlite3Expr(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->pLimit = pLimit; + pNew->pOffset = pOffset; + pNew->iLimit = -1; + pNew->iOffset = -1; + pNew->addrOpenVirt[0] = -1; + pNew->addrOpenVirt[1] = -1; + pNew->addrOpenVirt[2] = -1; + if( pNew==&standin) { + clearSelect(pNew); + pNew = 0; } return pNew; } +/* +** Delete the given Select structure and all of its substructures. +*/ +void sqlite3SelectDelete(Select *p){ + if( p ){ + clearSelect(p); + sqliteFree(p); + } +} + /* ** 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_CROSS ** JT_OUTER ** JT_NATURAL ** JT_LEFT @@ -77,14 +109,14 @@ Select *sqliteSelectNew( ** 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 sqlite3JoinType(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; + static const struct { + const char zKeyword[8]; + u8 nChar; + u8 code; } keywords[] = { { "natural", 7, JT_NATURAL }, { "left", 4, JT_LEFT|JT_OUTER }, @@ -92,7 +124,7 @@ int sqliteJoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ { "full", 4, JT_LEFT|JT_RIGHT|JT_OUTER }, { "outer", 5, JT_OUTER }, { "inner", 5, JT_INNER }, - { "cross", 5, JT_INNER }, + { "cross", 5, JT_INNER|JT_CROSS }, }; int i, j; apAll[0] = pA; @@ -102,7 +134,7 @@ int sqliteJoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ p = apAll[i]; for(j=0; jn==keywords[j].nChar - && sqliteStrNICmp(p->z, keywords[j].zKeyword, p->n)==0 ){ + && sqlite3StrNICmp((char*)p->z, keywords[j].zKeyword, p->n)==0 ){ jointype |= keywords[j].code; break; } @@ -116,16 +148,15 @@ int sqliteJoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ (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++; + const char *zSp1 = " "; + const char *zSp2 = " "; + if( pB==0 ){ zSp1++; } + if( pC==0 ){ zSp2++; } + sqlite3ErrorMsg(pParse, "unknown or unsupported join type: " + "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC); jointype = JT_INNER; }else if( jointype & JT_RIGHT ){ - sqliteErrorMsg(pParse, + sqlite3ErrorMsg(pParse, "RIGHT and FULL OUTER JOINs are not currently supported"); jointype = JT_INNER; } @@ -139,11 +170,30 @@ int sqliteJoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ 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; + if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i; } return -1; } +/* +** Set the value of a token to a '\000'-terminated string. +*/ +static void setToken(Token *p, const char *z){ + p->z = (u8*)z; + p->n = z ? strlen(z) : 0; + p->dyn = 0; +} + +/* +** Create an expression node for an identifier with the name of zName +*/ +static Expr *createIdExpr(const char *zName){ + Token dummy; + setToken(&dummy, zName); + return sqlite3Expr(TK_ID, 0, 0, &dummy); +} + + /* ** Add a term to the WHERE expression in *ppExpr that requires the ** zCol column to be equal in the two tables pTab1 and pTab2. @@ -151,38 +201,38 @@ static int columnIndex(Table *pTab, const char *zCol){ static void addWhereTerm( const char *zCol, /* Name of the column */ const Table *pTab1, /* First table */ + const char *zAlias1, /* Alias for first table. May be NULL */ const Table *pTab2, /* Second table */ + const char *zAlias2, /* Alias for second table. May be NULL */ + int iRightJoinTable, /* VDBE cursor for the right 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; + pE1a = createIdExpr(zCol); + pE2a = createIdExpr(zCol); + if( zAlias1==0 ){ + zAlias1 = pTab1->zName; } + pE1b = createIdExpr(zAlias1); + if( zAlias2==0 ){ + zAlias2 = pTab2->zName; + } + pE2b = createIdExpr(zAlias2); + pE1c = sqlite3Expr(TK_DOT, pE1b, pE1a, 0); + pE2c = sqlite3Expr(TK_DOT, pE2b, pE2a, 0); + pE = sqlite3Expr(TK_EQ, pE1c, pE2c, 0); + ExprSetProperty(pE, EP_FromJoin); + pE->iRightJoinTable = iRightJoinTable; + *ppExpr = sqlite3ExprAnd(*ppExpr, pE); } /* ** Set the EP_FromJoin property on all terms of the given expression. +** And set the Expr.iRightJoinTable to iTable for every term in the +** expression. ** ** The EP_FromJoin property is used on terms of an expression to tell ** the LEFT OUTER JOIN processing logic that this term is part of the @@ -190,11 +240,26 @@ static void addWhereTerm( ** of the more general WHERE clause. These terms are moved over to the ** WHERE clause during join processing but we need to remember that they ** originated in the ON or USING clause. +** +** The Expr.iRightJoinTable tells the WHERE clause processing that the +** expression depends on table iRightJoinTable even if that table is not +** explicitly mentioned in the expression. That information is needed +** for cases like this: +** +** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5 +** +** The where clause needs to defer the handling of the t1.x=5 +** term until after the t2 loop of the join. In that way, a +** NULL t2 row will be inserted whenever t1.x!=5. If we do not +** defer the handling of t1.x=5, it will be processed immediately +** after the t1 loop and rows with t1.x!=5 will never appear in +** the output, which is incorrect. */ -static void setJoinExpr(Expr *p){ +static void setJoinExpr(Expr *p, int iTable){ while( p ){ ExprSetProperty(p, EP_FromJoin); - setJoinExpr(p->pLeft); + p->iRightJoinTable = iTable; + setJoinExpr(p->pLeft, iTable); p = p->pRight; } } @@ -204,55 +269,65 @@ static void setJoinExpr(Expr *p){ ** ON and USING clauses are converted into extra terms of the WHERE clause. ** NATURAL joins also create extra WHERE clause terms. ** +** The terms of a FROM clause are contained in the Select.pSrc structure. +** The left most table is the first entry in Select.pSrc. The right-most +** table is the last entry. The join operator is held in the entry to +** the left. Thus entry 0 contains the join operator for the join between +** entries 0 and 1. Any ON or USING clauses associated with the join are +** also attached to the left entry. +** ** This routine returns the number of errors encountered. */ static int sqliteProcessJoin(Parse *pParse, Select *p){ - SrcList *pSrc; - 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]; + SrcList *pSrc; /* All tables in the FROM clause */ + int i, j; /* Loop counters */ + struct SrcList_item *pLeft; /* Left table being joined */ + struct SrcList_item *pRight; /* Right table being joined */ - if( pTerm->pTab==0 || pOther->pTab==0 ) continue; + pSrc = p->pSrc; + pLeft = &pSrc->a[0]; + pRight = &pLeft[1]; + for(i=0; inSrc-1; i++, pRight++, pLeft++){ + Table *pLeftTab = pLeft->pTab; + Table *pRightTab = pRight->pTab; + + if( pLeftTab==0 || pRightTab==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 " + if( pLeft->jointype & JT_NATURAL ){ + if( pLeft->pOn || pLeft->pUsing ){ + sqlite3ErrorMsg(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); + for(j=0; jnCol; j++){ + char *zName = pLeftTab->aCol[j].zName; + if( columnIndex(pRightTab, zName)>=0 ){ + addWhereTerm(zName, pLeftTab, pLeft->zAlias, + pRightTab, pRight->zAlias, + pRight->iCursor, &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 " + if( pLeft->pOn && pLeft->pUsing ){ + sqlite3ErrorMsg(pParse, "cannot have both ON and USING " "clauses in the same join"); return 1; } /* Add the ON clause to the end of the WHERE clause, connected by - ** and AND operator. + ** an 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; + if( pLeft->pOn ){ + setJoinExpr(pLeft->pOn, pRight->iCursor); + p->pWhere = sqlite3ExprAnd(p->pWhere, pLeft->pOn); + pLeft->pOn = 0; } /* Create extra terms on the WHERE clause for each column named @@ -262,108 +337,98 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){ ** 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; + if( pLeft->pUsing ){ + IdList *pList = pLeft->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); + char *zName = pList->a[j].zName; + if( columnIndex(pLeftTab, zName)<0 || columnIndex(pRightTab, zName)<0 ){ + sqlite3ErrorMsg(pParse, "cannot join using column %s - column " + "not present in both tables", zName); return 1; } - addWhereTerm(pList->a[j].zName, pTerm->pTab, pOther->pTab, &p->pWhere); + addWhereTerm(zName, pLeftTab, pLeft->zAlias, + pRightTab, pRight->zAlias, + pRight->iCursor, &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); +static void pushOntoSorter( + Parse *pParse, /* Parser context */ + ExprList *pOrderBy, /* The ORDER BY clause */ + Select *pSelect /* The whole SELECT statement */ +){ + Vdbe *v = pParse->pVdbe; + sqlite3ExprCodeExprList(pParse, pOrderBy); + sqlite3VdbeAddOp(v, OP_Sequence, pOrderBy->iECursor, 0); + sqlite3VdbeAddOp(v, OP_Pull, pOrderBy->nExpr + 1, 0); + sqlite3VdbeAddOp(v, OP_MakeRecord, pOrderBy->nExpr + 2, 0); + sqlite3VdbeAddOp(v, OP_IdxInsert, pOrderBy->iECursor, 0); + if( pSelect->iLimit>=0 ){ + int addr1, addr2; + addr1 = sqlite3VdbeAddOp(v, OP_IfMemZero, pSelect->iLimit+1, 0); + sqlite3VdbeAddOp(v, OP_MemIncr, -1, pSelect->iLimit+1); + addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp(v, OP_Last, pOrderBy->iECursor, 0); + sqlite3VdbeAddOp(v, OP_Delete, pOrderBy->iECursor, 0); + sqlite3VdbeJumpHere(v, addr2); + pSelect->iLimit = -1; } - 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. +** Add code to implement the OFFSET */ -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'; +static void codeOffset( + Vdbe *v, /* Generate code into this VM */ + Select *p, /* The SELECT statement being coded */ + int iContinue, /* Jump here to skip the current record */ + int nPop /* Number of times to pop stack when jumping */ +){ + if( p->iOffset>=0 && iContinue!=0 ){ + int addr; + sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iOffset); + addr = sqlite3VdbeAddOp(v, OP_IfMemNeg, p->iOffset, 0); + if( nPop>0 ){ + sqlite3VdbeAddOp(v, OP_Pop, nPop, 0); + } + sqlite3VdbeAddOp(v, OP_Goto, 0, iContinue); + VdbeComment((v, "# skip OFFSET records")); + sqlite3VdbeJumpHere(v, addr); } - zType[i] = 0; - sqliteVdbeChangeP3(v, -1, zType, P3_DYNAMIC); } +/* +** Add code that will check to make sure the top N elements of the +** stack are distinct. iTab is a sorting index that holds previously +** seen combinations of the N values. A new entry is made in iTab +** if the current N values are new. +** +** A jump to addrRepeat is made and the N+1 values are popped from the +** stack if the top N elements are not distinct. +*/ +static void codeDistinct( + Vdbe *v, /* Generate code into this VM */ + int iTab, /* A sorting index used to test for distinctness */ + int addrRepeat, /* Jump to here if not distinct */ + int N /* The top N elements of the stack must be distinct */ +){ + sqlite3VdbeAddOp(v, OP_MakeRecord, -N, 0); + sqlite3VdbeAddOp(v, OP_Distinct, iTab, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp(v, OP_Pop, N+1, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, addrRepeat); + VdbeComment((v, "# skip indistinct records")); + sqlite3VdbeAddOp(v, OP_IdxInsert, iTab, 0); +} + + /* ** This routine generates the code for the inside of the inner loop ** of a SELECT. @@ -384,10 +449,12 @@ static int selectInnerLoop( 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 */ + int iBreak, /* Jump here to break out of the inner loop */ + char *aff /* affinity string if eDest is SRT_Union */ ){ Vdbe *v = pParse->pVdbe; int i; + int hasDistinct; /* True if the DISTINCT keyword is present */ if( v==0 ) return 0; assert( pEList!=0 ); @@ -395,70 +462,46 @@ static int selectInnerLoop( /* If there was a LIMIT clause on the SELECT statement, then do the check ** to see if this row should be output. */ - if( pOrderBy==0 ){ - if( p->iOffset>=0 ){ - int addr = sqliteVdbeCurrentAddr(v); - sqliteVdbeAddOp(v, OP_MemIncr, p->iOffset, addr+2); - sqliteVdbeAddOp(v, OP_Goto, 0, iContinue); - } - if( p->iLimit>=0 ){ - sqliteVdbeAddOp(v, OP_MemIncr, p->iLimit, iBreak); - } + hasDistinct = distinct>=0 && pEList->nExpr>0; + if( pOrderBy==0 && !hasDistinct ){ + codeOffset(v, p, iContinue, 0); } /* Pull the requested columns. */ if( nColumn>0 ){ for(i=0; inExpr; - for(i=0; inExpr; i++){ - sqliteExprCode(pParse, pEList->a[i].pExpr); - } + sqlite3ExprCodeExprList(pParse, pEList); } /* 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( distinct>=0 && pEList && pEList->nExpr>0 ){ -#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( hasDistinct ){ + assert( pEList!=0 ); + assert( pEList->nExpr==nColumn ); + codeDistinct(v, distinct, iContinue, nColumn); + if( pOrderBy==0 ){ + codeOffset(v, p, iContinue, nColumn); + } } switch( eDest ){ /* In this mode, write each query result to the key of the temporary ** table iParm. */ +#ifndef SQLITE_OMIT_COMPOUND_SELECT case SRT_Union: { - 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); + sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0); + if( aff ){ + sqlite3VdbeChangeP3(v, -1, aff, P3_STATIC); } + sqlite3VdbeAddOp(v, OP_IdxInsert, iParm, 0); break; } @@ -468,30 +511,64 @@ static int selectInnerLoop( */ 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); + addr = sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0); + sqlite3VdbeChangeP3(v, -1, aff, P3_STATIC); + sqlite3VdbeAddOp(v, OP_NotFound, iParm, addr+3); + sqlite3VdbeAddOp(v, OP_Delete, iParm, 0); + break; + } +#endif + + /* Store the result as data using a unique key. + */ + case SRT_Table: + case SRT_VirtualTab: { + sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0); + if( pOrderBy ){ + pushOntoSorter(pParse, pOrderBy, p); + }else{ + sqlite3VdbeAddOp(v, OP_NewRowid, iParm, 0); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + sqlite3VdbeAddOp(v, OP_Insert, iParm, 0); + } break; } +#ifndef SQLITE_OMIT_SUBQUERY /* If we are creating a set for an "expr IN (SELECT ...)" construct, ** then there should be a single item on the stack. Write this ** item into the set table with bogus data. */ case SRT_Set: { - int addr1 = sqliteVdbeCurrentAddr(v); + int addr1 = sqlite3VdbeCurrentAddr(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); + sqlite3VdbeAddOp(v, OP_NotNull, -1, addr1+3); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0); if( pOrderBy ){ - pushOntoSorter(pParse, v, pOrderBy); + /* At first glance you would think we could optimize out the + ** ORDER BY in this case since the order of entries in the set + ** does not matter. But there might be a LIMIT clause, in which + ** case the order does matter */ + pushOntoSorter(pParse, pOrderBy, p); }else{ - sqliteVdbeAddOp(v, OP_String, 0, 0); - sqliteVdbeAddOp(v, OP_PutStrKey, iParm, 0); + char affinity = (iParm>>16)&0xFF; + affinity = sqlite3CompareAffinity(pEList->a[0].pExpr, affinity); + sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &affinity, 1); + sqlite3VdbeAddOp(v, OP_IdxInsert, (iParm&0x0000FFFF), 0); } - sqliteVdbeChangeP2(v, addr2, sqliteVdbeCurrentAddr(v)); + sqlite3VdbeJumpHere(v, addr2); + break; + } + + /* If any row exist in the result set, record that fact and abort. + */ + case SRT_Exists: { + sqlite3VdbeAddOp(v, OP_MemInt, 1, iParm); + sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0); + /* The LIMIT clause will terminate the loop for us */ break; } @@ -502,41 +579,33 @@ static int selectInnerLoop( case SRT_Mem: { assert( nColumn==1 ); if( pOrderBy ){ - pushOntoSorter(pParse, v, pOrderBy); + pushOntoSorter(pParse, pOrderBy, p); }else{ - sqliteVdbeAddOp(v, OP_MemStore, iParm, 1); - sqliteVdbeAddOp(v, OP_Goto, 0, iBreak); + sqlite3VdbeAddOp(v, OP_MemStore, iParm, 1); + /* The LIMIT clause will jump out of the loop for us */ } break; } +#endif /* #ifndef SQLITE_OMIT_SUBQUERY */ - /* Send the data to the callback function. + /* Send the data to the callback function or to a subroutine. In the + ** case of a subroutine, the subroutine itself is responsible for + ** popping the data from the stack. */ - case SRT_Callback: - case SRT_Sorter: { + case SRT_Subroutine: + case SRT_Callback: { if( pOrderBy ){ - sqliteVdbeAddOp(v, OP_SortMakeRec, nColumn, 0); - pushOntoSorter(pParse, v, pOrderBy); + sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0); + pushOntoSorter(pParse, pOrderBy, p); + }else if( eDest==SRT_Subroutine ){ + sqlite3VdbeAddOp(v, OP_Gosub, 0, iParm); }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); + sqlite3VdbeAddOp(v, OP_Callback, nColumn, 0); } break; } +#if !defined(SQLITE_OMIT_TRIGGER) /* Discard the results. This is used for SELECT statements inside ** the body of a TRIGGER. The purpose of such selects is to call ** user-defined functions that have side effects. We do not care @@ -544,13 +613,63 @@ static int selectInnerLoop( */ default: { assert( eDest==SRT_Discard ); - sqliteVdbeAddOp(v, OP_Pop, nColumn, 0); + sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0); break; } +#endif + } + + /* Jump to the end of the loop if the LIMIT is reached. + */ + if( p->iLimit>=0 && pOrderBy==0 ){ + sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iLimit); + sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, iBreak); } return 0; } +/* +** Given an expression list, generate a KeyInfo structure that records +** the collating sequence for each expression in that expression list. +** +** If the ExprList is an ORDER BY or GROUP BY clause then the resulting +** KeyInfo structure is appropriate for initializing a virtual index to +** implement that clause. If the ExprList is the result set of a SELECT +** then the KeyInfo structure is appropriate for initializing a virtual +** index to implement a DISTINCT test. +** +** Space to hold the KeyInfo structure is obtain from malloc. The calling +** function is responsible for seeing that this structure is eventually +** freed. Add the KeyInfo structure to the P3 field of an opcode using +** P3_KEYINFO_HANDOFF is the usual way of dealing with this. +*/ +static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){ + sqlite3 *db = pParse->db; + int nExpr; + KeyInfo *pInfo; + struct ExprList_item *pItem; + int i; + + nExpr = pList->nExpr; + pInfo = sqliteMalloc( sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) ); + if( pInfo ){ + pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr]; + pInfo->nField = nExpr; + pInfo->enc = ENC(db); + for(i=0, pItem=pList->a; ipExpr); + if( !pColl ){ + pColl = db->pDfltColl; + } + pInfo->aColl[i] = pColl; + pInfo->aSortOrder[i] = pItem->sortOrder; + } + } + return pInfo; +} + + /* ** 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 @@ -558,60 +677,69 @@ static int selectInnerLoop( ** routine generates the code needed to do that. */ static void generateSortTail( + Parse *pParse, /* Parsing context */ 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 brk = sqlite3VdbeMakeLabel(v); + int cont = sqlite3VdbeMakeLabel(v); int addr; - if( eDest==SRT_Sorter ) return; - sqliteVdbeAddOp(v, OP_Sort, 0, 0); - addr = sqliteVdbeAddOp(v, OP_SortNext, 0, end1); - if( p->iOffset>=0 ){ - sqliteVdbeAddOp(v, OP_MemIncr, p->iOffset, addr+4); - sqliteVdbeAddOp(v, OP_Pop, 1, 0); - sqliteVdbeAddOp(v, OP_Goto, 0, addr); + int iTab; + int pseudoTab; + ExprList *pOrderBy = p->pOrderBy; + + iTab = pOrderBy->iECursor; + if( eDest==SRT_Callback || eDest==SRT_Subroutine ){ + pseudoTab = pParse->nTab++; + sqlite3VdbeAddOp(v, OP_OpenPseudo, pseudoTab, 0); + sqlite3VdbeAddOp(v, OP_SetNumColumns, pseudoTab, nColumn); } - if( p->iLimit>=0 ){ - sqliteVdbeAddOp(v, OP_MemIncr, p->iLimit, end2); + addr = 1 + sqlite3VdbeAddOp(v, OP_Sort, iTab, brk); + codeOffset(v, p, cont, 0); + if( eDest==SRT_Callback || eDest==SRT_Subroutine ){ + sqlite3VdbeAddOp(v, OP_Integer, 1, 0); } + sqlite3VdbeAddOp(v, OP_Column, iTab, pOrderBy->nExpr + 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); + case SRT_VirtualTab: { + sqlite3VdbeAddOp(v, OP_NewRowid, iParm, 0); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + sqlite3VdbeAddOp(v, OP_Insert, iParm, 0); break; } +#ifndef SQLITE_OMIT_SUBQUERY 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); + sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, "c", P3_STATIC); + sqlite3VdbeAddOp(v, OP_IdxInsert, (iParm&0x0000FFFF), 0); break; } case SRT_Mem: { assert( nColumn==1 ); - sqliteVdbeAddOp(v, OP_MemStore, iParm, 1); - sqliteVdbeAddOp(v, OP_Goto, 0, end1); + sqlite3VdbeAddOp(v, OP_MemStore, iParm, 1); + /* The LIMIT clause will terminate the loop for us */ break; } +#endif + case SRT_Callback: case SRT_Subroutine: { int i; + sqlite3VdbeAddOp(v, OP_Insert, pseudoTab, 0); for(i=0; iiLimit>=0 ){ + sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iLimit); + sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, brk); + } + + /* The bottom of the loop + */ + sqlite3VdbeResolveLabel(v, cont); + sqlite3VdbeAddOp(v, OP_Next, iTab, addr); + sqlite3VdbeResolveLabel(v, brk); + if( eDest==SRT_Callback || eDest==SRT_Subroutine ){ + sqlite3VdbeAddOp(v, OP_Close, pseudoTab, 0); + } + } /* -** Generate code that will tell the VDBE the datatypes of -** columns in the result set. +** Return a pointer to a string containing the 'declaration type' of the +** expression pExpr. The string may be treated as static by the caller. ** -** This routine only generates code if the "PRAGMA show_datatypes=on" -** has been executed. The datatypes are reported out in the azCol -** parameter to the callback function. The first N azCol[] entries -** are the names of the columns, and the second N entries are the -** datatypes for the columns. +** The declaration type is the exact datatype definition extracted from the +** original CREATE TABLE statement if the expression is a column. The +** declaration type for a ROWID field is INTEGER. Exactly when an expression +** is considered a column can be complex in the presence of subqueries. The +** result-set expression in all of the following SELECT statements is +** considered a column by this function. ** -** The "datatype" for a result that is a column of a type is the -** datatype definition extracted from the CREATE TABLE statement. -** The datatype for an expression is either TEXT or NUMERIC. The -** datatype for a ROWID field is INTEGER. +** SELECT col FROM tbl; +** SELECT (SELECT col FROM tbl; +** SELECT (SELECT col FROM tbl); +** SELECT abc FROM (SELECT col AS abc FROM tbl); +** +** The declaration type for any expression other than a column is NULL. +*/ +static const char *columnType( + NameContext *pNC, + Expr *pExpr, + const char **pzOriginDb, + const char **pzOriginTab, + const char **pzOriginCol +){ + char const *zType = 0; + char const *zOriginDb = 0; + char const *zOriginTab = 0; + char const *zOriginCol = 0; + int j; + if( pExpr==0 || pNC->pSrcList==0 ) return 0; + + /* The TK_AS operator can only occur in ORDER BY, GROUP BY, HAVING, + ** and LIMIT clauses. But pExpr originates in the result set of a + ** SELECT. So pExpr can never contain an AS operator. + */ + assert( pExpr->op!=TK_AS ); + + switch( pExpr->op ){ + case TK_COLUMN: { + /* The expression is a column. Locate the table the column is being + ** extracted from in NameContext.pSrcList. This table may be real + ** database table or a subquery. + */ + Table *pTab = 0; /* Table structure column is extracted from */ + Select *pS = 0; /* Select the column is extracted from */ + int iCol = pExpr->iColumn; /* Index of column in pTab */ + while( pNC && !pTab ){ + SrcList *pTabList = pNC->pSrcList; + for(j=0;jnSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++); + if( jnSrc ){ + pTab = pTabList->a[j].pTab; + pS = pTabList->a[j].pSelect; + }else{ + pNC = pNC->pNext; + } + } + + if( pTab==0 ){ + /* FIX ME: + ** This can occurs if you have something like "SELECT new.x;" inside + ** a trigger. In other words, if you reference the special "new" + ** table in the result set of a select. We do not have a good way + ** to find the actual table type, so call it "TEXT". This is really + ** something of a bug, but I do not know how to fix it. + ** + ** This code does not produce the correct answer - it just prevents + ** a segfault. See ticket #1229. + */ + zType = "TEXT"; + break; + } + + assert( pTab ); +#ifndef SQLITE_OMIT_SUBQUERY + if( pS ){ + /* The "table" is actually a sub-select or a view in the FROM clause + ** of the SELECT statement. Return the declaration type and origin + ** data for the result-set column of the sub-select. + */ + if( iCol>=0 && iColpEList->nExpr ){ + /* If iCol is less than zero, then the expression requests the + ** rowid of the sub-select or view. This expression is legal (see + ** test case misc2.2.2) - it always evaluates to NULL. + */ + NameContext sNC; + Expr *p = pS->pEList->a[iCol].pExpr; + sNC.pSrcList = pS->pSrc; + sNC.pNext = 0; + sNC.pParse = pNC->pParse; + zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); + } + }else +#endif + if( pTab->pSchema ){ + /* A real table */ + assert( !pS ); + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==-1 || (iCol>=0 && iColnCol) ); + if( iCol<0 ){ + zType = "INTEGER"; + zOriginCol = "rowid"; + }else{ + zType = pTab->aCol[iCol].zType; + zOriginCol = pTab->aCol[iCol].zName; + } + zOriginTab = pTab->zName; + if( pNC->pParse ){ + int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema); + zOriginDb = pNC->pParse->db->aDb[iDb].zName; + } + } + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: { + /* The expression is a sub-select. Return the declaration type and + ** origin info for the single column in the result set of the SELECT + ** statement. + */ + NameContext sNC; + Select *pS = pExpr->pSelect; + Expr *p = pS->pEList->a[0].pExpr; + sNC.pSrcList = pS->pSrc; + sNC.pNext = pNC; + sNC.pParse = pNC->pParse; + zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); + break; + } +#endif + } + + if( pzOriginDb ){ + assert( pzOriginTab && pzOriginCol ); + *pzOriginDb = zOriginDb; + *pzOriginTab = zOriginTab; + *pzOriginCol = zOriginCol; + } + return zType; +} + +/* +** Generate code that will tell the VDBE the declaration types of columns +** in the result set. */ static void generateColumnTypes( Parse *pParse, /* Parser context */ @@ -647,32 +917,25 @@ static void generateColumnTypes( ExprList *pEList /* Expressions defining the result set */ ){ Vdbe *v = pParse->pVdbe; - int i, j; + int i; + NameContext sNC; + sNC.pSrcList = pTabList; + sNC.pParse = pParse; 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); + const char *zOrigDb = 0; + const char *zOrigTab = 0; + const char *zOrigCol = 0; + const char *zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol); + + /* The vdbe must make it's own copy of the column-type and other + ** column specific strings, in case the schema is reset before this + ** virtual machine is deleted. + */ + sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, P3_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, P3_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, P3_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, P3_TRANSIENT); } } @@ -688,22 +951,29 @@ static void generateColumnNames( ){ Vdbe *v = pParse->pVdbe; int i, j; - sqlite *db = pParse->db; + sqlite3 *db = pParse->db; int fullNames, shortNames; +#ifndef SQLITE_OMIT_EXPLAIN + /* If this is an EXPLAIN, skip this step */ + if( pParse->explain ){ + return; + } +#endif + assert( v!=0 ); - if( pParse->colNamesSet || v==0 || sqlite_malloc_failed ) return; + if( pParse->colNamesSet || v==0 || sqlite3MallocFailed() ) return; pParse->colNamesSet = 1; fullNames = (db->flags & SQLITE_FullColNames)!=0; shortNames = (db->flags & SQLITE_ShortColNames)!=0; + sqlite3VdbeSetNumCols(v, pEList->nExpr); for(i=0; inExpr; i++){ Expr *p; - 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); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, strlen(zName)); continue; } if( p->op==TK_COLUMN && pTabList ){ @@ -716,36 +986,37 @@ static void generateColumnNames( if( iCol<0 ) iCol = pTab->iPKey; assert( iCol==-1 || (iCol>=0 && iColnCol) ); if( iCol<0 ){ - zCol = "_ROWID_"; + 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); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n); }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); + sqlite3SetString(&zName, zTab, ".", zCol, (char*)0); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, P3_DYNAMIC); }else{ - sqliteVdbeOp3(v, OP_ColumnName, i, p2, zCol, 0); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, strlen(zCol)); } }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); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n); + /* sqlite3VdbeCompressSpace(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); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, 0); } } + generateColumnTypes(pParse, pTabList, pEList); } +#ifndef SQLITE_OMIT_COMPOUND_SELECT /* ** Name of the connection operator, used for error messages. */ @@ -759,58 +1030,101 @@ static const char *selectOpName(int id){ } return z; } +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ /* ** Forward declaration */ -static int fillInColumnList(Parse*, Select*); +static int prepSelectStmt(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 *sqlite3ResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){ Table *pTab; int i, j; ExprList *pEList; - Column *aCol; + Column *aCol, *pCol; - if( fillInColumnList(pParse, pSelect) ){ + while( pSelect->pPrior ) pSelect = pSelect->pPrior; + if( prepSelectStmt(pParse, pSelect) ){ + return 0; + } + if( sqlite3SelectResolve(pParse, pSelect, 0) ){ return 0; } pTab = sqliteMalloc( sizeof(Table) ); if( pTab==0 ){ return 0; } + pTab->nRef = 1; 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++){ + for(i=0, pCol=aCol; inCol; i++, pCol++){ 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; - } - } + char *zType; + char *zName; + char *zBasename; + CollSeq *pColl; + int cnt; + NameContext sNC; + + /* Get an appropriate name for the column + */ + p = pEList->a[i].pExpr; + assert( p->pRight==0 || p->pRight->token.z==0 || p->pRight->token.z[0]!=0 ); + if( (zName = pEList->a[i].zName)!=0 ){ + /* If the column contains an "AS " phrase, use as the name */ + zName = sqliteStrDup(zName); + }else if( p->op==TK_DOT + && (pR=p->pRight)!=0 && pR->token.z && pR->token.z[0] ){ + /* For columns of the from A.B use B as the name */ + zName = sqlite3MPrintf("%T", &pR->token); }else if( p->span.z && p->span.z[0] ){ - sqliteSetNString(&pTab->aCol[i].zName, p->span.z, p->span.n, 0); + /* Use the original text of the column expression as its name */ + zName = sqlite3MPrintf("%T", &p->span); }else{ - char zBuf[30]; - sprintf(zBuf, "column%d", i+1); - pTab->aCol[i].zName = sqliteStrDup(zBuf); + /* If all else fails, make up a name */ + zName = sqlite3MPrintf("column%d", i+1); + } + sqlite3Dequote(zName); + if( sqlite3MallocFailed() ){ + sqliteFree(zName); + sqlite3DeleteTable(0, pTab); + return 0; + } + + /* Make sure the column name is unique. If the name is not unique, + ** append a integer to the name so that it becomes unique. + */ + zBasename = zName; + for(j=cnt=0; jzName = zName; + + /* Get the typename, type affinity, and collating sequence for the + ** column. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pSrcList = pSelect->pSrc; + zType = sqliteStrDup(columnType(&sNC, p, 0, 0, 0)); + pCol->zType = zType; + pCol->affinity = sqlite3ExprAffinity(p); + pColl = sqlite3ExprCollSeq(pParse, p); + if( pColl ){ + pCol->zColl = sqliteStrDup(pColl->zName); } } pTab->iPKey = -1; @@ -818,20 +1132,24 @@ Table *sqliteResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){ } /* -** For the given SELECT statement, do three things. +** Prepare a SELECT statement for processing by doing the following +** things: ** -** (1) Fill in the pTabList->a[].pTab fields in the SrcList that -** defines the set of tables that should be scanned. For views, +** (1) Make sure VDBE cursor numbers have been assigned to every +** element of the FROM clause. +** +** (2) Fill in the pTabList->a[].pTab fields in the SrcList that +** defines FROM clause. When views appear in the FROM clause, ** fill pTabList->a[].pSelect with a copy of the SELECT statement ** that implements the view. A copy is made of the view's SELECT ** statement so that we can freely modify or delete that statement ** without worrying about messing up the presistent representation ** of the view. ** -** (2) Add terms to the WHERE clause to accomodate the NATURAL keyword +** (3) 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 +** (4) Scan the list of columns in the result set (pEList) looking ** for instances of the "*" operator or the TABLE.* operator. ** If found, expand each "*" to be every column in every table ** and TABLE.* to be every column in TABLE. @@ -839,35 +1157,46 @@ Table *sqliteResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){ ** 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){ +static int prepSelectStmt(Parse *pParse, Select *p){ int i, j, k, rc; SrcList *pTabList; ExprList *pEList; - Table *pTab; + struct SrcList_item *pFrom; - if( p==0 || p->pSrc==0 ) return 1; + if( p==0 || p->pSrc==0 || sqlite3MallocFailed() ){ + return 1; + } pTabList = p->pSrc; pEList = p->pEList; - /* Look up every table in the table list. + /* Make sure cursor numbers have been assigned to all entries in + ** the FROM clause of the SELECT statement. */ - for(i=0; inSrc; i++){ - if( pTabList->a[i].pTab ){ - /* This routine has run before! No need to continue */ + sqlite3SrcListAssignCursors(pParse, p->pSrc); + + /* Look up every table named in the FROM clause of the select. If + ** an entry of the FROM clause is a subquery instead of a table or view, + ** then create a transient table structure to describe the subquery. + */ + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab; + if( pFrom->pTab!=0 ){ + /* This statement has already been prepared. There is no need + ** to go further. */ + assert( i==0 ); return 0; } - if( pTabList->a[i].zName==0 ){ + if( pFrom->zName==0 ){ +#ifndef SQLITE_OMIT_SUBQUERY /* 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); + assert( pFrom->pSelect!=0 ); + if( pFrom->zAlias==0 ){ + pFrom->zAlias = + sqlite3MPrintf("sqlite_subquery_%p_", (void*)pFrom->pSelect); } - pTabList->a[i].pTab = pTab = - sqliteResultSetOfSelect(pParse, pTabList->a[i].zAlias, - pTabList->a[i].pSelect); + assert( pFrom->pTab==0 ); + pFrom->pTab = pTab = + sqlite3ResultSetOfSelect(pParse, pFrom->zAlias, pFrom->pSelect); if( pTab==0 ){ return 1; } @@ -876,27 +1205,32 @@ static int fillInColumnList(Parse *pParse, Select *p){ ** pTab is not pointing to a persistent table structure that defines ** part of the schema. */ pTab->isTransient = 1; +#endif }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); + assert( pFrom->pTab==0 ); + pFrom->pTab = pTab = + sqlite3LocateTable(pParse,pFrom->zName,pFrom->zDatabase); if( pTab==0 ){ return 1; } + pTab->nRef++; +#ifndef SQLITE_OMIT_VIEW if( pTab->pSelect ){ /* We reach here if the named table is a really a view */ - if( sqliteViewGetColumnNames(pParse, pTab) ){ + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ return 1; } - /* If pTabList->a[i].pSelect!=0 it means we are dealing with a + /* If pFrom->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); + if( pFrom->pSelect==0 ){ + pFrom->pSelect = sqlite3SelectDup(pTab->pSelect); } } +#endif } } @@ -929,67 +1263,72 @@ static int fillInColumnList(Parse *pParse, Select *p){ */ struct ExprList_item *a = pEList->a; ExprList *pNew = 0; + int flags = pParse->db->flags; + int longNames = (flags & SQLITE_FullColNames)!=0 && + (flags & SQLITE_ShortColNames)==0; + for(k=0; knExpr; k++){ 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; + pNew = sqlite3ExprListAppend(pNew, a[k].pExpr, 0); + if( pNew ){ + pNew->a[pNew->nExpr-1].zName = a[k].zName; + }else{ + rc = 1; + } 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 */ - Token *pName; /* text of name of TABLE */ + char *zTName; /* text of name of TABLE */ if( pE->op==TK_DOT && pE->pLeft ){ - pName = &pE->pLeft->token; + zTName = sqlite3NameFromToken(&pE->pLeft->token); }else{ - pName = 0; + zTName = 0; } - for(i=0; inSrc; i++){ - Table *pTab = pTabList->a[i].pTab; - char *zTabName = pTabList->a[i].zAlias; + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab = pFrom->pTab; + char *zTabName = pFrom->zAlias; if( zTabName==0 || zTabName[0]==0 ){ zTabName = pTab->zName; } - if( pName && (zTabName==0 || zTabName[0]==0 || - sqliteStrNICmp(pName->z, zTabName, pName->n)!=0 || - zTabName[pName->n]!=0) ){ + if( zTName && (zTabName==0 || zTabName[0]==0 || + sqlite3StrICmp(zTName, zTabName)!=0) ){ continue; } tableSeen = 1; for(j=0; jnCol; j++){ - Expr *pExpr, *pLeft, *pRight; + Expr *pExpr, *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 ){ + struct SrcList_item *pLeft = &pTabList->a[i-1]; + if( (pLeft->jointype & JT_NATURAL)!=0 && + columnIndex(pLeft->pTab, zName)>=0 ){ + /* In a NATURAL join, omit the join columns from the + ** table on the right */ + continue; + } + if( sqlite3IdListIndex(pLeft->pUsing, zName)>=0 ){ + /* In a join with a USING clause, omit columns in the + ** using clause 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); + pRight = sqlite3Expr(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); + setToken(&pRight->token, zName); + if( zTabName && (longNames || pTabList->nSrc>1) ){ + Expr *pLeft = sqlite3Expr(TK_ID, 0, 0, 0); + pExpr = sqlite3Expr(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); + setToken(&pLeft->token, zTabName); + setToken(&pExpr->span, sqlite3MPrintf("%s.%s", zTabName, zName)); pExpr->span.dyn = 1; pExpr->token.z = 0; pExpr->token.n = 0; @@ -998,56 +1337,31 @@ static int fillInColumnList(Parse *pParse, Select *p){ pExpr = pRight; pExpr->span = pExpr->token; } - pNew = sqliteExprListAppend(pNew, pExpr, 0); + if( longNames ){ + pNew = sqlite3ExprListAppend(pNew, pExpr, &pExpr->span); + }else{ + pNew = sqlite3ExprListAppend(pNew, pExpr, &pRight->token); + } } } if( !tableSeen ){ - if( pName ){ - sqliteErrorMsg(pParse, "no such table: %T", pName); + if( zTName ){ + sqlite3ErrorMsg(pParse, "no such table: %s", zTName); }else{ - sqliteErrorMsg(pParse, "no tables specified"); + sqlite3ErrorMsg(pParse, "no tables specified"); } rc = 1; } + sqliteFree(zTName); } } - sqliteExprListDelete(pEList); + sqlite3ExprListDelete(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); - } - } - } -} - +#ifndef SQLITE_OMIT_COMPOUND_SELECT /* ** This routine associates entries in an ORDER BY expression list with ** columns in a result. For each ORDER BY expression, the opcode of @@ -1060,13 +1374,6 @@ void sqliteSelectUnbind(Select *p){ ** ** 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 */ @@ -1083,7 +1390,7 @@ static int matchOrderbyToColumn( if( mustComplete ){ for(i=0; inExpr; i++){ pOrderBy->a[i].done = 0; } } - if( fillInColumnList(pParse, pSelect) ){ + if( prepSelectStmt(pParse, pSelect) ){ return 1; } if( pSelect->pPrior ){ @@ -1096,9 +1403,9 @@ static int matchOrderbyToColumn( Expr *pE = pOrderBy->a[i].pExpr; int iCol = -1; if( pOrderBy->a[i].done ) continue; - if( sqliteExprIsInteger(pE, &iCol) ){ + if( sqlite3ExprIsInteger(pE, &iCol) ){ if( iCol<=0 || iCol>pEList->nExpr ){ - sqliteErrorMsg(pParse, + sqlite3ErrorMsg(pParse, "ORDER BY position %d should be between 1 and %d", iCol, pEList->nExpr); nErr++; @@ -1111,15 +1418,14 @@ static int matchOrderbyToColumn( 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 ){ + zLabel = sqlite3NameFromToken(&pE->token); + assert( zLabel!=0 ); + if( sqlite3StrICmp(zName, zLabel)==0 ){ iCol = j; } sqliteFree(zLabel); } - if( iCol<0 && sqliteExprCompare(pE, pEList->a[j].pExpr) ){ + if( iCol<0 && sqlite3ExprCompare(pE, pEList->a[j].pExpr) ){ iCol = j; } } @@ -1127,10 +1433,11 @@ static int matchOrderbyToColumn( pE->op = TK_COLUMN; pE->iColumn = iCol; pE->iTable = iTable; + pE->iAgg = -1; pOrderBy->a[i].done = 1; } if( iCol<0 && mustComplete ){ - sqliteErrorMsg(pParse, + sqlite3ErrorMsg(pParse, "ORDER BY term number %d does not match any result column", i+1); nErr++; break; @@ -1138,114 +1445,129 @@ static int matchOrderbyToColumn( } return nErr; } +#endif /* #ifndef SQLITE_OMIT_COMPOUND_SELECT */ /* ** 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 *sqlite3GetVdbe(Parse *pParse){ Vdbe *v = pParse->pVdbe; if( v==0 ){ - v = pParse->pVdbe = sqliteVdbeCreate(pParse->db); + v = pParse->pVdbe = sqlite3VdbeCreate(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 +** pLimit and pOffset expressions. pLimit and pOffset hold the expressions ** 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. +** keywords. Or NULL if those keywords are omitted. iLimit and iOffset +** are the integer memory register numbers for counters used to compute +** the limit and offset. If there is no limit and/or offset, then +** iLimit and iOffset are negative. ** -** This routine changes the values if iLimit and iOffset only if -** a limit or offset is defined by nLimit and nOffset. iLimit and +** This routine changes the values of iLimit and iOffset only if +** a limit or offset is defined by pLimit and pOffset. iLimit and ** iOffset should have been preset to appropriate default values ** (usually but not always -1) prior to calling this routine. -** Only if nLimit>=0 or nOffset>0 do the limit registers get +** Only if pLimit!=0 or pOffset!=0 do the limit registers get ** redefined. The UNION ALL operator uses this property to force ** the reuse of the same limit and offset registers across multiple ** SELECT statements. */ -static void computeLimitRegisters(Parse *pParse, Select *p){ +static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){ + Vdbe *v = 0; + int iLimit = 0; + int iOffset; + int addr1, addr2; + /* - ** 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( p->pLimit ){ + p->iLimit = iLimit = pParse->nMem; + pParse->nMem += 2; + v = sqlite3GetVdbe(pParse); if( v==0 ) return; - sqliteVdbeAddOp(v, OP_Integer, -p->nLimit, 0); - sqliteVdbeAddOp(v, OP_MemStore, iMem, 1); - p->iLimit = iMem; + sqlite3ExprCode(pParse, p->pLimit); + sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0); + sqlite3VdbeAddOp(v, OP_MemStore, iLimit, 0); + VdbeComment((v, "# LIMIT counter")); + sqlite3VdbeAddOp(v, OP_IfMemZero, iLimit, iBreak); } - if( p->nOffset>0 ){ - int iMem = pParse->nMem++; - Vdbe *v = sqliteGetVdbe(pParse); + if( p->pOffset ){ + p->iOffset = iOffset = pParse->nMem++; + v = sqlite3GetVdbe(pParse); if( v==0 ) return; - sqliteVdbeAddOp(v, OP_Integer, -p->nOffset, 0); - sqliteVdbeAddOp(v, OP_MemStore, iMem, 1); - p->iOffset = iMem; + sqlite3ExprCode(pParse, p->pOffset); + sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0); + sqlite3VdbeAddOp(v, OP_MemStore, iOffset, p->pLimit==0); + VdbeComment((v, "# OFFSET counter")); + addr1 = sqlite3VdbeAddOp(v, OP_IfMemPos, iOffset, 0); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_Integer, 0, 0); + sqlite3VdbeJumpHere(v, addr1); + if( p->pLimit ){ + sqlite3VdbeAddOp(v, OP_Add, 0, 0); + } + } + if( p->pLimit ){ + addr1 = sqlite3VdbeAddOp(v, OP_IfMemPos, iLimit, 0); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_MemInt, -1, iLimit+1); + addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp(v, OP_MemStore, iLimit+1, 1); + VdbeComment((v, "# LIMIT+OFFSET")); + sqlite3VdbeJumpHere(v, addr2); } } +/* +** Allocate a virtual index to use for sorting. +*/ +static void createSortingIndex(Parse *pParse, Select *p, ExprList *pOrderBy){ + if( pOrderBy ){ + int addr; + assert( pOrderBy->iECursor==0 ); + pOrderBy->iECursor = pParse->nTab++; + addr = sqlite3VdbeAddOp(pParse->pVdbe, OP_OpenVirtual, + pOrderBy->iECursor, pOrderBy->nExpr+1); + assert( p->addrOpenVirt[2] == -1 ); + p->addrOpenVirt[2] = addr; + } +} + +#ifndef SQLITE_OMIT_COMPOUND_SELECT +/* +** Return the appropriate collating sequence for the iCol-th column of +** the result set for the compound-select statement "p". Return NULL if +** the column has no default collating sequence. +** +** The collating sequence for the compound select is taken from the +** left-most term of the select that has a collating sequence. +*/ +static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){ + CollSeq *pRet; + if( p->pPrior ){ + pRet = multiSelectCollSeq(pParse, p->pPrior, iCol); + }else{ + pRet = 0; + } + if( pRet==0 ){ + pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr); + } + return pRet; +} +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + +#ifndef SQLITE_OMIT_COMPOUND_SELECT /* ** This routine is called to process a query that is really the union ** or intersection of two or more separate queries. @@ -1276,56 +1598,92 @@ static void computeLimitRegisters(Parse *pParse, Select *p){ ** 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 */ +static int multiSelect( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + int eDest, /* \___ Store query results as specified */ + int iParm, /* / by these two parameters. */ + char *aff /* If eDest is SRT_Union, the affinity string */ +){ + int rc = SQLITE_OK; /* Success code from a subroutine */ + Select *pPrior; /* Another SELECT immediately to our left */ + Vdbe *v; /* Generate code to this VDBE */ + int nCol; /* Number of columns in the result set */ + ExprList *pOrderBy; /* The ORDER BY clause on p */ + int aSetP2[2]; /* Set P2 value of these op to number of columns */ + int nSetP2 = 0; /* Number of slots in aSetP2[] used */ /* 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. + ** the last (right-most) 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( p==0 || p->pPrior==0 ){ + rc = 1; + goto multi_select_end; } - if( pPrior->nLimit>=0 || pPrior->nOffset>0 ){ - sqliteErrorMsg(pParse,"LIMIT clause should come after %s not before", + pPrior = p->pPrior; + assert( pPrior->pRightmost!=pPrior ); + assert( pPrior->pRightmost==p->pRightmost ); + if( pPrior->pOrderBy ){ + sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before", selectOpName(p->op)); - return 1; + rc = 1; + goto multi_select_end; + } + if( pPrior->pLimit ){ + sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before", + selectOpName(p->op)); + rc = 1; + goto multi_select_end; } /* Make sure we have a valid query engine. If not, create a new one. */ - v = sqliteGetVdbe(pParse); - if( v==0 ) return 1; + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + rc = 1; + goto multi_select_end; + } /* Create the destination temporary table if necessary */ - if( eDest==SRT_TempTable ){ - sqliteVdbeAddOp(v, OP_OpenTemp, iParm, 0); + if( eDest==SRT_VirtualTab ){ + assert( p->pEList ); + assert( nSetP2pOrderBy; 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; + if( pOrderBy==0 ){ + int addr = 0; + assert( !pPrior->pLimit ); + pPrior->pLimit = p->pLimit; + pPrior->pOffset = p->pOffset; + rc = sqlite3Select(pParse, pPrior, eDest, iParm, 0, 0, 0, aff); + p->pLimit = 0; + p->pOffset = 0; + if( rc ){ + goto multi_select_end; + } 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); + if( p->iLimit>=0 ){ + addr = sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, 0); + VdbeComment((v, "# Jump ahead if LIMIT reached")); + } + rc = sqlite3Select(pParse, p, eDest, iParm, 0, 0, 0, aff); p->pPrior = pPrior; - if( rc ) return rc; + if( rc ){ + goto multi_select_end; + } + if( addr ){ + sqlite3VdbeJumpHere(v, addr); + } break; } /* For UNION ALL ... ORDER BY fall through to the next case */ @@ -1333,13 +1691,13 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ 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 op = 0; /* 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 */ + Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */ + int addr; priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union; - if( eDest==priorOp && p->pOrderBy==0 && p->nLimit<0 && p->nOffset==0 ){ + if( eDest==priorOp && pOrderBy==0 && !p->pLimit && !p->pOffset ){ /* We can reuse a temporary table generated by a SELECT to our ** right. */ @@ -1349,22 +1707,30 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ ** intermediate results. */ unionTab = pParse->nTab++; - if( p->pOrderBy - && matchOrderbyToColumn(pParse, p, p->pOrderBy, unionTab, 1) ){ - return 1; + if( pOrderBy && matchOrderbyToColumn(pParse, p, pOrderBy, unionTab,1) ){ + rc = 1; + goto multi_select_end; } - if( p->op!=TK_ALL ){ - sqliteVdbeAddOp(v, OP_OpenTemp, unionTab, 1); - sqliteVdbeAddOp(v, OP_KeyAsData, unionTab, 1); + addr = sqlite3VdbeAddOp(v, OP_OpenVirtual, unionTab, 0); + if( priorOp==SRT_Table ){ + assert( nSetP2addrOpenVirt[0] == -1 ); + p->addrOpenVirt[0] = addr; + p->pRightmost->usesVirt = 1; } + createSortingIndex(pParse, p, pOrderBy); + assert( p->pEList ); } /* Code the SELECT statements to our left */ - rc = sqliteSelect(pParse, pPrior, priorOp, unionTab, 0, 0, 0); - if( rc ) return rc; + assert( !pPrior->pOrderBy ); + rc = sqlite3Select(pParse, pPrior, priorOp, unionTab, 0, 0, 0, aff); + if( rc ){ + goto multi_select_end; + } /* Code the current SELECT statement */ @@ -1374,18 +1740,24 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ 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->disallowOrderBy = pOrderBy!=0; + pLimit = p->pLimit; + p->pLimit = 0; + pOffset = p->pOffset; + p->pOffset = 0; + rc = sqlite3Select(pParse, p, op, unionTab, 0, 0, 0, aff); p->pPrior = pPrior; p->pOrderBy = pOrderBy; - p->nLimit = nLimit; - p->nOffset = nOffset; - if( rc ) return rc; + sqlite3ExprDelete(p->pLimit); + p->pLimit = pLimit; + p->pOffset = pOffset; + p->iLimit = -1; + p->iOffset = -1; + if( rc ){ + goto multi_select_end; + } + /* Convert the data in the temporary table into whatever form ** it is that we currently need. @@ -1394,33 +1766,34 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ int iCont, iBreak, iStart; assert( p->pEList ); if( eDest==SRT_Callback ){ - generateColumnNames(pParse, 0, p->pEList); - generateColumnTypes(pParse, p->pSrc, p->pEList); + Select *pFirst = p; + while( pFirst->pPrior ) pFirst = pFirst->pPrior; + generateColumnNames(pParse, 0, pFirst->pEList); } - iBreak = sqliteVdbeMakeLabel(v); - iCont = sqliteVdbeMakeLabel(v); - sqliteVdbeAddOp(v, OP_Rewind, unionTab, iBreak); - computeLimitRegisters(pParse, p); - iStart = sqliteVdbeCurrentAddr(v); - multiSelectSortOrder(p, p->pOrderBy); + iBreak = sqlite3VdbeMakeLabel(v); + iCont = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, iBreak); + sqlite3VdbeAddOp(v, OP_Rewind, unionTab, iBreak); + iStart = sqlite3VdbeCurrentAddr(v); 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); + pOrderBy, -1, eDest, iParm, + iCont, iBreak, 0); + if( rc ){ + rc = 1; + goto multi_select_end; } + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp(v, OP_Next, unionTab, iStart); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp(v, OP_Close, unionTab, 0); } break; } case TK_INTERSECT: { int tab1, tab2; int iCont, iBreak, iStart; - int nLimit, nOffset; + Expr *pLimit, *pOffset; + int addr; /* INTERSECT is different from the others since it requires ** two temporary tables. Hence it has its own case. Begin @@ -1428,71 +1801,181 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ */ tab1 = pParse->nTab++; tab2 = pParse->nTab++; - if( p->pOrderBy && matchOrderbyToColumn(pParse,p,p->pOrderBy,tab1,1) ){ - return 1; + if( pOrderBy && matchOrderbyToColumn(pParse,p,pOrderBy,tab1,1) ){ + rc = 1; + goto multi_select_end; } - sqliteVdbeAddOp(v, OP_OpenTemp, tab1, 1); - sqliteVdbeAddOp(v, OP_KeyAsData, tab1, 1); + createSortingIndex(pParse, p, pOrderBy); + + addr = sqlite3VdbeAddOp(v, OP_OpenVirtual, tab1, 0); + assert( p->addrOpenVirt[0] == -1 ); + p->addrOpenVirt[0] = addr; + p->pRightmost->usesVirt = 1; + assert( p->pEList ); /* Code the SELECTs to our left into temporary table "tab1". */ - rc = sqliteSelect(pParse, pPrior, SRT_Union, tab1, 0, 0, 0); - if( rc ) return rc; + rc = sqlite3Select(pParse, pPrior, SRT_Union, tab1, 0, 0, 0, aff); + if( rc ){ + goto multi_select_end; + } /* Code the current SELECT into temporary table "tab2" */ - sqliteVdbeAddOp(v, OP_OpenTemp, tab2, 1); - sqliteVdbeAddOp(v, OP_KeyAsData, tab2, 1); + addr = sqlite3VdbeAddOp(v, OP_OpenVirtual, tab2, 0); + assert( p->addrOpenVirt[1] == -1 ); + p->addrOpenVirt[1] = addr; 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); + pLimit = p->pLimit; + p->pLimit = 0; + pOffset = p->pOffset; + p->pOffset = 0; + rc = sqlite3Select(pParse, p, SRT_Union, tab2, 0, 0, 0, aff); p->pPrior = pPrior; - p->nLimit = nLimit; - p->nOffset = nOffset; - if( rc ) return rc; + sqlite3ExprDelete(p->pLimit); + p->pLimit = pLimit; + p->pOffset = pOffset; + if( rc ){ + goto multi_select_end; + } /* 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); + Select *pFirst = p; + while( pFirst->pPrior ) pFirst = pFirst->pPrior; + generateColumnNames(pParse, 0, pFirst->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); + iBreak = sqlite3VdbeMakeLabel(v); + iCont = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, iBreak); + sqlite3VdbeAddOp(v, OP_Rewind, tab1, iBreak); + iStart = sqlite3VdbeAddOp(v, OP_RowKey, tab1, 0); + sqlite3VdbeAddOp(v, OP_NotFound, tab2, iCont); 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); + pOrderBy, -1, eDest, iParm, + iCont, iBreak, 0); + if( rc ){ + rc = 1; + goto multi_select_end; } + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp(v, OP_Next, tab1, iStart); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp(v, OP_Close, tab2, 0); + sqlite3VdbeAddOp(v, OP_Close, tab1, 0); break; } } + + /* Make sure all SELECTs in the statement have the same number of elements + ** in their result sets. + */ assert( p->pEList && pPrior->pEList ); if( p->pEList->nExpr!=pPrior->pEList->nExpr ){ - sqliteErrorMsg(pParse, "SELECTs to the left and right of %s" + sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s" " do not have the same number of result columns", selectOpName(p->op)); - return 1; + rc = 1; + goto multi_select_end; } - return 0; -} + /* Set the number of columns in temporary tables + */ + nCol = p->pEList->nExpr; + while( nSetP2 ){ + sqlite3VdbeChangeP2(v, aSetP2[--nSetP2], nCol); + } + + /* Compute collating sequences used by either the ORDER BY clause or + ** by any temporary tables needed to implement the compound select. + ** Attach the KeyInfo structure to all temporary tables. Invoke the + ** ORDER BY processing if there is an ORDER BY clause. + ** + ** This section is run by the right-most SELECT statement only. + ** SELECT statements to the left always skip this part. The right-most + ** SELECT might also skip this part if it has no ORDER BY clause and + ** no temp tables are required. + */ + if( pOrderBy || p->usesVirt ){ + int i; /* Loop counter */ + KeyInfo *pKeyInfo; /* Collating sequence for the result set */ + Select *pLoop; /* For looping through SELECT statements */ + CollSeq **apColl; + CollSeq **aCopy; + + assert( p->pRightmost==p ); + pKeyInfo = sqliteMalloc(sizeof(*pKeyInfo)+nCol*2*sizeof(CollSeq*) + nCol); + if( !pKeyInfo ){ + rc = SQLITE_NOMEM; + goto multi_select_end; + } + + pKeyInfo->enc = ENC(pParse->db); + pKeyInfo->nField = nCol; + + for(i=0, apColl=pKeyInfo->aColl; idb->pDfltColl; + } + } + + for(pLoop=p; pLoop; pLoop=pLoop->pPrior){ + for(i=0; i<2; i++){ + int addr = pLoop->addrOpenVirt[i]; + if( addr<0 ){ + /* If [0] is unused then [1] is also unused. So we can + ** always safely abort as soon as the first unused slot is found */ + assert( pLoop->addrOpenVirt[1]<0 ); + break; + } + sqlite3VdbeChangeP2(v, addr, nCol); + sqlite3VdbeChangeP3(v, addr, (char*)pKeyInfo, P3_KEYINFO); + } + } + + if( pOrderBy ){ + struct ExprList_item *pOTerm = pOrderBy->a; + int nOrderByExpr = pOrderBy->nExpr; + int addr; + u8 *pSortOrder; + + aCopy = &pKeyInfo->aColl[nCol]; + pSortOrder = pKeyInfo->aSortOrder = (u8*)&aCopy[nCol]; + memcpy(aCopy, pKeyInfo->aColl, nCol*sizeof(CollSeq*)); + apColl = pKeyInfo->aColl; + for(i=0; ipExpr; + char *zName = pOTerm->zName; + assert( pExpr->op==TK_COLUMN && pExpr->iColumniColumn]; + } + *pSortOrder = pOTerm->sortOrder; + } + assert( p->pRightmost==p ); + assert( p->addrOpenVirt[2]>=0 ); + addr = p->addrOpenVirt[2]; + sqlite3VdbeChangeP2(v, addr, p->pEList->nExpr+2); + pKeyInfo->nField = nOrderByExpr; + sqlite3VdbeChangeP3(v, addr, (char*)pKeyInfo, P3_KEYINFO_HANDOFF); + pKeyInfo = 0; + generateSortTail(pParse, p, v, p->pEList->nExpr, eDest, iParm); + } + + sqliteFree(pKeyInfo); + } + +multi_select_end: + return rc; +} +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + +#ifndef SQLITE_OMIT_VIEW /* ** Scan through the expression pExpr. Replace every reference to ** a column in table number iTable with a copy of the iColumn-th @@ -1507,6 +1990,7 @@ static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ ** of the subquery rather the result set of the subquery. */ static void substExprList(ExprList*,int,ExprList*); /* Forward Decl */ +static void substSelect(Select *, 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 ){ @@ -1519,34 +2003,45 @@ static void substExpr(Expr *pExpr, int iTable, ExprList *pEList){ 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); + pExpr->pLeft = sqlite3ExprDup(pNew->pLeft); assert( pExpr->pRight==0 ); - pExpr->pRight = sqliteExprDup(pNew->pRight); + pExpr->pRight = sqlite3ExprDup(pNew->pRight); assert( pExpr->pList==0 ); - pExpr->pList = sqliteExprListDup(pNew->pList); + pExpr->pList = sqlite3ExprListDup(pNew->pList); pExpr->iTable = pNew->iTable; pExpr->iColumn = pNew->iColumn; pExpr->iAgg = pNew->iAgg; - sqliteTokenCopy(&pExpr->token, &pNew->token); - sqliteTokenCopy(&pExpr->span, &pNew->span); + sqlite3TokenCopy(&pExpr->token, &pNew->token); + sqlite3TokenCopy(&pExpr->span, &pNew->span); + pExpr->pSelect = sqlite3SelectDup(pNew->pSelect); + pExpr->flags = pNew->flags; } }else{ substExpr(pExpr->pLeft, iTable, pEList); substExpr(pExpr->pRight, iTable, pEList); + substSelect(pExpr->pSelect, iTable, pEList); substExprList(pExpr->pList, iTable, pEList); } } -static void -substExprList(ExprList *pList, int iTable, ExprList *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); } } +static void substSelect(Select *p, int iTable, ExprList *pEList){ + if( !p ) return; + substExprList(p->pEList, iTable, pEList); + substExprList(p->pGroupBy, iTable, pEList); + substExprList(p->pOrderBy, iTable, pEList); + substExpr(p->pHaving, iTable, pEList); + substExpr(p->pWhere, iTable, pEList); +} +#endif /* !defined(SQLITE_OMIT_VIEW) */ +#ifndef SQLITE_OMIT_VIEW /* ** This routine attempts to flatten subqueries in order to speed ** execution. It returns 1 if it makes changes and 0 if no flattening @@ -1606,6 +2101,10 @@ substExprList(ExprList *pList, int iTable, ExprList *pEList){ ** (12) The subquery is not the right term of a LEFT OUTER JOIN or the ** subquery has no WHERE clause. (added by ticket #350) ** +** (13) The subquery and outer query do not both use LIMIT +** +** (14) The subquery does not use OFFSET +** ** 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. @@ -1617,7 +2116,6 @@ substExprList(ExprList *pList, int iTable, ExprList *pEList){ ** 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 */ @@ -1628,26 +2126,38 @@ static int flattenSubquery( 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; + int i; /* Loop counter */ + Expr *pWhere; /* The WHERE clause */ + struct SrcList_item *pSubitem; /* The subquery */ /* 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; + pSubitem = &pSrc->a[iFrom]; + pSub = pSubitem->pSelect; assert( pSub!=0 ); - if( isAgg && subqueryIsAgg ) return 0; - if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; + if( isAgg && subqueryIsAgg ) return 0; /* Restriction (1) */ + if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; /* Restriction (2) */ pSubSrc = pSub->pSrc; assert( pSubSrc ); - if( pSubSrc->nSrc==0 ) return 0; - if( (pSub->isDistinct || pSub->nLimit>=0) && (pSrc->nSrc>1 || isAgg) ){ - return 0; + /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants, + ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET + ** because they could be computed at compile-time. But when LIMIT and OFFSET + ** became arbitrary expressions, we were forced to add restrictions (13) + ** and (14). */ + if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */ + if( pSub->pOffset ) return 0; /* Restriction (14) */ + if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */ + if( (pSub->isDistinct || pSub->pLimit) + && (pSrc->nSrc>1 || isAgg) ){ /* Restrictions (4)(5)(8)(9) */ + return 0; + } + if( p->isDistinct && subqueryIsAgg ) return 0; /* Restriction (6) */ + if( (p->disallowOrderBy || p->pOrderBy) && pSub->pOrderBy ){ + return 0; /* Restriction (11) */ } - 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 @@ -1695,21 +2205,19 @@ static int flattenSubquery( ** those references with expressions that resolve to the subquery FROM ** elements we are now copying in. */ - iParent = pSrc->a[iFrom].iCursor; + iParent = pSubitem->iCursor; { int nSubSrc = pSubSrc->nSrc; - int jointype = pSrc->a[iFrom].jointype; + int jointype = pSubitem->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); + sqlite3DeleteTable(0, pSubitem->pTab); + sqliteFree(pSubitem->zDatabase); + sqliteFree(pSubitem->zName); + sqliteFree(pSubitem->zAlias); if( nSubSrc>1 ){ int extra = nSubSrc - 1; for(i=1; ipSrc = pSrc; for(i=pSrc->nSrc-1; i-extra>=iFrom; i--){ @@ -1735,14 +2243,14 @@ static int flattenSubquery( ** 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); + pList->a[i].zName = sqliteStrNDup((char*)pExpr->span.z, pExpr->span.n); } } + substExprList(p->pEList, iParent, pSub->pEList); if( isAgg ){ substExprList(p->pGroupBy, iParent, pSub->pEList); substExpr(p->pHaving, iParent, pSub->pEList); @@ -1755,7 +2263,7 @@ static int flattenSubquery( substExprList(p->pOrderBy, iParent, pSub->pEList); } if( pSub->pWhere ){ - pWhere = sqliteExprDup(pSub->pWhere); + pWhere = sqlite3ExprDup(pSub->pWhere); }else{ pWhere = 0; } @@ -1764,23 +2272,12 @@ static int flattenSubquery( 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; - } - } + p->pHaving = sqlite3ExprAnd(p->pHaving, sqlite3ExprDup(pSub->pHaving)); assert( p->pGroupBy==0 ); - p->pGroupBy = sqliteExprListDup(pSub->pGroupBy); - }else if( p->pWhere==0 ){ - p->pWhere = pWhere; + p->pGroupBy = sqlite3ExprListDup(pSub->pGroupBy); }else{ substExpr(p->pWhere, iParent, pSub->pEList); - if( pWhere ){ - p->pWhere = sqliteExpr(TK_AND, p->pWhere, pWhere, 0); - } + p->pWhere = sqlite3ExprAnd(p->pWhere, pWhere); } /* The flattened query is distinct if either the inner or the @@ -1788,24 +2285,24 @@ static int flattenSubquery( */ p->isDistinct = p->isDistinct || pSub->isDistinct; - /* Transfer the limit expression from the subquery to the outer - ** query. + /* + ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y; + ** + ** One is tempted to try to add a and b to combine the limits. But this + ** does not work if either limit is negative. */ - if( pSub->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; - } + if( pSub->pLimit ){ + p->pLimit = pSub->pLimit; + pSub->pLimit = 0; } - p->nOffset += pSub->nOffset; /* Finially, delete what is left of the subquery and return ** success. */ - sqliteSelectDelete(pSub); + sqlite3SelectDelete(pSub); return 1; } +#endif /* SQLITE_OMIT_VIEW */ /* ** Analyze the SELECT statement passed in as an argument to see if it @@ -1824,7 +2321,7 @@ static int flattenSubquery( ** 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(). +** The parameters to this routine are the same as for sqlite3Select(). ** See the header comment on that routine for additional information. */ static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ @@ -1835,31 +2332,37 @@ static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ int base; Vdbe *v; int seekOp; - int cont; - ExprList eList; + ExprList *pEList, *pList, eList; struct ExprList_item eListItem; + SrcList *pSrc; + int brk; + int iDb; /* 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; - if( p->pSrc->nSrc!=1 ) return 0; - if( p->pEList->nExpr!=1 ) return 0; - pExpr = p->pEList->a[0].pExpr; + 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; - if( pExpr->pList==0 || pExpr->pList->nExpr!=1 ) 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 ){ + if( sqlite3StrNICmp((char*)pExpr->token.z,"min",3)==0 ){ seekOp = OP_Rewind; - }else if( sqliteStrNICmp(pExpr->token.z,"max",3)==0 ){ + }else if( sqlite3StrNICmp((char*)pExpr->token.z,"max",3)==0 ){ seekOp = OP_Last; }else{ return 0; } - pExpr = pExpr->pList->a[0].pExpr; + pExpr = pList->a[0].pExpr; if( pExpr->op!=TK_COLUMN ) return 0; iCol = pExpr->iColumn; - pTab = p->pSrc->a[0].pTab; + 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 @@ -1870,9 +2373,13 @@ static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ if( iCol<0 ){ pIdx = 0; }else{ + CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr); for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ assert( pIdx->nColumn>=1 ); - if( pIdx->aiColumn[0]==iCol ) break; + if( pIdx->aiColumn[0]==iCol && + 0==sqlite3StrICmp(pIdx->azColl[0], pColl->zName) ){ + break; + } } if( pIdx==0 ) return 0; } @@ -1881,16 +2388,13 @@ static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ ** 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); + v = sqlite3GetVdbe(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); + if( eDest==SRT_VirtualTab ){ + sqlite3VdbeAddOp(v, OP_OpenVirtual, iParm, 1); } /* Generating code to find the min or the max. Basically all we have @@ -1898,32 +2402,313 @@ static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ ** 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 = p->pSrc->a[0].iCursor; - computeLimitRegisters(pParse, p); - sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); - sqliteVdbeOp3(v, OP_OpenRead, base, pTab->tnum, pTab->zName, 0); - cont = sqliteVdbeMakeLabel(v); + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + assert( iDb>=0 || pTab->isTransient ); + sqlite3CodeVerifySchema(pParse, iDb); + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + base = pSrc->a[0].iCursor; + brk = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, brk); + if( pSrc->a[0].pSelect==0 ){ + sqlite3OpenTable(pParse, base, iDb, pTab, OP_OpenRead); + } if( pIdx==0 ){ - sqliteVdbeAddOp(v, seekOp, base, 0); + sqlite3VdbeAddOp(v, seekOp, base, 0); }else{ - sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0); - sqliteVdbeOp3(v, OP_OpenRead, base+1, pIdx->tnum, pIdx->zName, P3_STATIC); - 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); + /* Even though the cursor used to open the index here is closed + ** as soon as a single value has been read from it, allocate it + ** using (pParse->nTab++) to prevent the cursor id from being + ** reused. This is important for statements of the form + ** "INSERT INTO x SELECT max() FROM x". + */ + int iIdx; + KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx); + iIdx = pParse->nTab++; + assert( pIdx->pSchema==pTab->pSchema ); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + sqlite3VdbeOp3(v, OP_OpenRead, iIdx, pIdx->tnum, + (char*)pKey, P3_KEYINFO_HANDOFF); + if( seekOp==OP_Rewind ){ + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + sqlite3VdbeAddOp(v, OP_MakeRecord, 1, 0); + seekOp = OP_MoveGt; + } + sqlite3VdbeAddOp(v, seekOp, iIdx, 0); + sqlite3VdbeAddOp(v, OP_IdxRowid, iIdx, 0); + sqlite3VdbeAddOp(v, OP_Close, iIdx, 0); + sqlite3VdbeAddOp(v, OP_MoveGe, 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); + selectInnerLoop(pParse, p, &eList, 0, 0, 0, -1, eDest, iParm, brk, brk, 0); + sqlite3VdbeResolveLabel(v, brk); + sqlite3VdbeAddOp(v, OP_Close, base, 0); + return 1; } +/* +** Analyze and ORDER BY or GROUP BY clause in a SELECT statement. Return +** the number of errors seen. +** +** An ORDER BY or GROUP BY is a list of expressions. If any expression +** is an integer constant, then that expression is replaced by the +** corresponding entry in the result set. +*/ +static int processOrderGroupBy( + NameContext *pNC, /* Name context of the SELECT statement. */ + ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */ + const char *zType /* Either "ORDER" or "GROUP", as appropriate */ +){ + int i; + ExprList *pEList = pNC->pEList; /* The result set of the SELECT */ + Parse *pParse = pNC->pParse; /* The result set of the SELECT */ + assert( pEList ); + + if( pOrderBy==0 ) return 0; + for(i=0; inExpr; i++){ + int iCol; + Expr *pE = pOrderBy->a[i].pExpr; + if( sqlite3ExprIsInteger(pE, &iCol) ){ + if( iCol>0 && iCol<=pEList->nExpr ){ + sqlite3ExprDelete(pE); + pE = pOrderBy->a[i].pExpr = sqlite3ExprDup(pEList->a[iCol-1].pExpr); + }else{ + sqlite3ErrorMsg(pParse, + "%s BY column number %d out of range - should be " + "between 1 and %d", zType, iCol, pEList->nExpr); + return 1; + } + } + if( sqlite3ExprResolveNames(pNC, pE) ){ + return 1; + } + if( sqlite3ExprIsConstant(pE) ){ + sqlite3ErrorMsg(pParse, + "%s BY terms must not be non-integer constants", zType); + return 1; + } + } + return 0; +} + +/* +** This routine resolves any names used in the result set of the +** supplied SELECT statement. If the SELECT statement being resolved +** is a sub-select, then pOuterNC is a pointer to the NameContext +** of the parent SELECT. +*/ +int sqlite3SelectResolve( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + NameContext *pOuterNC /* The outer name context. May be NULL. */ +){ + ExprList *pEList; /* Result set. */ + int i; /* For-loop variable used in multiple places */ + NameContext sNC; /* Local name-context */ + ExprList *pGroupBy; /* The group by clause */ + + /* If this routine has run before, return immediately. */ + if( p->isResolved ){ + assert( !pOuterNC ); + return SQLITE_OK; + } + p->isResolved = 1; + + /* If there have already been errors, do nothing. */ + if( pParse->nErr>0 ){ + return SQLITE_ERROR; + } + + /* Prepare the select statement. This call will allocate all cursors + ** required to handle the tables and subqueries in the FROM clause. + */ + if( prepSelectStmt(pParse, p) ){ + return SQLITE_ERROR; + } + + /* Resolve the expressions in the LIMIT and OFFSET clauses. These + ** are not allowed to refer to any names, so pass an empty NameContext. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + if( sqlite3ExprResolveNames(&sNC, p->pLimit) || + sqlite3ExprResolveNames(&sNC, p->pOffset) ){ + return SQLITE_ERROR; + } + + /* Set up the local name-context to pass to ExprResolveNames() to + ** resolve the expression-list. + */ + sNC.allowAgg = 1; + sNC.pSrcList = p->pSrc; + sNC.pNext = pOuterNC; + + /* Resolve names in the result set. */ + pEList = p->pEList; + if( !pEList ) return SQLITE_ERROR; + for(i=0; inExpr; i++){ + Expr *pX = pEList->a[i].pExpr; + if( sqlite3ExprResolveNames(&sNC, pX) ){ + return SQLITE_ERROR; + } + } + + /* If there are no aggregate functions in the result-set, and no GROUP BY + ** expression, do not allow aggregates in any of the other expressions. + */ + assert( !p->isAgg ); + pGroupBy = p->pGroupBy; + if( pGroupBy || sNC.hasAgg ){ + p->isAgg = 1; + }else{ + sNC.allowAgg = 0; + } + + /* If a HAVING clause is present, then there must be a GROUP BY clause. + */ + if( p->pHaving && !pGroupBy ){ + sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING"); + return SQLITE_ERROR; + } + + /* Add the expression list to the name-context before parsing the + ** other expressions in the SELECT statement. This is so that + ** expressions in the WHERE clause (etc.) can refer to expressions by + ** aliases in the result set. + ** + ** Minor point: If this is the case, then the expression will be + ** re-evaluated for each reference to it. + */ + sNC.pEList = p->pEList; + if( sqlite3ExprResolveNames(&sNC, p->pWhere) || + sqlite3ExprResolveNames(&sNC, p->pHaving) || + processOrderGroupBy(&sNC, p->pOrderBy, "ORDER") || + processOrderGroupBy(&sNC, pGroupBy, "GROUP") + ){ + return SQLITE_ERROR; + } + + /* Make sure the GROUP BY clause does not contain aggregate functions. + */ + if( pGroupBy ){ + struct ExprList_item *pItem; + + for(i=0, pItem=pGroupBy->a; inExpr; i++, pItem++){ + if( ExprHasProperty(pItem->pExpr, EP_Agg) ){ + sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in " + "the GROUP BY clause"); + return SQLITE_ERROR; + } + } + } + + return SQLITE_OK; +} + +/* +** Reset the aggregate accumulator. +** +** The aggregate accumulator is a set of memory cells that hold +** intermediate results while calculating an aggregate. This +** routine simply stores NULLs in all of those memory cells. +*/ +static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + struct AggInfo_func *pFunc; + if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){ + return; + } + for(i=0; inColumn; i++){ + sqlite3VdbeAddOp(v, OP_MemNull, pAggInfo->aCol[i].iMem, 0); + } + for(pFunc=pAggInfo->aFunc, i=0; inFunc; i++, pFunc++){ + sqlite3VdbeAddOp(v, OP_MemNull, pFunc->iMem, 0); + if( pFunc->iDistinct>=0 ){ + Expr *pE = pFunc->pExpr; + if( pE->pList==0 || pE->pList->nExpr!=1 ){ + sqlite3ErrorMsg(pParse, "DISTINCT in aggregate must be followed " + "by an expression"); + pFunc->iDistinct = -1; + }else{ + KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->pList); + sqlite3VdbeOp3(v, OP_OpenVirtual, pFunc->iDistinct, 0, + (char*)pKeyInfo, P3_KEYINFO_HANDOFF); + } + } + } +} + +/* +** Invoke the OP_AggFinalize opcode for every aggregate function +** in the AggInfo structure. +*/ +static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + struct AggInfo_func *pF; + for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ + ExprList *pList = pF->pExpr->pList; + sqlite3VdbeOp3(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0, + (void*)pF->pFunc, P3_FUNCDEF); + } +} + +/* +** Update the accumulator memory cells for an aggregate based on +** the current cursor position. +*/ +static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + struct AggInfo_func *pF; + struct AggInfo_col *pC; + + pAggInfo->directMode = 1; + for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ + int nArg; + int addrNext = 0; + ExprList *pList = pF->pExpr->pList; + if( pList ){ + nArg = pList->nExpr; + sqlite3ExprCodeExprList(pParse, pList); + }else{ + nArg = 0; + } + if( pF->iDistinct>=0 ){ + addrNext = sqlite3VdbeMakeLabel(v); + assert( nArg==1 ); + codeDistinct(v, pF->iDistinct, addrNext, 1); + } + if( pF->pFunc->needCollSeq ){ + CollSeq *pColl = 0; + struct ExprList_item *pItem; + int j; + assert( pList!=0 ); /* pList!=0 if pF->pFunc->needCollSeq is true */ + for(j=0, pItem=pList->a; !pColl && jpExpr); + } + if( !pColl ){ + pColl = pParse->db->pDfltColl; + } + sqlite3VdbeOp3(v, OP_CollSeq, 0, 0, (char *)pColl, P3_COLLSEQ); + } + sqlite3VdbeOp3(v, OP_AggStep, pF->iMem, nArg, (void*)pF->pFunc, P3_FUNCDEF); + if( addrNext ){ + sqlite3VdbeResolveLabel(v, addrNext); + } + } + for(i=0, pC=pAggInfo->aCol; inAccumulator; i++, pC++){ + sqlite3ExprCode(pParse, pC->pExpr); + sqlite3VdbeAddOp(v, OP_MemStore, pC->iMem, 1); + } + pAggInfo->directMode = 0; +} + + /* ** Generate code for the given SELECT statement. ** @@ -1936,7 +2721,7 @@ static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ ** ** SRT_Mem Store first result in memory cell iParm ** -** SRT_Set Store results as keys of a table with cursor iParm +** SRT_Set Store results as keys of table iParm. ** ** SRT_Union Store results as a key in a temporary table iParm ** @@ -1976,19 +2761,20 @@ static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ ** the second element in a three-way join, the parentTab parameter will ** be 1 (the 2nd value of a 0-indexed array.) */ -int sqliteSelect( +int sqlite3Select( 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 *pParentAgg, /* True if pParent uses aggregate functions */ + char *aff /* If eDest is SRT_Union, the affinity string */ ){ - int i; - WhereInfo *pWInfo; - Vdbe *v; - int isAgg = 0; /* True for select lists like "count(*)" */ + int i, j; /* Loop counters */ + WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */ + Vdbe *v; /* The virtual machine under construction */ + int isAgg; /* True for select lists like "count(*)" */ ExprList *pEList; /* List of columns to extract. */ SrcList *pTabList; /* List of tables to select from */ Expr *pWhere; /* The WHERE clause. May be NULL */ @@ -1998,28 +2784,49 @@ int sqliteSelect( 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 */ + int addrSortIndex; /* Address of an OP_OpenVirtual instruction */ + AggInfo sAggInfo; /* Information used by aggregate queries */ + int iEnd; /* Address of the end of the query */ - if( sqlite_malloc_failed || pParse->nErr || p==0 ) return 1; - if( sqliteAuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; + if( p==0 || sqlite3MallocFailed() || pParse->nErr ){ + return 1; + } + if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; + memset(&sAggInfo, 0, sizeof(sAggInfo)); +#ifndef SQLITE_OMIT_COMPOUND_SELECT /* If there is are a sequence of queries, do the earlier ones first. */ if( p->pPrior ){ - return multiSelect(pParse, p, eDest, iParm); + if( p->pRightmost==0 ){ + Select *pLoop; + for(pLoop=p; pLoop; pLoop=pLoop->pPrior){ + pLoop->pRightmost = p; + } + } + return multiSelect(pParse, p, eDest, iParm, aff); } +#endif + + pOrderBy = p->pOrderBy; + if( IgnorableOrderby(eDest) ){ + p->pOrderBy = 0; + } + if( sqlite3SelectResolve(pParse, p, 0) ){ + goto select_end; + } + p->pOrderBy = pOrderBy; /* Make local copies of the parameters for this query. */ pTabList = p->pSrc; pWhere = p->pWhere; - pOrderBy = p->pOrderBy; pGroupBy = p->pGroupBy; pHaving = p->pHaving; + isAgg = p->isAgg; isDistinct = p->isDistinct; - - /* Allocate VDBE cursors for each table in the FROM clause - */ - sqliteSrcListAssignCursors(pParse, pTabList); + pEList = p->pEList; + if( pEList==0 ) goto select_end; /* ** Do not even attempt to generate any code if we have already seen @@ -2027,139 +2834,59 @@ int sqliteSelect( */ 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. */ +#ifndef SQLITE_OMIT_SUBQUERY if( (eDest==SRT_Mem || eDest==SRT_Set) && pEList->nExpr>1 ){ - sqliteErrorMsg(pParse, "only a single result allowed for " + sqlite3ErrorMsg(pParse, "only a single result allowed for " "a SELECT that is part of an expression"); goto select_end; } +#endif /* 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; - } - } - } + if( IgnorableOrderby(eDest) ){ + pOrderBy = 0; } /* Begin generating code. */ - v = sqliteGetVdbe(pParse); + v = sqlite3GetVdbe(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. + /* Generate code for all sub-queries in the FROM clause */ - if( eDest==SRT_Callback ){ - generateColumnNames(pParse, pTabList, pEList); +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + for(i=0; inSrc; i++){ + const char *zSavedAuthContext = 0; + int needRestoreContext; + struct SrcList_item *pItem = &pTabList->a[i]; + + if( pItem->pSelect==0 || pItem->isPopulated ) continue; + if( pItem->zName!=0 ){ + zSavedAuthContext = pParse->zAuthContext; + pParse->zAuthContext = pItem->zName; + needRestoreContext = 1; + }else{ + needRestoreContext = 0; + } + sqlite3Select(pParse, pItem->pSelect, SRT_VirtualTab, + pItem->iCursor, p, i, &isAgg, 0); + if( needRestoreContext ){ + pParse->zAuthContext = zSavedAuthContext; + } + pTabList = p->pSrc; + pWhere = p->pWhere; + if( !IgnorableOrderby(eDest) ){ + pOrderBy = p->pOrderBy; + } + pGroupBy = p->pGroupBy; + pHaving = p->pHaving; + isDistinct = p->isDistinct; } +#endif /* Check for the special case of a min() or max() function by itself ** in the result set. @@ -2169,226 +2896,382 @@ int sqliteSelect( goto select_end; } - /* 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 to see if this is a subquery that can be "flattened" into its parent. ** If flattening is a possiblity, do so and return immediately. */ +#ifndef SQLITE_OMIT_VIEW if( pParent && pParentAgg && - flattenSubquery(pParse, pParent, parentTab, *pParentAgg, isAgg) ){ + flattenSubquery(pParent, parentTab, *pParentAgg, isAgg) ){ if( isAgg ) *pParentAgg = 1; - return rc; + goto select_end; + } +#endif + + /* If there is an ORDER BY clause, resolve any collation sequences + ** names that have been explicitly specified and create a sorting index. + ** + ** This sorting index might end up being unused if the data can be + ** extracted in pre-sorted order. If that is the case, then the + ** OP_OpenVirtual instruction will be changed to an OP_Noop once + ** we figure out that the sorting index is not needed. The addrSortIndex + ** variable is used to facilitate that change. + */ + if( pOrderBy ){ + struct ExprList_item *pTerm; + KeyInfo *pKeyInfo; + for(i=0, pTerm=pOrderBy->a; inExpr; i++, pTerm++){ + if( pTerm->zName ){ + pTerm->pExpr->pColl = sqlite3LocateCollSeq(pParse, pTerm->zName, -1); + } + } + if( pParse->nErr ){ + goto select_end; + } + pKeyInfo = keyInfoFromExprList(pParse, pOrderBy); + pOrderBy->iECursor = pParse->nTab++; + p->addrOpenVirt[2] = addrSortIndex = + sqlite3VdbeOp3(v, OP_OpenVirtual, pOrderBy->iECursor, pOrderBy->nExpr+2, + (char*)pKeyInfo, P3_KEYINFO_HANDOFF); + }else{ + addrSortIndex = -1; } /* 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); - } + iEnd = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, iEnd); /* If the output is destined for a temporary table, open that table. */ - if( eDest==SRT_TempTable ){ - sqliteVdbeAddOp(v, OP_OpenTemp, iParm, 0); + if( eDest==SRT_VirtualTab ){ + sqlite3VdbeAddOp(v, OP_OpenVirtual, iParm, pEList->nExpr); } - /* 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. + /* Open a virtual index to use for the distinct set. */ if( isDistinct ){ + KeyInfo *pKeyInfo; distinct = pParse->nTab++; - sqliteVdbeAddOp(v, OP_OpenTemp, distinct, 1); + pKeyInfo = keyInfoFromExprList(pParse, p->pEList); + sqlite3VdbeOp3(v, OP_OpenVirtual, distinct, 0, + (char*)pKeyInfo, P3_KEYINFO_HANDOFF); }else{ distinct = -1; } - /* Begin the database scan - */ - pWInfo = sqliteWhereBegin(pParse, pTabList, pWhere, 0, - pGroupBy ? 0 : &pOrderBy); - if( pWInfo==0 ) goto select_end; + /* Aggregate and non-aggregate queries are handled differently */ + if( !isAgg && pGroupBy==0 ){ + /* This case is for non-aggregate queries + ** Begin the database scan + */ + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy); + if( pWInfo==0 ) goto select_end; - /* Use the standard inner loop if we are not dealing with - ** aggregates - */ - if( !isAgg ){ + /* If sorting index that was created by a prior OP_OpenVirtual + ** instruction ended up not being needed, then change the OP_OpenVirtual + ** into an OP_Noop. + */ + if( addrSortIndex>=0 && pOrderBy==0 ){ + sqlite3VdbeChangeToNoop(v, addrSortIndex, 1); + p->addrOpenVirt[2] = -1; + } + + /* Use the standard inner loop + */ if( selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, distinct, eDest, - iParm, pWInfo->iContinue, pWInfo->iBreak) ){ + iParm, pWInfo->iContinue, pWInfo->iBreak, aff) ){ 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. + */ + sqlite3WhereEnd(pWInfo); + }else{ + /* This is the processing for aggregate queries */ + NameContext sNC; /* Name context for processing aggregate information */ + int iAMem; /* First Mem address for storing current GROUP BY */ + int iBMem; /* First Mem address for previous GROUP BY */ + int iUseFlag; /* Mem address holding flag indicating that at least + ** one row of the input to the aggregator has been + ** processed */ + int iAbortFlag; /* Mem address which causes query abort if positive */ + int groupBySort; /* Rows come from source in GROUP BY order */ - /* 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) ){ + /* The following variables hold addresses or labels for parts of the + ** virtual machine program we are putting together */ + int addrOutputRow; /* Start of subroutine that outputs a result row */ + int addrSetAbort; /* Set the abort flag and return */ + int addrInitializeLoop; /* Start of code that initializes the input loop */ + int addrTopOfLoop; /* Top of the input loop */ + int addrGroupByChange; /* Code that runs when any GROUP BY term changes */ + int addrProcessRow; /* Code to process a single input row */ + int addrEnd; /* End of all processing */ + int addrSortingIdx; /* The OP_OpenVirtual for the sorting index */ + int addrReset; /* Subroutine for resetting the accumulator */ + + addrEnd = sqlite3VdbeMakeLabel(v); + + /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in + ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the + ** SELECT statement. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + sNC.pAggInfo = &sAggInfo; + sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0; + sAggInfo.pGroupBy = pGroupBy; + if( sqlite3ExprAnalyzeAggList(&sNC, pEList) ){ goto select_end; } - sqliteVdbeAddOp(v, OP_Goto, 0, startagg); - sqliteVdbeResolveLabel(v, endagg); - sqliteVdbeAddOp(v, OP_Noop, 0, 0); - pParse->useAgg = 0; - } + if( sqlite3ExprAnalyzeAggList(&sNC, pOrderBy) ){ + goto select_end; + } + if( pHaving && sqlite3ExprAnalyzeAggregates(&sNC, pHaving) ){ + goto select_end; + } + sAggInfo.nAccumulator = sAggInfo.nColumn; + for(i=0; ipList) ){ + goto select_end; + } + } + if( sqlite3MallocFailed() ) goto select_end; + + /* Processing for aggregates with GROUP BY is very different and + ** much more complex tha aggregates without a GROUP BY. + */ + if( pGroupBy ){ + KeyInfo *pKeyInfo; /* Keying information for the group by clause */ + + /* Create labels that we will be needing + */ + + addrInitializeLoop = sqlite3VdbeMakeLabel(v); + addrGroupByChange = sqlite3VdbeMakeLabel(v); + addrProcessRow = sqlite3VdbeMakeLabel(v); + + /* If there is a GROUP BY clause we might need a sorting index to + ** implement it. Allocate that sorting index now. If it turns out + ** that we do not need it after all, the OpenVirtual instruction + ** will be converted into a Noop. + */ + sAggInfo.sortingIdx = pParse->nTab++; + pKeyInfo = keyInfoFromExprList(pParse, pGroupBy); + addrSortingIdx = + sqlite3VdbeOp3(v, OP_OpenVirtual, sAggInfo.sortingIdx, + sAggInfo.nSortingColumn, + (char*)pKeyInfo, P3_KEYINFO_HANDOFF); + + /* Initialize memory locations used by GROUP BY aggregate processing + */ + iUseFlag = pParse->nMem++; + iAbortFlag = pParse->nMem++; + iAMem = pParse->nMem; + pParse->nMem += pGroupBy->nExpr; + iBMem = pParse->nMem; + pParse->nMem += pGroupBy->nExpr; + sqlite3VdbeAddOp(v, OP_MemInt, 0, iAbortFlag); + VdbeComment((v, "# clear abort flag")); + sqlite3VdbeAddOp(v, OP_MemInt, 0, iUseFlag); + VdbeComment((v, "# indicate accumulator empty")); + sqlite3VdbeAddOp(v, OP_Goto, 0, addrInitializeLoop); + + /* Generate a subroutine that outputs a single row of the result + ** set. This subroutine first looks at the iUseFlag. If iUseFlag + ** is less than or equal to zero, the subroutine is a no-op. If + ** the processing calls for the query to abort, this subroutine + ** increments the iAbortFlag memory location before returning in + ** order to signal the caller to abort. + */ + addrSetAbort = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp(v, OP_MemInt, 1, iAbortFlag); + VdbeComment((v, "# set abort flag")); + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + addrOutputRow = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp(v, OP_IfMemPos, iUseFlag, addrOutputRow+2); + VdbeComment((v, "# Groupby result generator entry point")); + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + finalizeAggFunctions(pParse, &sAggInfo); + if( pHaving ){ + sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, 1); + } + rc = selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy, + distinct, eDest, iParm, + addrOutputRow+1, addrSetAbort, aff); + if( rc ){ + goto select_end; + } + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + VdbeComment((v, "# end groupby result generator")); + + /* Generate a subroutine that will reset the group-by accumulator + */ + addrReset = sqlite3VdbeCurrentAddr(v); + resetAccumulator(pParse, &sAggInfo); + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + + /* Begin a loop that will extract all source rows in GROUP BY order. + ** This might involve two separate loops with an OP_Sort in between, or + ** it might be a single loop that uses an index to extract information + ** in the right order to begin with. + */ + sqlite3VdbeResolveLabel(v, addrInitializeLoop); + sqlite3VdbeAddOp(v, OP_Gosub, 0, addrReset); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pGroupBy); + if( pWInfo==0 ) goto select_end; + if( pGroupBy==0 ){ + /* The optimizer is able to deliver rows in group by order so + ** we do not have to sort. The OP_OpenVirtual table will be + ** cancelled later because we still need to use the pKeyInfo + */ + pGroupBy = p->pGroupBy; + groupBySort = 0; + }else{ + /* Rows are coming out in undetermined order. We have to push + ** each row into a sorting index, terminate the first loop, + ** then loop over the sorting index in order to get the output + ** in sorted order + */ + groupBySort = 1; + sqlite3ExprCodeExprList(pParse, pGroupBy); + sqlite3VdbeAddOp(v, OP_Sequence, sAggInfo.sortingIdx, 0); + j = pGroupBy->nExpr+1; + for(i=0; iiSorterColumniColumn<0 ){ + sqlite3VdbeAddOp(v, OP_Rowid, pCol->iTable, 0); + }else{ + sqlite3VdbeAddOp(v, OP_Column, pCol->iTable, pCol->iColumn); + } + j++; + } + sqlite3VdbeAddOp(v, OP_MakeRecord, j, 0); + sqlite3VdbeAddOp(v, OP_IdxInsert, sAggInfo.sortingIdx, 0); + sqlite3WhereEnd(pWInfo); + sqlite3VdbeAddOp(v, OP_Sort, sAggInfo.sortingIdx, addrEnd); + VdbeComment((v, "# GROUP BY sort")); + sAggInfo.useSortingIdx = 1; + } + + /* Evaluate the current GROUP BY terms and store in b0, b1, b2... + ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth) + ** Then compare the current GROUP BY terms against the GROUP BY terms + ** from the previous row currently stored in a0, a1, a2... + */ + addrTopOfLoop = sqlite3VdbeCurrentAddr(v); + for(j=0; jnExpr; j++){ + if( groupBySort ){ + sqlite3VdbeAddOp(v, OP_Column, sAggInfo.sortingIdx, j); + }else{ + sAggInfo.directMode = 1; + sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr); + } + sqlite3VdbeAddOp(v, OP_MemStore, iBMem+j, jnExpr-1); + } + for(j=pGroupBy->nExpr-1; j>=0; j--){ + if( jnExpr-1 ){ + sqlite3VdbeAddOp(v, OP_MemLoad, iBMem+j, 0); + } + sqlite3VdbeAddOp(v, OP_MemLoad, iAMem+j, 0); + if( j==0 ){ + sqlite3VdbeAddOp(v, OP_Eq, 0x200, addrProcessRow); + }else{ + sqlite3VdbeAddOp(v, OP_Ne, 0x200, addrGroupByChange); + } + sqlite3VdbeChangeP3(v, -1, (void*)pKeyInfo->aColl[j], P3_COLLSEQ); + } + + /* Generate code that runs whenever the GROUP BY changes. + ** Change in the GROUP BY are detected by the previous code + ** block. If there were no changes, this block is skipped. + ** + ** This code copies current group by terms in b0,b1,b2,... + ** over to a0,a1,a2. It then calls the output subroutine + ** and resets the aggregate accumulator registers in preparation + ** for the next GROUP BY batch. + */ + sqlite3VdbeResolveLabel(v, addrGroupByChange); + for(j=0; jnExpr; j++){ + sqlite3VdbeAddOp(v, OP_MemMove, iAMem+j, iBMem+j); + } + sqlite3VdbeAddOp(v, OP_Gosub, 0, addrOutputRow); + VdbeComment((v, "# output one row")); + sqlite3VdbeAddOp(v, OP_IfMemPos, iAbortFlag, addrEnd); + VdbeComment((v, "# check abort flag")); + sqlite3VdbeAddOp(v, OP_Gosub, 0, addrReset); + VdbeComment((v, "# reset accumulator")); + + /* Update the aggregate accumulators based on the content of + ** the current row + */ + sqlite3VdbeResolveLabel(v, addrProcessRow); + updateAccumulator(pParse, &sAggInfo); + sqlite3VdbeAddOp(v, OP_MemInt, 1, iUseFlag); + VdbeComment((v, "# indicate data in accumulator")); + + /* End of the loop + */ + if( groupBySort ){ + sqlite3VdbeAddOp(v, OP_Next, sAggInfo.sortingIdx, addrTopOfLoop); + }else{ + sqlite3WhereEnd(pWInfo); + sqlite3VdbeChangeToNoop(v, addrSortingIdx, 1); + } + + /* Output the final row of result + */ + sqlite3VdbeAddOp(v, OP_Gosub, 0, addrOutputRow); + VdbeComment((v, "# output final row")); + + } /* endif pGroupBy */ + else { + /* This case runs if the aggregate has no GROUP BY clause. The + ** processing is much simpler since there is only a single row + ** of output. + */ + resetAccumulator(pParse, &sAggInfo); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0); + if( pWInfo==0 ) goto select_end; + updateAccumulator(pParse, &sAggInfo); + sqlite3WhereEnd(pWInfo); + finalizeAggFunctions(pParse, &sAggInfo); + pOrderBy = 0; + if( pHaving ){ + sqlite3ExprIfFalse(pParse, pHaving, addrEnd, 1); + } + selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1, + eDest, iParm, addrEnd, addrEnd, aff); + } + sqlite3VdbeResolveLabel(v, addrEnd); + + } /* endif aggregate query */ /* 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); + generateSortTail(pParse, p, v, pEList->nExpr, eDest, iParm); } +#ifndef SQLITE_OMIT_SUBQUERY /* 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. + ** temporary table. So set the SrcList_item.isPopulated flag to prevent + ** this subquery from being evaluated again and to force 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; + pParent->pSrc->a[parentTab].isPopulated = 1; } +#endif + + /* Jump here to skip this query + */ + sqlite3VdbeResolveLabel(v, iEnd); /* The SELECT was successfully coded. Set the return code to 0 ** to indicate no errors. @@ -2399,6 +3282,15 @@ int sqliteSelect( ** successful coding of the SELECT. */ select_end: - sqliteAggregateInfoReset(pParse); + + /* 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( rc==SQLITE_OK && eDest==SRT_Callback ){ + generateColumnNames(pParse, pTabList, pEList); + } + + sqliteFree(sAggInfo.aCol); + sqliteFree(sAggInfo.aFunc); return rc; } diff --git a/sqlite/shell.c b/sqlite/shell.c index 84f262bf2..dc9a4d5e7 100755 --- a/sqlite/shell.c +++ b/sqlite/shell.c @@ -12,12 +12,13 @@ ** This file contains code to implement the "sqlite" command line ** utility for accessing SQLite databases. ** -** $Id: shell.c,v 1.1.1.1 2004-03-11 22:22:22 alex Exp $ +** $Id: shell.c,v 1.2 2006-04-13 12:44:29 guy Exp $ */ #include #include #include -#include "sqlite.h" +#include +#include "sqlite3.h" #include #if !defined(_WIN32) && !defined(WIN32) && !defined(__MACOS__) @@ -56,12 +57,12 @@ extern int isatty(); ** to this database a static variable so that it can be accessed ** by the SIGINT handler to interrupt database processing. */ -static sqlite *db = 0; +static sqlite3 *db = 0; /* ** True if an interrupt (Control-C) has been received. */ -static int seenInterrupt = 0; +static volatile int seenInterrupt = 0; /* ** This is the name of our program. It is set in main(), used @@ -80,10 +81,52 @@ static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */ /* ** Determines if a string is a number of not. */ -extern int sqliteIsNumber(const char*); +static int isNumber(const char *z, int *realnum){ + if( *z=='-' || *z=='+' ) z++; + if( !isdigit(*z) ){ + return 0; + } + z++; + if( realnum ) *realnum = 0; + while( isdigit(*z) ){ z++; } + if( *z=='.' ){ + z++; + if( !isdigit(*z) ) return 0; + while( isdigit(*z) ){ z++; } + if( realnum ) *realnum = 1; + } + if( *z=='e' || *z=='E' ){ + z++; + if( *z=='+' || *z=='-' ) z++; + if( !isdigit(*z) ) return 0; + while( isdigit(*z) ){ z++; } + if( realnum ) *realnum = 1; + } + return *z==0; +} /* -** This routine reads a line of text from standard input, stores +** A global char* and an SQL function to access its current value +** from within an SQL statement. This program used to use the +** sqlite_exec_printf() API to substitue a string into an SQL statement. +** The correct way to do this with sqlite3 is to use the bind API, but +** since the shell is built around the callback paradigm it would be a lot +** of work. Instead just use this hack, which is quite harmless. +*/ +static const char *zShellStatic = 0; +static void shellstaticFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + assert( 0==argc ); + assert( zShellStatic ); + sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC); +} + + +/* +** This routine reads a line of text from FILE in, stores ** the text in memory obtained from malloc() and returns a pointer ** to the text. NULL is returned at end of file, or if malloc() ** fails. @@ -153,7 +196,9 @@ static char *one_input_line(const char *zPrior, FILE *in){ zPrompt = mainPrompt; } zResult = readline(zPrompt); +#if defined(HAVE_READLINE) && HAVE_READLINE==1 if( zResult ) add_history(zResult); +#endif return zResult; } @@ -169,7 +214,7 @@ struct previous_mode_data { ** state and mode information. */ struct callback_data { - sqlite *db; /* The database */ + sqlite3 *db; /* The database */ int echoOn; /* True to echo input commands */ int cnt; /* Number of records displayed so far */ FILE *out; /* Write results here */ @@ -198,15 +243,19 @@ struct callback_data { #define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */ #define MODE_Html 4 /* Generate an XHTML table */ #define MODE_Insert 5 /* Generate SQL "insert" statements */ -#define MODE_NUM_OF 6 /* The number of modes (not a mode itself) */ +#define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */ +#define MODE_Csv 7 /* Quote strings, numbers are plain */ +#define MODE_NUM_OF 8 /* The number of modes (not a mode itself) */ -char *modeDescr[MODE_NUM_OF] = { +static const char *modeDescr[MODE_NUM_OF] = { "line", "column", "list", "semi", "html", - "insert" + "insert", + "tcl", + "csv", }; /* @@ -244,6 +293,34 @@ static void output_quoted_string(FILE *out, const char *z){ } } +/* +** Output the given string as a quoted according to C or TCL quoting rules. +*/ +static void output_c_string(FILE *out, const char *z){ + unsigned int c; + fputc('"', out); + while( (c = *(z++))!=0 ){ + if( c=='\\' ){ + fputc(c, out); + fputc(c, out); + }else if( c=='\t' ){ + fputc('\\', out); + fputc('t', out); + }else if( c=='\n' ){ + fputc('\\', out); + fputc('n', out); + }else if( c=='\r' ){ + fputc('\\', out); + fputc('r', out); + }else if( !isprint(c) ){ + fprintf(out, "\\%03o", c&0xff); + }else{ + fputc(c, out); + } + } + fputc('"', out); +} + /* ** Output the given string with characters that are special to ** HTML escaped. @@ -266,13 +343,34 @@ static void output_html_string(FILE *out, const char *z){ } } +/* +** Output a single term of CSV. Actually, p->separator is used for +** the separator, which may or may not be a comma. p->nullvalue is +** the null value. Strings are quoted using ANSI-C rules. Numbers +** appear outside of quotes. +*/ +static void output_csv(struct callback_data *p, const char *z, int bSep){ + if( z==0 ){ + fprintf(p->out,"%s",p->nullvalue); + }else if( isNumber(z, 0) ){ + fprintf(p->out,"%s",z); + }else{ + output_c_string(p->out, z); + } + if( bSep ){ + fprintf(p->out, p->separator); + } +} + +#ifdef SIGINT /* ** This routine runs when the user presses Ctrl-C */ static void interrupt_handler(int NotUsed){ seenInterrupt = 1; - if( db ) sqlite_interrupt(db); + if( db ) sqlite3_interrupt(db); } +#endif /* ** This is the callback routine that the SQLite library @@ -385,6 +483,36 @@ static int callback(void *pArg, int nArg, char **azArg, char **azCol){ fprintf(p->out,"\n"); break; } + case MODE_Tcl: { + if( p->cnt++==0 && p->showHeader ){ + for(i=0; iout,azCol[i]); + fprintf(p->out, "%s", p->separator); + } + fprintf(p->out,"\n"); + } + if( azArg==0 ) break; + for(i=0; iout, azArg[i] ? azArg[i] : p->nullvalue); + fprintf(p->out, "%s", p->separator); + } + fprintf(p->out,"\n"); + break; + } + case MODE_Csv: { + if( p->cnt++==0 && p->showHeader ){ + for(i=0; iout,"\n"); + } + if( azArg==0 ) break; + for(i=0; iout,"\n"); + break; + } case MODE_Insert: { if( azArg==0 ) break; fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable); @@ -392,7 +520,7 @@ static int callback(void *pArg, int nArg, char **azArg, char **azCol){ char *zSep = i>0 ? ",": ""; if( azArg[i]==0 ){ fprintf(p->out,"%sNULL",zSep); - }else if( sqliteIsNumber(azArg[i]) ){ + }else if( isNumber(azArg[i], 0) ){ fprintf(p->out,"%s%s",zSep, azArg[i]); }else{ if( zSep[0] ) fprintf(p->out,"%s",zSep); @@ -421,9 +549,9 @@ static void set_table_name(struct callback_data *p, const char *zName){ p->zDestTable = 0; } if( zName==0 ) return; - needQuote = !isalpha(*zName) && *zName!='_'; + needQuote = !isalpha((unsigned char)*zName) && *zName!='_'; for(i=n=0; zName[i]; i++, n++){ - if( !isalnum(zName[i]) && zName[i]!='_' ){ + if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){ needQuote = 1; if( zName[i]=='\'' ) n++; } @@ -444,6 +572,72 @@ static void set_table_name(struct callback_data *p, const char *zName){ z[n] = 0; } +/* zIn is either a pointer to a NULL-terminated string in memory obtained +** from malloc(), or a NULL pointer. The string pointed to by zAppend is +** added to zIn, and the result returned in memory obtained from malloc(). +** zIn, if it was not NULL, is freed. +** +** If the third argument, quote, is not '\0', then it is used as a +** quote character for zAppend. +*/ +static char * appendText(char *zIn, char const *zAppend, char quote){ + int len; + int i; + int nAppend = strlen(zAppend); + int nIn = (zIn?strlen(zIn):0); + + len = nAppend+nIn+1; + if( quote ){ + len += 2; + for(i=0; iout, "%s;\n", azArg[2]); - if( strcmp(azArg[1],"table")==0 ){ - struct callback_data d2; - d2 = *p; - d2.mode = MODE_Insert; - d2.zDestTable = 0; - set_table_name(&d2, azArg[0]); - sqlite_exec_printf(p->db, - "SELECT * FROM '%q'", - callback, &d2, 0, azArg[0] - ); - set_table_name(&d2, 0); + zTable = azArg[0]; + zType = azArg[1]; + zSql = azArg[2]; + + if( strcmp(zTable, "sqlite_sequence")==0 ){ + fprintf(p->out, "DELETE FROM sqlite_sequence;\n"); + }else if( strcmp(zTable, "sqlite_stat1")==0 ){ + fprintf(p->out, "ANALYZE sqlite_master;\n"); + }else if( strncmp(zTable, "sqlite_", 7)==0 ){ + return 0; + }else{ + fprintf(p->out, "%s;\n", zSql); + } + + if( strcmp(zType, "table")==0 ){ + sqlite3_stmt *pTableInfo = 0; + char *zSelect = 0; + char *zTableInfo = 0; + char *zTmp = 0; + + zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0); + zTableInfo = appendText(zTableInfo, zTable, '"'); + zTableInfo = appendText(zTableInfo, ");", 0); + + rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0); + if( zTableInfo ) free(zTableInfo); + if( rc!=SQLITE_OK || !pTableInfo ){ + return 1; + } + + zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0); + zTmp = appendText(zTmp, zTable, '"'); + if( zTmp ){ + zSelect = appendText(zSelect, zTmp, '\''); + } + zSelect = appendText(zSelect, " || ' VALUES(' || ", 0); + rc = sqlite3_step(pTableInfo); + while( rc==SQLITE_ROW ){ + const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1); + zSelect = appendText(zSelect, "quote(", 0); + zSelect = appendText(zSelect, zText, '"'); + rc = sqlite3_step(pTableInfo); + if( rc==SQLITE_ROW ){ + zSelect = appendText(zSelect, ") || ', ' || ", 0); + }else{ + zSelect = appendText(zSelect, ") ", 0); + } + } + rc = sqlite3_finalize(pTableInfo); + if( rc!=SQLITE_OK ){ + if( zSelect ) free(zSelect); + return 1; + } + zSelect = appendText(zSelect, "|| ')' FROM ", 0); + zSelect = appendText(zSelect, zTable, '"'); + + rc = run_table_dump_query(p->out, p->db, zSelect); + if( rc==SQLITE_CORRUPT ){ + zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0); + rc = run_table_dump_query(p->out, p->db, zSelect); + } + if( zSelect ) free(zSelect); + if( rc!=SQLITE_OK ){ + return 1; + } } return 0; } +/* +** Run zQuery. Update dump_callback() as the callback routine. +** If we get a SQLITE_CORRUPT error, rerun the query after appending +** "ORDER BY rowid DESC" to the end. +*/ +static int run_schema_dump_query( + struct callback_data *p, + const char *zQuery, + char **pzErrMsg +){ + int rc; + rc = sqlite3_exec(p->db, zQuery, dump_callback, p, pzErrMsg); + if( rc==SQLITE_CORRUPT ){ + char *zQ2; + int len = strlen(zQuery); + if( pzErrMsg ) sqlite3_free(*pzErrMsg); + zQ2 = malloc( len+100 ); + if( zQ2==0 ) return rc; + sprintf(zQ2, "%s ORDER BY rowid DESC", zQuery); + rc = sqlite3_exec(p->db, zQ2, dump_callback, p, pzErrMsg); + free(zQ2); + } + return rc; +} + /* ** Text of a help message */ static char zHelp[] = ".databases List names and files of attached databases\n" - ".dump ?TABLE? ... Dump the database in a text format\n" + ".dump ?TABLE? ... Dump the database in an SQL text format\n" ".echo ON|OFF Turn command echo on or off\n" ".exit Exit this program\n" ".explain ON|OFF Turn output mode suitable for EXPLAIN on or off.\n" ".header(s) ON|OFF Turn display of headers on or off\n" ".help Show this message\n" + ".import FILE TABLE Import data from FILE into TABLE\n" ".indices TABLE Show names of all indices on TABLE\n" - ".mode MODE Set mode to one of \"line(s)\", \"column(s)\", \n" - " \"insert\", \"list\", or \"html\"\n" - ".mode insert TABLE Generate SQL insert statements for TABLE\n" - ".nullvalue STRING Print STRING instead of nothing for NULL data\n" + ".mode MODE ?TABLE? Set output mode where MODE is one of:\n" + " csv Comma-separated values\n" + " column Left-aligned columns. (See .width)\n" + " html HTML
code\n" + " insert SQL insert statements for TABLE\n" + " line One value per line\n" + " list Values delimited by .separator string\n" + " tabs Tab-separated values\n" + " tcl TCL list elements\n" + ".nullvalue STRING Print STRING in place of NULL values\n" ".output FILENAME Send output to FILENAME\n" ".output stdout Send output to the screen\n" ".prompt MAIN CONTINUE Replace the standard prompts\n" ".quit Exit this program\n" ".read FILENAME Execute SQL in FILENAME\n" -#ifdef SQLITE_HAS_CODEC - ".rekey OLD NEW NEW Change the encryption key\n" -#endif ".schema ?TABLE? Show the CREATE statements\n" - ".separator STRING Change separator string for \"list\" mode\n" + ".separator STRING Change separator used by output mode and .import\n" ".show Show the current values for various settings\n" - ".tables ?PATTERN? List names of tables matching a pattern\n" + ".tables ?PATTERN? List names of tables matching a LIKE pattern\n" ".timeout MS Try opening locked tables for MS milliseconds\n" ".width NUM NUM ... Set column widths for \"column\" mode\n" ; @@ -510,25 +791,55 @@ static void process_input(struct callback_data *p, FILE *in); */ static void open_db(struct callback_data *p){ if( p->db==0 ){ - char *zErrMsg = 0; -#ifdef SQLITE_HAS_CODEC - int n = p->zKey ? strlen(p->zKey) : 0; - db = p->db = sqlite_open_encrypted(p->zDbFilename, p->zKey, n, 0, &zErrMsg); -#else - db = p->db = sqlite_open(p->zDbFilename, 0, &zErrMsg); -#endif - if( p->db==0 ){ - if( zErrMsg ){ - fprintf(stderr,"Unable to open database \"%s\": %s\n", - p->zDbFilename, zErrMsg); - }else{ - fprintf(stderr,"Unable to open database %s\n", p->zDbFilename); - } + sqlite3_open(p->zDbFilename, &p->db); + db = p->db; + sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0, + shellstaticFunc, 0, 0); + if( SQLITE_OK!=sqlite3_errcode(db) ){ + fprintf(stderr,"Unable to open database \"%s\": %s\n", + p->zDbFilename, sqlite3_errmsg(db)); exit(1); } } } +/* +** Do C-language style dequoting. +** +** \t -> tab +** \n -> newline +** \r -> carriage return +** \NNN -> ascii character NNN in octal +** \\ -> backslash +*/ +static void resolve_backslashes(char *z){ + int i, j, c; + for(i=j=0; (c = z[i])!=0; i++, j++){ + if( c=='\\' ){ + c = z[++i]; + if( c=='n' ){ + c = '\n'; + }else if( c=='t' ){ + c = '\t'; + }else if( c=='r' ){ + c = '\r'; + }else if( c>='0' && c<='7' ){ + c -= '0'; + if( z[i+1]>='0' && z[i+1]<='7' ){ + i++; + c = (c<<3) + z[i] - '0'; + if( z[i+1]>='0' && z[i+1]<='7' ){ + i++; + c = (c<<3) + z[i] - '0'; + } + } + } + } + z[j] = c; + } + z[j] = 0; +} + /* ** If an input line begins with "." then invoke this routine to ** process that line. @@ -545,7 +856,8 @@ static int do_meta_command(char *zLine, struct callback_data *p){ /* Parse the input line into tokens. */ while( zLine[i] && nArgdb, "PRAGMA database_list; ", callback, &data, &zErrMsg); + data.colWidth[0] = 3; + data.colWidth[1] = 15; + data.colWidth[2] = 58; + data.cnt = 0; + sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg); if( zErrMsg ){ fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_free(zErrMsg); } }else @@ -584,26 +902,32 @@ static int do_meta_command(char *zLine, struct callback_data *p){ open_db(p); fprintf(p->out, "BEGIN TRANSACTION;\n"); if( nArg==1 ){ - sqlite_exec(p->db, + run_schema_dump_query(p, "SELECT name, type, sql FROM sqlite_master " - "WHERE type!='meta' AND sql NOT NULL " - "ORDER BY substr(type,2,1), name", - dump_callback, p, &zErrMsg + "WHERE sql NOT NULL AND type=='table'", 0 + ); + run_schema_dump_query(p, + "SELECT name, type, sql FROM sqlite_master " + "WHERE sql NOT NULL AND type!='table' AND type!='meta'", 0 ); }else{ int i; - for(i=1; idb, + for(i=1; iout, "COMMIT;\n"); } @@ -614,7 +938,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ char *z = azArg[1]; int val = atoi(azArg[1]); for(j=0; z[j]; j++){ - if( isupper(z[j]) ) z[j] = tolower(z[j]); + z[j] = tolower((unsigned char)z[j]); } if( strcmp(z,"on")==0 ){ val = 1; @@ -630,10 +954,11 @@ static int do_meta_command(char *zLine, struct callback_data *p){ if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){ int j; - char *z = nArg>=2 ? azArg[1] : "1"; + static char zOne[] = "1"; + char *z = nArg>=2 ? azArg[1] : zOne; int val = atoi(z); for(j=0; z[j]; j++){ - if( isupper(z[j]) ) z[j] = tolower(z[j]); + z[j] = tolower((unsigned char)z[j]); } if( strcmp(z,"on")==0 ){ val = 1; @@ -658,10 +983,10 @@ static int do_meta_command(char *zLine, struct callback_data *p){ p->showHeader = 1; memset(p->colWidth,0,ArraySize(p->colWidth)); p->colWidth[0] = 4; - p->colWidth[1] = 12; + p->colWidth[1] = 14; p->colWidth[2] = 10; p->colWidth[3] = 10; - p->colWidth[4] = 35; + p->colWidth[4] = 33; }else if (p->explainPrev.valid) { p->explainPrev.valid = 0; p->mode = p->explainPrev.mode; @@ -677,7 +1002,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ char *z = azArg[1]; int val = atoi(azArg[1]); for(j=0; z[j]; j++){ - if( isupper(z[j]) ) z[j] = tolower(z[j]); + z[j] = tolower((unsigned char)z[j]); } if( strcmp(z,"on")==0 ){ val = 1; @@ -691,6 +1016,110 @@ static int do_meta_command(char *zLine, struct callback_data *p){ fprintf(stderr,zHelp); }else + if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg>=3 ){ + char *zTable = azArg[2]; /* Insert data into this table */ + char *zFile = azArg[1]; /* The file from which to extract data */ + sqlite3_stmt *pStmt; /* A statement */ + int rc; /* Result code */ + int nCol; /* Number of columns in the table */ + int nByte; /* Number of bytes in an SQL string */ + int i, j; /* Loop counters */ + int nSep; /* Number of bytes in p->separator[] */ + char *zSql; /* An SQL statement */ + char *zLine; /* A single line of input from the file */ + char **azCol; /* zLine[] broken up into columns */ + char *zCommit; /* How to commit changes */ + FILE *in; /* The input file */ + int lineno = 0; /* Line number of input file */ + + nSep = strlen(p->separator); + if( nSep==0 ){ + fprintf(stderr, "non-null separator required for import\n"); + return 0; + } + zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable); + if( zSql==0 ) return 0; + nByte = strlen(zSql); + rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + if( rc ){ + fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db)); + nCol = 0; + }else{ + nCol = sqlite3_column_count(pStmt); + } + sqlite3_finalize(pStmt); + if( nCol==0 ) return 0; + zSql = malloc( nByte + 20 + nCol*2 ); + if( zSql==0 ) return 0; + sqlite3_snprintf(nByte+20, zSql, "INSERT INTO '%q' VALUES(?", zTable); + j = strlen(zSql); + for(i=1; idb, zSql, -1, &pStmt, 0); + free(zSql); + if( rc ){ + fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db)); + sqlite3_finalize(pStmt); + return 0; + } + in = fopen(zFile, "rb"); + if( in==0 ){ + fprintf(stderr, "cannot open file: %s\n", zFile); + sqlite3_finalize(pStmt); + return 0; + } + azCol = malloc( sizeof(azCol[0])*(nCol+1) ); + if( azCol==0 ){ + fclose(in); + return 0; + } + sqlite3_exec(p->db, "BEGIN", 0, 0, 0); + zCommit = "COMMIT"; + while( (zLine = local_getline(0, in))!=0 ){ + char *z; + i = 0; + lineno++; + azCol[0] = zLine; + for(i=0, z=zLine; *z && *z!='\n' && *z!='\r'; z++){ + if( *z==p->separator[0] && strncmp(z, p->separator, nSep)==0 ){ + *z = 0; + i++; + if( idb, zCommit, 0, 0, 0); + }else + if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg>1 ){ struct callback_data data; char *zErrMsg = 0; @@ -698,18 +1127,20 @@ static int do_meta_command(char *zLine, struct callback_data *p){ memcpy(&data, p, sizeof(data)); data.showHeader = 0; data.mode = MODE_List; - sqlite_exec_printf(p->db, + zShellStatic = azArg[1]; + sqlite3_exec(p->db, "SELECT name FROM sqlite_master " - "WHERE type='index' AND tbl_name LIKE '%q' " + "WHERE type='index' AND tbl_name LIKE shellstatic() " "UNION ALL " "SELECT name FROM sqlite_temp_master " - "WHERE type='index' AND tbl_name LIKE '%q' " + "WHERE type='index' AND tbl_name LIKE shellstatic() " "ORDER BY 1", - callback, &data, &zErrMsg, azArg[1], azArg[1] + callback, &data, &zErrMsg ); + zShellStatic = 0; if( zErrMsg ){ fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_free(zErrMsg); } }else @@ -727,6 +1158,14 @@ static int do_meta_command(char *zLine, struct callback_data *p){ p->mode = MODE_List; }else if( strncmp(azArg[1],"html",n2)==0 ){ p->mode = MODE_Html; + }else if( strncmp(azArg[1],"tcl",n2)==0 ){ + p->mode = MODE_Tcl; + }else if( strncmp(azArg[1],"csv",n2)==0 ){ + p->mode = MODE_Csv; + strcpy(p->separator, ","); + }else if( strncmp(azArg[1],"tabs",n2)==0 ){ + p->mode = MODE_List; + strcpy(p->separator, "\t"); }else if( strncmp(azArg[1],"insert",n2)==0 ){ p->mode = MODE_Insert; if( nArg>=3 ){ @@ -735,7 +1174,8 @@ static int do_meta_command(char *zLine, struct callback_data *p){ set_table_name(p, "table"); } }else { - fprintf(stderr,"mode should be on of: column html insert line list\n"); + fprintf(stderr,"mode should be on of: " + "column csv html insert line list tabs tcl\n"); } }else @@ -784,22 +1224,6 @@ static int do_meta_command(char *zLine, struct callback_data *p){ } }else -#ifdef SQLITE_HAS_CODEC - if( c=='r' && strncmp(azArg[0],"rekey", n)==0 && nArg==4 ){ - char *zOld = p->zKey; - if( zOld==0 ) zOld = ""; - if( strcmp(azArg[1],zOld) ){ - fprintf(stderr,"old key is incorrect\n"); - }else if( strcmp(azArg[2], azArg[3]) ){ - fprintf(stderr,"2nd copy of new key does not match the 1st\n"); - }else{ - sqlite_freemem(p->zKey); - p->zKey = sqlite_mprintf("%s", azArg[2]); - sqlite_rekey(p->db, p->zKey, strlen(p->zKey)); - } - }else -#endif - if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){ struct callback_data data; char *zErrMsg = 0; @@ -808,8 +1232,9 @@ static int do_meta_command(char *zLine, struct callback_data *p){ data.showHeader = 0; data.mode = MODE_Semi; if( nArg>1 ){ - extern int sqliteStrICmp(const char*,const char*); - if( sqliteStrICmp(azArg[1],"sqlite_master")==0 ){ + int i; + for(i=0; azArg[1][i]; i++) azArg[1][i] = tolower(azArg[1][i]); + if( strcmp(azArg[1],"sqlite_master")==0 ){ char *new_argv[2], *new_colv[2]; new_argv[0] = "CREATE TABLE sqlite_master (\n" " type text,\n" @@ -822,7 +1247,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ new_colv[0] = "sql"; new_colv[1] = 0; callback(&data, 1, new_argv, new_colv); - }else if( sqliteStrICmp(azArg[1],"sqlite_temp_master")==0 ){ + }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){ char *new_argv[2], *new_colv[2]; new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n" " type text,\n" @@ -836,27 +1261,29 @@ static int do_meta_command(char *zLine, struct callback_data *p){ new_colv[1] = 0; callback(&data, 1, new_argv, new_colv); }else{ - sqlite_exec_printf(p->db, + zShellStatic = azArg[1]; + sqlite3_exec(p->db, "SELECT sql FROM " " (SELECT * FROM sqlite_master UNION ALL" " SELECT * FROM sqlite_temp_master) " - "WHERE tbl_name LIKE '%q' AND type!='meta' AND sql NOTNULL " + "WHERE tbl_name LIKE shellstatic() AND type!='meta' AND sql NOTNULL " "ORDER BY substr(type,2,1), name", - callback, &data, &zErrMsg, azArg[1]); + callback, &data, &zErrMsg); + zShellStatic = 0; } }else{ - sqlite_exec(p->db, + sqlite3_exec(p->db, "SELECT sql FROM " " (SELECT * FROM sqlite_master UNION ALL" " SELECT * FROM sqlite_temp_master) " - "WHERE type!='meta' AND sql NOTNULL " + "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'" "ORDER BY substr(type,2,1), name", callback, &data, &zErrMsg ); } if( zErrMsg ){ fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_free(zErrMsg); } }else @@ -870,15 +1297,19 @@ static int do_meta_command(char *zLine, struct callback_data *p){ fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off"); fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off"); fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]); - fprintf(p->out,"%9.9s: %s\n","nullvalue", p->nullvalue); + fprintf(p->out,"%9.9s: ", "nullvalue"); + output_c_string(p->out, p->nullvalue); + fprintf(p->out, "\n"); fprintf(p->out,"%9.9s: %s\n","output", strlen(p->outfile) ? p->outfile : "stdout"); - fprintf(p->out,"%9.9s: %s\n","separator", p->separator); + fprintf(p->out,"%9.9s: ", "separator"); + output_c_string(p->out, p->separator); + fprintf(p->out, "\n"); fprintf(p->out,"%9.9s: ","width"); for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) { - fprintf(p->out,"%d ",p->colWidth[i]); + fprintf(p->out,"%d ",p->colWidth[i]); } - fprintf(p->out,"\n\n"); + fprintf(p->out,"\n"); }else if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){ @@ -887,9 +1318,9 @@ static int do_meta_command(char *zLine, struct callback_data *p){ char *zErrMsg; open_db(p); if( nArg==1 ){ - rc = sqlite_get_table(p->db, + rc = sqlite3_get_table(p->db, "SELECT name FROM sqlite_master " - "WHERE type IN ('table','view') " + "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%'" "UNION ALL " "SELECT name FROM sqlite_temp_master " "WHERE type IN ('table','view') " @@ -897,19 +1328,21 @@ static int do_meta_command(char *zLine, struct callback_data *p){ &azResult, &nRow, 0, &zErrMsg ); }else{ - rc = sqlite_get_table_printf(p->db, + zShellStatic = azArg[1]; + rc = sqlite3_get_table(p->db, "SELECT name FROM sqlite_master " - "WHERE type IN ('table','view') AND name LIKE '%%%q%%' " + "WHERE type IN ('table','view') AND name LIKE '%'||shellstatic()||'%' " "UNION ALL " "SELECT name FROM sqlite_temp_master " - "WHERE type IN ('table','view') AND name LIKE '%%%q%%' " + "WHERE type IN ('table','view') AND name LIKE '%'||shellstatic()||'%' " "ORDER BY 1", - &azResult, &nRow, 0, &zErrMsg, azArg[1], azArg[1] + &azResult, &nRow, 0, &zErrMsg ); + zShellStatic = 0; } if( zErrMsg ){ fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_free(zErrMsg); } if( rc==SQLITE_OK ){ int len, maxlen = 0; @@ -931,16 +1364,17 @@ static int do_meta_command(char *zLine, struct callback_data *p){ printf("\n"); } } - sqlite_free_table(azResult); + sqlite3_free_table(azResult); }else if( c=='t' && n>1 && strncmp(azArg[0], "timeout", n)==0 && nArg>=2 ){ open_db(p); - sqlite_busy_timeout(p->db, atoi(azArg[1])); + sqlite3_busy_timeout(p->db, atoi(azArg[1])); }else if( c=='w' && strncmp(azArg[0], "width", n)==0 ){ int j; + assert( nArg<=ArraySize(azArg) ); for(j=1; jcolWidth); j++){ p->colWidth[j-1] = atoi(azArg[j]); } @@ -959,7 +1393,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){ ** z[] is N characters long. */ static int _ends_with_semicolon(const char *z, int N){ - while( N>0 && isspace(z[N-1]) ){ N--; } + while( N>0 && isspace((unsigned char)z[N-1]) ){ N--; } return N>0 && z[N-1]==';'; } @@ -968,7 +1402,7 @@ static int _ends_with_semicolon(const char *z, int N){ */ static int _all_whitespace(const char *z){ for(; *z; z++){ - if( isspace(*z) ) continue; + if( isspace(*(unsigned char*)z) ) continue; if( *z=='/' && z[1]=='*' ){ z += 2; while( *z && (*z!='*' || z[1]!='/') ){ z++; } @@ -993,10 +1427,10 @@ static int _all_whitespace(const char *z){ ** as is the Oracle "/". */ static int _is_command_terminator(const char *zLine){ - extern int sqliteStrNICmp(const char*,const char*,int); - while( isspace(*zLine) ){ zLine++; }; + while( isspace(*(unsigned char*)zLine) ){ zLine++; }; if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ) return 1; /* Oracle */ - if( sqliteStrNICmp(zLine,"go",2)==0 && _all_whitespace(&zLine[2]) ){ + if( tolower(zLine[0])=='g' && tolower(zLine[1])=='o' + && _all_whitespace(&zLine[2]) ){ return 1; /* SQL Server */ } return 0; @@ -1033,7 +1467,7 @@ static void process_input(struct callback_data *p, FILE *in){ } if( zSql==0 ){ int i; - for(i=0; zLine[i] && isspace(zLine[i]); i++){} + for(i=0; zLine[i] && isspace((unsigned char)zLine[i]); i++){} if( zLine[i]!=0 ){ nSql = strlen(zLine); zSql = malloc( nSql+1 ); @@ -1051,18 +1485,18 @@ static void process_input(struct callback_data *p, FILE *in){ nSql += len; } free(zLine); - if( zSql && _ends_with_semicolon(zSql, nSql) && sqlite_complete(zSql) ){ + if( zSql && _ends_with_semicolon(zSql, nSql) && sqlite3_complete(zSql) ){ p->cnt = 0; open_db(p); - rc = sqlite_exec(p->db, zSql, callback, p, &zErrMsg); + rc = sqlite3_exec(p->db, zSql, callback, p, &zErrMsg); if( rc || zErrMsg ){ - if( in!=0 && !p->echoOn ) printf("%s\n",zSql); + /* if( in!=0 && !p->echoOn ) printf("%s\n",zSql); */ if( zErrMsg!=0 ){ printf("SQL error: %s\n", zErrMsg); - sqlite_freemem(zErrMsg); + sqlite3_free(zErrMsg); zErrMsg = 0; }else{ - printf("SQL error: %s\n", sqlite_error_string(rc)); + printf("SQL error: %s\n", sqlite3_errmsg(p->db)); } } free(zSql); @@ -1130,7 +1564,7 @@ static void process_sqliterc( ){ char *home_dir = NULL; const char *sqliterc = sqliterc_override; - char *zBuf; + char *zBuf = 0; FILE *in = NULL; if (sqliterc == NULL) { @@ -1156,6 +1590,7 @@ static void process_sqliterc( process_input(p,in); fclose(in); } + free(zBuf); return; } @@ -1168,9 +1603,6 @@ static const char zOptions[] = " -[no]header turn headers on or off\n" " -column set output mode to 'column'\n" " -html set output mode to HTML\n" -#ifdef SQLITE_HAS_CODEC - " -key KEY encryption key\n" -#endif " -line set output mode to 'line'\n" " -list set output mode to 'list'\n" " -separator 'x' set output field separator (|)\n" @@ -1191,7 +1623,7 @@ static void usage(int showDetail){ /* ** Initialize the state information in data */ -void main_init(struct callback_data *data) { +static void main_init(struct callback_data *data) { memset(data, 0, sizeof(*data)); data->mode = MODE_List; strcpy(data->separator,"|"); @@ -1206,7 +1638,6 @@ int main(int argc, char **argv){ const char *zInitFile = 0; char *zFirstCmd = 0; int i; - extern int sqliteOsFileExists(const char*); #ifdef __MACOS__ argc = ccommand(&argv); @@ -1235,25 +1666,36 @@ int main(int argc, char **argv){ zInitFile = argv[i]; }else if( strcmp(argv[i],"-key")==0 ){ i++; - data.zKey = sqlite_mprintf("%s",argv[i]); + data.zKey = sqlite3_mprintf("%s",argv[i]); } } if( i /* Needed for the definition of va_list */ - -#ifdef WIN32 - -#ifdef SQLITE_EXPORTS - #define SQLITE_EXPORT __declspec(dllexport) -#else - #define SQLITE_EXPORT __declspec(dllimport) -#endif - -#else - -#define SQLITE_EXPORT - -#endif // WIN32 - - -/* -** Make sure we can call this stuff from C++. -*/ -#ifdef __cplusplus -extern "C" { -#endif - -/* -** The version of the SQLite library. -*/ -#define SQLITE_VERSION "2.8.13" - -/* -** 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_ISO8859 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_EXPORT 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. -*/ -SQLITE_EXPORT 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.) -*/ -SQLITE_EXPORT 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. -*/ -SQLITE_EXPORT 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) -#define SQLITE_ARGS (-3) - -/* -** 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 */ -); - -#ifdef __cplusplus -} /* End of the 'extern "C"' block */ -#endif - -#endif /* _SQLITE_H_ */ diff --git a/sqlite/sqlite3.def b/sqlite/sqlite3.def new file mode 100755 index 000000000..e42a0cd3d --- /dev/null +++ b/sqlite/sqlite3.def @@ -0,0 +1,101 @@ +EXPORTS +sqlite3_aggregate_context +sqlite3_aggregate_count +sqlite3_bind_blob +sqlite3_bind_double +sqlite3_bind_int +sqlite3_bind_int64 +sqlite3_bind_null +sqlite3_bind_parameter_count +sqlite3_bind_parameter_index +sqlite3_bind_parameter_name +sqlite3_bind_text +sqlite3_bind_text16 +sqlite3_busy_handler +sqlite3_busy_timeout +sqlite3_changes +sqlite3_close +sqlite3_collation_needed +sqlite3_collation_needed16 +sqlite3_column_blob +sqlite3_column_bytes +sqlite3_column_bytes16 +sqlite3_column_count +sqlite3_column_decltype +sqlite3_column_decltype16 +sqlite3_column_double +sqlite3_column_int +sqlite3_column_int64 +sqlite3_column_name +sqlite3_column_name16 +sqlite3_column_text +sqlite3_column_text16 +sqlite3_column_type +sqlite3_commit_hook +sqlite3_complete +sqlite3_complete16 +sqlite3_create_collation +sqlite3_create_collation16 +sqlite3_create_function +sqlite3_create_function16 +sqlite3_data_count +sqlite3_db_handle +sqlite3_enable_shared_cache +sqlite3_errcode +sqlite3_errmsg +sqlite3_errmsg16 +sqlite3_exec +sqlite3_expired +sqlite3_finalize +sqlite3_free +sqlite3_free_table +sqlite3_get_autocommit +sqlite3_get_auxdata +sqlite3_get_table +sqlite3_global_recover +sqlite3_interrupt +sqlite3_last_insert_rowid +sqlite3_libversion +sqlite3_libversion_number +sqlite3_mprintf +sqlite3_open +sqlite3_open16 +sqlite3_prepare +sqlite3_prepare16 +sqlite3_progress_handler +sqlite3_reset +sqlite3_result_blob +sqlite3_result_double +sqlite3_result_error +sqlite3_result_error16 +sqlite3_result_int +sqlite3_result_int64 +sqlite3_result_null +sqlite3_result_text +sqlite3_result_text16 +sqlite3_result_text16be +sqlite3_result_text16le +sqlite3_result_value +sqlite3_rollback_hook +sqlite3_set_authorizer +sqlite3_set_auxdata +sqlite3_snprintf +sqlite3_step +sqlite3_thread_cleanup +sqlite3_total_changes +sqlite3_trace +sqlite3_transfer_bindings +sqlite3_update_hook +sqlite3_user_data +sqlite3_value_blob +sqlite3_value_bytes +sqlite3_value_bytes16 +sqlite3_value_double +sqlite3_value_int +sqlite3_value_int64 +sqlite3_value_text +sqlite3_value_text16 +sqlite3_value_text16be +sqlite3_value_text16le +sqlite3_value_type +sqlite3_vmprintf diff --git a/sqlite/sqlite3.h b/sqlite/sqlite3.h new file mode 100755 index 000000000..9aaebcd53 --- /dev/null +++ b/sqlite/sqlite3.h @@ -0,0 +1,1482 @@ +/* +** 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: sqlite3.h,v 1.1 2006-04-13 12:44:29 guy Exp $ +*/ +#ifndef _SQLITE3_H_ +#define _SQLITE3_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 +#endif +#define SQLITE_VERSION "3.3.5" + +/* +** The format of the version string is "X.Y.Z", where +** X is the major version number, Y is the minor version number and Z +** is the release number. The trailing string is often "alpha" or "beta". +** For example "3.1.1beta". +** +** The SQLITE_VERSION_NUMBER is an integer with the value +** (X*100000 + Y*1000 + Z). For example, for version "3.1.1beta", +** SQLITE_VERSION_NUMBER is set to 3001001. To detect if they are using +** version 3.1.1 or greater at compile time, programs may use the test +** (SQLITE_VERSION_NUMBER>=3001001). +*/ +#ifdef SQLITE_VERSION_NUMBER +# undef SQLITE_VERSION_NUMBER +#endif +#define SQLITE_VERSION_NUMBER 3003005 + +/* +** 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. The sqlite3_libversion() function returns a pointer +** to the sqlite3_version variable - useful in DLLs which cannot access +** global variables. +*/ +extern const char sqlite3_version[]; +const char *sqlite3_libversion(void); + +/* +** Return the value of the SQLITE_VERSION_NUMBER macro when the +** library was compiled. +*/ +int sqlite3_libversion_number(void); + +/* +** Each open sqlite database is represented by an instance of the +** following opaque structure. +*/ +typedef struct sqlite3 sqlite3; + + +/* +** Some compilers do not support the "long long" datatype. So we have +** to do a typedef that for 64-bit integers that depends on what compiler +** is being used. +*/ +#ifdef SQLITE_INT64_TYPE + typedef SQLITE_INT64_TYPE sqlite_int64; + typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; +#elif defined(_MSC_VER) || defined(__BORLANDC__) + typedef __int64 sqlite_int64; + typedef unsigned __int64 sqlite_uint64; +#else + typedef long long int sqlite_int64; + typedef unsigned long long int sqlite_uint64; +#endif + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite_int64 +#endif + +/* +** A function to close the database. +** +** Call this function with a pointer to a structure that was previously +** returned from sqlite3_open() and the corresponding database will by closed. +** +** All SQL statements prepared using sqlite3_prepare() or +** sqlite3_prepare16() must be deallocated using sqlite3_finalize() before +** this routine is called. Otherwise, SQLITE_BUSY is returned and the +** database connection remains open. +*/ +int sqlite3_close(sqlite3 *); + +/* +** The type for a callback function. +*/ +typedef int (*sqlite3_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 sqlite3_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 sqlite3_free() 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 sqlite3_busy_handler() +** and sqlite3_busy_timeout() functions below.) +*/ +int sqlite3_exec( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be executed */ + sqlite3_callback, /* Callback function */ + void *, /* 1st argument to callback function */ + char **errmsg /* Error msg written here */ +); + +/* +** Return values for sqlite3_exec() and sqlite3_step() +*/ +#define SQLITE_OK 0 /* Successful result */ +/* beginning-of-error-codes */ +#define SQLITE_ERROR 1 /* SQL error or missing database */ +#define SQLITE_INTERNAL 2 /* NOT USED. Internal logic error in SQLite */ +#define SQLITE_PERM 3 /* Access permission denied */ +#define SQLITE_ABORT 4 /* Callback routine requested an abort */ +#define SQLITE_BUSY 5 /* The database file is locked */ +#define SQLITE_LOCKED 6 /* A table in the database is locked */ +#define SQLITE_NOMEM 7 /* A malloc() failed */ +#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ +#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ +#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ +#define SQLITE_NOTFOUND 12 /* NOT USED. 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 /* Database is empty */ +#define SQLITE_SCHEMA 17 /* The database schema changed */ +#define SQLITE_TOOBIG 18 /* NOT USED. Too much data for one row */ +#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 sqlite3_bind out of range */ +#define SQLITE_NOTADB 26 /* File opened that is not a database file */ +#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ +/* end-of-error-codes */ + +/* +** 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. +*/ +sqlite_int64 sqlite3_last_insert_rowid(sqlite3*); + +/* +** This function returns the number of database rows that were changed +** (or inserted or deleted) by the most recent called sqlite3_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 sqlite3_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 sqlite3_changes(sqlite3*); + +/* +** This function returns the number of database rows that have been +** modified by INSERT, UPDATE or DELETE statements since the database handle +** was opened. This includes UPDATE, INSERT and DELETE statements executed +** as part of trigger programs. All changes are counted as soon as the +** statement that makes them is completed (when the statement handle is +** passed to sqlite3_reset() or sqlite_finalise()). +** +** 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 sqlite3_total_changes(sqlite3*); + +/* This function causes any pending database operation to abort and +** return at its earliest opportunity. This routine is typically +** called in response to a user action such as pressing "Cancel" +** or Ctrl-C where the user wants a long query operation to halt +** immediately. +*/ +void sqlite3_interrupt(sqlite3*); + + +/* These functions return true if the given input string comprises +** one or more complete SQL statements. For the sqlite3_complete() call, +** the parameter must be a nul-terminated UTF-8 string. For +** sqlite3_complete16(), a nul-terminated machine byte order UTF-16 string +** is required. +** +** The algorithm is simple. If the last token other than spaces +** and comments is a semicolon, then return true. otherwise return +** false. +*/ +int sqlite3_complete(const char *sql); +int sqlite3_complete16(const void *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 sqlite3_exec() returns SQLITE_BUSY immediately if +** it finds a locked table. If the busy callback is not NULL, then +** sqlite3_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 sqlite3_exec() immediately returns +** SQLITE_BUSY. If the callback returns non-zero, then sqlite3_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. +*/ +int sqlite3_busy_handler(sqlite3*, int(*)(void*,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 sqlite3_exec() to return SQLITE_BUSY. +** +** Calling this routine with an argument less than or equal to zero +** turns off all busy handlers. +*/ +int sqlite3_busy_timeout(sqlite3*, int ms); + +/* +** This next routine is really just a wrapper around sqlite3_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 sqlite3_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 +** free() directly. Only sqlite3_free_table() is able to release +** the memory properly and safely. +** +** The return value of this routine is the same as from sqlite3_exec(). +*/ +int sqlite3_get_table( + sqlite3*, /* 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 sqlite3_get_table() allocated. +*/ +void sqlite3_free_table(char **result); + +/* +** The following routines are variants of the "sprintf()" from the +** standard C library. The resulting string is written into memory +** obtained from malloc() so that there is never a possiblity of buffer +** overflow. These routines also implement some additional formatting +** options that are useful for constructing SQL statements. +** +** The strings returned by these routines should be freed by calling +** sqlite3_free(). +** +** 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: +** +** char *z = sqlite3_mprintf("INSERT INTO TABLES('%q')", zText); +** sqlite3_exec(db, z, callback1, 0, 0); +** sqlite3_free(z); +** +** 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. +*/ +char *sqlite3_mprintf(const char*,...); +char *sqlite3_vmprintf(const char*, va_list); +void sqlite3_free(char *z); +char *sqlite3_snprintf(int,char*,const char*, ...); + +#ifndef SQLITE_OMIT_AUTHORIZATION +/* +** 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 sqlite3_set_authorizer( + sqlite3*, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pUserData +); +#endif + +/* +** 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 */ +#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ +#define SQLITE_REINDEX 27 /* Index Name NULL */ +#define SQLITE_ANALYZE 28 /* Table 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 for tracing SQL command evaluation. The function +** registered by sqlite3_trace() is invoked at the first sqlite3_step() +** for the evaluation of an SQL statement. The function registered by +** sqlite3_profile() runs at the end of each SQL statement and includes +** information on how long that statement ran. +** +** The sqlite3_profile() API is currently considered experimental and +** is subject to change. +*/ +void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); +void *sqlite3_profile(sqlite3*, + void(*xProfile)(void*,const char*,sqlite_uint64), void*); + +/* +** This routine configures a callback function - the progress callback - that +** is invoked periodically during long running calls to sqlite3_exec(), +** sqlite3_step() and sqlite3_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 sqlite3_exec(), sqlite3_step() or sqlite3_get_table() results +** in less than N opcodes being executed, then the progress callback is not +** invoked. +** +** 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 sqlite3_exec() call returns SQLITE_ABORT. +** +******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** +*/ +void sqlite3_progress_handler(sqlite3*, 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 *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); + +/* +** Open the sqlite database file "filename". The "filename" is UTF-8 +** encoded for sqlite3_open() and UTF-16 encoded in the native byte order +** for sqlite3_open16(). An sqlite3* handle is returned in *ppDb, even +** if an error occurs. If the database is opened (or created) successfully, +** then SQLITE_OK is returned. Otherwise an error code is returned. The +** sqlite3_errmsg() or sqlite3_errmsg16() routines can be used to obtain +** an English language description of the error. +** +** If the database file does not exist, then a new database is created. +** The encoding for the database is UTF-8 if sqlite3_open() is called and +** UTF-16 if sqlite3_open16 is used. +** +** Whether or not an error occurs when it is opened, resources associated +** with the sqlite3* handle should be released by passing it to +** sqlite3_close() when it is no longer required. +*/ +int sqlite3_open( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +int sqlite3_open16( + const void *filename, /* Database filename (UTF-16) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); + +/* +** Return the error code for the most recent sqlite3_* API call associated +** with sqlite3 handle 'db'. SQLITE_OK is returned if the most recent +** API call was successful. +** +** Calls to many sqlite3_* functions set the error code and string returned +** by sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16() +** (overwriting the previous values). Note that calls to sqlite3_errcode(), +** sqlite3_errmsg() and sqlite3_errmsg16() themselves do not affect the +** results of future invocations. +** +** Assuming no other intervening sqlite3_* API calls are made, the error +** code returned by this function is associated with the same error as +** the strings returned by sqlite3_errmsg() and sqlite3_errmsg16(). +*/ +int sqlite3_errcode(sqlite3 *db); + +/* +** Return a pointer to a UTF-8 encoded string describing in english the +** error condition for the most recent sqlite3_* API call. The returned +** string is always terminated by an 0x00 byte. +** +** The string "not an error" is returned when the most recent API call was +** successful. +*/ +const char *sqlite3_errmsg(sqlite3*); + +/* +** Return a pointer to a UTF-16 native byte order encoded string describing +** in english the error condition for the most recent sqlite3_* API call. +** The returned string is always terminated by a pair of 0x00 bytes. +** +** The string "not an error" is returned when the most recent API call was +** successful. +*/ +const void *sqlite3_errmsg16(sqlite3*); + +/* +** An instance of the following opaque structure is used to represent +** a compiled SQL statment. +*/ +typedef struct sqlite3_stmt sqlite3_stmt; + +/* +** To execute an SQL query, it must first be compiled into a byte-code +** program using one of the following routines. The only difference between +** them is that the second argument, specifying the SQL statement to +** compile, is assumed to be encoded in UTF-8 for the sqlite3_prepare() +** function and UTF-16 for sqlite3_prepare16(). +** +** The first parameter "db" is an SQLite database handle. The second +** parameter "zSql" is the statement to be compiled, encoded as either +** UTF-8 or UTF-16 (see above). If the next parameter, "nBytes", is less +** than zero, then zSql is read up to the first nul terminator. If +** "nBytes" is not less than zero, then it is the length of the string zSql +** in bytes (not characters). +** +** *pzTail is made to point to the first byte 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. +** +** *ppStmt is left pointing to a compiled SQL statement that can be +** executed using sqlite3_step(). Or if there is an error, *ppStmt may be +** set to NULL. If the input text contained no SQL (if the input is and +** empty string or a comment) then *ppStmt is set to NULL. +** +** On success, SQLITE_OK is returned. Otherwise an error code is returned. +*/ +int sqlite3_prepare( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +int sqlite3_prepare16( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); + +/* +** Pointers to the following two opaque structures are used to communicate +** with the implementations of user-defined functions. +*/ +typedef struct sqlite3_context sqlite3_context; +typedef struct Mem sqlite3_value; + +/* +** In the SQL strings input to sqlite3_prepare() and sqlite3_prepare16(), +** one or more literals can be replace by parameters "?" or ":AAA" or +** "$VVV" where AAA is an identifer and VVV is a variable name according +** to the syntax rules of the TCL programming language. +** The value of these parameters (also called "host parameter names") can +** be set using the routines listed below. +** +** In every case, the first parameter is a pointer to the sqlite3_stmt +** structure returned from sqlite3_prepare(). The second parameter is the +** index of the parameter. The first parameter as an index of 1. For +** named parameters (":AAA" or "$VVV") you can use +** sqlite3_bind_parameter_index() to get the correct index value given +** the parameters name. If the same named parameter occurs more than +** once, it is assigned the same index each time. +** +** The fifth parameter to sqlite3_bind_blob(), sqlite3_bind_text(), and +** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or +** text after SQLite has finished with it. If the fifth argument is the +** special value SQLITE_STATIC, then the library assumes that the information +** is in static, unmanaged space and does not need to be freed. If the +** fifth argument has the value SQLITE_TRANSIENT, then SQLite makes its +** own private copy of the data. +** +** The sqlite3_bind_* routine must be called before sqlite3_step() after +** an sqlite3_prepare() or sqlite3_reset(). Unbound parameterss are +** interpreted as NULL. +*/ +int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); +int sqlite3_bind_double(sqlite3_stmt*, int, double); +int sqlite3_bind_int(sqlite3_stmt*, int, int); +int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite_int64); +int sqlite3_bind_null(sqlite3_stmt*, int); +int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); +int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); +int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); + +/* +** Return the number of parameters in a compiled SQL statement. This +** routine was added to support DBD::SQLite. +*/ +int sqlite3_bind_parameter_count(sqlite3_stmt*); + +/* +** Return the name of the i-th parameter. Ordinary parameters "?" are +** nameless and a NULL is returned. For parameters of the form :AAA or +** $VVV the complete text of the parameter name is returned, including +** the initial ":" or "$". NULL is returned if the index is out of range. +*/ +const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); + +/* +** Return the index of a parameter with the given name. The name +** must match exactly. If no parameter with the given name is found, +** return 0. +*/ +int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); + +/* +** Set all the parameters in the compiled SQL statement to NULL. +*/ +int sqlite3_clear_bindings(sqlite3_stmt*); + +/* +** Return the number of columns in the result set returned by the compiled +** SQL statement. This routine returns 0 if pStmt is an SQL statement +** that does not return data (for example an UPDATE). +*/ +int sqlite3_column_count(sqlite3_stmt *pStmt); + +/* +** The first parameter is a compiled SQL statement. This function returns +** the column heading for the Nth column of that statement, where N is the +** second function parameter. The string returned is UTF-8 for +** sqlite3_column_name() and UTF-16 for sqlite3_column_name16(). +*/ +const char *sqlite3_column_name(sqlite3_stmt*,int); +const void *sqlite3_column_name16(sqlite3_stmt*,int); + +/* +** The first parameter to the following calls is a compiled SQL statement. +** These functions return information about the Nth column returned by +** the statement, where N is the second function argument. +** +** If the Nth column returned by the statement is not a column value, +** then all of the functions return NULL. Otherwise, the return the +** name of the attached database, table and column that the expression +** extracts a value from. +** +** As with all other SQLite APIs, those postfixed with "16" return UTF-16 +** encoded strings, the other functions return UTF-8. The memory containing +** the returned strings is valid until the statement handle is finalized(). +** +** These APIs are only available if the library was compiled with the +** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. +*/ +const char *sqlite3_column_database_name(sqlite3_stmt*,int); +const void *sqlite3_column_database_name16(sqlite3_stmt*,int); +const char *sqlite3_column_table_name(sqlite3_stmt*,int); +const void *sqlite3_column_table_name16(sqlite3_stmt*,int); +const char *sqlite3_column_origin_name(sqlite3_stmt*,int); +const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); + +/* +** The first parameter is a compiled SQL statement. If this statement +** is a SELECT statement, the Nth column of the returned result set +** of the SELECT is a table column then the declared type of the table +** column is returned. If the Nth column of the result set is not at table +** column, then a NULL pointer is returned. The returned string is always +** UTF-8 encoded. For example, in the database schema: +** +** CREATE TABLE t1(c1 VARIANT); +** +** And the following statement compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** Then this routine would return the string "VARIANT" for the second +** result column (i==1), and a NULL pointer for the first result column +** (i==0). +*/ +const char *sqlite3_column_decltype(sqlite3_stmt *, int i); + +/* +** The first parameter is a compiled SQL statement. If this statement +** is a SELECT statement, the Nth column of the returned result set +** of the SELECT is a table column then the declared type of the table +** column is returned. If the Nth column of the result set is not at table +** column, then a NULL pointer is returned. The returned string is always +** UTF-16 encoded. For example, in the database schema: +** +** CREATE TABLE t1(c1 INTEGER); +** +** And the following statement compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** Then this routine would return the string "INTEGER" for the second +** result column (i==1), and a NULL pointer for the first result column +** (i==0). +*/ +const void *sqlite3_column_decltype16(sqlite3_stmt*,int); + +/* +** After an SQL query has been compiled with a call to either +** sqlite3_prepare() or sqlite3_prepare16(), then this function must be +** called one or more times to execute the statement. +** +** The return value will be either SQLITE_BUSY, SQLITE_DONE, +** SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE. +** +** SQLITE_BUSY means that the database engine attempted to open +** a locked database and there is no busy callback registered. +** Call sqlite3_step() again to retry the open. +** +** SQLITE_DONE means that the statement has finished executing +** successfully. sqlite3_step() should not be called again on this virtual +** machine. +** +** If the SQL statement being executed returns any data, then +** SQLITE_ROW is returned each time a new row of data is ready +** for processing by the caller. The values may be accessed using +** the sqlite3_column_*() functions described below. sqlite3_step() +** is called again to retrieve the next row of data. +** +** SQLITE_ERROR means that a run-time error (such as a constraint +** violation) has occurred. sqlite3_step() should not be called again on +** the VM. More information may be found by calling sqlite3_errmsg(). +** +** SQLITE_MISUSE means that the this routine was called inappropriately. +** Perhaps it was called on a virtual machine that had already been +** finalized or on one that had previously returned SQLITE_ERROR or +** SQLITE_DONE. Or it could be the case the the same database connection +** is being used simulataneously by two or more threads. +*/ +int sqlite3_step(sqlite3_stmt*); + +/* +** Return the number of values in the current row of the result set. +** +** After a call to sqlite3_step() that returns SQLITE_ROW, this routine +** will return the same value as the sqlite3_column_count() function. +** After sqlite3_step() has returned an SQLITE_DONE, SQLITE_BUSY or +** error code, or before sqlite3_step() has been called on a +** compiled SQL statement, this routine returns zero. +*/ +int sqlite3_data_count(sqlite3_stmt *pStmt); + +/* +** Values are stored in the database in one of the following fundamental +** types. +*/ +#define SQLITE_INTEGER 1 +#define SQLITE_FLOAT 2 +/* #define SQLITE_TEXT 3 // See below */ +#define SQLITE_BLOB 4 +#define SQLITE_NULL 5 + +/* +** SQLite version 2 defines SQLITE_TEXT differently. To allow both +** version 2 and version 3 to be included, undefine them both if a +** conflict is seen. Define SQLITE3_TEXT to be the version 3 value. +*/ +#ifdef SQLITE_TEXT +# undef SQLITE_TEXT +#else +# define SQLITE_TEXT 3 +#endif +#define SQLITE3_TEXT 3 + +/* +** The next group of routines returns information about the information +** in a single column of the current result row of a query. In every +** case the first parameter is a pointer to the SQL statement that is being +** executed (the sqlite_stmt* that was returned from sqlite3_prepare()) and +** the second argument is the index of the column for which information +** should be returned. iCol is zero-indexed. The left-most column as an +** index of 0. +** +** If the SQL statement is not currently point to a valid row, or if the +** the colulmn index is out of range, the result is undefined. +** +** These routines attempt to convert the value where appropriate. For +** example, if the internal representation is FLOAT and a text result +** is requested, sprintf() is used internally to do the conversion +** automatically. The following table details the conversions that +** are applied: +** +** Internal Type Requested Type Conversion +** ------------- -------------- -------------------------- +** NULL INTEGER Result is 0 +** NULL FLOAT Result is 0.0 +** NULL TEXT Result is an empty string +** NULL BLOB Result is a zero-length BLOB +** INTEGER FLOAT Convert from integer to float +** INTEGER TEXT ASCII rendering of the integer +** INTEGER BLOB Same as for INTEGER->TEXT +** FLOAT INTEGER Convert from float to integer +** FLOAT TEXT ASCII rendering of the float +** FLOAT BLOB Same as FLOAT->TEXT +** TEXT INTEGER Use atoi() +** TEXT FLOAT Use atof() +** TEXT BLOB No change +** BLOB INTEGER Convert to TEXT then use atoi() +** BLOB FLOAT Convert to TEXT then use atof() +** BLOB TEXT Add a \000 terminator if needed +** +** The following access routines are provided: +** +** _type() Return the datatype of the result. This is one of +** SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT, SQLITE_BLOB, +** or SQLITE_NULL. +** _blob() Return the value of a BLOB. +** _bytes() Return the number of bytes in a BLOB value or the number +** of bytes in a TEXT value represented as UTF-8. The \000 +** terminator is included in the byte count for TEXT values. +** _bytes16() Return the number of bytes in a BLOB value or the number +** of bytes in a TEXT value represented as UTF-16. The \u0000 +** terminator is included in the byte count for TEXT values. +** _double() Return a FLOAT value. +** _int() Return an INTEGER value in the host computer's native +** integer representation. This might be either a 32- or 64-bit +** integer depending on the host. +** _int64() Return an INTEGER value as a 64-bit signed integer. +** _text() Return the value as UTF-8 text. +** _text16() Return the value as UTF-16 text. +*/ +const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); +int sqlite3_column_bytes(sqlite3_stmt*, int iCol); +int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); +double sqlite3_column_double(sqlite3_stmt*, int iCol); +int sqlite3_column_int(sqlite3_stmt*, int iCol); +sqlite_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); +const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); +const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); +int sqlite3_column_type(sqlite3_stmt*, int iCol); +int sqlite3_column_numeric_type(sqlite3_stmt*, int iCol); + +/* +** The sqlite3_finalize() function is called to delete a compiled +** SQL statement obtained by a previous call to sqlite3_prepare() +** or sqlite3_prepare16(). If the statement was executed successfully, or +** not executed at all, then SQLITE_OK is returned. If execution of the +** statement failed then an error code is returned. +** +** 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 sqlite3_interrupt().) Incomplete updates may be +** rolled back and transactions cancelled, depending on the circumstances, +** and the result code returned will be SQLITE_ABORT. +*/ +int sqlite3_finalize(sqlite3_stmt *pStmt); + +/* +** The sqlite3_reset() function is called to reset a compiled SQL +** statement obtained by a previous call to sqlite3_prepare() or +** sqlite3_prepare16() back to it's initial state, ready to be re-executed. +** Any SQL statement variables that had values bound to them using +** the sqlite3_bind_*() API retain their values. +*/ +int sqlite3_reset(sqlite3_stmt *pStmt); + +/* +** The following two functions are used to add user functions or aggregates +** implemented in C to the SQL langauge interpreted by SQLite. The +** difference only between the two is that the second parameter, the +** name of the (scalar) function or aggregate, is encoded in UTF-8 for +** sqlite3_create_function() and UTF-16 for sqlite3_create_function16(). +** +** The first argument is the database handle that the new function or +** aggregate is to be added to. If a single program uses more than one +** database handle internally, then user functions or aggregates must +** be added individually to each database handle with which they will be +** used. +** +** The third parameter is the number of arguments that the function or +** aggregate takes. If this parameter is negative, then the function or +** aggregate may take any number of arguments. +** +** The fourth parameter is one of SQLITE_UTF* values defined below, +** indicating the encoding that the function is most likely to handle +** values in. This does not change the behaviour of the programming +** interface. However, if two versions of the same function are registered +** with different encoding values, SQLite invokes the version likely to +** minimize conversions between text encodings. +** +** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are +** pointers to user implemented C functions that implement the user +** function or aggregate. A scalar function requires an implementation of +** the xFunc callback only, NULL pointers should be passed as the xStep +** and xFinal parameters. An aggregate function requires an implementation +** of xStep and xFinal, but NULL should be passed for xFunc. To delete an +** existing user function or aggregate, pass NULL for all three function +** callback. Specifying an inconstent set of callback values, such as an +** xFunc and an xFinal, or an xStep but no xFinal, SQLITE_ERROR is +** returned. +*/ +int sqlite3_create_function( + sqlite3 *, + const char *zFunctionName, + int nArg, + int eTextRep, + void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +int sqlite3_create_function16( + sqlite3*, + const void *zFunctionName, + int nArg, + int eTextRep, + void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); + +/* +** This function is deprecated. Do not use it. It continues to exist +** so as not to break legacy code. But new code should avoid using it. +*/ +int sqlite3_aggregate_count(sqlite3_context*); + +/* +** The next group of routines returns information about parameters to +** a user-defined function. Function implementations use these routines +** to access their parameters. These routines are the same as the +** sqlite3_column_* routines except that these routines take a single +** sqlite3_value* pointer instead of an sqlite3_stmt* and an integer +** column number. +*/ +const void *sqlite3_value_blob(sqlite3_value*); +int sqlite3_value_bytes(sqlite3_value*); +int sqlite3_value_bytes16(sqlite3_value*); +double sqlite3_value_double(sqlite3_value*); +int sqlite3_value_int(sqlite3_value*); +sqlite_int64 sqlite3_value_int64(sqlite3_value*); +const unsigned char *sqlite3_value_text(sqlite3_value*); +const void *sqlite3_value_text16(sqlite3_value*); +const void *sqlite3_value_text16le(sqlite3_value*); +const void *sqlite3_value_text16be(sqlite3_value*); +int sqlite3_value_type(sqlite3_value*); +int sqlite3_value_numeric_type(sqlite3_value*); + +/* +** 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 by SQLite. +*/ +void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); + +/* +** The pUserData parameter to the sqlite3_create_function() +** routine used to register user functions is available to +** the implementation of the function using this call. +*/ +void *sqlite3_user_data(sqlite3_context*); + +/* +** The following two functions may be used by scalar user functions to +** associate meta-data with argument values. If the same value is passed to +** multiple invocations of the user-function during query execution, under +** some circumstances the associated meta-data may be preserved. This may +** be used, for example, to add a regular-expression matching scalar +** function. The compiled version of the regular expression is stored as +** meta-data associated with the SQL value passed as the regular expression +** pattern. +** +** Calling sqlite3_get_auxdata() returns a pointer to the meta data +** associated with the Nth argument value to the current user function +** call, where N is the second parameter. If no meta-data has been set for +** that value, then a NULL pointer is returned. +** +** The sqlite3_set_auxdata() is used to associate meta data with a user +** function argument. The third parameter is a pointer to the meta data +** to be associated with the Nth user function argument value. The fourth +** parameter specifies a 'delete function' that will be called on the meta +** data pointer to release it when it is no longer required. If the delete +** function pointer is NULL, it is not invoked. +** +** In practice, meta-data is preserved between function calls for +** expressions that are constant at compile time. This includes literal +** values and SQL variables. +*/ +void *sqlite3_get_auxdata(sqlite3_context*, int); +void sqlite3_set_auxdata(sqlite3_context*, int, void*, void (*)(void*)); + + +/* +** These are special value for the destructor that is passed in as the +** final argument to routines like sqlite3_result_blob(). If the destructor +** argument is SQLITE_STATIC, it means that the content pointer is constant +** and will never change. It does not need to be destroyed. The +** SQLITE_TRANSIENT value means that the content will likely change in +** the near future and that SQLite should make its own private copy of +** the content before returning. +*/ +#define SQLITE_STATIC ((void(*)(void *))0) +#define SQLITE_TRANSIENT ((void(*)(void *))-1) + +/* +** User-defined functions invoke the following routines in order to +** set their return value. +*/ +void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); +void sqlite3_result_double(sqlite3_context*, double); +void sqlite3_result_error(sqlite3_context*, const char*, int); +void sqlite3_result_error16(sqlite3_context*, const void*, int); +void sqlite3_result_int(sqlite3_context*, int); +void sqlite3_result_int64(sqlite3_context*, sqlite_int64); +void sqlite3_result_null(sqlite3_context*); +void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); +void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); +void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); +void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); +void sqlite3_result_value(sqlite3_context*, sqlite3_value*); + +/* +** These are the allowed values for the eTextRep argument to +** sqlite3_create_collation and sqlite3_create_function. +*/ +#define SQLITE_UTF8 1 +#define SQLITE_UTF16LE 2 +#define SQLITE_UTF16BE 3 +#define SQLITE_UTF16 4 /* Use native byte order */ +#define SQLITE_ANY 5 /* sqlite3_create_function only */ +#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ + +/* +** These two functions are used to add new collation sequences to the +** sqlite3 handle specified as the first argument. +** +** The name of the new collation sequence is specified as a UTF-8 string +** for sqlite3_create_collation() and a UTF-16 string for +** sqlite3_create_collation16(). In both cases the name is passed as the +** second function argument. +** +** The third argument must be one of the constants SQLITE_UTF8, +** SQLITE_UTF16LE or SQLITE_UTF16BE, indicating that the user-supplied +** routine expects to be passed pointers to strings encoded using UTF-8, +** UTF-16 little-endian or UTF-16 big-endian respectively. +** +** A pointer to the user supplied routine must be passed as the fifth +** argument. If it is NULL, this is the same as deleting the collation +** sequence (so that SQLite cannot call it anymore). Each time the user +** supplied function is invoked, it is passed a copy of the void* passed as +** the fourth argument to sqlite3_create_collation() or +** sqlite3_create_collation16() as its first parameter. +** +** The remaining arguments to the user-supplied routine are two strings, +** each represented by a [length, data] pair and encoded in the encoding +** that was passed as the third argument when the collation sequence was +** registered. The user routine should return negative, zero or positive if +** the first string is less than, equal to, or greater than the second +** string. i.e. (STRING1 - STRING2). +*/ +int sqlite3_create_collation( + sqlite3*, + const char *zName, + int eTextRep, + void*, + int(*xCompare)(void*,int,const void*,int,const void*) +); +int sqlite3_create_collation16( + sqlite3*, + const char *zName, + int eTextRep, + void*, + int(*xCompare)(void*,int,const void*,int,const void*) +); + +/* +** To avoid having to register all collation sequences before a database +** can be used, a single callback function may be registered with the +** database handle to be called whenever an undefined collation sequence is +** required. +** +** If the function is registered using the sqlite3_collation_needed() API, +** then it is passed the names of undefined collation sequences as strings +** encoded in UTF-8. If sqlite3_collation_needed16() is used, the names +** are passed as UTF-16 in machine native byte order. A call to either +** function replaces any existing callback. +** +** When the user-function is invoked, the first argument passed is a copy +** of the second argument to sqlite3_collation_needed() or +** sqlite3_collation_needed16(). The second argument is the database +** handle. The third argument is one of SQLITE_UTF8, SQLITE_UTF16BE or +** SQLITE_UTF16LE, indicating the most desirable form of the collation +** sequence function required. The fourth parameter is the name of the +** required collation sequence. +** +** The collation sequence is returned to SQLite by a collation-needed +** callback using the sqlite3_create_collation() or +** sqlite3_create_collation16() APIs, described above. +*/ +int sqlite3_collation_needed( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const char*) +); +int sqlite3_collation_needed16( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const void*) +); + +/* +** Specify the key for an encrypted database. This routine should be +** called right after sqlite3_open(). +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +int sqlite3_key( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The key */ +); + +/* +** Change the key on an open database. If the current database is not +** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the +** database is decrypted. +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +int sqlite3_rekey( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The new key */ +); + +/* +** Sleep for a little while. The second parameter is the number of +** miliseconds to sleep for. +** +** If the operating system does not support sleep requests with +** milisecond time resolution, then the time will be rounded up to +** the nearest second. The number of miliseconds of sleep actually +** requested from the operating system is returned. +*/ +int sqlite3_sleep(int); + +/* +** Return TRUE (non-zero) if the statement supplied as an argument needs +** to be recompiled. A statement needs to be recompiled whenever the +** execution environment changes in a way that would alter the program +** that sqlite3_prepare() generates. For example, if new functions or +** collating sequences are registered or if an authorizer function is +** added or changed. +** +*/ +int sqlite3_expired(sqlite3_stmt*); + +/* +** Move all bindings from the first prepared statement over to the second. +** This routine is useful, for example, if the first prepared statement +** fails with an SQLITE_SCHEMA error. The same SQL can be prepared into +** the second prepared statement then all of the bindings transfered over +** to the second statement before the first statement is finalized. +*/ +int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); + +/* +** If the following global variable is made to point to a +** string which is the name of a directory, then all temporary files +** created by SQLite will be placed in that directory. If this variable +** is NULL pointer, then SQLite does a search for an appropriate temporary +** file directory. +** +** Once sqlite3_open() has been called, changing this variable will invalidate +** the current temporary database, if any. +*/ +extern char *sqlite3_temp_directory; + +/* +** This function is called to recover from a malloc() failure that occured +** within the SQLite library. Normally, after a single malloc() fails the +** library refuses to function (all major calls return SQLITE_NOMEM). +** This function restores the library state so that it can be used again. +** +** All existing statements (sqlite3_stmt pointers) must be finalized or +** reset before this call is made. Otherwise, SQLITE_BUSY is returned. +** If any in-memory databases are in use, either as a main or TEMP +** database, SQLITE_ERROR is returned. In either of these cases, the +** library is not reset and remains unusable. +** +** This function is *not* threadsafe. Calling this from within a threaded +** application when threads other than the caller have used SQLite is +** dangerous and will almost certainly result in malfunctions. +** +** This functionality can be omitted from a build by defining the +** SQLITE_OMIT_GLOBALRECOVER at compile time. +*/ +int sqlite3_global_recover(void); + +/* +** Test to see whether or not the database connection is in autocommit +** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on +** by default. Autocommit is disabled by a BEGIN statement and reenabled +** by the next COMMIT or ROLLBACK. +*/ +int sqlite3_get_autocommit(sqlite3*); + +/* +** Return the sqlite3* database handle to which the prepared statement given +** in the argument belongs. This is the same database handle that was +** the first argument to the sqlite3_prepare() that was used to create +** the statement in the first place. +*/ +sqlite3 *sqlite3_db_handle(sqlite3_stmt*); + +/* +** Register a callback function with the database connection identified by the +** first argument to be invoked whenever a row is updated, inserted or deleted. +** Any callback set by a previous call to this function for the same +** database connection is overridden. +** +** The second argument is a pointer to the function to invoke when a +** row is updated, inserted or deleted. The first argument to the callback is +** a copy of the third argument to sqlite3_update_hook. The second callback +** argument is one of SQLITE_INSERT, SQLITE_DELETE or SQLITE_UPDATE, depending +** on the operation that caused the callback to be invoked. The third and +** fourth arguments to the callback contain pointers to the database and +** table name containing the affected row. The final callback parameter is +** the rowid of the row. In the case of an update, this is the rowid after +** the update takes place. +** +** The update hook is not invoked when internal system tables are +** modified (i.e. sqlite_master and sqlite_sequence). +** +** If another function was previously registered, its pArg value is returned. +** Otherwise NULL is returned. +*/ +void *sqlite3_update_hook( + sqlite3*, + void(*)(void *,int ,char const *,char const *,sqlite_int64), + void* +); + +/* +** Register a callback to be invoked whenever a transaction is rolled +** back. +** +** The new callback function overrides any existing rollback-hook +** callback. If there was an existing callback, then it's pArg value +** (the third argument to sqlite3_rollback_hook() when it was registered) +** is returned. Otherwise, NULL is returned. +** +** For the purposes of this API, a transaction is said to have been +** rolled back if an explicit "ROLLBACK" statement is executed, or +** an error or constraint causes an implicit rollback to occur. The +** callback is not invoked if a transaction is automatically rolled +** back because the database connection is closed. +*/ +void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); + +/* +** This function is only available if the library is compiled without +** the SQLITE_OMIT_SHARED_CACHE macro defined. It is used to enable or +** disable (if the argument is true or false, respectively) the +** "shared pager" feature. +*/ +int sqlite3_enable_shared_cache(int); + +/* +** Attempt to free N bytes of heap memory by deallocating non-essential +** memory allocations held by the database library (example: memory +** used to cache database pages to improve performance). +** +** This function is not a part of standard builds. It is only created +** if SQLite is compiled with the SQLITE_ENABLE_MEMORY_MANAGEMENT macro. +*/ +int sqlite3_release_memory(int); + +/* +** Place a "soft" limit on the amount of heap memory that may be allocated by +** SQLite within the current thread. If an internal allocation is requested +** that would exceed the specified limit, sqlite3_release_memory() is invoked +** one or more times to free up some space before the allocation is made. +** +** The limit is called "soft", because if sqlite3_release_memory() cannot free +** sufficient memory to prevent the limit from being exceeded, the memory is +** allocated anyway and the current operation proceeds. +** +** This function is only available if the library was compiled with the +** SQLITE_ENABLE_MEMORY_MANAGEMENT option set. +** memory-management has been enabled. +*/ +void sqlite3_soft_heap_limit(int); + +/* +** This routine makes sure that all thread-local storage has been +** deallocated for the current thread. +** +** This routine is not technically necessary. All thread-local storage +** will be automatically deallocated once memory-management and +** shared-cache are disabled and the soft heap limit has been set +** to zero. This routine is provided as a convenience for users who +** want to make absolutely sure they have not forgotten something +** prior to killing off a thread. +*/ +void sqlite3_thread_cleanup(void); + +/* +** Return meta information about a specific column of a specific database +** table accessible using the connection handle passed as the first function +** argument. +** +** The column is identified by the second, third and fourth parameters to +** this function. The second parameter is either the name of the database +** (i.e. "main", "temp" or an attached database) containing the specified +** table or NULL. If it is NULL, then all attached databases are searched +** for the table using the same algorithm as the database engine uses to +** resolve unqualified table references. +** +** The third and fourth parameters to this function are the table and column +** name of the desired column, respectively. Neither of these parameters +** may be NULL. +** +** Meta information is returned by writing to the memory locations passed as +** the 5th and subsequent parameters to this function. Any of these +** arguments may be NULL, in which case the corresponding element of meta +** information is ommitted. +** +** Parameter Output Type Description +** ----------------------------------- +** +** 5th const char* Data type +** 6th const char* Name of the default collation sequence +** 7th int True if the column has a NOT NULL constraint +** 8th int True if the column is part of the PRIMARY KEY +** 9th int True if the column is AUTOINCREMENT +** +** +** The memory pointed to by the character pointers returned for the +** declaration type and collation sequence is valid only until the next +** call to any sqlite API function. +** +** If the specified table is actually a view, then an error is returned. +** +** If the specified column is "rowid", "oid" or "_rowid_" and an +** INTEGER PRIMARY KEY column has been explicitly declared, then the output +** parameters are set for the explicitly declared column. If there is no +** explicitly declared IPK column, then the output parameters are set as +** follows: +** +** data type: "INTEGER" +** collation sequence: "BINARY" +** not null: 0 +** primary key: 1 +** auto increment: 0 +** +** This function may load one or more schemas from database files. If an +** error occurs during this process, or if the requested table or column +** cannot be found, an SQLITE error code is returned and an error message +** left in the database handle (to be retrieved using sqlite3_errmsg()). +** +** This API is only available if the library was compiled with the +** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. +*/ +int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if colums is auto-increment */ +); + +/* +** Undo the hack that converts floating point types to integer for +** builds on processors without floating point support. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# undef double +#endif + +#ifdef __cplusplus +} /* End of the 'extern "C"' block */ +#endif +#endif diff --git a/sqlite/sqliteInt.h b/sqlite/sqliteInt.h index 6430b579f..3279b3ad4 100755 --- a/sqlite/sqliteInt.h +++ b/sqlite/sqliteInt.h @@ -11,36 +11,106 @@ ************************************************************************* ** Internal interface definitions for SQLite. ** -** @(#) $Id: sqliteInt.h,v 1.1.1.1 2004-03-11 22:22:22 alex Exp $ +** @(#) $Id: sqliteInt.h,v 1.2 2006-04-13 12:44:29 guy Exp $ */ -#include "config.h" -#include "sqlite.h" +#ifndef _SQLITEINT_H_ +#define _SQLITEINT_H_ + +/* +** Extra interface definitions for those who need them +*/ +#ifdef SQLITE_EXTRA +# include "sqliteExtra.h" +#endif + +/* +** Many people are failing to set -DNDEBUG=1 when compiling SQLite. +** Setting NDEBUG makes the code smaller and run faster. So the following +** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1 +** option is set. Thus NDEBUG becomes an opt-in rather than an opt-out +** feature. +*/ +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif + +/* +** 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 + +#include "sqlite3.h" #include "hash.h" #include "parse.h" -#include "btree.h" #include #include #include #include +#include + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite_int64 +# define LONGDOUBLE_TYPE sqlite_int64 +# ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (0x7fffffffffffffff) +# endif +# define SQLITE_OMIT_DATETIME_FUNCS 1 +# define SQLITE_OMIT_TRACE 1 +#endif +#ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (1e99) +#endif /* ** The maximum number of in-memory pages to use for the main database -** table and for temporary tables. +** table and for temporary tables. Internally, the MAX_PAGES and +** TEMP_PAGES macros are used. To override the default values at +** compilation time, the SQLITE_DEFAULT_CACHE_SIZE and +** SQLITE_DEFAULT_TEMP_CACHE_SIZE macros should be set. */ -#define MAX_PAGES 2000 -#define TEMP_PAGES 500 +#ifdef SQLITE_DEFAULT_CACHE_SIZE +# define MAX_PAGES SQLITE_DEFAULT_CACHE_SIZE +#else +# define MAX_PAGES 2000 +#endif +#ifdef SQLITE_DEFAULT_TEMP_CACHE_SIZE +# define TEMP_PAGES SQLITE_DEFAULT_TEMP_CACHE_SIZE +#else +# define TEMP_PAGES 500 +#endif /* -** 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. +** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0 +** afterward. Having this macro allows us to cause the C compiler +** to omit code used by TEMP tables without messy #ifndef statements. */ -#define NULL_ALWAYS_DISTINCT 0 +#ifdef SQLITE_OMIT_TEMPDB +#define OMIT_TEMPDB 1 +#else +#define OMIT_TEMPDB 0 +#endif /* ** If the following macro is set to 1, then NULL values are considered @@ -59,35 +129,53 @@ /* ** 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. +** hold temporary tables (1). And it must be less than 32 because +** we use a bitmask of databases with a u32 in places (for example +** the Parse.cookieMask field). */ #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 +** The maximum value of a ?nnn wildcard that the parser will accept. +*/ +#define SQLITE_MAX_VARIABLE_NUMBER 999 + +/* +** The "file format" number is an integer that is incremented whenever +** the VDBE-level file format changes. The following macros define the +** the default file format for new databases and the maximum file format +** that the library can read. +*/ +#define SQLITE_MAX_FILE_FORMAT 4 +#ifndef SQLITE_DEFAULT_FILE_FORMAT +# define SQLITE_DEFAULT_FILE_FORMAT 4 +#endif + +/* +** Provide a default value for TEMP_STORE in case it is not specified +** on the command-line */ #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. +** GCC does not define the offsetof() macro so we'll have to do it +** ourselves. */ -/* #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 */ +#ifndef offsetof +#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) +#endif + +/* +** Check to see if this machine uses EBCDIC. (Yes, believe it or +** not, there are still machines out there that use EBCDIC.) +*/ +#if 'A' == '\301' +# define SQLITE_EBCDIC 1 +#else +# define SQLITE_ASCII 1 +#endif /* ** Integers of known sizes. These typedefs might change for architectures @@ -102,106 +190,118 @@ #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 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 +typedef sqlite_int64 i64; /* 8-byte signed integer */ +typedef sqlite_uint64 u64; /* 8-byte unsigned integer */ +typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ +typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ +typedef INT16_TYPE i16; /* 2-byte signed integer */ +typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ +typedef UINT8_TYPE i8; /* 1-byte signed integer */ /* -** This macro casts a pointer to an integer. Useful for doing -** pointer arithmetic. +** Macros to determine whether the machine is big or little endian, +** evaluated at runtime. */ -#define Addr(X) ((uptr)X) +extern const int sqlite3one; +#define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0) +#define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1) /* -** 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. +** An instance of the following structure is used to store the busy-handler +** callback for a given sqlite handle. ** -** The 16777198 is computed as follows: 238 bytes of payload on the -** original pages plus 16448 overflow pages each holding 1020 bytes of -** data. +** The sqlite.busyHandler member of the sqlite struct contains the busy +** callback for the database handle. Each pager opened via the sqlite +** handle is passed a pointer to sqlite.busyHandler. The busy-handler +** callback is currently invoked only from within pager.c. */ -#define MAX_BYTES_PER_ROW 1048576 -/* #define MAX_BYTES_PER_ROW 16777198 */ +typedef struct BusyHandler BusyHandler; +struct BusyHandler { + int (*xFunc)(void *,int); /* The busy callback */ + void *pArg; /* First arg to busy callback */ + int nBusy; /* Incremented with each busy call */ +}; /* -** 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. +** Defer sourcing vdbe.h and btree.h until after the "u8" and +** "BusyHandler typedefs. */ -#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; +#include "vdbe.h" +#include "btree.h" +#include "pager.h" +#ifdef SQLITE_MEMDEBUG /* ** The following global variables are used for testing and debugging -** only. They only work if MEMORY_DEBUG is defined. +** only. They only work if SQLITE_MEMDEBUG 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 */ +extern int sqlite3_nMalloc; /* Number of sqliteMalloc() calls */ +extern int sqlite3_nFree; /* Number of sqliteFree() calls */ +extern int sqlite3_iMallocFail; /* Fail sqliteMalloc() after this many calls */ +extern int sqlite3_iMallocReset; /* Set iMallocFail to this when it reaches 0 */ + +extern void *sqlite3_pFirst; /* Pointer to linked list of allocations */ +extern int sqlite3_nMaxAlloc; /* High water mark of ThreadData.nAlloc */ +extern int sqlite3_mallocDisallowed; /* assert() in sqlite3Malloc() if set */ +extern int sqlite3_isFail; /* True if all malloc calls should fail */ +extern const char *sqlite3_zFile; /* Filename to associate debug info with */ +extern int sqlite3_iLine; /* Line number for debug info */ + +#define ENTER_MALLOC (sqlite3_zFile = __FILE__, sqlite3_iLine = __LINE__) +#define sqliteMalloc(x) (ENTER_MALLOC, sqlite3Malloc(x,1)) +#define sqliteMallocRaw(x) (ENTER_MALLOC, sqlite3MallocRaw(x,1)) +#define sqliteRealloc(x,y) (ENTER_MALLOC, sqlite3Realloc(x,y)) +#define sqliteStrDup(x) (ENTER_MALLOC, sqlite3StrDup(x)) +#define sqliteStrNDup(x,y) (ENTER_MALLOC, sqlite3StrNDup(x,y)) +#define sqliteReallocOrFree(x,y) (ENTER_MALLOC, sqlite3ReallocOrFree(x,y)) + +#else + +#define ENTER_MALLOC 0 +#define sqliteMalloc(x) sqlite3Malloc(x,1) +#define sqliteMallocRaw(x) sqlite3MallocRaw(x,1) +#define sqliteRealloc(x,y) sqlite3Realloc(x,y) +#define sqliteStrDup(x) sqlite3StrDup(x) +#define sqliteStrNDup(x,y) sqlite3StrNDup(x,y) +#define sqliteReallocOrFree(x,y) sqlite3ReallocOrFree(x,y) + #endif +#define sqliteFree(x) sqlite3FreeX(x) +#define sqliteAllocSize(x) sqlite3AllocSize(x) + + +/* +** An instance of this structure might be allocated to store information +** specific to a single thread. +*/ +struct ThreadData { + int dummy; /* So that this structure is never empty */ + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + int nSoftHeapLimit; /* Suggested max mem allocation. No limit if <0 */ + int nAlloc; /* Number of bytes currently allocated */ + Pager *pPager; /* Linked list of all pagers in this thread */ +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE + u8 useSharedData; /* True if shared pagers and schemas are enabled */ + BtShared *pBtree; /* Linked list of all currently open BTrees */ +#endif +}; + /* ** Name of the master database table. The master database table ** is a special table that holds the names and attributes of all @@ -210,10 +310,15 @@ extern int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */ #define MASTER_NAME "sqlite_master" #define TEMP_MASTER_NAME "sqlite_temp_master" +/* +** The root-page of the master database table. +*/ +#define MASTER_ROOT 1 + /* ** The name of the schema table. */ -#define SCHEMA_TABLE(x) (x?TEMP_MASTER_NAME:MASTER_NAME) +#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME) /* ** A convenience macro that returns the number of elements in @@ -224,27 +329,33 @@ extern int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */ /* ** Forward references to structures */ +typedef struct AggInfo AggInfo; +typedef struct AuthContext AuthContext; +typedef struct CollSeq CollSeq; typedef struct Column Column; -typedef struct Table Table; -typedef struct Index Index; -typedef struct Instruction Instruction; +typedef struct Db Db; +typedef struct Schema Schema; typedef struct Expr Expr; typedef struct ExprList ExprList; -typedef struct Parse Parse; -typedef struct Token Token; +typedef struct FKey FKey; +typedef struct FuncDef FuncDef; typedef struct IdList IdList; +typedef struct Index Index; +typedef struct KeyClass KeyClass; +typedef struct KeyInfo KeyInfo; +typedef struct NameContext NameContext; +typedef struct Parse Parse; +typedef struct Select Select; typedef struct SrcList SrcList; +typedef struct ThreadData ThreadData; +typedef struct Table Table; +typedef struct TableLock TableLock; +typedef struct Token Token; +typedef struct TriggerStack TriggerStack; +typedef struct TriggerStep TriggerStep; +typedef struct Trigger Trigger; 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 @@ -256,36 +367,41 @@ typedef struct AuthContext AuthContext; struct Db { char *zName; /* Name of this database */ Btree *pBt; /* The B*Tree structure for this database file */ + u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */ + u8 safety_level; /* How aggressive at synching data to disk */ + void *pAux; /* Auxiliary data. Usually NULL */ + void (*xFreeAux)(void*); /* Routine to free pAux */ + Schema *pSchema; /* Pointer to database schema (possibly shared) */ +}; + +/* +** An instance of the following structure stores a database schema. +*/ +struct Schema { 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 */ + Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */ + u8 file_format; /* Schema format version for this file */ + u8 enc; /* Text encoding used by this database */ + u16 flags; /* Flags associated with this schema */ + int cache_size; /* Number of pages to use in the cache */ }; /* ** These macros can be used to test, set, or clear bits in the ** Db.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) +#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))==(P)) +#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))!=0) +#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->flags|=(P) +#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->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. ** @@ -293,32 +409,15 @@ struct Db { ** 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 */ +#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */ +#define DB_UnresetViews 0x0002 /* Some views have defined column names */ +#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */ +#define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) /* ** 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 @@ -327,7 +426,7 @@ struct Db { ** 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. +** context. It is reset at start of sqlite3_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 @@ -336,39 +435,49 @@ struct Db { ** 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. +** +** The member variables sqlite.errCode, sqlite.zErrMsg and sqlite.zErrMsg16 +** store the most recent error code and, if applicable, string. The +** internal function sqlite3Error() is used to set these variables +** consistently. */ -struct sqlite { +struct sqlite3 { 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 errCode; /* Most recent error code (SQLITE_*) */ + u8 autoCommit; /* The auto-commit flag. */ + u8 temp_store; /* 1: file 2: memory 0: default */ 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 */ + CollSeq *pDfltColl; /* The default collating sequence (BINARY) */ + i64 lastRowid; /* ROWID of most recent insert (see above) */ + i64 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 */ + int nChange; /* Value returned by sqlite3_changes() */ + int nTotalChange; /* Value returned by sqlite3_total_changes() */ + struct sqlite3InitInfo { /* 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 */ + int activeVdbeCnt; /* Number of vdbes currently executing */ + void (*xTrace)(void*,const char*); /* Trace function */ + void *pTraceArg; /* Argument to the trace function */ + void (*xProfile)(void*,const char*,u64); /* Profiling function */ + void *pProfileArg; /* Argument to profile function */ + void *pCommitArg; /* Argument to xCommitCallback() */ + int (*xCommitCallback)(void*); /* Invoked at every commit. */ + void *pRollbackArg; /* Argument to xRollbackCallback() */ + void (*xRollbackCallback)(void*); /* Invoked at every commit. */ + void *pUpdateArg; + void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64); + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*); + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*); + void *pCollNeededArg; + sqlite3_value *pErr; /* Most recent error message */ + char *zErrMsg; /* Most recent error message (UTF-8 encoded) */ + char *zErrMsg16; /* Most recent error message (UTF-16 encoded) */ #ifndef SQLITE_OMIT_AUTHORIZATION int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); /* Access authorization function */ @@ -379,8 +488,24 @@ struct sqlite { void *pProgressArg; /* Argument to the progress callback */ int nProgressOps; /* Number of opcodes for progress callback */ #endif +#ifndef SQLITE_OMIT_GLOBALRECOVER + sqlite3 *pNext; /* Linked list of open db handles. */ +#endif + Hash aFunc; /* All functions that can be in SQL exprs */ + Hash aCollSeq; /* All collating sequences */ + BusyHandler busyHandler; /* Busy callback */ + int busyTimeout; /* Busy handler timeout, in msec */ + Db aDbStatic[2]; /* Static space for the 2 default backends */ +#ifdef SQLITE_SSE + sqlite3_stmt *pFetch; /* Used by SSE to fetch stored statements */ +#endif }; +/* +** A macro to discover the encoding of a database. +*/ +#define ENC(db) ((db)->aDb[0].pSchema->enc) + /* ** Possible values for the sqlite.flags and or Db.flags fields. ** @@ -389,7 +514,6 @@ struct sqlite { ** 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 */ @@ -400,8 +524,15 @@ struct sqlite { /* 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 */ +#define SQLITE_SqlTrace 0x00000200 /* Debug print SQL as it executes */ +#define SQLITE_VdbeListing 0x00000400 /* Debug listings of VDBE programs */ +#define SQLITE_WriteSchema 0x00000800 /* OK to update SQLITE_MASTER */ +#define SQLITE_NoReadlock 0x00001000 /* Readlocks are omitted when + ** accessing read-only databases */ +#define SQLITE_IgnoreChecks 0x00002000 /* Do not enforce check constraints */ +#define SQLITE_ReadUncommitted 0x00004000 /* For shared-cache mode */ +#define SQLITE_LegacyFileFmt 0x00008000 /* Create new databases in format 1 */ +#define SQLITE_FullFSync 0x00010000 /* Use full fsync on the backend */ /* ** Possible values for the sqlite.magic field. @@ -420,44 +551,102 @@ struct sqlite { ** 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 */ + i16 nArg; /* Number of arguments. -1 means unlimited */ + u8 iPrefEnc; /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */ + u8 needCollSeq; /* True if sqlite3GetFuncCollSeq() might be called */ + u8 flags; /* Some combination of SQLITE_FUNC_* */ + void *pUserData; /* User data parameter */ + FuncDef *pNext; /* Next function with same name */ + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */ + void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */ + void (*xFinalize)(sqlite3_context*); /* Aggregate finializer */ + char zName[1]; /* SQL name of the function. MUST BE LAST */ }; +/* +** Possible values for FuncDef.flags +*/ +#define SQLITE_FUNC_LIKE 0x01 /* Candidate for the LIKE optimization */ +#define SQLITE_FUNC_CASE 0x02 /* Case-sensitive LIKE-type function */ + /* ** 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 */ + Expr *pDflt; /* Default value of this column */ char *zType; /* Data type for this column */ + char *zColl; /* Collating sequence. If NULL, use the default */ 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 */ + char affinity; /* One of the SQLITE_AFF_... values */ }; /* -** The allowed sort orders. +** A "Collating Sequence" is defined by an instance of the following +** structure. Conceptually, a collating sequence consists of a name and +** a comparison routine that defines the order of that sequence. ** -** 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. +** There may two seperate implementations of the collation function, one +** that processes text in UTF-8 encoding (CollSeq.xCmp) and another that +** processes text encoded in UTF-16 (CollSeq.xCmp16), using the machine +** native byte order. When a collation sequence is invoked, SQLite selects +** the version that will require the least expensive encoding +** translations, if any. +** +** The CollSeq.pUser member variable is an extra parameter that passed in +** as the first argument to the UTF-8 comparison function, xCmp. +** CollSeq.pUser16 is the equivalent for the UTF-16 comparison function, +** xCmp16. +** +** If both CollSeq.xCmp and CollSeq.xCmp16 are NULL, it means that the +** collating sequence is undefined. Indices built on an undefined +** collating sequence may not be read or written. +*/ +struct CollSeq { + char *zName; /* Name of the collating sequence, UTF-8 encoded */ + u8 enc; /* Text encoding handled by xCmp() */ + u8 type; /* One of the SQLITE_COLL_... values below */ + void *pUser; /* First argument to xCmp() */ + int (*xCmp)(void*,int, const void*, int, const void*); +}; + +/* +** Allowed values of CollSeq flags: +*/ +#define SQLITE_COLL_BINARY 1 /* The default memcmp() collating sequence */ +#define SQLITE_COLL_NOCASE 2 /* The built-in NOCASE collating sequence */ +#define SQLITE_COLL_REVERSE 3 /* The built-in REVERSE collating sequence */ +#define SQLITE_COLL_USER 0 /* Any other user-defined collating sequence */ + +/* +** A sort order can be either ASC or DESC. */ -#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 */ +#define SQLITE_SO_DESC 1 /* Sort in ascending order */ + +/* +** Column affinity types. +** +** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and +** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve +** the speed a little by number the values consecutively. +** +** But rather than start with 0 or 1, we begin with 'a'. That way, +** when multiple affinity types are concatenated into a string and +** used as the P3 operand, they will be more readable. +** +** Note also that the numeric types are grouped together so that testing +** for a numeric type is a single comparison. +*/ +#define SQLITE_AFF_TEXT 'a' +#define SQLITE_AFF_NONE 'b' +#define SQLITE_AFF_NUMERIC 'c' +#define SQLITE_AFF_INTEGER 'd' +#define SQLITE_AFF_REAL 'e' + +#define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC) /* ** Each SQL table is represented in memory by an instance of the @@ -498,12 +687,21 @@ struct 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 */ + u8 autoInc; /* True if the integer primary key is autoincrement */ + int nRef; /* Number of pointers to this Table */ Trigger *pTrigger; /* List of SQL triggers on this table */ FKey *pFKey; /* Linked list of all foreign keys in this table */ + char *zColAff; /* String defining the affinity of each column */ +#ifndef SQLITE_OMIT_CHECK + Expr *pCheck; /* The AND of all CHECK constraints */ +#endif +#ifndef SQLITE_OMIT_ALTERTABLE + int addColOffset; /* Offset in CREATE TABLE statement to add a new column */ +#endif + Schema *pSchema; }; /* @@ -586,6 +784,24 @@ struct FKey { #define OE_Default 99 /* Do whatever the default action is */ + +/* +** An instance of the following structure is passed as the first +** argument to sqlite3VdbeKeyCompare and is used to control the +** comparison of the two index keys. +** +** If the KeyInfo.incrKey value is true and the comparison would +** otherwise be equal, then return a result as if the second key +** were larger. +*/ +struct KeyInfo { + u8 enc; /* Text encoding - one of the TEXT_Utf* values */ + u8 incrKey; /* Increase 2nd key by epsilon before comparison */ + int nField; /* Number of entries in aColl[] */ + u8 *aSortOrder; /* If defined an aSortOrder[i] is true, sort DESC */ + CollSeq *aColl[1]; /* Collating sequence for each term of the key */ +}; + /* ** Each SQL index is represented in memory by an ** instance of the following structure. @@ -616,12 +832,16 @@ 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 */ + unsigned *aiRowEst; /* Result of ANALYZE: Est. rows selected by each column */ 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 */ + char *zColAff; /* String defining the affinity of each column */ Index *pNext; /* The next index associated with the same table */ + Schema *pSchema; /* Schema containing this index */ + u8 *aSortOrder; /* Array of size Index.nColumn. True==DESC, False==ASC */ + char **azColl; /* Array of collation sequence names for index */ }; /* @@ -633,9 +853,52 @@ struct Index { ** 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 */ + const unsigned 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 */ +}; + +/* +** An instance of this structure contains information needed to generate +** code for a SELECT that contains aggregate functions. +** +** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a +** pointer to this structure. The Expr.iColumn field is the index in +** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate +** code for that node. +** +** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the +** original Select structure that describes the SELECT statement. These +** fields do not need to be freed when deallocating the AggInfo structure. +*/ +struct AggInfo { + u8 directMode; /* Direct rendering mode means take data directly + ** from source tables rather than from accumulators */ + u8 useSortingIdx; /* In direct mode, reference the sorting index rather + ** than the source table */ + int sortingIdx; /* Cursor number of the sorting index */ + ExprList *pGroupBy; /* The group by clause */ + int nSortingColumn; /* Number of columns in the sorting index */ + struct AggInfo_col { /* For each column used in source tables */ + int iTable; /* Cursor number of the source table */ + int iColumn; /* Column number within the source table */ + int iSorterColumn; /* Column number in the sorting index */ + int iMem; /* Memory location that acts as accumulator */ + Expr *pExpr; /* The original expression */ + } *aCol; + int nColumn; /* Number of used entries in aCol[] */ + int nColumnAlloc; /* Number of slots allocated for aCol[] */ + int nAccumulator; /* Number of columns that show through to the output. + ** Additional columns are used only as parameters to + ** aggregate functions */ + struct AggInfo_func { /* For each aggregate function */ + Expr *pExpr; /* Expression encoding the function */ + FuncDef *pFunc; /* The aggregate function implementation */ + int iMem; /* Memory location that acts as accumulator */ + int iDistinct; /* Virtual table used to enforce DISTINCT */ + } *aFunc; + int nFunc; /* Number of entries in aFunc[] */ + int nFuncAlloc; /* Number of slots allocated for aFunc[] */ }; /* @@ -669,16 +932,26 @@ struct Token { ** marker (a question mark character '?' in the original SQL) then the ** Expr.iTable holds the index number for that variable. ** +** If the expression is a subquery then Expr.iColumn holds an integer +** register number containing the result of the subquery. If the +** subquery gives a constant result, then iTable is -1. If the subquery +** gives a different answer at different times during statement processing +** then iTable is the address of a subroutine that computes the subquery. +** ** 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. +** +** If the Expr is of type OP_Column, and the table it is selecting from +** is a disk table or the "old.*" pseudo-table, then pTab points to the +** corresponding table definition. */ 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 */ + char affinity; /* The affinity of the column or 0 if not a column */ u8 flags; /* Various flags. See below */ + CollSeq *pColl; /* The collation type of the column or 0 */ 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 */ + AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */ + int iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */ + int iRightJoinTable; /* If EP_FromJoin, the right table of the join */ Select *pSelect; /* When the expression is a sub-select. Also the ** right side of " IN (